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/disk_reader.h"
36 #include "ardour/graph.h"
37 #include "ardour/port.h"
38 #include "ardour/process_thread.h"
39 #include "ardour/scene_changer.h"
40 #include "ardour/session.h"
41 #include "ardour/slave.h"
42 #include "ardour/ticker.h"
43 #include "ardour/types.h"
44 #include "ardour/vca.h"
45 #include "ardour/vca_manager.h"
47 #include "midi++/mmc.h"
51 using namespace ARDOUR;
55 /** Called by the audio engine when there is work to be done with JACK.
56 * @param nframes Number of samples to process.
60 Session::process (pframes_t nframes)
62 samplepos_t transport_at_start = _transport_sample;
66 if (processing_blocked()) {
71 if (non_realtime_work_pending()) {
72 if (!_butler->transport_work_requested ()) {
77 _engine.main_thread()->get_buffers ();
79 (this->*process_function) (nframes);
81 /* realtime-safe meter-position and processor-order changes
83 * ideally this would be done in
84 * Route::process_output_buffers() but various functions
85 * callig it hold a _processor_lock reader-lock
87 boost::shared_ptr<RouteList> r = routes.reader ();
88 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
89 if ((*i)->apply_processor_changes_rt()) {
90 _rt_emit_pending = true;
93 if (_rt_emit_pending) {
94 if (!_rt_thread_active) {
95 emit_route_signals ();
97 if (pthread_mutex_trylock (&_rt_emit_mutex) == 0) {
98 pthread_cond_signal (&_rt_emit_cond);
99 pthread_mutex_unlock (&_rt_emit_mutex);
100 _rt_emit_pending = false;
104 _engine.main_thread()->drop_buffers ();
106 /* deliver MIDI clock. Note that we need to use the transport sample
107 * position at the start of process(), not the value at the end of
108 * it. We may already have ticked() because of a transport state
109 * change, for example.
113 if (!_silent && !_engine.freewheeling() && Config->get_send_midi_clock() && (transport_speed() == 1.0f || transport_speed() == 0.0f) && midi_clock->has_midi_port()) {
114 midi_clock->tick (transport_at_start, nframes);
117 _scene_changer->run (transport_at_start, transport_at_start + nframes);
120 /* don't bother with a message */
123 SendFeedback (); /* EMIT SIGNAL */
127 Session::fail_roll (pframes_t nframes)
129 return no_roll (nframes);
133 Session::no_roll (pframes_t nframes)
137 samplepos_t end_sample = _transport_sample + nframes; // FIXME: varispeed + no_roll ??
139 int declick = (config.get_use_transport_fades() ? get_transport_declick_required() : false);
140 boost::shared_ptr<RouteList> r = routes.reader ();
143 _click_io->silence (nframes);
146 ltc_tx_send_time_code_for_cycle (_transport_sample, end_sample, _target_transport_speed, _transport_speed, nframes);
148 VCAList v = _vca_manager->vcas ();
149 for (VCAList::const_iterator i = v.begin(); i != v.end(); ++i) {
150 (*i)->automation_run (_transport_sample, nframes);
153 if (_process_graph) {
154 DEBUG_TRACE(DEBUG::ProcessThreads,"calling graph/no-roll\n");
155 _process_graph->routes_no_roll( nframes, _transport_sample, end_sample, non_realtime_work_pending(), declick);
157 PT_TIMING_CHECK (10);
158 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
160 if ((*i)->is_auditioner()) {
164 (*i)->set_pending_declick (declick);
166 if ((*i)->no_roll (nframes, _transport_sample, end_sample, non_realtime_work_pending())) {
167 error << string_compose(_("Session: error in no roll for %1"), (*i)->name()) << endmsg;
172 PT_TIMING_CHECK (11);
179 /** @param need_butler to be set to true by this method if it needs the butler,
180 * otherwise it must be left alone.
183 Session::process_routes (pframes_t nframes, bool& need_butler)
185 int declick = (config.get_use_transport_fades() ? get_transport_declick_required() : false);
186 boost::shared_ptr<RouteList> r = routes.reader ();
188 const samplepos_t start_sample = _transport_sample;
189 const samplepos_t end_sample = _transport_sample + floor (nframes * _transport_speed);
191 VCAList v = _vca_manager->vcas ();
192 for (VCAList::const_iterator i = v.begin(); i != v.end(); ++i) {
193 (*i)->automation_run (start_sample, nframes);
196 _global_locate_pending = locate_pending ();
198 if (_process_graph) {
199 DEBUG_TRACE(DEBUG::ProcessThreads,"calling graph/process-routes\n");
200 if (_process_graph->process_routes (nframes, start_sample, end_sample, declick, need_butler) < 0) {
206 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
210 if ((*i)->is_auditioner()) {
214 (*i)->set_pending_declick (declick);
218 if ((ret = (*i)->roll (nframes, start_sample, end_sample, declick, b)) < 0) {
224 DEBUG_TRACE (DEBUG::Butler, string_compose ("%1 rolled and needs butler\n", (*i)->name()));
234 Session::get_track_statistics ()
239 boost::shared_ptr<RouteList> rl = routes.reader();
240 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
242 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
244 if (!tr || tr->is_private_route()) {
248 pworst = min (pworst, tr->playback_buffer_load());
249 cworst = min (cworst, tr->capture_buffer_load());
252 g_atomic_int_set (&_playback_load, (uint32_t) floor (pworst * 100.0f));
253 g_atomic_int_set (&_capture_load, (uint32_t) floor (cworst * 100.0f));
255 if (actively_recording()) {
260 /** Process callback used when the auditioner is not active */
262 Session::process_with_events (pframes_t nframes)
267 pframes_t this_nframes;
268 samplepos_t end_sample;
269 bool session_needs_butler = false;
270 samplecnt_t samples_moved;
272 /* make sure the auditioner is silent */
275 auditioner->silence (nframes);
278 /* handle any pending events */
280 while (pending_events.read (&ev, 1) == 1) {
284 /* if we are not in the middle of a state change,
285 and there are immediate events queued up,
289 while (!non_realtime_work_pending() && !immediate_events.empty()) {
290 SessionEvent *ev = immediate_events.front ();
291 immediate_events.pop_front ();
296 if (_transport_speed != 1.0 && _count_in_samples > 0) {
297 _count_in_samples = 0;
300 if (_count_in_samples > 0) {
301 samplecnt_t ns = std::min ((samplecnt_t)nframes, _count_in_samples);
304 run_click (_transport_sample - _count_in_samples, ns);
306 _count_in_samples -= ns;
309 /* process events.. */
310 if (!events.empty() && next_event != events.end()) {
311 SessionEvent* this_event = *next_event;
312 Events::iterator the_next_one = next_event;
315 while (this_event && this_event->action_sample == _transport_sample) {
316 process_event (this_event);
317 if (the_next_one == events.end()) {
320 this_event = *the_next_one;
327 check_declick_out ();
332 _engine.split_cycle (ns);
336 /* Decide on what to do with quarter-frame MTC during this cycle */
338 bool const was_sending_qf_mtc = _send_qf_mtc;
339 double const tolerance = Config->get_mtc_qf_speed_tolerance() / 100.0;
341 if (_transport_speed != 0) {
343 Config->get_send_mtc () &&
344 _transport_speed >= (1 - tolerance) &&
345 _transport_speed <= (1 + tolerance)
348 if (_send_qf_mtc && !was_sending_qf_mtc) {
349 /* we will re-start quarter-frame MTC this cycle, so send a full update to set things up */
350 _send_timecode_update = true;
353 if (Config->get_send_mtc() && !_send_qf_mtc && _pframes_since_last_mtc > (sample_rate () / 4)) {
354 /* we're sending MTC, but we're not sending QF MTC at the moment, and it's been
355 a quarter of a second since we sent anything at all, so send a full MTC update
358 _send_timecode_update = true;
361 _pframes_since_last_mtc += nframes;
364 /* Events caused a transport change (or we re-started sending
365 * MTC), so send an MTC Full Frame (Timecode) message. This
366 * is sent whether rolling or not, to give slaves an idea of
367 * ardour time on locates (and allow slow slaves to position
368 * and prepare for rolling)
370 if (_send_timecode_update) {
371 send_full_time_code (_transport_sample, nframes);
374 if (!process_can_proceed()) {
379 if (events.empty() || next_event == events.end()) {
380 try_run_lua (nframes); // also during export ?? ->move to process_without_events()
381 /* lua scripts may inject events */
382 while (_n_lua_scripts > 0 && pending_events.read (&ev, 1) == 1) {
385 if (events.empty() || next_event == events.end()) {
386 process_without_events (nframes);
391 if (_transport_speed == 1.0) {
392 samples_moved = (samplecnt_t) nframes;
394 interpolation.set_target_speed (_target_transport_speed);
395 interpolation.set_speed (_transport_speed);
396 samples_moved = (samplecnt_t) interpolation.interpolate (0, nframes, 0, 0);
399 end_sample = _transport_sample + samples_moved;
402 SessionEvent* this_event;
403 Events::iterator the_next_one;
405 if (!process_can_proceed()) {
410 if (!_exporting && _slave) {
411 if (!follow_slave (nframes)) {
416 if (_transport_speed == 0) {
421 if (!_exporting && !timecode_transmission_suspended()) {
422 send_midi_time_code_for_cycle (_transport_sample, end_sample, nframes);
425 ltc_tx_send_time_code_for_cycle (_transport_sample, end_sample, _target_transport_speed, _transport_speed, nframes);
427 samplepos_t stop_limit = compute_stop_limit ();
429 if (maybe_stop (stop_limit)) {
434 this_event = *next_event;
435 the_next_one = next_event;
438 /* yes folks, here it is, the actual loop where we really truly
444 this_nframes = nframes; /* real (jack) time relative */
445 samples_moved = (samplecnt_t) floor (_transport_speed * nframes); /* transport relative */
447 /* running an event, position transport precisely to its time */
448 if (this_event && this_event->action_sample <= end_sample && this_event->action_sample >= _transport_sample) {
449 /* this isn't quite right for reverse play */
450 samples_moved = (samplecnt_t) (this_event->action_sample - _transport_sample);
451 this_nframes = abs (floor(samples_moved / _transport_speed));
454 try_run_lua (this_nframes);
458 click (_transport_sample, this_nframes);
460 if (process_routes (this_nframes, session_needs_butler)) {
465 get_track_statistics ();
467 nframes -= this_nframes;
469 if (samples_moved < 0) {
470 decrement_transport_position (-samples_moved);
471 } else if (samples_moved) {
472 increment_transport_position (samples_moved);
475 maybe_stop (stop_limit);
476 check_declick_out ();
480 _engine.split_cycle (this_nframes);
483 /* now handle this event and all others scheduled for the same time */
485 while (this_event && this_event->action_sample == _transport_sample) {
486 process_event (this_event);
488 if (the_next_one == events.end()) {
491 this_event = *the_next_one;
496 /* if an event left our state changing, do the right thing */
498 if (nframes && non_realtime_work_pending()) {
503 /* this is necessary to handle the case of seamless looping */
504 end_sample = _transport_sample + floor (nframes * _transport_speed);
509 } /* implicit release of route lock */
511 if (session_needs_butler) {
512 DEBUG_TRACE (DEBUG::Butler, "p-with-events: session needs butler, call it\n");
518 Session::reset_slave_state ()
520 average_slave_delta = 1800;
521 delta_accumulator_cnt = 0;
522 have_first_delta_accumulator = false;
523 _slave_state = Stopped;
524 DiskReader::set_no_disk_output (false);
528 Session::transport_locked () const
532 if (!locate_pending() && (!config.get_external_sync() || (sl && sl->ok() && sl->locked()))) {
540 Session::follow_slave (pframes_t nframes)
543 samplepos_t slave_transport_sample;
544 samplecnt_t this_delta;
549 config.set_external_sync (false);
553 _slave->speed_and_position (slave_speed, slave_transport_sample);
555 DEBUG_TRACE (DEBUG::Slave, string_compose ("Slave position %1 speed %2\n", slave_transport_sample, slave_speed));
557 if (!_slave->locked()) {
558 DEBUG_TRACE (DEBUG::Slave, "slave not locked\n");
562 if (slave_transport_sample > _transport_sample) {
563 this_delta = slave_transport_sample - _transport_sample;
566 this_delta = _transport_sample - slave_transport_sample;
570 if (_slave->starting()) {
574 if (_slave->is_always_synced() ||
575 (Config->get_timecode_source_is_synced() && (dynamic_cast<TimecodeSlave*>(_slave)) != 0)
578 /* if the TC source is synced, then we assume that its
579 speed is binary: 0.0 or 1.0
582 if (slave_speed != 0.0f) {
588 /* if we are chasing and the average delta between us and the
589 master gets too big, we want to switch to silent
590 motion. so keep track of that here.
593 if (_slave_state == Running) {
594 calculate_moving_average_of_slave_delta(dir, abs(this_delta));
598 track_slave_state (slave_speed, slave_transport_sample, this_delta);
600 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave state %1 @ %2 speed %3 cur delta %4 avg delta %5\n",
601 _slave_state, slave_transport_sample, slave_speed, this_delta, average_slave_delta));
604 if (_slave_state == Running && !_slave->is_always_synced() && !(Config->get_timecode_source_is_synced() && (dynamic_cast<TimecodeSlave*>(_slave)) != 0)) {
606 /* may need to varispeed to sync with slave */
608 if (_transport_speed != 0.0f) {
611 note that average_dir is +1 or -1
616 if (average_slave_delta == 0) {
620 delta = average_slave_delta;
621 delta *= average_dir;
625 if (slave_speed != 0.0) {
626 DEBUG_TRACE (DEBUG::Slave, string_compose ("delta = %1 speed = %2 ts = %3 M@%4 S@%5 avgdelta %6\n",
627 (int) (dir * this_delta),
631 slave_transport_sample,
632 average_slave_delta));
636 if (_slave->give_slave_full_control_over_transport_speed()) {
637 set_transport_speed (slave_speed, 0, false, false);
638 //std::cout << "set speed = " << slave_speed << "\n";
640 float adjusted_speed = slave_speed + (1.5 * (delta / float(_current_sample_rate)));
641 request_transport_speed (adjusted_speed);
642 DEBUG_TRACE (DEBUG::Slave, string_compose ("adjust using %1 towards %2 ratio %3 current %4 slave @ %5\n",
643 delta, adjusted_speed, adjusted_speed/slave_speed, _transport_speed,
647 if (!actively_recording() && (samplecnt_t) average_slave_delta > _slave->resolution()) {
648 DEBUG_TRACE (DEBUG::Slave, string_compose ("average slave delta %1 greater than slave resolution %2 => no disk output\n", average_slave_delta, _slave->resolution()));
649 /* run routes as normal, but no disk output */
650 DiskReader::set_no_disk_output (true);
654 if (!have_first_delta_accumulator) {
655 DEBUG_TRACE (DEBUG::Slave, "waiting for first slave delta accumulator to be ready, no disk output\n");
656 /* run routes as normal, but no disk output */
657 DiskReader::set_no_disk_output (true);
664 if (!have_first_delta_accumulator) {
665 DEBUG_TRACE (DEBUG::Slave, "still waiting to compute slave delta, no disk output\n");
666 DiskReader::set_no_disk_output (true);
668 DiskReader::set_no_disk_output (false);
671 if ((_slave_state == Running) && (0 == (post_transport_work () & ~PostTransportSpeed))) {
672 /* speed is set, we're locked, and good to go */
677 /* don't move at all */
678 DEBUG_TRACE (DEBUG::Slave, "no roll\n")
684 Session::calculate_moving_average_of_slave_delta (int dir, samplecnt_t this_delta)
686 if (delta_accumulator_cnt >= delta_accumulator_size) {
687 have_first_delta_accumulator = true;
688 delta_accumulator_cnt = 0;
691 if (delta_accumulator_cnt != 0 || this_delta < _current_sample_rate) {
692 delta_accumulator[delta_accumulator_cnt++] = (samplecnt_t) dir * (samplecnt_t) this_delta;
695 if (have_first_delta_accumulator) {
696 average_slave_delta = 0L;
697 for (int i = 0; i < delta_accumulator_size; ++i) {
698 average_slave_delta += delta_accumulator[i];
700 average_slave_delta /= (int32_t) delta_accumulator_size;
701 if (average_slave_delta < 0L) {
703 average_slave_delta = average_slave_delta;
711 Session::track_slave_state (float slave_speed, samplepos_t slave_transport_sample, samplecnt_t /*this_delta*/)
713 if (slave_speed != 0.0f) {
715 /* slave is running */
717 switch (_slave_state) {
719 if (_slave->requires_seekahead()) {
720 slave_wait_end = slave_transport_sample + _slave->seekahead_distance ();
721 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped, but running, requires seekahead to %1\n", slave_wait_end));
722 /* we can call locate() here because we are in process context */
723 locate (slave_wait_end, false, false);
724 _slave_state = Waiting;
728 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped -> running at %1\n", slave_transport_sample));
730 memset (delta_accumulator, 0, sizeof (int32_t) * delta_accumulator_size);
731 average_slave_delta = 0L;
733 Location* al = _locations->auto_loop_location();
735 if (al && play_loop && (slave_transport_sample < al->start() || slave_transport_sample > al->end())) {
737 request_play_loop(false);
740 if (slave_transport_sample != _transport_sample) {
741 DEBUG_TRACE (DEBUG::Slave, string_compose ("require locate to run. eng: %1 -> sl: %2\n", _transport_sample, slave_transport_sample));
742 locate (slave_transport_sample, false, false);
744 _slave_state = Running;
753 if (_slave_state == Waiting) {
755 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave waiting at %1\n", slave_transport_sample));
757 if (slave_transport_sample >= slave_wait_end) {
759 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave start at %1 vs %2\n", slave_transport_sample, _transport_sample));
761 _slave_state = Running;
763 /* now perform a "micro-seek" within the disk buffers to realign ourselves
764 precisely with the master.
769 samplecnt_t sample_delta = slave_transport_sample - _transport_sample;
771 boost::shared_ptr<RouteList> rl = routes.reader();
772 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
773 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
774 if (tr && !tr->can_internal_playback_seek (sample_delta)) {
781 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
782 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
784 tr->internal_playback_seek (sample_delta);
787 _transport_sample += sample_delta;
790 cerr << "cannot micro-seek\n";
796 if (_slave_state == Running && _transport_speed == 0.0f) {
797 DEBUG_TRACE (DEBUG::Slave, "slave starts transport\n");
801 } else { // slave_speed is 0
803 /* slave has stopped */
805 if (_transport_speed != 0.0f) {
806 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stops transport: %1 sample %2 tf %3\n", slave_speed, slave_transport_sample, _transport_sample));
810 if (slave_transport_sample != _transport_sample) {
811 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped, move to %1\n", slave_transport_sample));
812 force_locate (slave_transport_sample, false);
820 Session::process_without_events (pframes_t nframes)
822 bool session_needs_butler = false;
823 samplecnt_t samples_moved;
825 if (!process_can_proceed()) {
830 if (!_exporting && _slave) {
831 if (!follow_slave (nframes)) {
832 ltc_tx_send_time_code_for_cycle (_transport_sample, _transport_sample, 0, 0 , nframes);
837 if (_transport_speed == 0) {
842 if (_transport_speed == 1.0) {
843 samples_moved = (samplecnt_t) nframes;
845 interpolation.set_target_speed (_target_transport_speed);
846 interpolation.set_speed (_transport_speed);
847 samples_moved = (samplecnt_t) interpolation.interpolate (0, nframes, 0, 0);
850 if (!_exporting && !timecode_transmission_suspended()) {
851 send_midi_time_code_for_cycle (_transport_sample, _transport_sample + samples_moved, nframes);
854 ltc_tx_send_time_code_for_cycle (_transport_sample, _transport_sample + samples_moved, _target_transport_speed, _transport_speed, nframes);
856 samplepos_t const stop_limit = compute_stop_limit ();
858 if (maybe_stop (stop_limit)) {
863 if (maybe_sync_start (nframes)) {
867 click (_transport_sample, nframes);
869 if (process_routes (nframes, session_needs_butler)) {
874 get_track_statistics ();
876 if (samples_moved < 0) {
877 decrement_transport_position (-samples_moved);
878 } else if (samples_moved) {
879 increment_transport_position (samples_moved);
882 maybe_stop (stop_limit);
883 check_declick_out ();
885 if (session_needs_butler) {
886 DEBUG_TRACE (DEBUG::Butler, "p-without-events: session needs butler, call it\n");
891 /** Process callback used when the auditioner is active.
892 * @param nframes number of samples to process.
895 Session::process_audition (pframes_t nframes)
898 boost::shared_ptr<RouteList> r = routes.reader ();
900 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
901 if (!(*i)->is_auditioner()) {
902 (*i)->silence (nframes);
906 /* run the auditioner, and if it says we need butler service, ask for it */
908 if (auditioner->play_audition (nframes) > 0) {
909 DEBUG_TRACE (DEBUG::Butler, "auditioner needs butler, call it\n");
913 /* if using a monitor section, run it because otherwise we don't hear anything */
915 if (_monitor_out && auditioner->needs_monitor()) {
916 _monitor_out->monitor_run (_transport_sample, _transport_sample + nframes, nframes, false);
919 /* handle pending events */
921 while (pending_events.read (&ev, 1) == 1) {
925 /* if we are not in the middle of a state change,
926 and there are immediate events queued up,
930 while (!non_realtime_work_pending() && !immediate_events.empty()) {
931 SessionEvent *ev = immediate_events.front ();
932 immediate_events.pop_front ();
936 if (!auditioner->auditioning()) {
937 /* auditioner no longer active, so go back to the normal process callback */
938 process_function = &Session::process_with_events;
943 Session::maybe_sync_start (pframes_t & nframes)
945 pframes_t sync_offset;
947 if (!waiting_for_sync_offset) {
951 if (_engine.get_sync_offset (sync_offset) && sync_offset < nframes) {
953 /* generate silence up to the sync point, then
954 adjust nframes + offset to reflect whatever
958 no_roll (sync_offset);
959 nframes -= sync_offset;
960 Port::increment_global_port_buffer_offset (sync_offset);
961 waiting_for_sync_offset = false;
964 return true; // done, nothing left to process
969 /* sync offset point is not within this process()
970 cycle, so just generate silence. and don't bother
971 with any fancy stuff here, just the minimal silence.
976 if (Config->get_locate_while_waiting_for_sync()) {
977 if (micro_locate (nframes)) {
978 /* XXX ERROR !!! XXX */
982 return true; // done, nothing left to process
989 Session::queue_event (SessionEvent* ev)
991 if (_state_of_the_state & Deletion) {
993 } else if (_state_of_the_state & Loading) {
996 Glib::Threads::Mutex::Lock lm (rb_write_lock);
997 pending_events.write (&ev, 1);
1002 Session::set_next_event ()
1004 if (events.empty()) {
1005 next_event = events.end();
1009 if (next_event == events.end()) {
1010 next_event = events.begin();
1013 if ((*next_event)->action_sample > _transport_sample) {
1014 next_event = events.begin();
1017 for (; next_event != events.end(); ++next_event) {
1018 if ((*next_event)->action_sample >= _transport_sample) {
1025 Session::process_event (SessionEvent* ev)
1030 /* if we're in the middle of a state change (i.e. waiting
1031 for the butler thread to complete the non-realtime
1032 part of the change), we'll just have to queue this
1033 event for a time when the change is complete.
1036 if (non_realtime_work_pending()) {
1038 /* except locates, which we have the capability to handle */
1040 if (ev->type != SessionEvent::Locate) {
1041 immediate_events.insert (immediate_events.end(), ev);
1047 DEBUG_TRACE (DEBUG::SessionEvents, string_compose ("Processing event: %1 @ %2\n", enum_2_string (ev->type), _transport_sample));
1050 case SessionEvent::SetLoop:
1051 set_play_loop (ev->yes_or_no, ev->speed);
1054 case SessionEvent::AutoLoop:
1056 /* roll after locate, do not flush, set "with loop"
1057 true only if we are seamless looping
1059 start_locate (ev->target_sample, true, false, Config->get_seamless_loop());
1065 case SessionEvent::AutoLoopDeclick:
1067 /* Request a declick fade-out and a fade-in; the fade-out will happen
1068 at the end of the loop, and the fade-in at the start.
1070 transport_sub_state |= (PendingLoopDeclickOut | PendingLoopDeclickIn);
1076 case SessionEvent::Locate:
1077 if (ev->yes_or_no) { /* force locate */
1078 /* args: do not roll after locate, do flush, not with loop */
1079 locate (ev->target_sample, false, true, false);
1081 /* args: do not roll after locate, do flush, not with loop */
1082 start_locate (ev->target_sample, false, true, false);
1084 _send_timecode_update = true;
1087 case SessionEvent::LocateRoll:
1088 if (ev->yes_or_no) {
1089 /* args: roll after locate, do flush, not with loop */
1090 locate (ev->target_sample, true, true, false);
1092 /* args: roll after locate, do flush, not with loop */
1093 start_locate (ev->target_sample, true, true, false);
1095 _send_timecode_update = true;
1098 case SessionEvent::Skip:
1099 if (Config->get_skip_playback()) {
1100 start_locate (ev->target_sample, true, true, false);
1101 _send_timecode_update = true;
1107 case SessionEvent::LocateRollLocate:
1108 // locate is handled by ::request_roll_at_and_return()
1109 _requested_return_sample = ev->target_sample;
1110 request_locate (ev->target2_sample, true);
1114 case SessionEvent::SetTransportSpeed:
1115 set_transport_speed (ev->speed, ev->target_sample, ev->yes_or_no, ev->second_yes_or_no, ev->third_yes_or_no);
1118 case SessionEvent::PunchIn:
1119 // cerr << "PunchIN at " << transport_sample() << endl;
1120 if (config.get_punch_in() && record_status() == Enabled && !preroll_record_punch_enabled()) {
1127 case SessionEvent::PunchOut:
1128 // cerr << "PunchOUT at " << transport_sample() << endl;
1129 if (config.get_punch_out() && !preroll_record_punch_enabled()) {
1130 step_back_from_record ();
1136 case SessionEvent::RecordStart:
1137 if (preroll_record_punch_enabled() && record_status() == Enabled) {
1144 case SessionEvent::StopOnce:
1145 if (!non_realtime_work_pending()) {
1146 _clear_event_type (SessionEvent::StopOnce);
1147 stop_transport (ev->yes_or_no);
1153 case SessionEvent::RangeStop:
1154 if (!non_realtime_work_pending()) {
1155 stop_transport (ev->yes_or_no);
1161 case SessionEvent::RangeLocate:
1162 /* args: roll after locate, do flush, not with loop */
1163 start_locate (ev->target_sample, true, true, false);
1168 case SessionEvent::Overwrite:
1169 overwrite_some_buffers (static_cast<Track*>(ev->ptr));
1172 case SessionEvent::SetSyncSource:
1173 DEBUG_TRACE (DEBUG::Slave, "seen request for new slave\n");
1174 use_sync_source (ev->slave);
1177 case SessionEvent::Audition:
1178 set_audition (ev->region);
1179 // drop reference to region
1180 ev->region.reset ();
1183 case SessionEvent::SetPlayAudioRange:
1184 set_play_range (ev->audio_range, (ev->speed == 1.0f));
1187 case SessionEvent::CancelPlayAudioRange:
1191 case SessionEvent::RealTimeOperation:
1193 del = false; // other side of RT request needs to clean up
1196 case SessionEvent::AdjustPlaybackBuffering:
1197 schedule_playback_buffering_adjustment ();
1200 case SessionEvent::AdjustCaptureBuffering:
1201 schedule_capture_buffering_adjustment ();
1204 case SessionEvent::SetTimecodeTransmission:
1205 g_atomic_int_set (&_suspend_timecode_transmission, ev->yes_or_no ? 0 : 1);
1209 fatal << string_compose(_("Programming error: illegal event type in process_event (%1)"), ev->type) << endmsg;
1210 abort(); /*NOTREACHED*/
1215 del = del && !_remove_event (ev);
1224 Session::compute_stop_limit () const
1226 if (!Config->get_stop_at_session_end ()) {
1227 return max_samplepos;
1231 return max_samplepos;
1234 if (preroll_record_punch_enabled ()) {
1235 return max_samplepos;
1238 bool const punching_in = (config.get_punch_in () && _locations->auto_punch_location());
1239 bool const punching_out = (config.get_punch_out () && _locations->auto_punch_location());
1241 if (actively_recording ()) {
1242 /* permanently recording */
1243 return max_samplepos;
1244 } else if (punching_in && !punching_out) {
1245 /* punching in but never out */
1246 return max_samplepos;
1247 } else if (punching_in && punching_out && _locations->auto_punch_location()->end() > current_end_sample()) {
1248 /* punching in and punching out after session end */
1249 return max_samplepos;
1252 return current_end_sample ();
1257 /* dedicated thread for signal emission.
1259 * while sending cross-thread signals from the process thread
1260 * is fine in general, PBD::Signal's use of boost::function and
1261 * boost:bind can produce a vast overhead which is not
1262 * acceptable for low latency.
1264 * This works around the issue by moving the boost overhead
1265 * out of the RT thread. The overall load is probably higher but
1266 * the realtime thread remains unaffected.
1270 Session::emit_route_signals ()
1272 // TODO use RAII to allow using these signals in other places
1273 BatchUpdateStart(); /* EMIT SIGNAL */
1274 boost::shared_ptr<RouteList> r = routes.reader ();
1275 for (RouteList::const_iterator ci = r->begin(); ci != r->end(); ++ci) {
1276 (*ci)->emit_pending_signals ();
1278 BatchUpdateEnd(); /* EMIT SIGNAL */
1282 Session::emit_thread_start ()
1284 if (_rt_thread_active) {
1287 _rt_thread_active = true;
1289 if (pthread_create (&_rt_emit_thread, NULL, emit_thread, this)) {
1290 _rt_thread_active = false;
1295 Session::emit_thread_terminate ()
1297 if (!_rt_thread_active) {
1300 _rt_thread_active = false;
1302 if (pthread_mutex_lock (&_rt_emit_mutex) == 0) {
1303 pthread_cond_signal (&_rt_emit_cond);
1304 pthread_mutex_unlock (&_rt_emit_mutex);
1308 pthread_join (_rt_emit_thread, &status);
1312 Session::emit_thread (void *arg)
1314 Session *s = static_cast<Session *>(arg);
1315 s->emit_thread_run ();
1321 Session::emit_thread_run ()
1323 pthread_mutex_lock (&_rt_emit_mutex);
1324 while (_rt_thread_active) {
1325 emit_route_signals();
1326 pthread_cond_wait (&_rt_emit_cond, &_rt_emit_mutex);
1328 pthread_mutex_unlock (&_rt_emit_mutex);