2 Copyright (C) 1999-2002 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 #include "pbd/error.h"
26 #include "pbd/enumwriter.h"
28 #include <glibmm/threads.h>
30 #include "ardour/audioengine.h"
31 #include "ardour/auditioner.h"
32 #include "ardour/butler.h"
33 #include "ardour/cycle_timer.h"
34 #include "ardour/debug.h"
35 #include "ardour/graph.h"
36 #include "ardour/port.h"
37 #include "ardour/process_thread.h"
38 #include "ardour/scene_changer.h"
39 #include "ardour/session.h"
40 #include "ardour/slave.h"
41 #include "ardour/ticker.h"
42 #include "ardour/types.h"
44 #include "midi++/mmc.h"
48 using namespace ARDOUR;
52 /** Called by the audio engine when there is work to be done with JACK.
53 * @param nframes Number of frames to process.
57 Session::process (pframes_t nframes)
59 framepos_t transport_at_start = _transport_frame;
63 if (processing_blocked()) {
68 if (non_realtime_work_pending()) {
69 if (!_butler->transport_work_requested ()) {
74 _engine.main_thread()->get_buffers ();
76 (this->*process_function) (nframes);
78 /* realtime-safe meter-position and processor-order changes
80 * ideally this would be done in
81 * Route::process_output_buffers() but various functions
82 * callig it hold a _processor_lock reader-lock
84 boost::shared_ptr<RouteList> r = routes.reader ();
85 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
86 if ((*i)->apply_processor_changes_rt()) {
87 _rt_emit_pending = true;
90 if (_rt_emit_pending) {
91 if (!_rt_thread_active) {
92 emit_route_signals ();
94 if (pthread_mutex_trylock (&_rt_emit_mutex) == 0) {
95 pthread_cond_signal (&_rt_emit_cond);
96 pthread_mutex_unlock (&_rt_emit_mutex);
97 _rt_emit_pending = false;
101 _engine.main_thread()->drop_buffers ();
103 /* deliver MIDI clock. Note that we need to use the transport frame
104 * position at the start of process(), not the value at the end of
105 * it. We may already have ticked() because of a transport state
106 * change, for example.
110 if (!_silent && !_engine.freewheeling() && Config->get_send_midi_clock() && (transport_speed() == 1.0f || transport_speed() == 0.0f) && midi_clock->has_midi_port()) {
111 midi_clock->tick (transport_at_start, nframes);
114 _scene_changer->run (transport_at_start, transport_at_start + nframes);
117 /* don't bother with a message */
120 SendFeedback (); /* EMIT SIGNAL */
124 Session::fail_roll (pframes_t nframes)
126 return no_roll (nframes);
130 Session::no_roll (pframes_t nframes)
134 framepos_t end_frame = _transport_frame + nframes; // FIXME: varispeed + no_roll ??
136 int declick = (config.get_use_transport_fades() ? get_transport_declick_required() : false);
137 boost::shared_ptr<RouteList> r = routes.reader ();
140 _click_io->silence (nframes);
143 ltc_tx_send_time_code_for_cycle (_transport_frame, end_frame, _target_transport_speed, _transport_speed, nframes);
145 if (_process_graph) {
146 DEBUG_TRACE(DEBUG::ProcessThreads,"calling graph/no-roll\n");
147 _process_graph->routes_no_roll( nframes, _transport_frame, end_frame, non_realtime_work_pending(), declick);
149 PT_TIMING_CHECK (10);
150 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
152 if ((*i)->is_auditioner()) {
156 (*i)->set_pending_declick (declick);
158 if ((*i)->no_roll (nframes, _transport_frame, end_frame, non_realtime_work_pending())) {
159 error << string_compose(_("Session: error in no roll for %1"), (*i)->name()) << endmsg;
164 PT_TIMING_CHECK (11);
171 /** @param need_butler to be set to true by this method if it needs the butler,
172 * otherwise it must be left alone.
175 Session::process_routes (pframes_t nframes, bool& need_butler)
177 int declick = (config.get_use_transport_fades() ? get_transport_declick_required() : false);
178 boost::shared_ptr<RouteList> r = routes.reader ();
180 const framepos_t start_frame = _transport_frame;
181 const framepos_t end_frame = _transport_frame + floor (nframes * _transport_speed);
183 if (_process_graph) {
184 DEBUG_TRACE(DEBUG::ProcessThreads,"calling graph/process-routes\n");
185 if (_process_graph->process_routes (nframes, start_frame, end_frame, declick, need_butler) < 0) {
191 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
195 if ((*i)->is_auditioner()) {
199 (*i)->set_pending_declick (declick);
203 if ((ret = (*i)->roll (nframes, start_frame, end_frame, declick, b)) < 0) {
217 /** @param need_butler to be set to true by this method if it needs the butler,
218 * otherwise it must be left alone.
221 Session::silent_process_routes (pframes_t nframes, bool& need_butler)
223 boost::shared_ptr<RouteList> r = routes.reader ();
225 const framepos_t start_frame = _transport_frame;
226 const framepos_t end_frame = _transport_frame + lrintf(nframes * _transport_speed);
228 if (_process_graph) {
229 _process_graph->silent_process_routes (nframes, start_frame, end_frame, need_butler);
231 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
235 if ((*i)->is_auditioner()) {
241 if ((ret = (*i)->silent_roll (nframes, start_frame, end_frame, b)) < 0) {
256 Session::get_track_statistics ()
261 boost::shared_ptr<RouteList> rl = routes.reader();
262 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
264 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
266 if (!tr || tr->hidden()) {
270 pworst = min (pworst, tr->playback_buffer_load());
271 cworst = min (cworst, tr->capture_buffer_load());
274 g_atomic_int_set (&_playback_load, (uint32_t) floor (pworst * 100.0f));
275 g_atomic_int_set (&_capture_load, (uint32_t) floor (cworst * 100.0f));
277 if (actively_recording()) {
282 /** Process callback used when the auditioner is not active */
284 Session::process_with_events (pframes_t nframes)
289 pframes_t this_nframes;
290 framepos_t end_frame;
291 bool session_needs_butler = false;
292 framecnt_t frames_moved;
294 /* make sure the auditioner is silent */
297 auditioner->silence (nframes);
300 /* handle any pending events */
302 while (pending_events.read (&ev, 1) == 1) {
306 /* if we are not in the middle of a state change,
307 and there are immediate events queued up,
311 while (!non_realtime_work_pending() && !immediate_events.empty()) {
312 SessionEvent *ev = immediate_events.front ();
313 immediate_events.pop_front ();
317 /* Decide on what to do with quarter-frame MTC during this cycle */
319 bool const was_sending_qf_mtc = _send_qf_mtc;
320 double const tolerance = Config->get_mtc_qf_speed_tolerance() / 100.0;
322 if (_transport_speed != 0) {
324 Config->get_send_mtc () &&
325 _transport_speed >= (1 - tolerance) &&
326 _transport_speed <= (1 + tolerance)
329 if (_send_qf_mtc && !was_sending_qf_mtc) {
330 /* we will re-start quarter-frame MTC this cycle, so send a full update to set things up */
331 _send_timecode_update = true;
334 if (Config->get_send_mtc() && !_send_qf_mtc && _pframes_since_last_mtc > (frame_rate () / 4)) {
335 /* we're sending MTC, but we're not sending QF MTC at the moment, and it's been
336 a quarter of a second since we sent anything at all, so send a full MTC update
339 _send_timecode_update = true;
342 _pframes_since_last_mtc += nframes;
345 /* Events caused a transport change (or we re-started sending
346 * MTC), so send an MTC Full Frame (Timecode) message. This
347 * is sent whether rolling or not, to give slaves an idea of
348 * ardour time on locates (and allow slow slaves to position
349 * and prepare for rolling)
351 if (_send_timecode_update) {
352 send_full_time_code (_transport_frame, nframes);
355 if (!process_can_proceed()) {
360 if (events.empty() || next_event == events.end()) {
361 try_run_lua (nframes); // also during export ?? ->move to process_without_events()
362 process_without_events (nframes);
366 if (_transport_speed == 1.0) {
367 frames_moved = (framecnt_t) nframes;
369 interpolation.set_target_speed (_target_transport_speed);
370 interpolation.set_speed (_transport_speed);
371 frames_moved = (framecnt_t) interpolation.interpolate (0, nframes, 0, 0);
374 end_frame = _transport_frame + frames_moved;
377 SessionEvent* this_event;
378 Events::iterator the_next_one;
380 if (!process_can_proceed()) {
385 if (!_exporting && _slave) {
386 if (!follow_slave (nframes)) {
391 if (_transport_speed == 0) {
396 if (!_exporting && !timecode_transmission_suspended()) {
397 send_midi_time_code_for_cycle (_transport_frame, end_frame, nframes);
400 ltc_tx_send_time_code_for_cycle (_transport_frame, end_frame, _target_transport_speed, _transport_speed, nframes);
402 framepos_t stop_limit = compute_stop_limit ();
404 if (maybe_stop (stop_limit)) {
409 this_event = *next_event;
410 the_next_one = next_event;
413 /* yes folks, here it is, the actual loop where we really truly
419 this_nframes = nframes; /* real (jack) time relative */
420 frames_moved = (framecnt_t) floor (_transport_speed * nframes); /* transport relative */
422 /* running an event, position transport precisely to its time */
423 if (this_event && this_event->action_frame <= end_frame && this_event->action_frame >= _transport_frame) {
424 /* this isn't quite right for reverse play */
425 frames_moved = (framecnt_t) (this_event->action_frame - _transport_frame);
426 this_nframes = abs (floor(frames_moved / _transport_speed));
429 try_run_lua (this_nframes);
433 click (_transport_frame, this_nframes);
435 if (process_routes (this_nframes, session_needs_butler)) {
440 get_track_statistics ();
442 nframes -= this_nframes;
444 if (frames_moved < 0) {
445 decrement_transport_position (-frames_moved);
447 increment_transport_position (frames_moved);
450 maybe_stop (stop_limit);
451 check_declick_out ();
455 _engine.split_cycle (this_nframes);
458 /* now handle this event and all others scheduled for the same time */
460 while (this_event && this_event->action_frame == _transport_frame) {
461 process_event (this_event);
463 if (the_next_one == events.end()) {
466 this_event = *the_next_one;
471 /* if an event left our state changing, do the right thing */
473 if (nframes && non_realtime_work_pending()) {
478 /* this is necessary to handle the case of seamless looping */
479 end_frame = _transport_frame + floor (nframes * _transport_speed);
484 } /* implicit release of route lock */
486 if (session_needs_butler) {
492 Session::reset_slave_state ()
494 average_slave_delta = 1800;
495 delta_accumulator_cnt = 0;
496 have_first_delta_accumulator = false;
497 _slave_state = Stopped;
501 Session::transport_locked () const
505 if (!locate_pending() && (!config.get_external_sync() || (sl && sl->ok() && sl->locked()))) {
513 Session::follow_slave (pframes_t nframes)
516 framepos_t slave_transport_frame;
517 framecnt_t this_delta;
522 config.set_external_sync (false);
526 _slave->speed_and_position (slave_speed, slave_transport_frame);
528 DEBUG_TRACE (DEBUG::Slave, string_compose ("Slave position %1 speed %2\n", slave_transport_frame, slave_speed));
530 if (!_slave->locked()) {
531 DEBUG_TRACE (DEBUG::Slave, "slave not locked\n");
535 if (slave_transport_frame > _transport_frame) {
536 this_delta = slave_transport_frame - _transport_frame;
539 this_delta = _transport_frame - slave_transport_frame;
543 if (_slave->starting()) {
547 if (_slave->is_always_synced() ||
548 (Config->get_timecode_source_is_synced() && (dynamic_cast<TimecodeSlave*>(_slave)) != 0)
551 /* if the TC source is synced, then we assume that its
552 speed is binary: 0.0 or 1.0
555 if (slave_speed != 0.0f) {
561 /* if we are chasing and the average delta between us and the
562 master gets too big, we want to switch to silent
563 motion. so keep track of that here.
566 if (_slave_state == Running) {
567 calculate_moving_average_of_slave_delta(dir, this_delta);
571 track_slave_state (slave_speed, slave_transport_frame, this_delta);
573 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave state %1 @ %2 speed %3 cur delta %4 avg delta %5\n",
574 _slave_state, slave_transport_frame, slave_speed, this_delta, average_slave_delta));
577 if (_slave_state == Running && !_slave->is_always_synced() &&
578 !(Config->get_timecode_source_is_synced() && (dynamic_cast<TimecodeSlave*>(_slave)) != 0)
581 if (_transport_speed != 0.0f) {
584 note that average_dir is +1 or -1
589 if (average_slave_delta == 0) {
593 delta = average_slave_delta;
594 delta *= average_dir;
598 if (slave_speed != 0.0) {
599 DEBUG_TRACE (DEBUG::Slave, string_compose ("delta = %1 speed = %2 ts = %3 M@%4 S@%5 avgdelta %6\n",
600 (int) (dir * this_delta),
604 slave_transport_frame,
605 average_slave_delta));
609 if (_slave->give_slave_full_control_over_transport_speed()) {
610 set_transport_speed (slave_speed, 0, false, false);
611 //std::cout << "set speed = " << slave_speed << "\n";
613 float adjusted_speed = slave_speed + (1.5 * (delta / float(_current_frame_rate)));
614 request_transport_speed (adjusted_speed);
615 DEBUG_TRACE (DEBUG::Slave, string_compose ("adjust using %1 towards %2 ratio %3 current %4 slave @ %5\n",
616 delta, adjusted_speed, adjusted_speed/slave_speed, _transport_speed,
621 if (!actively_recording() && (framecnt_t) abs(average_slave_delta) > _slave->resolution()) {
622 cerr << "average slave delta greater than slave resolution (" << _slave->resolution() << "), going to silent motion\n";
630 if (_slave_state == Running && !non_realtime_work_pending()) {
631 /* speed is set, we're locked, and good to go */
636 DEBUG_TRACE (DEBUG::Slave, "silent motion\n")
637 follow_slave_silently (nframes, slave_speed);
640 /* don't move at all */
641 DEBUG_TRACE (DEBUG::Slave, "no roll\n")
647 Session::calculate_moving_average_of_slave_delta (int dir, framecnt_t this_delta)
649 if (delta_accumulator_cnt >= delta_accumulator_size) {
650 have_first_delta_accumulator = true;
651 delta_accumulator_cnt = 0;
654 if (delta_accumulator_cnt != 0 || this_delta < _current_frame_rate) {
655 delta_accumulator[delta_accumulator_cnt++] = (framecnt_t) dir * (framecnt_t) this_delta;
658 if (have_first_delta_accumulator) {
659 average_slave_delta = 0L;
660 for (int i = 0; i < delta_accumulator_size; ++i) {
661 average_slave_delta += delta_accumulator[i];
663 average_slave_delta /= (int32_t) delta_accumulator_size;
664 if (average_slave_delta < 0L) {
666 average_slave_delta = abs(average_slave_delta);
674 Session::track_slave_state (float slave_speed, framepos_t slave_transport_frame, framecnt_t /*this_delta*/)
676 if (slave_speed != 0.0f) {
678 /* slave is running */
680 switch (_slave_state) {
682 if (_slave->requires_seekahead()) {
683 slave_wait_end = slave_transport_frame + _slave->seekahead_distance ();
684 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped, but running, requires seekahead to %1\n", slave_wait_end));
685 /* we can call locate() here because we are in process context */
686 locate (slave_wait_end, false, false);
687 _slave_state = Waiting;
691 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped -> running at %1\n", slave_transport_frame));
693 memset (delta_accumulator, 0, sizeof (int32_t) * delta_accumulator_size);
694 average_slave_delta = 0L;
696 Location* al = _locations->auto_loop_location();
698 if (al && play_loop && (slave_transport_frame < al->start() || slave_transport_frame > al->end())) {
700 request_play_loop(false);
703 if (slave_transport_frame != _transport_frame) {
704 DEBUG_TRACE (DEBUG::Slave, string_compose ("require locate to run. eng: %1 -> sl: %2\n", _transport_frame, slave_transport_frame));
705 locate (slave_transport_frame, false, false);
707 _slave_state = Running;
716 if (_slave_state == Waiting) {
718 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave waiting at %1\n", slave_transport_frame));
720 if (slave_transport_frame >= slave_wait_end) {
722 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave start at %1 vs %2\n", slave_transport_frame, _transport_frame));
724 _slave_state = Running;
726 /* now perform a "micro-seek" within the disk buffers to realign ourselves
727 precisely with the master.
732 framecnt_t frame_delta = slave_transport_frame - _transport_frame;
734 boost::shared_ptr<RouteList> rl = routes.reader();
735 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
736 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
737 if (tr && !tr->can_internal_playback_seek (frame_delta)) {
744 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
745 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
747 tr->internal_playback_seek (frame_delta);
750 _transport_frame += frame_delta;
753 cerr << "cannot micro-seek\n";
759 if (_slave_state == Running && _transport_speed == 0.0f) {
760 DEBUG_TRACE (DEBUG::Slave, "slave starts transport\n");
764 } else { // slave_speed is 0
766 /* slave has stopped */
768 if (_transport_speed != 0.0f) {
769 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stops transport: %1 frame %2 tf %3\n", slave_speed, slave_transport_frame, _transport_frame));
773 if (slave_transport_frame != _transport_frame) {
774 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped, move to %1\n", slave_transport_frame));
775 force_locate (slave_transport_frame, false);
783 Session::follow_slave_silently (pframes_t nframes, float slave_speed)
785 if (slave_speed && _transport_speed) {
787 /* something isn't right, but we should move with the master
791 bool need_butler = false;
793 silent_process_routes (nframes, need_butler);
795 get_track_statistics ();
801 int32_t frames_moved = (int32_t) floor (_transport_speed * nframes);
803 if (frames_moved < 0) {
804 decrement_transport_position (-frames_moved);
806 increment_transport_position (frames_moved);
809 framepos_t const stop_limit = compute_stop_limit ();
810 maybe_stop (stop_limit);
815 Session::process_without_events (pframes_t nframes)
817 bool session_needs_butler = false;
818 framecnt_t frames_moved;
820 if (!process_can_proceed()) {
825 if (!_exporting && _slave) {
826 if (!follow_slave (nframes)) {
827 ltc_tx_send_time_code_for_cycle (_transport_frame, _transport_frame, 0, 0 , nframes);
832 if (_transport_speed == 0) {
837 if (_transport_speed == 1.0) {
838 frames_moved = (framecnt_t) nframes;
840 interpolation.set_target_speed (_target_transport_speed);
841 interpolation.set_speed (_transport_speed);
842 frames_moved = (framecnt_t) interpolation.interpolate (0, nframes, 0, 0);
845 if (!_exporting && !timecode_transmission_suspended()) {
846 send_midi_time_code_for_cycle (_transport_frame, _transport_frame + frames_moved, nframes);
849 ltc_tx_send_time_code_for_cycle (_transport_frame, _transport_frame + frames_moved, _target_transport_speed, _transport_speed, nframes);
851 framepos_t const stop_limit = compute_stop_limit ();
853 if (maybe_stop (stop_limit)) {
858 if (maybe_sync_start (nframes)) {
862 click (_transport_frame, nframes);
864 if (process_routes (nframes, session_needs_butler)) {
869 get_track_statistics ();
871 if (frames_moved < 0) {
872 decrement_transport_position (-frames_moved);
874 increment_transport_position (frames_moved);
877 maybe_stop (stop_limit);
878 check_declick_out ();
880 if (session_needs_butler) {
885 /** Process callback used when the auditioner is active.
886 * @param nframes number of frames to process.
889 Session::process_audition (pframes_t nframes)
892 boost::shared_ptr<RouteList> r = routes.reader ();
894 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
895 if (!(*i)->is_auditioner()) {
896 (*i)->silence (nframes);
900 /* run the auditioner, and if it says we need butler service, ask for it */
902 if (auditioner->play_audition (nframes) > 0) {
906 /* if using a monitor section, run it because otherwise we don't hear anything */
908 if (_monitor_out && auditioner->needs_monitor()) {
909 _monitor_out->monitor_run (_transport_frame, _transport_frame + nframes, nframes, false);
912 /* handle pending events */
914 while (pending_events.read (&ev, 1) == 1) {
918 /* if we are not in the middle of a state change,
919 and there are immediate events queued up,
923 while (!non_realtime_work_pending() && !immediate_events.empty()) {
924 SessionEvent *ev = immediate_events.front ();
925 immediate_events.pop_front ();
929 if (!auditioner->auditioning()) {
930 /* auditioner no longer active, so go back to the normal process callback */
931 process_function = &Session::process_with_events;
936 Session::maybe_sync_start (pframes_t & nframes)
938 pframes_t sync_offset;
940 if (!waiting_for_sync_offset) {
944 if (_engine.get_sync_offset (sync_offset) && sync_offset < nframes) {
946 /* generate silence up to the sync point, then
947 adjust nframes + offset to reflect whatever
951 no_roll (sync_offset);
952 nframes -= sync_offset;
953 Port::increment_global_port_buffer_offset (sync_offset);
954 waiting_for_sync_offset = false;
957 return true; // done, nothing left to process
962 /* sync offset point is not within this process()
963 cycle, so just generate silence. and don't bother
964 with any fancy stuff here, just the minimal silence.
969 if (Config->get_locate_while_waiting_for_sync()) {
970 if (micro_locate (nframes)) {
971 /* XXX ERROR !!! XXX */
975 return true; // done, nothing left to process
982 Session::queue_event (SessionEvent* ev)
984 if (_state_of_the_state & Deletion) {
986 } else if (_state_of_the_state & Loading) {
989 pending_events.write (&ev, 1);
994 Session::set_next_event ()
996 if (events.empty()) {
997 next_event = events.end();
1001 if (next_event == events.end()) {
1002 next_event = events.begin();
1005 if ((*next_event)->action_frame > _transport_frame) {
1006 next_event = events.begin();
1009 for (; next_event != events.end(); ++next_event) {
1010 if ((*next_event)->action_frame >= _transport_frame) {
1017 Session::process_event (SessionEvent* ev)
1022 /* if we're in the middle of a state change (i.e. waiting
1023 for the butler thread to complete the non-realtime
1024 part of the change), we'll just have to queue this
1025 event for a time when the change is complete.
1028 if (non_realtime_work_pending()) {
1030 /* except locates, which we have the capability to handle */
1032 if (ev->type != SessionEvent::Locate) {
1033 immediate_events.insert (immediate_events.end(), ev);
1039 DEBUG_TRACE (DEBUG::SessionEvents, string_compose ("Processing event: %1 @ %2\n", enum_2_string (ev->type), _transport_frame));
1042 case SessionEvent::SetLoop:
1043 set_play_loop (ev->yes_or_no, ev->speed);
1046 case SessionEvent::AutoLoop:
1048 /* roll after locate, do not flush, set "with loop"
1049 true only if we are seamless looping
1051 start_locate (ev->target_frame, true, false, Config->get_seamless_loop());
1057 case SessionEvent::AutoLoopDeclick:
1059 /* Request a declick fade-out and a fade-in; the fade-out will happen
1060 at the end of the loop, and the fade-in at the start.
1062 transport_sub_state |= (PendingLoopDeclickOut | PendingLoopDeclickIn);
1068 case SessionEvent::Locate:
1069 if (ev->yes_or_no) {
1070 /* args: do not roll after locate, do flush, not with loop */
1071 locate (ev->target_frame, false, true, false);
1073 /* args: do not roll after locate, do flush, not with loop */
1074 start_locate (ev->target_frame, false, true, false);
1076 _send_timecode_update = true;
1079 case SessionEvent::LocateRoll:
1080 if (ev->yes_or_no) {
1081 /* args: roll after locate, do flush, not with loop */
1082 locate (ev->target_frame, true, true, false);
1084 /* args: roll after locate, do flush, not with loop */
1085 start_locate (ev->target_frame, true, true, false);
1087 _send_timecode_update = true;
1090 case SessionEvent::Skip:
1091 if (Config->get_skip_playback()) {
1092 start_locate (ev->target_frame, true, true, false);
1093 _send_timecode_update = true;
1099 case SessionEvent::LocateRollLocate:
1100 // locate is handled by ::request_roll_at_and_return()
1101 _requested_return_frame = ev->target_frame;
1102 request_locate (ev->target2_frame, true);
1106 case SessionEvent::SetTransportSpeed:
1107 set_transport_speed (ev->speed, ev->target_frame, ev->yes_or_no, ev->second_yes_or_no, ev->third_yes_or_no);
1110 case SessionEvent::PunchIn:
1111 // cerr << "PunchIN at " << transport_frame() << endl;
1112 if (config.get_punch_in() && record_status() == Enabled) {
1119 case SessionEvent::PunchOut:
1120 // cerr << "PunchOUT at " << transport_frame() << endl;
1121 if (config.get_punch_out()) {
1122 step_back_from_record ();
1128 case SessionEvent::StopOnce:
1129 if (!non_realtime_work_pending()) {
1130 _clear_event_type (SessionEvent::StopOnce);
1131 stop_transport (ev->yes_or_no);
1137 case SessionEvent::RangeStop:
1138 if (!non_realtime_work_pending()) {
1139 stop_transport (ev->yes_or_no);
1145 case SessionEvent::RangeLocate:
1146 /* args: roll after locate, do flush, not with loop */
1147 start_locate (ev->target_frame, true, true, false);
1152 case SessionEvent::Overwrite:
1153 overwrite_some_buffers (static_cast<Track*>(ev->ptr));
1156 case SessionEvent::SetTrackSpeed:
1157 set_track_speed (static_cast<Track*> (ev->ptr), ev->speed);
1160 case SessionEvent::SetSyncSource:
1161 DEBUG_TRACE (DEBUG::Slave, "seen request for new slave\n");
1162 use_sync_source (ev->slave);
1165 case SessionEvent::Audition:
1166 set_audition (ev->region);
1167 // drop reference to region
1168 ev->region.reset ();
1171 case SessionEvent::InputConfigurationChange:
1172 add_post_transport_work (PostTransportInputChange);
1173 _butler->schedule_transport_work ();
1176 case SessionEvent::SetPlayAudioRange:
1177 set_play_range (ev->audio_range, (ev->speed == 1.0f));
1180 case SessionEvent::CancelPlayAudioRange:
1184 case SessionEvent::RealTimeOperation:
1186 del = false; // other side of RT request needs to clean up
1189 case SessionEvent::AdjustPlaybackBuffering:
1190 schedule_playback_buffering_adjustment ();
1193 case SessionEvent::AdjustCaptureBuffering:
1194 schedule_capture_buffering_adjustment ();
1197 case SessionEvent::SetTimecodeTransmission:
1198 g_atomic_int_set (&_suspend_timecode_transmission, ev->yes_or_no ? 0 : 1);
1202 fatal << string_compose(_("Programming error: illegal event type in process_event (%1)"), ev->type) << endmsg;
1203 abort(); /*NOTREACHED*/
1208 del = del && !_remove_event (ev);
1217 Session::compute_stop_limit () const
1219 if (!Config->get_stop_at_session_end ()) {
1220 return max_framepos;
1224 return max_framepos;
1228 bool const punching_in = (config.get_punch_in () && _locations->auto_punch_location());
1229 bool const punching_out = (config.get_punch_out () && _locations->auto_punch_location());
1231 if (actively_recording ()) {
1232 /* permanently recording */
1233 return max_framepos;
1234 } else if (punching_in && !punching_out) {
1235 /* punching in but never out */
1236 return max_framepos;
1237 } else if (punching_in && punching_out && _locations->auto_punch_location()->end() > current_end_frame()) {
1238 /* punching in and punching out after session end */
1239 return max_framepos;
1242 return current_end_frame ();
1247 /* dedicated thread for signal emission.
1249 * while sending cross-thread signals from the process thread
1250 * is fine in general, PBD::Signal's use of boost::function and
1251 * boost:bind can produce a vast overhead which is not
1252 * acceptable for low latency.
1254 * This works around the issue by moving the boost overhead
1255 * out of the RT thread. The overall load is probably higher but
1256 * the realtime thread remains unaffected.
1260 Session::emit_route_signals ()
1262 // TODO use RAII to allow using these signals in other places
1263 BatchUpdateStart(); /* EMIT SIGNAL */
1264 boost::shared_ptr<RouteList> r = routes.reader ();
1265 for (RouteList::const_iterator ci = r->begin(); ci != r->end(); ++ci) {
1266 (*ci)->emit_pending_signals ();
1268 BatchUpdateEnd(); /* EMIT SIGNAL */
1272 Session::emit_thread_start ()
1274 if (_rt_thread_active) {
1277 _rt_thread_active = true;
1279 if (pthread_create (&_rt_emit_thread, NULL, emit_thread, this)) {
1280 _rt_thread_active = false;
1285 Session::emit_thread_terminate ()
1287 if (!_rt_thread_active) {
1290 _rt_thread_active = false;
1292 if (pthread_mutex_lock (&_rt_emit_mutex) == 0) {
1293 pthread_cond_signal (&_rt_emit_cond);
1294 pthread_mutex_unlock (&_rt_emit_mutex);
1298 pthread_join (_rt_emit_thread, &status);
1302 Session::emit_thread (void *arg)
1304 Session *s = static_cast<Session *>(arg);
1305 s->emit_thread_run ();
1311 Session::emit_thread_run ()
1313 pthread_mutex_lock (&_rt_emit_mutex);
1314 while (_rt_thread_active) {
1315 emit_route_signals();
1316 pthread_cond_wait (&_rt_emit_cond, &_rt_emit_mutex);
1318 pthread_mutex_unlock (&_rt_emit_mutex);