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 if (_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 if (_transport_speed == 1.0) {
437 samples_moved = (samplecnt_t) nframes;
439 /* use a cubic midi interpolation to compute the number of
440 * samples we will move at the current speed.
442 CubicInterpolation interp;
443 interp.set_speed (_transport_speed);
444 samples_moved = interp.distance (nframes);
447 end_sample = _transport_sample + samples_moved;
450 SessionEvent* this_event;
451 Events::iterator the_next_one;
453 if (!process_can_proceed()) {
458 if (!_exporting && _slave) {
459 if (!follow_slave (nframes)) {
464 if (_transport_speed == 0) {
469 if (!_exporting && !timecode_transmission_suspended()) {
470 send_midi_time_code_for_cycle (_transport_sample, end_sample, nframes);
473 ltc_tx_send_time_code_for_cycle (_transport_sample, end_sample, _target_transport_speed, _transport_speed, nframes);
475 samplepos_t stop_limit = compute_stop_limit ();
477 if (maybe_stop (stop_limit)) {
482 this_event = *next_event;
483 the_next_one = next_event;
486 /* yes folks, here it is, the actual loop where we really truly
492 this_nframes = nframes; /* real (jack) time relative */
493 samples_moved = (samplecnt_t) floor (_transport_speed * nframes); /* transport relative */
495 /* running an event, position transport precisely to its time */
496 if (this_event && this_event->action_sample <= end_sample && this_event->action_sample >= _transport_sample) {
497 /* this isn't quite right for reverse play */
498 samples_moved = (samplecnt_t) (this_event->action_sample - _transport_sample);
499 this_nframes = abs (floor(samples_moved / _transport_speed));
502 try_run_lua (this_nframes);
506 click (_transport_sample, this_nframes);
508 if (process_routes (this_nframes, session_needs_butler)) {
513 get_track_statistics ();
515 nframes -= this_nframes;
517 if (samples_moved < 0) {
518 decrement_transport_position (-samples_moved);
519 } else if (samples_moved) {
520 increment_transport_position (samples_moved);
523 maybe_stop (stop_limit);
524 check_declick_out ();
528 _engine.split_cycle (this_nframes);
531 /* now handle this event and all others scheduled for the same time */
533 while (this_event && this_event->action_sample == _transport_sample) {
534 process_event (this_event);
536 if (the_next_one == events.end()) {
539 this_event = *the_next_one;
544 /* if an event left our state changing, do the right thing */
546 if (nframes && non_realtime_work_pending()) {
551 /* this is necessary to handle the case of seamless looping */
552 end_sample = _transport_sample + floor (nframes * _transport_speed);
557 } /* implicit release of route lock */
559 if (session_needs_butler) {
560 DEBUG_TRACE (DEBUG::Butler, "p-with-events: session needs butler, call it\n");
566 Session::reset_slave_state ()
568 average_slave_delta = 1800;
569 delta_accumulator_cnt = 0;
570 have_first_delta_accumulator = false;
571 _slave_state = Stopped;
572 DiskReader::set_no_disk_output (false);
576 Session::transport_locked () const
580 if (!locate_pending() && (!config.get_external_sync() || (sl && sl->ok() && sl->locked()))) {
588 Session::follow_slave (pframes_t nframes)
591 samplepos_t slave_transport_sample;
592 samplecnt_t this_delta;
597 config.set_external_sync (false);
601 _slave->speed_and_position (slave_speed, slave_transport_sample);
603 DEBUG_TRACE (DEBUG::Slave, string_compose ("Slave position %1 speed %2\n", slave_transport_sample, slave_speed));
605 if (!_slave->locked()) {
606 DEBUG_TRACE (DEBUG::Slave, "slave not locked\n");
610 if (slave_transport_sample > _transport_sample) {
611 this_delta = slave_transport_sample - _transport_sample;
614 this_delta = _transport_sample - slave_transport_sample;
618 if (_slave->starting()) {
622 if (_slave->is_always_synced() ||
623 (Config->get_timecode_source_is_synced() && (dynamic_cast<TimecodeSlave*>(_slave)) != 0)
626 /* if the TC source is synced, then we assume that its
627 speed is binary: 0.0 or 1.0
630 if (slave_speed != 0.0f) {
636 /* if we are chasing and the average delta between us and the
637 master gets too big, we want to switch to silent
638 motion. so keep track of that here.
641 if (_slave_state == Running) {
642 calculate_moving_average_of_slave_delta(dir, abs(this_delta));
646 track_slave_state (slave_speed, slave_transport_sample, this_delta);
648 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave state %1 @ %2 speed %3 cur delta %4 avg delta %5\n",
649 _slave_state, slave_transport_sample, slave_speed, this_delta, average_slave_delta));
652 if (_slave_state == Running && !_slave->is_always_synced() && !(Config->get_timecode_source_is_synced() && (dynamic_cast<TimecodeSlave*>(_slave)) != 0)) {
654 /* may need to varispeed to sync with slave */
656 if (_transport_speed != 0.0f) {
659 note that average_dir is +1 or -1
664 if (average_slave_delta == 0) {
668 delta = average_slave_delta;
669 delta *= average_dir;
673 if (slave_speed != 0.0) {
674 DEBUG_TRACE (DEBUG::Slave, string_compose ("delta = %1 speed = %2 ts = %3 M@%4 S@%5 avgdelta %6\n",
675 (int) (dir * this_delta),
679 slave_transport_sample,
680 average_slave_delta));
684 if (_slave->give_slave_full_control_over_transport_speed()) {
685 set_transport_speed (slave_speed, 0, false, false);
686 //std::cout << "set speed = " << slave_speed << "\n";
688 float adjusted_speed = slave_speed + (1.5 * (delta / float(_current_sample_rate)));
689 request_transport_speed (adjusted_speed);
690 DEBUG_TRACE (DEBUG::Slave, string_compose ("adjust using %1 towards %2 ratio %3 current %4 slave @ %5\n",
691 delta, adjusted_speed, adjusted_speed/slave_speed, _transport_speed,
695 if (!actively_recording() && (samplecnt_t) average_slave_delta > _slave->resolution()) {
696 DEBUG_TRACE (DEBUG::Slave, string_compose ("average slave delta %1 greater than slave resolution %2 => no disk output\n", average_slave_delta, _slave->resolution()));
697 /* run routes as normal, but no disk output */
698 DiskReader::set_no_disk_output (true);
702 if (!have_first_delta_accumulator) {
703 DEBUG_TRACE (DEBUG::Slave, "waiting for first slave delta accumulator to be ready, no disk output\n");
704 /* run routes as normal, but no disk output */
705 DiskReader::set_no_disk_output (true);
712 if (!have_first_delta_accumulator) {
713 DEBUG_TRACE (DEBUG::Slave, "still waiting to compute slave delta, no disk output\n");
714 DiskReader::set_no_disk_output (true);
716 DiskReader::set_no_disk_output (false);
719 if ((_slave_state == Running) && (0 == (post_transport_work () & ~PostTransportSpeed))) {
720 /* speed is set, we're locked, and good to go */
725 /* don't move at all */
726 DEBUG_TRACE (DEBUG::Slave, "no roll\n")
732 Session::calculate_moving_average_of_slave_delta (int dir, samplecnt_t this_delta)
734 if (delta_accumulator_cnt >= delta_accumulator_size) {
735 have_first_delta_accumulator = true;
736 delta_accumulator_cnt = 0;
739 if (delta_accumulator_cnt != 0 || this_delta < _current_sample_rate) {
740 delta_accumulator[delta_accumulator_cnt++] = (samplecnt_t) dir * (samplecnt_t) this_delta;
743 if (have_first_delta_accumulator) {
744 average_slave_delta = 0L;
745 for (int i = 0; i < delta_accumulator_size; ++i) {
746 average_slave_delta += delta_accumulator[i];
748 average_slave_delta /= (int32_t) delta_accumulator_size;
749 if (average_slave_delta < 0L) {
751 average_slave_delta = average_slave_delta;
759 Session::track_slave_state (float slave_speed, samplepos_t slave_transport_sample, samplecnt_t /*this_delta*/)
761 if (slave_speed != 0.0f) {
763 /* slave is running */
765 switch (_slave_state) {
767 if (_slave->requires_seekahead()) {
768 slave_wait_end = slave_transport_sample + _slave->seekahead_distance ();
769 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped, but running, requires seekahead to %1\n", slave_wait_end));
770 /* we can call locate() here because we are in process context */
771 locate (slave_wait_end, false, false);
772 _slave_state = Waiting;
776 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped -> running at %1\n", slave_transport_sample));
778 memset (delta_accumulator, 0, sizeof (int32_t) * delta_accumulator_size);
779 average_slave_delta = 0L;
781 Location* al = _locations->auto_loop_location();
783 if (al && play_loop && (slave_transport_sample < al->start() || slave_transport_sample > al->end())) {
785 request_play_loop(false);
788 if (slave_transport_sample != _transport_sample) {
789 DEBUG_TRACE (DEBUG::Slave, string_compose ("require locate to run. eng: %1 -> sl: %2\n", _transport_sample, slave_transport_sample));
790 locate (slave_transport_sample, false, false);
792 _slave_state = Running;
801 if (_slave_state == Waiting) {
803 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave waiting at %1\n", slave_transport_sample));
805 if (slave_transport_sample >= slave_wait_end) {
807 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave start at %1 vs %2\n", slave_transport_sample, _transport_sample));
809 _slave_state = Running;
811 /* now perform a "micro-seek" within the disk buffers to realign ourselves
812 precisely with the master.
817 samplecnt_t sample_delta = slave_transport_sample - _transport_sample;
819 boost::shared_ptr<RouteList> rl = routes.reader();
820 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
821 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
822 if (tr && !tr->can_internal_playback_seek (sample_delta)) {
829 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
830 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
832 tr->internal_playback_seek (sample_delta);
835 _transport_sample += sample_delta;
838 cerr << "cannot micro-seek\n";
844 if (_slave_state == Running && _transport_speed == 0.0f) {
845 DEBUG_TRACE (DEBUG::Slave, "slave starts transport\n");
849 } else { // slave_speed is 0
851 /* slave has stopped */
853 if (_transport_speed != 0.0f) {
854 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stops transport: %1 sample %2 tf %3\n", slave_speed, slave_transport_sample, _transport_sample));
858 if (slave_transport_sample != _transport_sample) {
859 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped, move to %1\n", slave_transport_sample));
860 force_locate (slave_transport_sample, false);
868 Session::process_without_events (pframes_t nframes)
870 bool session_needs_butler = false;
871 samplecnt_t samples_moved;
873 if (!process_can_proceed()) {
878 if (!_exporting && _slave) {
879 if (!follow_slave (nframes)) {
880 ltc_tx_send_time_code_for_cycle (_transport_sample, _transport_sample, 0, 0 , nframes);
885 if (_transport_speed == 0) {
890 if (_transport_speed == 1.0) {
891 samples_moved = (samplecnt_t) nframes;
893 interpolation.set_speed (_transport_speed);
894 samples_moved = interpolation.distance (nframes);
897 if (!_exporting && !timecode_transmission_suspended()) {
898 send_midi_time_code_for_cycle (_transport_sample, _transport_sample + samples_moved, nframes);
901 ltc_tx_send_time_code_for_cycle (_transport_sample, _transport_sample + samples_moved, _target_transport_speed, _transport_speed, nframes);
903 samplepos_t const stop_limit = compute_stop_limit ();
905 if (maybe_stop (stop_limit)) {
910 if (maybe_sync_start (nframes)) {
914 click (_transport_sample, nframes);
916 if (process_routes (nframes, session_needs_butler)) {
921 get_track_statistics ();
923 if (samples_moved < 0) {
924 decrement_transport_position (-samples_moved);
925 } else if (samples_moved) {
926 increment_transport_position (samples_moved);
929 maybe_stop (stop_limit);
930 check_declick_out ();
932 if (session_needs_butler) {
933 DEBUG_TRACE (DEBUG::Butler, "p-without-events: session needs butler, call it\n");
938 /** Process callback used when the auditioner is active.
939 * @param nframes number of samples to process.
942 Session::process_audition (pframes_t nframes)
945 boost::shared_ptr<RouteList> r = routes.reader ();
947 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
948 if (!(*i)->is_auditioner()) {
949 (*i)->silence (nframes);
953 /* run the auditioner, and if it says we need butler service, ask for it */
955 if (auditioner->play_audition (nframes) > 0) {
956 DEBUG_TRACE (DEBUG::Butler, "auditioner needs butler, call it\n");
960 /* if using a monitor section, run it because otherwise we don't hear anything */
962 if (_monitor_out && auditioner->needs_monitor()) {
963 _monitor_out->monitor_run (_transport_sample, _transport_sample + nframes, nframes, false);
966 /* handle pending events */
968 while (pending_events.read (&ev, 1) == 1) {
972 /* if we are not in the middle of a state change,
973 and there are immediate events queued up,
977 while (!non_realtime_work_pending() && !immediate_events.empty()) {
978 SessionEvent *ev = immediate_events.front ();
979 immediate_events.pop_front ();
983 if (!auditioner->auditioning()) {
984 /* auditioner no longer active, so go back to the normal process callback */
985 process_function = &Session::process_with_events;
990 Session::maybe_sync_start (pframes_t & nframes)
992 pframes_t sync_offset;
994 if (!waiting_for_sync_offset) {
998 if (_engine.get_sync_offset (sync_offset) && sync_offset < nframes) {
1000 /* generate silence up to the sync point, then
1001 adjust nframes + offset to reflect whatever
1005 no_roll (sync_offset);
1006 nframes -= sync_offset;
1007 Port::increment_global_port_buffer_offset (sync_offset);
1008 waiting_for_sync_offset = false;
1011 return true; // done, nothing left to process
1016 /* sync offset point is not within this process()
1017 cycle, so just generate silence. and don't bother
1018 with any fancy stuff here, just the minimal silence.
1023 if (Config->get_locate_while_waiting_for_sync()) {
1024 if (micro_locate (nframes)) {
1025 /* XXX ERROR !!! XXX */
1029 return true; // done, nothing left to process
1036 Session::queue_event (SessionEvent* ev)
1038 if (_state_of_the_state & Deletion) {
1040 } else if (_state_of_the_state & Loading) {
1043 Glib::Threads::Mutex::Lock lm (rb_write_lock);
1044 pending_events.write (&ev, 1);
1049 Session::set_next_event ()
1051 if (events.empty()) {
1052 next_event = events.end();
1056 if (next_event == events.end()) {
1057 next_event = events.begin();
1060 if ((*next_event)->action_sample > _transport_sample) {
1061 next_event = events.begin();
1064 for (; next_event != events.end(); ++next_event) {
1065 if ((*next_event)->action_sample >= _transport_sample) {
1072 Session::process_event (SessionEvent* ev)
1077 /* if we're in the middle of a state change (i.e. waiting
1078 for the butler thread to complete the non-realtime
1079 part of the change), we'll just have to queue this
1080 event for a time when the change is complete.
1083 if (non_realtime_work_pending()) {
1085 /* except locates, which we have the capability to handle */
1087 if (ev->type != SessionEvent::Locate) {
1088 immediate_events.insert (immediate_events.end(), ev);
1094 DEBUG_TRACE (DEBUG::SessionEvents, string_compose ("Processing event: %1 @ %2\n", enum_2_string (ev->type), _transport_sample));
1097 case SessionEvent::SetLoop:
1098 set_play_loop (ev->yes_or_no, ev->speed);
1101 case SessionEvent::AutoLoop:
1103 /* roll after locate, do not flush, set "with loop"
1104 true only if we are seamless looping
1106 start_locate (ev->target_sample, true, false, Config->get_seamless_loop());
1112 case SessionEvent::AutoLoopDeclick:
1114 /* Request a declick fade-out and a fade-in; the fade-out will happen
1115 at the end of the loop, and the fade-in at the start.
1117 transport_sub_state |= (PendingLoopDeclickOut | PendingLoopDeclickIn);
1123 case SessionEvent::Locate:
1124 if (ev->yes_or_no) { /* force locate */
1125 /* args: do not roll after locate, do flush, not with loop */
1126 locate (ev->target_sample, false, true, false);
1128 /* args: do not roll after locate, do flush, not with loop */
1129 start_locate (ev->target_sample, false, true, false);
1131 _send_timecode_update = true;
1134 case SessionEvent::LocateRoll:
1135 if (ev->yes_or_no) {
1136 /* args: roll after locate, do flush, not with loop */
1137 locate (ev->target_sample, true, true, false);
1139 /* args: roll after locate, do flush, not with loop */
1140 start_locate (ev->target_sample, true, true, false);
1142 _send_timecode_update = true;
1145 case SessionEvent::Skip:
1146 if (Config->get_skip_playback()) {
1147 start_locate (ev->target_sample, true, true, false);
1148 _send_timecode_update = true;
1154 case SessionEvent::LocateRollLocate:
1155 // locate is handled by ::request_roll_at_and_return()
1156 _requested_return_sample = ev->target_sample;
1157 request_locate (ev->target2_sample, true);
1161 case SessionEvent::SetTransportSpeed:
1162 set_transport_speed (ev->speed, ev->target_sample, ev->yes_or_no, ev->second_yes_or_no, ev->third_yes_or_no);
1165 case SessionEvent::PunchIn:
1166 // cerr << "PunchIN at " << transport_sample() << endl;
1167 if (config.get_punch_in() && record_status() == Enabled) {
1174 case SessionEvent::PunchOut:
1175 // cerr << "PunchOUT at " << transport_sample() << endl;
1176 if (config.get_punch_out()) {
1177 step_back_from_record ();
1183 case SessionEvent::StopOnce:
1184 if (!non_realtime_work_pending()) {
1185 _clear_event_type (SessionEvent::StopOnce);
1186 stop_transport (ev->yes_or_no);
1192 case SessionEvent::RangeStop:
1193 if (!non_realtime_work_pending()) {
1194 stop_transport (ev->yes_or_no);
1200 case SessionEvent::RangeLocate:
1201 /* args: roll after locate, do flush, not with loop */
1202 start_locate (ev->target_sample, true, true, false);
1207 case SessionEvent::Overwrite:
1208 overwrite_some_buffers (static_cast<Track*>(ev->ptr));
1211 case SessionEvent::SetSyncSource:
1212 DEBUG_TRACE (DEBUG::Slave, "seen request for new slave\n");
1213 use_sync_source (ev->slave);
1216 case SessionEvent::Audition:
1217 set_audition (ev->region);
1218 // drop reference to region
1219 ev->region.reset ();
1222 case SessionEvent::SetPlayAudioRange:
1223 set_play_range (ev->audio_range, (ev->speed == 1.0f));
1226 case SessionEvent::CancelPlayAudioRange:
1230 case SessionEvent::RealTimeOperation:
1232 del = false; // other side of RT request needs to clean up
1235 case SessionEvent::AdjustPlaybackBuffering:
1236 schedule_playback_buffering_adjustment ();
1239 case SessionEvent::AdjustCaptureBuffering:
1240 schedule_capture_buffering_adjustment ();
1243 case SessionEvent::SetTimecodeTransmission:
1244 g_atomic_int_set (&_suspend_timecode_transmission, ev->yes_or_no ? 0 : 1);
1248 fatal << string_compose(_("Programming error: illegal event type in process_event (%1)"), ev->type) << endmsg;
1249 abort(); /*NOTREACHED*/
1254 del = del && !_remove_event (ev);
1263 Session::compute_stop_limit () const
1265 if (!Config->get_stop_at_session_end ()) {
1266 return max_samplepos;
1270 return max_samplepos;
1273 bool const punching_in = (config.get_punch_in () && _locations->auto_punch_location());
1274 bool const punching_out = (config.get_punch_out () && _locations->auto_punch_location());
1276 if (actively_recording ()) {
1277 /* permanently recording */
1278 return max_samplepos;
1279 } else if (punching_in && !punching_out) {
1280 /* punching in but never out */
1281 return max_samplepos;
1282 } else if (punching_in && punching_out && _locations->auto_punch_location()->end() > current_end_sample()) {
1283 /* punching in and punching out after session end */
1284 return max_samplepos;
1287 return current_end_sample ();
1292 /* dedicated thread for signal emission.
1294 * while sending cross-thread signals from the process thread
1295 * is fine in general, PBD::Signal's use of boost::function and
1296 * boost:bind can produce a vast overhead which is not
1297 * acceptable for low latency.
1299 * This works around the issue by moving the boost overhead
1300 * out of the RT thread. The overall load is probably higher but
1301 * the realtime thread remains unaffected.
1305 Session::emit_route_signals ()
1307 // TODO use RAII to allow using these signals in other places
1308 BatchUpdateStart(); /* EMIT SIGNAL */
1309 boost::shared_ptr<RouteList> r = routes.reader ();
1310 for (RouteList::const_iterator ci = r->begin(); ci != r->end(); ++ci) {
1311 (*ci)->emit_pending_signals ();
1313 BatchUpdateEnd(); /* EMIT SIGNAL */
1317 Session::emit_thread_start ()
1319 if (_rt_thread_active) {
1322 _rt_thread_active = true;
1324 if (pthread_create (&_rt_emit_thread, NULL, emit_thread, this)) {
1325 _rt_thread_active = false;
1330 Session::emit_thread_terminate ()
1332 if (!_rt_thread_active) {
1335 _rt_thread_active = false;
1337 if (pthread_mutex_lock (&_rt_emit_mutex) == 0) {
1338 pthread_cond_signal (&_rt_emit_cond);
1339 pthread_mutex_unlock (&_rt_emit_mutex);
1343 pthread_join (_rt_emit_thread, &status);
1347 Session::emit_thread (void *arg)
1349 Session *s = static_cast<Session *>(arg);
1350 s->emit_thread_run ();
1356 Session::emit_thread_run ()
1358 pthread_mutex_lock (&_rt_emit_mutex);
1359 while (_rt_thread_active) {
1360 emit_route_signals();
1361 pthread_cond_wait (&_rt_emit_cond, &_rt_emit_mutex);
1363 pthread_mutex_unlock (&_rt_emit_mutex);