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 ();
295 /* only count-in when going to roll at speed 1.0 */
296 if (_transport_speed != 1.0 && _count_in_samples > 0) {
297 _count_in_samples = 0;
299 if (_transport_speed == 0.0) {
300 _remaining_latency_preroll = 0;
303 assert (_count_in_samples == 0 || _remaining_latency_preroll == 0 || _count_in_samples == _remaining_latency_preroll);
305 while (_count_in_samples > 0 || _remaining_latency_preroll > 0) {
308 if (_remaining_latency_preroll > 0) {
309 ns = std::min ((samplecnt_t)nframes, _remaining_latency_preroll);
311 ns = std::min ((samplecnt_t)nframes, _count_in_samples);
314 boost::shared_ptr<RouteList> r = routes.reader ();
315 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
316 samplecnt_t route_offset = (*i)->playback_latency ();
317 if (_remaining_latency_preroll > route_offset + ns) {
318 /* route will no-roll for complete pre-roll cycle */
321 if (_remaining_latency_preroll > route_offset) {
322 /* route may need partial no-roll and partial roll from
323 * (_transport_sample - _remaining_latency_preroll) .. +ns.
324 * shorten and split the cycle.
326 ns = std::min (ns, (_remaining_latency_preroll - route_offset));
330 if (_count_in_samples > 0) {
331 run_click (_transport_sample - _count_in_samples, ns);
332 assert (_count_in_samples >= ns);
333 _count_in_samples -= ns;
336 if (_remaining_latency_preroll > 0) {
337 if (_count_in_samples == 0) {
338 click (_transport_sample - _remaining_latency_preroll, ns);
340 if (process_routes (ns, session_needs_butler)) {
347 if (_remaining_latency_preroll > 0) {
348 assert (_remaining_latency_preroll >= ns);
349 _remaining_latency_preroll -= ns;
354 /* process events.. */
355 if (!events.empty() && next_event != events.end()) {
356 SessionEvent* this_event = *next_event;
357 Events::iterator the_next_one = next_event;
360 while (this_event && this_event->action_sample == _transport_sample) {
361 process_event (this_event);
362 if (the_next_one == events.end()) {
365 this_event = *the_next_one;
372 check_declick_out ();
377 _engine.split_cycle (ns);
381 /* Decide on what to do with quarter-frame MTC during this cycle */
383 bool const was_sending_qf_mtc = _send_qf_mtc;
384 double const tolerance = Config->get_mtc_qf_speed_tolerance() / 100.0;
386 if (_transport_speed != 0) {
388 Config->get_send_mtc () &&
389 _transport_speed >= (1 - tolerance) &&
390 _transport_speed <= (1 + tolerance)
393 if (_send_qf_mtc && !was_sending_qf_mtc) {
394 /* we will re-start quarter-frame MTC this cycle, so send a full update to set things up */
395 _send_timecode_update = true;
398 if (Config->get_send_mtc() && !_send_qf_mtc && _pframes_since_last_mtc > (sample_rate () / 4)) {
399 /* we're sending MTC, but we're not sending QF MTC at the moment, and it's been
400 a quarter of a second since we sent anything at all, so send a full MTC update
403 _send_timecode_update = true;
406 _pframes_since_last_mtc += nframes;
409 /* Events caused a transport change (or we re-started sending
410 * MTC), so send an MTC Full Frame (Timecode) message. This
411 * is sent whether rolling or not, to give slaves an idea of
412 * ardour time on locates (and allow slow slaves to position
413 * and prepare for rolling)
415 if (_send_timecode_update) {
416 send_full_time_code (_transport_sample, nframes);
419 if (!process_can_proceed()) {
424 if (events.empty() || next_event == events.end()) {
425 try_run_lua (nframes); // also during export ?? ->move to process_without_events()
426 /* lua scripts may inject events */
427 while (_n_lua_scripts > 0 && pending_events.read (&ev, 1) == 1) {
430 if (events.empty() || next_event == events.end()) {
431 process_without_events (nframes);
436 assert (_transport_speed == 0 || _transport_speed == 1.0 || _transport_speed == -1.0);
438 samples_moved = (samplecnt_t) nframes * _transport_speed;
440 end_sample = _transport_sample + samples_moved;
443 SessionEvent* this_event;
444 Events::iterator the_next_one;
446 if (!process_can_proceed()) {
451 if (!_exporting && _slave) {
452 if (!follow_slave (nframes)) {
457 if (_transport_speed == 0) {
462 if (!_exporting && !timecode_transmission_suspended()) {
463 send_midi_time_code_for_cycle (_transport_sample, end_sample, nframes);
466 ltc_tx_send_time_code_for_cycle (_transport_sample, end_sample, _target_transport_speed, _transport_speed, nframes);
468 samplepos_t stop_limit = compute_stop_limit ();
470 if (maybe_stop (stop_limit)) {
475 this_event = *next_event;
476 the_next_one = next_event;
479 /* yes folks, here it is, the actual loop where we really truly
485 this_nframes = nframes; /* real (jack) time relative */
486 samples_moved = (samplecnt_t) floor (_transport_speed * nframes); /* transport relative */
488 /* running an event, position transport precisely to its time */
489 if (this_event && this_event->action_sample <= end_sample && this_event->action_sample >= _transport_sample) {
490 /* this isn't quite right for reverse play */
491 samples_moved = (samplecnt_t) (this_event->action_sample - _transport_sample);
492 this_nframes = abs (floor(samples_moved / _transport_speed));
495 try_run_lua (this_nframes);
499 click (_transport_sample, this_nframes);
501 if (process_routes (this_nframes, session_needs_butler)) {
506 get_track_statistics ();
508 nframes -= this_nframes;
510 if (samples_moved < 0) {
511 decrement_transport_position (-samples_moved);
512 } else if (samples_moved) {
513 increment_transport_position (samples_moved);
516 maybe_stop (stop_limit);
517 check_declick_out ();
521 _engine.split_cycle (this_nframes);
524 /* now handle this event and all others scheduled for the same time */
526 while (this_event && this_event->action_sample == _transport_sample) {
527 process_event (this_event);
529 if (the_next_one == events.end()) {
532 this_event = *the_next_one;
537 /* if an event left our state changing, do the right thing */
539 if (nframes && non_realtime_work_pending()) {
544 /* this is necessary to handle the case of seamless looping */
545 end_sample = _transport_sample + floor (nframes * _transport_speed);
550 } /* implicit release of route lock */
552 if (session_needs_butler) {
553 DEBUG_TRACE (DEBUG::Butler, "p-with-events: session needs butler, call it\n");
559 Session::reset_slave_state ()
561 average_slave_delta = 1800;
562 delta_accumulator_cnt = 0;
563 have_first_delta_accumulator = false;
564 _slave_state = Stopped;
565 DiskReader::set_no_disk_output (false);
569 Session::transport_locked () const
573 if (!locate_pending() && (!config.get_external_sync() || (sl && sl->ok() && sl->locked()))) {
581 Session::follow_slave (pframes_t nframes)
584 samplepos_t slave_transport_sample;
585 samplecnt_t this_delta;
590 config.set_external_sync (false);
594 _slave->speed_and_position (slave_speed, slave_transport_sample);
596 DEBUG_TRACE (DEBUG::Slave, string_compose ("Slave position %1 speed %2\n", slave_transport_sample, slave_speed));
598 if (!_slave->locked()) {
599 DEBUG_TRACE (DEBUG::Slave, "slave not locked\n");
603 if (slave_transport_sample > _transport_sample) {
604 this_delta = slave_transport_sample - _transport_sample;
607 this_delta = _transport_sample - slave_transport_sample;
611 if (_slave->starting()) {
615 if (_slave->is_always_synced() ||
616 (Config->get_timecode_source_is_synced() && (dynamic_cast<TimecodeSlave*>(_slave)) != 0)
619 /* if the TC source is synced, then we assume that its
620 speed is binary: 0.0 or 1.0
623 if (slave_speed != 0.0f) {
629 /* if we are chasing and the average delta between us and the
630 master gets too big, we want to switch to silent
631 motion. so keep track of that here.
634 if (_slave_state == Running) {
635 calculate_moving_average_of_slave_delta(dir, abs(this_delta));
639 track_slave_state (slave_speed, slave_transport_sample, this_delta);
641 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave state %1 @ %2 speed %3 cur delta %4 avg delta %5\n",
642 _slave_state, slave_transport_sample, slave_speed, this_delta, average_slave_delta));
645 if (_slave_state == Running && !_slave->is_always_synced() && !(Config->get_timecode_source_is_synced() && (dynamic_cast<TimecodeSlave*>(_slave)) != 0)) {
647 /* may need to varispeed to sync with slave */
649 if (_transport_speed != 0.0f) {
652 note that average_dir is +1 or -1
657 if (average_slave_delta == 0) {
661 delta = average_slave_delta;
662 delta *= average_dir;
666 if (slave_speed != 0.0) {
667 DEBUG_TRACE (DEBUG::Slave, string_compose ("delta = %1 speed = %2 ts = %3 M@%4 S@%5 avgdelta %6\n",
668 (int) (dir * this_delta),
672 slave_transport_sample,
673 average_slave_delta));
677 if (_slave->give_slave_full_control_over_transport_speed()) {
678 set_transport_speed (slave_speed, 0, false, false);
679 //std::cout << "set speed = " << slave_speed << "\n";
681 float adjusted_speed = slave_speed + (1.5 * (delta / float(_current_sample_rate)));
682 request_transport_speed (adjusted_speed);
683 DEBUG_TRACE (DEBUG::Slave, string_compose ("adjust using %1 towards %2 ratio %3 current %4 slave @ %5\n",
684 delta, adjusted_speed, adjusted_speed/slave_speed, _transport_speed,
688 if (!actively_recording() && (samplecnt_t) average_slave_delta > _slave->resolution()) {
689 DEBUG_TRACE (DEBUG::Slave, string_compose ("average slave delta %1 greater than slave resolution %2 => no disk output\n", average_slave_delta, _slave->resolution()));
690 /* run routes as normal, but no disk output */
691 DiskReader::set_no_disk_output (true);
695 if (!have_first_delta_accumulator) {
696 DEBUG_TRACE (DEBUG::Slave, "waiting for first slave delta accumulator to be ready, no disk output\n");
697 /* run routes as normal, but no disk output */
698 DiskReader::set_no_disk_output (true);
705 if (!have_first_delta_accumulator) {
706 DEBUG_TRACE (DEBUG::Slave, "still waiting to compute slave delta, no disk output\n");
707 DiskReader::set_no_disk_output (true);
709 DiskReader::set_no_disk_output (false);
712 if ((_slave_state == Running) && (0 == (post_transport_work () & ~PostTransportSpeed))) {
713 /* speed is set, we're locked, and good to go */
718 /* don't move at all */
719 DEBUG_TRACE (DEBUG::Slave, "no roll\n")
725 Session::calculate_moving_average_of_slave_delta (int dir, samplecnt_t this_delta)
727 if (delta_accumulator_cnt >= delta_accumulator_size) {
728 have_first_delta_accumulator = true;
729 delta_accumulator_cnt = 0;
732 if (delta_accumulator_cnt != 0 || this_delta < _current_sample_rate) {
733 delta_accumulator[delta_accumulator_cnt++] = (samplecnt_t) dir * (samplecnt_t) this_delta;
736 if (have_first_delta_accumulator) {
737 average_slave_delta = 0L;
738 for (int i = 0; i < delta_accumulator_size; ++i) {
739 average_slave_delta += delta_accumulator[i];
741 average_slave_delta /= (int32_t) delta_accumulator_size;
742 if (average_slave_delta < 0L) {
744 average_slave_delta = average_slave_delta;
752 Session::track_slave_state (float slave_speed, samplepos_t slave_transport_sample, samplecnt_t /*this_delta*/)
754 if (slave_speed != 0.0f) {
756 /* slave is running */
758 switch (_slave_state) {
760 if (_slave->requires_seekahead()) {
761 slave_wait_end = slave_transport_sample + _slave->seekahead_distance ();
762 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped, but running, requires seekahead to %1\n", slave_wait_end));
763 /* we can call locate() here because we are in process context */
764 locate (slave_wait_end, false, false);
765 _slave_state = Waiting;
769 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped -> running at %1\n", slave_transport_sample));
771 memset (delta_accumulator, 0, sizeof (int32_t) * delta_accumulator_size);
772 average_slave_delta = 0L;
774 Location* al = _locations->auto_loop_location();
776 if (al && play_loop && (slave_transport_sample < al->start() || slave_transport_sample > al->end())) {
778 request_play_loop(false);
781 if (slave_transport_sample != _transport_sample) {
782 DEBUG_TRACE (DEBUG::Slave, string_compose ("require locate to run. eng: %1 -> sl: %2\n", _transport_sample, slave_transport_sample));
783 locate (slave_transport_sample, false, false);
785 _slave_state = Running;
794 if (_slave_state == Waiting) {
796 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave waiting at %1\n", slave_transport_sample));
798 if (slave_transport_sample >= slave_wait_end) {
800 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave start at %1 vs %2\n", slave_transport_sample, _transport_sample));
802 _slave_state = Running;
804 /* now perform a "micro-seek" within the disk buffers to realign ourselves
805 precisely with the master.
810 samplecnt_t sample_delta = slave_transport_sample - _transport_sample;
812 boost::shared_ptr<RouteList> rl = routes.reader();
813 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
814 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
815 if (tr && !tr->can_internal_playback_seek (sample_delta)) {
822 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
823 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
825 tr->internal_playback_seek (sample_delta);
828 _transport_sample += sample_delta;
831 cerr << "cannot micro-seek\n";
837 if (_slave_state == Running && _transport_speed == 0.0f) {
838 DEBUG_TRACE (DEBUG::Slave, "slave starts transport\n");
842 } else { // slave_speed is 0
844 /* slave has stopped */
846 if (_transport_speed != 0.0f) {
847 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stops transport: %1 sample %2 tf %3\n", slave_speed, slave_transport_sample, _transport_sample));
851 if (slave_transport_sample != _transport_sample) {
852 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped, move to %1\n", slave_transport_sample));
853 force_locate (slave_transport_sample, false);
861 Session::process_without_events (pframes_t nframes)
863 bool session_needs_butler = false;
864 samplecnt_t samples_moved;
866 if (!process_can_proceed()) {
871 if (!_exporting && _slave) {
872 if (!follow_slave (nframes)) {
873 ltc_tx_send_time_code_for_cycle (_transport_sample, _transport_sample, 0, 0 , nframes);
878 if (_transport_speed == 0) {
883 if (_transport_speed == 1.0) {
884 samples_moved = (samplecnt_t) nframes;
886 interpolation.set_speed (_transport_speed);
887 samples_moved = interpolation.distance (nframes);
890 if (!_exporting && !timecode_transmission_suspended()) {
891 send_midi_time_code_for_cycle (_transport_sample, _transport_sample + samples_moved, nframes);
894 ltc_tx_send_time_code_for_cycle (_transport_sample, _transport_sample + samples_moved, _target_transport_speed, _transport_speed, nframes);
896 samplepos_t const stop_limit = compute_stop_limit ();
898 if (maybe_stop (stop_limit)) {
903 if (maybe_sync_start (nframes)) {
907 click (_transport_sample, nframes);
909 if (process_routes (nframes, session_needs_butler)) {
914 get_track_statistics ();
916 if (samples_moved < 0) {
917 decrement_transport_position (-samples_moved);
918 } else if (samples_moved) {
919 increment_transport_position (samples_moved);
922 maybe_stop (stop_limit);
923 check_declick_out ();
925 if (session_needs_butler) {
926 DEBUG_TRACE (DEBUG::Butler, "p-without-events: session needs butler, call it\n");
931 /** Process callback used when the auditioner is active.
932 * @param nframes number of samples to process.
935 Session::process_audition (pframes_t nframes)
938 boost::shared_ptr<RouteList> r = routes.reader ();
940 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
941 if (!(*i)->is_auditioner()) {
942 (*i)->silence (nframes);
946 /* run the auditioner, and if it says we need butler service, ask for it */
948 if (auditioner->play_audition (nframes) > 0) {
949 DEBUG_TRACE (DEBUG::Butler, "auditioner needs butler, call it\n");
953 /* if using a monitor section, run it because otherwise we don't hear anything */
955 if (_monitor_out && auditioner->needs_monitor()) {
956 _monitor_out->monitor_run (_transport_sample, _transport_sample + nframes, nframes, false);
959 /* handle pending events */
961 while (pending_events.read (&ev, 1) == 1) {
965 /* if we are not in the middle of a state change,
966 and there are immediate events queued up,
970 while (!non_realtime_work_pending() && !immediate_events.empty()) {
971 SessionEvent *ev = immediate_events.front ();
972 immediate_events.pop_front ();
976 if (!auditioner->auditioning()) {
977 /* auditioner no longer active, so go back to the normal process callback */
978 process_function = &Session::process_with_events;
983 Session::maybe_sync_start (pframes_t & nframes)
985 pframes_t sync_offset;
987 if (!waiting_for_sync_offset) {
991 if (_engine.get_sync_offset (sync_offset) && sync_offset < nframes) {
993 /* generate silence up to the sync point, then
994 adjust nframes + offset to reflect whatever
998 no_roll (sync_offset);
999 nframes -= sync_offset;
1000 Port::increment_global_port_buffer_offset (sync_offset);
1001 waiting_for_sync_offset = false;
1004 return true; // done, nothing left to process
1009 /* sync offset point is not within this process()
1010 cycle, so just generate silence. and don't bother
1011 with any fancy stuff here, just the minimal silence.
1016 if (Config->get_locate_while_waiting_for_sync()) {
1017 if (micro_locate (nframes)) {
1018 /* XXX ERROR !!! XXX */
1022 return true; // done, nothing left to process
1029 Session::queue_event (SessionEvent* ev)
1031 if (_state_of_the_state & Deletion) {
1033 } else if (_state_of_the_state & Loading) {
1036 Glib::Threads::Mutex::Lock lm (rb_write_lock);
1037 pending_events.write (&ev, 1);
1042 Session::set_next_event ()
1044 if (events.empty()) {
1045 next_event = events.end();
1049 if (next_event == events.end()) {
1050 next_event = events.begin();
1053 if ((*next_event)->action_sample > _transport_sample) {
1054 next_event = events.begin();
1057 for (; next_event != events.end(); ++next_event) {
1058 if ((*next_event)->action_sample >= _transport_sample) {
1065 Session::process_event (SessionEvent* ev)
1070 /* if we're in the middle of a state change (i.e. waiting
1071 for the butler thread to complete the non-realtime
1072 part of the change), we'll just have to queue this
1073 event for a time when the change is complete.
1076 if (non_realtime_work_pending()) {
1078 /* except locates, which we have the capability to handle */
1080 if (ev->type != SessionEvent::Locate) {
1081 immediate_events.insert (immediate_events.end(), ev);
1087 DEBUG_TRACE (DEBUG::SessionEvents, string_compose ("Processing event: %1 @ %2\n", enum_2_string (ev->type), _transport_sample));
1090 case SessionEvent::SetLoop:
1091 set_play_loop (ev->yes_or_no, ev->speed);
1094 case SessionEvent::AutoLoop:
1096 /* roll after locate, do not flush, set "with loop"
1097 true only if we are seamless looping
1099 start_locate (ev->target_sample, true, false, Config->get_seamless_loop());
1105 case SessionEvent::AutoLoopDeclick:
1107 /* Request a declick fade-out and a fade-in; the fade-out will happen
1108 at the end of the loop, and the fade-in at the start.
1110 transport_sub_state |= (PendingLoopDeclickOut | PendingLoopDeclickIn);
1116 case SessionEvent::Locate:
1117 if (ev->yes_or_no) { /* force locate */
1118 /* args: do not roll after locate, do flush, not with loop */
1119 locate (ev->target_sample, false, true, false);
1121 /* args: do not roll after locate, do flush, not with loop */
1122 start_locate (ev->target_sample, false, true, false);
1124 _send_timecode_update = true;
1127 case SessionEvent::LocateRoll:
1128 if (ev->yes_or_no) {
1129 /* args: roll after locate, do flush, not with loop */
1130 locate (ev->target_sample, true, true, false);
1132 /* args: roll after locate, do flush, not with loop */
1133 start_locate (ev->target_sample, true, true, false);
1135 _send_timecode_update = true;
1138 case SessionEvent::Skip:
1139 if (Config->get_skip_playback()) {
1140 start_locate (ev->target_sample, true, true, false);
1141 _send_timecode_update = true;
1147 case SessionEvent::LocateRollLocate:
1148 // locate is handled by ::request_roll_at_and_return()
1149 _requested_return_sample = ev->target_sample;
1150 request_locate (ev->target2_sample, true);
1154 case SessionEvent::SetTransportSpeed:
1155 set_transport_speed (ev->speed, ev->target_sample, ev->yes_or_no, ev->second_yes_or_no, ev->third_yes_or_no);
1158 case SessionEvent::PunchIn:
1159 // cerr << "PunchIN at " << transport_sample() << endl;
1160 if (config.get_punch_in() && record_status() == Enabled) {
1167 case SessionEvent::PunchOut:
1168 // cerr << "PunchOUT at " << transport_sample() << endl;
1169 if (config.get_punch_out()) {
1170 step_back_from_record ();
1176 case SessionEvent::StopOnce:
1177 if (!non_realtime_work_pending()) {
1178 _clear_event_type (SessionEvent::StopOnce);
1179 stop_transport (ev->yes_or_no);
1185 case SessionEvent::RangeStop:
1186 if (!non_realtime_work_pending()) {
1187 stop_transport (ev->yes_or_no);
1193 case SessionEvent::RangeLocate:
1194 /* args: roll after locate, do flush, not with loop */
1195 start_locate (ev->target_sample, true, true, false);
1200 case SessionEvent::Overwrite:
1201 overwrite_some_buffers (static_cast<Track*>(ev->ptr));
1204 case SessionEvent::SetSyncSource:
1205 DEBUG_TRACE (DEBUG::Slave, "seen request for new slave\n");
1206 use_sync_source (ev->slave);
1209 case SessionEvent::Audition:
1210 set_audition (ev->region);
1211 // drop reference to region
1212 ev->region.reset ();
1215 case SessionEvent::SetPlayAudioRange:
1216 set_play_range (ev->audio_range, (ev->speed == 1.0f));
1219 case SessionEvent::CancelPlayAudioRange:
1223 case SessionEvent::RealTimeOperation:
1225 del = false; // other side of RT request needs to clean up
1228 case SessionEvent::AdjustPlaybackBuffering:
1229 schedule_playback_buffering_adjustment ();
1232 case SessionEvent::AdjustCaptureBuffering:
1233 schedule_capture_buffering_adjustment ();
1236 case SessionEvent::SetTimecodeTransmission:
1237 g_atomic_int_set (&_suspend_timecode_transmission, ev->yes_or_no ? 0 : 1);
1241 fatal << string_compose(_("Programming error: illegal event type in process_event (%1)"), ev->type) << endmsg;
1242 abort(); /*NOTREACHED*/
1247 del = del && !_remove_event (ev);
1256 Session::compute_stop_limit () const
1258 if (!Config->get_stop_at_session_end ()) {
1259 return max_samplepos;
1263 return max_samplepos;
1266 bool const punching_in = (config.get_punch_in () && _locations->auto_punch_location());
1267 bool const punching_out = (config.get_punch_out () && _locations->auto_punch_location());
1269 if (actively_recording ()) {
1270 /* permanently recording */
1271 return max_samplepos;
1272 } else if (punching_in && !punching_out) {
1273 /* punching in but never out */
1274 return max_samplepos;
1275 } else if (punching_in && punching_out && _locations->auto_punch_location()->end() > current_end_sample()) {
1276 /* punching in and punching out after session end */
1277 return max_samplepos;
1280 return current_end_sample ();
1285 /* dedicated thread for signal emission.
1287 * while sending cross-thread signals from the process thread
1288 * is fine in general, PBD::Signal's use of boost::function and
1289 * boost:bind can produce a vast overhead which is not
1290 * acceptable for low latency.
1292 * This works around the issue by moving the boost overhead
1293 * out of the RT thread. The overall load is probably higher but
1294 * the realtime thread remains unaffected.
1298 Session::emit_route_signals ()
1300 // TODO use RAII to allow using these signals in other places
1301 BatchUpdateStart(); /* EMIT SIGNAL */
1302 boost::shared_ptr<RouteList> r = routes.reader ();
1303 for (RouteList::const_iterator ci = r->begin(); ci != r->end(); ++ci) {
1304 (*ci)->emit_pending_signals ();
1306 BatchUpdateEnd(); /* EMIT SIGNAL */
1310 Session::emit_thread_start ()
1312 if (_rt_thread_active) {
1315 _rt_thread_active = true;
1317 if (pthread_create (&_rt_emit_thread, NULL, emit_thread, this)) {
1318 _rt_thread_active = false;
1323 Session::emit_thread_terminate ()
1325 if (!_rt_thread_active) {
1328 _rt_thread_active = false;
1330 if (pthread_mutex_lock (&_rt_emit_mutex) == 0) {
1331 pthread_cond_signal (&_rt_emit_cond);
1332 pthread_mutex_unlock (&_rt_emit_mutex);
1336 pthread_join (_rt_emit_thread, &status);
1340 Session::emit_thread (void *arg)
1342 Session *s = static_cast<Session *>(arg);
1343 s->emit_thread_run ();
1349 Session::emit_thread_run ()
1351 pthread_mutex_lock (&_rt_emit_mutex);
1352 while (_rt_thread_active) {
1353 emit_route_signals();
1354 pthread_cond_wait (&_rt_emit_cond, &_rt_emit_mutex);
1356 pthread_mutex_unlock (&_rt_emit_mutex);