2 Copyright (C) 1999-2002 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 #include "pbd/error.h"
26 #include "pbd/enumwriter.h"
28 #include <glibmm/threads.h>
30 #include "ardour/audioengine.h"
31 #include "ardour/auditioner.h"
32 #include "ardour/butler.h"
33 #include "ardour/cycle_timer.h"
34 #include "ardour/debug.h"
35 #include "ardour/graph.h"
36 #include "ardour/port.h"
37 #include "ardour/process_thread.h"
38 #include "ardour/scene_changer.h"
39 #include "ardour/session.h"
40 #include "ardour/slave.h"
41 #include "ardour/ticker.h"
42 #include "ardour/types.h"
43 #include "ardour/vca.h"
44 #include "ardour/vca_manager.h"
46 #include "midi++/mmc.h"
50 using namespace ARDOUR;
54 /** Called by the audio engine when there is work to be done with JACK.
55 * @param nframes Number of frames to process.
59 Session::process (pframes_t nframes)
61 framepos_t transport_at_start = _transport_frame;
65 if (processing_blocked()) {
70 if (non_realtime_work_pending()) {
71 if (!_butler->transport_work_requested ()) {
76 _engine.main_thread()->get_buffers ();
78 (this->*process_function) (nframes);
80 /* realtime-safe meter-position and processor-order changes
82 * ideally this would be done in
83 * Route::process_output_buffers() but various functions
84 * callig it hold a _processor_lock reader-lock
86 boost::shared_ptr<RouteList> r = routes.reader ();
87 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
88 if ((*i)->apply_processor_changes_rt()) {
89 _rt_emit_pending = true;
92 if (_rt_emit_pending) {
93 if (!_rt_thread_active) {
94 emit_route_signals ();
96 if (pthread_mutex_trylock (&_rt_emit_mutex) == 0) {
97 pthread_cond_signal (&_rt_emit_cond);
98 pthread_mutex_unlock (&_rt_emit_mutex);
99 _rt_emit_pending = false;
103 _engine.main_thread()->drop_buffers ();
105 /* deliver MIDI clock. Note that we need to use the transport frame
106 * position at the start of process(), not the value at the end of
107 * it. We may already have ticked() because of a transport state
108 * change, for example.
112 if (!_silent && !_engine.freewheeling() && Config->get_send_midi_clock() && (transport_speed() == 1.0f || transport_speed() == 0.0f) && midi_clock->has_midi_port()) {
113 midi_clock->tick (transport_at_start, nframes);
116 _scene_changer->run (transport_at_start, transport_at_start + nframes);
119 /* don't bother with a message */
122 SendFeedback (); /* EMIT SIGNAL */
126 Session::fail_roll (pframes_t nframes)
128 return no_roll (nframes);
132 Session::no_roll (pframes_t nframes)
136 framepos_t end_frame = _transport_frame + nframes; // FIXME: varispeed + no_roll ??
138 int declick = (config.get_use_transport_fades() ? get_transport_declick_required() : false);
139 boost::shared_ptr<RouteList> r = routes.reader ();
142 _click_io->silence (nframes);
145 ltc_tx_send_time_code_for_cycle (_transport_frame, end_frame, _target_transport_speed, _transport_speed, nframes);
147 VCAList v = _vca_manager->vcas ();
148 for (VCAList::const_iterator i = v.begin(); i != v.end(); ++i) {
149 (*i)->automation_run (_transport_frame, nframes);
152 if (_process_graph) {
153 DEBUG_TRACE(DEBUG::ProcessThreads,"calling graph/no-roll\n");
154 _process_graph->routes_no_roll( nframes, _transport_frame, end_frame, non_realtime_work_pending(), declick);
156 PT_TIMING_CHECK (10);
157 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
159 if ((*i)->is_auditioner()) {
163 (*i)->set_pending_declick (declick);
165 if ((*i)->no_roll (nframes, _transport_frame, end_frame, non_realtime_work_pending())) {
166 error << string_compose(_("Session: error in no roll for %1"), (*i)->name()) << endmsg;
171 PT_TIMING_CHECK (11);
178 /** @param need_butler to be set to true by this method if it needs the butler,
179 * otherwise it must be left alone.
182 Session::process_routes (pframes_t nframes, bool& need_butler)
184 int declick = (config.get_use_transport_fades() ? get_transport_declick_required() : false);
185 boost::shared_ptr<RouteList> r = routes.reader ();
187 const framepos_t start_frame = _transport_frame;
188 const framepos_t end_frame = _transport_frame + floor (nframes * _transport_speed);
190 VCAList v = _vca_manager->vcas ();
191 for (VCAList::const_iterator i = v.begin(); i != v.end(); ++i) {
192 (*i)->automation_run (start_frame, nframes);
195 if (_process_graph) {
196 DEBUG_TRACE(DEBUG::ProcessThreads,"calling graph/process-routes\n");
197 if (_process_graph->process_routes (nframes, start_frame, end_frame, declick, need_butler) < 0) {
203 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
207 if ((*i)->is_auditioner()) {
211 (*i)->set_pending_declick (declick);
215 if ((ret = (*i)->roll (nframes, start_frame, end_frame, declick, b)) < 0) {
221 DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 rolled and needs butler\n", (*i)->name()));
230 /** @param need_butler to be set to true by this method if it needs the butler,
231 * otherwise it must be left alone.
234 Session::silent_process_routes (pframes_t nframes, bool& need_butler)
236 boost::shared_ptr<RouteList> r = routes.reader ();
238 const framepos_t start_frame = _transport_frame;
239 const framepos_t end_frame = _transport_frame + lrintf(nframes * _transport_speed);
241 VCAList v = _vca_manager->vcas ();
242 for (VCAList::const_iterator i = v.begin(); i != v.end(); ++i) {
243 (*i)->automation_run (start_frame, nframes);
246 if (_process_graph) {
247 _process_graph->silent_process_routes (nframes, start_frame, end_frame, need_butler);
249 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
253 if ((*i)->is_auditioner()) {
259 if ((ret = (*i)->silent_roll (nframes, start_frame, end_frame, b)) < 0) {
274 Session::get_track_statistics ()
279 boost::shared_ptr<RouteList> rl = routes.reader();
280 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
282 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
284 if (!tr || tr->hidden()) {
288 pworst = min (pworst, tr->playback_buffer_load());
289 cworst = min (cworst, tr->capture_buffer_load());
292 g_atomic_int_set (&_playback_load, (uint32_t) floor (pworst * 100.0f));
293 g_atomic_int_set (&_capture_load, (uint32_t) floor (cworst * 100.0f));
295 if (actively_recording()) {
300 /** Process callback used when the auditioner is not active */
302 Session::process_with_events (pframes_t nframes)
307 pframes_t this_nframes;
308 framepos_t end_frame;
309 bool session_needs_butler = false;
310 framecnt_t frames_moved;
312 /* make sure the auditioner is silent */
315 auditioner->silence (nframes);
318 /* handle any pending events */
320 while (pending_events.read (&ev, 1) == 1) {
324 /* if we are not in the middle of a state change,
325 and there are immediate events queued up,
329 while (!non_realtime_work_pending() && !immediate_events.empty()) {
330 SessionEvent *ev = immediate_events.front ();
331 immediate_events.pop_front ();
336 if (_transport_speed != 1.0 && _count_in_samples > 0) {
337 _count_in_samples = 0;
340 if (_count_in_samples > 0) {
341 framecnt_t ns = std::min ((framecnt_t)nframes, _count_in_samples);
344 run_click (_transport_frame - _count_in_samples, ns);
346 _count_in_samples -= ns;
349 /* process events.. */
350 if (!events.empty() && next_event != events.end()) {
351 SessionEvent* this_event = *next_event;
352 Events::iterator the_next_one = next_event;
355 while (this_event && this_event->action_frame == _transport_frame) {
356 process_event (this_event);
357 if (the_next_one == events.end()) {
360 this_event = *the_next_one;
367 check_declick_out ();
372 _engine.split_cycle (ns);
376 /* Decide on what to do with quarter-frame MTC during this cycle */
378 bool const was_sending_qf_mtc = _send_qf_mtc;
379 double const tolerance = Config->get_mtc_qf_speed_tolerance() / 100.0;
381 if (_transport_speed != 0) {
383 Config->get_send_mtc () &&
384 _transport_speed >= (1 - tolerance) &&
385 _transport_speed <= (1 + tolerance)
388 if (_send_qf_mtc && !was_sending_qf_mtc) {
389 /* we will re-start quarter-frame MTC this cycle, so send a full update to set things up */
390 _send_timecode_update = true;
393 if (Config->get_send_mtc() && !_send_qf_mtc && _pframes_since_last_mtc > (frame_rate () / 4)) {
394 /* we're sending MTC, but we're not sending QF MTC at the moment, and it's been
395 a quarter of a second since we sent anything at all, so send a full MTC update
398 _send_timecode_update = true;
401 _pframes_since_last_mtc += nframes;
404 /* Events caused a transport change (or we re-started sending
405 * MTC), so send an MTC Full Frame (Timecode) message. This
406 * is sent whether rolling or not, to give slaves an idea of
407 * ardour time on locates (and allow slow slaves to position
408 * and prepare for rolling)
410 if (_send_timecode_update) {
411 send_full_time_code (_transport_frame, nframes);
414 if (!process_can_proceed()) {
419 if (events.empty() || next_event == events.end()) {
420 try_run_lua (nframes); // also during export ?? ->move to process_without_events()
421 /* lua scripts may inject events */
422 while (_n_lua_scripts > 0 && pending_events.read (&ev, 1) == 1) {
425 if (events.empty() || next_event == events.end()) {
426 process_without_events (nframes);
431 if (_transport_speed == 1.0) {
432 frames_moved = (framecnt_t) nframes;
434 interpolation.set_target_speed (_target_transport_speed);
435 interpolation.set_speed (_transport_speed);
436 frames_moved = (framecnt_t) interpolation.interpolate (0, nframes, 0, 0);
439 end_frame = _transport_frame + frames_moved;
442 SessionEvent* this_event;
443 Events::iterator the_next_one;
445 if (!process_can_proceed()) {
450 if (!_exporting && _slave) {
451 if (!follow_slave (nframes)) {
456 if (_transport_speed == 0) {
461 if (!_exporting && !timecode_transmission_suspended()) {
462 send_midi_time_code_for_cycle (_transport_frame, end_frame, nframes);
465 ltc_tx_send_time_code_for_cycle (_transport_frame, end_frame, _target_transport_speed, _transport_speed, nframes);
467 framepos_t stop_limit = compute_stop_limit ();
469 if (maybe_stop (stop_limit)) {
474 this_event = *next_event;
475 the_next_one = next_event;
478 /* yes folks, here it is, the actual loop where we really truly
484 this_nframes = nframes; /* real (jack) time relative */
485 frames_moved = (framecnt_t) floor (_transport_speed * nframes); /* transport relative */
487 /* running an event, position transport precisely to its time */
488 if (this_event && this_event->action_frame <= end_frame && this_event->action_frame >= _transport_frame) {
489 /* this isn't quite right for reverse play */
490 frames_moved = (framecnt_t) (this_event->action_frame - _transport_frame);
491 this_nframes = abs (floor(frames_moved / _transport_speed));
494 try_run_lua (this_nframes);
498 click (_transport_frame, this_nframes);
500 if (process_routes (this_nframes, session_needs_butler)) {
505 get_track_statistics ();
507 nframes -= this_nframes;
509 if (frames_moved < 0) {
510 decrement_transport_position (-frames_moved);
512 increment_transport_position (frames_moved);
515 maybe_stop (stop_limit);
516 check_declick_out ();
520 _engine.split_cycle (this_nframes);
523 /* now handle this event and all others scheduled for the same time */
525 while (this_event && this_event->action_frame == _transport_frame) {
526 process_event (this_event);
528 if (the_next_one == events.end()) {
531 this_event = *the_next_one;
536 /* if an event left our state changing, do the right thing */
538 if (nframes && non_realtime_work_pending()) {
543 /* this is necessary to handle the case of seamless looping */
544 end_frame = _transport_frame + floor (nframes * _transport_speed);
549 } /* implicit release of route lock */
551 if (session_needs_butler) {
552 DEBUG_TRACE (DEBUG::Butler, "p-with-events: session needs butler, call it\n");
558 Session::reset_slave_state ()
560 average_slave_delta = 1800;
561 delta_accumulator_cnt = 0;
562 have_first_delta_accumulator = false;
563 _slave_state = Stopped;
567 Session::transport_locked () const
571 if (!locate_pending() && (!config.get_external_sync() || (sl && sl->ok() && sl->locked()))) {
579 Session::follow_slave (pframes_t nframes)
582 framepos_t slave_transport_frame;
583 framecnt_t this_delta;
588 config.set_external_sync (false);
592 _slave->speed_and_position (slave_speed, slave_transport_frame);
594 DEBUG_TRACE (DEBUG::Slave, string_compose ("Slave position %1 speed %2\n", slave_transport_frame, slave_speed));
596 if (!_slave->locked()) {
597 DEBUG_TRACE (DEBUG::Slave, "slave not locked\n");
601 if (slave_transport_frame > _transport_frame) {
602 this_delta = slave_transport_frame - _transport_frame;
605 this_delta = _transport_frame - slave_transport_frame;
609 if (_slave->starting()) {
613 if (_slave->is_always_synced() ||
614 (Config->get_timecode_source_is_synced() && (dynamic_cast<TimecodeSlave*>(_slave)) != 0)
617 /* if the TC source is synced, then we assume that its
618 speed is binary: 0.0 or 1.0
621 if (slave_speed != 0.0f) {
627 /* if we are chasing and the average delta between us and the
628 master gets too big, we want to switch to silent
629 motion. so keep track of that here.
632 if (_slave_state == Running) {
633 calculate_moving_average_of_slave_delta(dir, this_delta);
637 track_slave_state (slave_speed, slave_transport_frame, this_delta);
639 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave state %1 @ %2 speed %3 cur delta %4 avg delta %5\n",
640 _slave_state, slave_transport_frame, slave_speed, this_delta, average_slave_delta));
643 if (_slave_state == Running && !_slave->is_always_synced() &&
644 !(Config->get_timecode_source_is_synced() && (dynamic_cast<TimecodeSlave*>(_slave)) != 0)
647 if (_transport_speed != 0.0f) {
650 note that average_dir is +1 or -1
655 if (average_slave_delta == 0) {
659 delta = average_slave_delta;
660 delta *= average_dir;
664 if (slave_speed != 0.0) {
665 DEBUG_TRACE (DEBUG::Slave, string_compose ("delta = %1 speed = %2 ts = %3 M@%4 S@%5 avgdelta %6\n",
666 (int) (dir * this_delta),
670 slave_transport_frame,
671 average_slave_delta));
675 if (_slave->give_slave_full_control_over_transport_speed()) {
676 set_transport_speed (slave_speed, 0, false, false);
677 //std::cout << "set speed = " << slave_speed << "\n";
679 float adjusted_speed = slave_speed + (1.5 * (delta / float(_current_frame_rate)));
680 request_transport_speed (adjusted_speed);
681 DEBUG_TRACE (DEBUG::Slave, string_compose ("adjust using %1 towards %2 ratio %3 current %4 slave @ %5\n",
682 delta, adjusted_speed, adjusted_speed/slave_speed, _transport_speed,
687 if (!actively_recording() && (framecnt_t) abs(average_slave_delta) > _slave->resolution()) {
688 cerr << "average slave delta greater than slave resolution (" << _slave->resolution() << "), going to silent motion\n";
696 if (_slave_state == Running && 0 == (post_transport_work () & ~PostTransportSpeed)) {
697 /* speed is set, we're locked, and good to go */
702 DEBUG_TRACE (DEBUG::Slave, "silent motion\n")
703 follow_slave_silently (nframes, slave_speed);
706 /* don't move at all */
707 DEBUG_TRACE (DEBUG::Slave, "no roll\n")
713 Session::calculate_moving_average_of_slave_delta (int dir, framecnt_t this_delta)
715 if (delta_accumulator_cnt >= delta_accumulator_size) {
716 have_first_delta_accumulator = true;
717 delta_accumulator_cnt = 0;
720 if (delta_accumulator_cnt != 0 || this_delta < _current_frame_rate) {
721 delta_accumulator[delta_accumulator_cnt++] = (framecnt_t) dir * (framecnt_t) this_delta;
724 if (have_first_delta_accumulator) {
725 average_slave_delta = 0L;
726 for (int i = 0; i < delta_accumulator_size; ++i) {
727 average_slave_delta += delta_accumulator[i];
729 average_slave_delta /= (int32_t) delta_accumulator_size;
730 if (average_slave_delta < 0L) {
732 average_slave_delta = abs(average_slave_delta);
740 Session::track_slave_state (float slave_speed, framepos_t slave_transport_frame, framecnt_t /*this_delta*/)
742 if (slave_speed != 0.0f) {
744 /* slave is running */
746 switch (_slave_state) {
748 if (_slave->requires_seekahead()) {
749 slave_wait_end = slave_transport_frame + _slave->seekahead_distance ();
750 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped, but running, requires seekahead to %1\n", slave_wait_end));
751 /* we can call locate() here because we are in process context */
752 locate (slave_wait_end, false, false);
753 _slave_state = Waiting;
757 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped -> running at %1\n", slave_transport_frame));
759 memset (delta_accumulator, 0, sizeof (int32_t) * delta_accumulator_size);
760 average_slave_delta = 0L;
762 Location* al = _locations->auto_loop_location();
764 if (al && play_loop && (slave_transport_frame < al->start() || slave_transport_frame > al->end())) {
766 request_play_loop(false);
769 if (slave_transport_frame != _transport_frame) {
770 DEBUG_TRACE (DEBUG::Slave, string_compose ("require locate to run. eng: %1 -> sl: %2\n", _transport_frame, slave_transport_frame));
771 locate (slave_transport_frame, false, false);
773 _slave_state = Running;
782 if (_slave_state == Waiting) {
784 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave waiting at %1\n", slave_transport_frame));
786 if (slave_transport_frame >= slave_wait_end) {
788 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave start at %1 vs %2\n", slave_transport_frame, _transport_frame));
790 _slave_state = Running;
792 /* now perform a "micro-seek" within the disk buffers to realign ourselves
793 precisely with the master.
798 framecnt_t frame_delta = slave_transport_frame - _transport_frame;
800 boost::shared_ptr<RouteList> rl = routes.reader();
801 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
802 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
803 if (tr && !tr->can_internal_playback_seek (frame_delta)) {
810 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
811 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
813 tr->internal_playback_seek (frame_delta);
816 _transport_frame += frame_delta;
819 cerr << "cannot micro-seek\n";
825 if (_slave_state == Running && _transport_speed == 0.0f) {
826 DEBUG_TRACE (DEBUG::Slave, "slave starts transport\n");
830 } else { // slave_speed is 0
832 /* slave has stopped */
834 if (_transport_speed != 0.0f) {
835 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stops transport: %1 frame %2 tf %3\n", slave_speed, slave_transport_frame, _transport_frame));
839 if (slave_transport_frame != _transport_frame) {
840 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped, move to %1\n", slave_transport_frame));
841 force_locate (slave_transport_frame, false);
849 Session::follow_slave_silently (pframes_t nframes, float slave_speed)
851 if (slave_speed && _transport_speed) {
853 /* something isn't right, but we should move with the master
857 bool need_butler = false;
859 silent_process_routes (nframes, need_butler);
861 get_track_statistics ();
864 DEBUG_TRACE (DEBUG::Butler, "f-slave-silently: session needs butler, call it\n");
868 int32_t frames_moved = (int32_t) floor (_transport_speed * nframes);
870 if (frames_moved < 0) {
871 decrement_transport_position (-frames_moved);
873 increment_transport_position (frames_moved);
876 framepos_t const stop_limit = compute_stop_limit ();
877 maybe_stop (stop_limit);
882 Session::process_without_events (pframes_t nframes)
884 bool session_needs_butler = false;
885 framecnt_t frames_moved;
887 if (!process_can_proceed()) {
892 if (!_exporting && _slave) {
893 if (!follow_slave (nframes)) {
894 ltc_tx_send_time_code_for_cycle (_transport_frame, _transport_frame, 0, 0 , nframes);
899 if (_transport_speed == 0) {
904 if (_transport_speed == 1.0) {
905 frames_moved = (framecnt_t) nframes;
907 interpolation.set_target_speed (_target_transport_speed);
908 interpolation.set_speed (_transport_speed);
909 frames_moved = (framecnt_t) interpolation.interpolate (0, nframes, 0, 0);
912 if (!_exporting && !timecode_transmission_suspended()) {
913 send_midi_time_code_for_cycle (_transport_frame, _transport_frame + frames_moved, nframes);
916 ltc_tx_send_time_code_for_cycle (_transport_frame, _transport_frame + frames_moved, _target_transport_speed, _transport_speed, nframes);
918 framepos_t const stop_limit = compute_stop_limit ();
920 if (maybe_stop (stop_limit)) {
925 if (maybe_sync_start (nframes)) {
929 click (_transport_frame, nframes);
931 if (process_routes (nframes, session_needs_butler)) {
936 get_track_statistics ();
938 if (frames_moved < 0) {
939 decrement_transport_position (-frames_moved);
941 increment_transport_position (frames_moved);
944 maybe_stop (stop_limit);
945 check_declick_out ();
947 if (session_needs_butler) {
948 DEBUG_TRACE (DEBUG::Butler, "p-without-events: session needs butler, call it\n");
953 /** Process callback used when the auditioner is active.
954 * @param nframes number of frames to process.
957 Session::process_audition (pframes_t nframes)
960 boost::shared_ptr<RouteList> r = routes.reader ();
962 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
963 if (!(*i)->is_auditioner()) {
964 (*i)->silence (nframes);
968 /* run the auditioner, and if it says we need butler service, ask for it */
970 if (auditioner->play_audition (nframes) > 0) {
971 DEBUG_TRACE (DEBUG::Butler, "auditioner needs butler, call it\n");
975 /* if using a monitor section, run it because otherwise we don't hear anything */
977 if (_monitor_out && auditioner->needs_monitor()) {
978 _monitor_out->monitor_run (_transport_frame, _transport_frame + nframes, nframes, false);
981 /* handle pending events */
983 while (pending_events.read (&ev, 1) == 1) {
987 /* if we are not in the middle of a state change,
988 and there are immediate events queued up,
992 while (!non_realtime_work_pending() && !immediate_events.empty()) {
993 SessionEvent *ev = immediate_events.front ();
994 immediate_events.pop_front ();
998 if (!auditioner->auditioning()) {
999 /* auditioner no longer active, so go back to the normal process callback */
1000 process_function = &Session::process_with_events;
1005 Session::maybe_sync_start (pframes_t & nframes)
1007 pframes_t sync_offset;
1009 if (!waiting_for_sync_offset) {
1013 if (_engine.get_sync_offset (sync_offset) && sync_offset < nframes) {
1015 /* generate silence up to the sync point, then
1016 adjust nframes + offset to reflect whatever
1020 no_roll (sync_offset);
1021 nframes -= sync_offset;
1022 Port::increment_global_port_buffer_offset (sync_offset);
1023 waiting_for_sync_offset = false;
1026 return true; // done, nothing left to process
1031 /* sync offset point is not within this process()
1032 cycle, so just generate silence. and don't bother
1033 with any fancy stuff here, just the minimal silence.
1038 if (Config->get_locate_while_waiting_for_sync()) {
1039 if (micro_locate (nframes)) {
1040 /* XXX ERROR !!! XXX */
1044 return true; // done, nothing left to process
1051 Session::queue_event (SessionEvent* ev)
1053 if (_state_of_the_state & Deletion) {
1055 } else if (_state_of_the_state & Loading) {
1058 Glib::Threads::Mutex::Lock lm (rb_write_lock);
1059 pending_events.write (&ev, 1);
1064 Session::set_next_event ()
1066 if (events.empty()) {
1067 next_event = events.end();
1071 if (next_event == events.end()) {
1072 next_event = events.begin();
1075 if ((*next_event)->action_frame > _transport_frame) {
1076 next_event = events.begin();
1079 for (; next_event != events.end(); ++next_event) {
1080 if ((*next_event)->action_frame >= _transport_frame) {
1087 Session::process_event (SessionEvent* ev)
1092 /* if we're in the middle of a state change (i.e. waiting
1093 for the butler thread to complete the non-realtime
1094 part of the change), we'll just have to queue this
1095 event for a time when the change is complete.
1098 if (non_realtime_work_pending()) {
1100 /* except locates, which we have the capability to handle */
1102 if (ev->type != SessionEvent::Locate) {
1103 immediate_events.insert (immediate_events.end(), ev);
1109 DEBUG_TRACE (DEBUG::SessionEvents, string_compose ("Processing event: %1 @ %2\n", enum_2_string (ev->type), _transport_frame));
1112 case SessionEvent::SetLoop:
1113 set_play_loop (ev->yes_or_no, ev->speed);
1116 case SessionEvent::AutoLoop:
1118 /* roll after locate, do not flush, set "with loop"
1119 true only if we are seamless looping
1121 start_locate (ev->target_frame, true, false, Config->get_seamless_loop());
1127 case SessionEvent::AutoLoopDeclick:
1129 /* Request a declick fade-out and a fade-in; the fade-out will happen
1130 at the end of the loop, and the fade-in at the start.
1132 transport_sub_state |= (PendingLoopDeclickOut | PendingLoopDeclickIn);
1138 case SessionEvent::Locate:
1139 if (ev->yes_or_no) {
1140 /* args: do not roll after locate, do flush, not with loop */
1141 locate (ev->target_frame, false, true, false);
1143 /* args: do not roll after locate, do flush, not with loop */
1144 start_locate (ev->target_frame, false, true, false);
1146 _send_timecode_update = true;
1149 case SessionEvent::LocateRoll:
1150 if (ev->yes_or_no) {
1151 /* args: roll after locate, do flush, not with loop */
1152 locate (ev->target_frame, true, true, false);
1154 /* args: roll after locate, do flush, not with loop */
1155 start_locate (ev->target_frame, true, true, false);
1157 _send_timecode_update = true;
1160 case SessionEvent::Skip:
1161 if (Config->get_skip_playback()) {
1162 start_locate (ev->target_frame, true, true, false);
1163 _send_timecode_update = true;
1169 case SessionEvent::LocateRollLocate:
1170 // locate is handled by ::request_roll_at_and_return()
1171 _requested_return_frame = ev->target_frame;
1172 request_locate (ev->target2_frame, true);
1176 case SessionEvent::SetTransportSpeed:
1177 set_transport_speed (ev->speed, ev->target_frame, ev->yes_or_no, ev->second_yes_or_no, ev->third_yes_or_no);
1180 case SessionEvent::PunchIn:
1181 // cerr << "PunchIN at " << transport_frame() << endl;
1182 if (config.get_punch_in() && record_status() == Enabled && !preroll_record_punch_enabled()) {
1189 case SessionEvent::PunchOut:
1190 // cerr << "PunchOUT at " << transport_frame() << endl;
1191 if (config.get_punch_out() && !preroll_record_punch_enabled()) {
1192 step_back_from_record ();
1198 case SessionEvent::RecordStart:
1199 if (preroll_record_punch_enabled() && record_status() == Enabled) {
1206 case SessionEvent::StopOnce:
1207 if (!non_realtime_work_pending()) {
1208 _clear_event_type (SessionEvent::StopOnce);
1209 stop_transport (ev->yes_or_no);
1215 case SessionEvent::RangeStop:
1216 if (!non_realtime_work_pending()) {
1217 stop_transport (ev->yes_or_no);
1223 case SessionEvent::RangeLocate:
1224 /* args: roll after locate, do flush, not with loop */
1225 start_locate (ev->target_frame, true, true, false);
1230 case SessionEvent::Overwrite:
1231 overwrite_some_buffers (static_cast<Track*>(ev->ptr));
1234 case SessionEvent::SetSyncSource:
1235 DEBUG_TRACE (DEBUG::Slave, "seen request for new slave\n");
1236 use_sync_source (ev->slave);
1239 case SessionEvent::Audition:
1240 set_audition (ev->region);
1241 // drop reference to region
1242 ev->region.reset ();
1245 case SessionEvent::SetPlayAudioRange:
1246 set_play_range (ev->audio_range, (ev->speed == 1.0f));
1249 case SessionEvent::CancelPlayAudioRange:
1253 case SessionEvent::RealTimeOperation:
1255 del = false; // other side of RT request needs to clean up
1258 case SessionEvent::AdjustPlaybackBuffering:
1259 schedule_playback_buffering_adjustment ();
1262 case SessionEvent::AdjustCaptureBuffering:
1263 schedule_capture_buffering_adjustment ();
1266 case SessionEvent::SetTimecodeTransmission:
1267 g_atomic_int_set (&_suspend_timecode_transmission, ev->yes_or_no ? 0 : 1);
1271 fatal << string_compose(_("Programming error: illegal event type in process_event (%1)"), ev->type) << endmsg;
1272 abort(); /*NOTREACHED*/
1277 del = del && !_remove_event (ev);
1286 Session::compute_stop_limit () const
1288 if (!Config->get_stop_at_session_end ()) {
1289 return max_framepos;
1293 return max_framepos;
1296 if (preroll_record_punch_enabled ()) {
1297 return max_framepos;
1300 bool const punching_in = (config.get_punch_in () && _locations->auto_punch_location());
1301 bool const punching_out = (config.get_punch_out () && _locations->auto_punch_location());
1303 if (actively_recording ()) {
1304 /* permanently recording */
1305 return max_framepos;
1306 } else if (punching_in && !punching_out) {
1307 /* punching in but never out */
1308 return max_framepos;
1309 } else if (punching_in && punching_out && _locations->auto_punch_location()->end() > current_end_frame()) {
1310 /* punching in and punching out after session end */
1311 return max_framepos;
1314 return current_end_frame ();
1319 /* dedicated thread for signal emission.
1321 * while sending cross-thread signals from the process thread
1322 * is fine in general, PBD::Signal's use of boost::function and
1323 * boost:bind can produce a vast overhead which is not
1324 * acceptable for low latency.
1326 * This works around the issue by moving the boost overhead
1327 * out of the RT thread. The overall load is probably higher but
1328 * the realtime thread remains unaffected.
1332 Session::emit_route_signals ()
1334 // TODO use RAII to allow using these signals in other places
1335 BatchUpdateStart(); /* EMIT SIGNAL */
1336 boost::shared_ptr<RouteList> r = routes.reader ();
1337 for (RouteList::const_iterator ci = r->begin(); ci != r->end(); ++ci) {
1338 (*ci)->emit_pending_signals ();
1340 BatchUpdateEnd(); /* EMIT SIGNAL */
1344 Session::emit_thread_start ()
1346 if (_rt_thread_active) {
1349 _rt_thread_active = true;
1351 if (pthread_create (&_rt_emit_thread, NULL, emit_thread, this)) {
1352 _rt_thread_active = false;
1357 Session::emit_thread_terminate ()
1359 if (!_rt_thread_active) {
1362 _rt_thread_active = false;
1364 if (pthread_mutex_lock (&_rt_emit_mutex) == 0) {
1365 pthread_cond_signal (&_rt_emit_cond);
1366 pthread_mutex_unlock (&_rt_emit_mutex);
1370 pthread_join (_rt_emit_thread, &status);
1374 Session::emit_thread (void *arg)
1376 Session *s = static_cast<Session *>(arg);
1377 s->emit_thread_run ();
1383 Session::emit_thread_run ()
1385 pthread_mutex_lock (&_rt_emit_mutex);
1386 while (_rt_thread_active) {
1387 emit_route_signals();
1388 pthread_cond_wait (&_rt_emit_cond, &_rt_emit_mutex);
1390 pthread_mutex_unlock (&_rt_emit_mutex);