2 Copyright (C) 1999-2002 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
25 #include "pbd/error.h"
26 #include "pbd/enumwriter.h"
28 #include <glibmm/threads.h>
30 #include "ardour/audioengine.h"
31 #include "ardour/auditioner.h"
32 #include "ardour/butler.h"
33 #include "ardour/cycle_timer.h"
34 #include "ardour/debug.h"
35 #include "ardour/graph.h"
36 #include "ardour/port.h"
37 #include "ardour/process_thread.h"
38 #include "ardour/scene_changer.h"
39 #include "ardour/session.h"
40 #include "ardour/slave.h"
41 #include "ardour/ticker.h"
42 #include "ardour/types.h"
43 #include "ardour/vca.h"
44 #include "ardour/vca_manager.h"
46 #include "midi++/mmc.h"
50 using namespace ARDOUR;
54 /** Called by the audio engine when there is work to be done with JACK.
55 * @param nframes Number of frames to process.
59 Session::process (pframes_t nframes)
61 framepos_t transport_at_start = _transport_frame;
65 if (processing_blocked()) {
70 if (non_realtime_work_pending()) {
71 if (!_butler->transport_work_requested ()) {
76 _engine.main_thread()->get_buffers ();
78 (this->*process_function) (nframes);
80 /* realtime-safe meter-position and processor-order changes
82 * ideally this would be done in
83 * Route::process_output_buffers() but various functions
84 * callig it hold a _processor_lock reader-lock
86 boost::shared_ptr<RouteList> r = routes.reader ();
87 for (RouteList::const_iterator i = r->begin(); i != r->end(); ++i) {
88 if ((*i)->apply_processor_changes_rt()) {
89 _rt_emit_pending = true;
92 if (_rt_emit_pending) {
93 if (!_rt_thread_active) {
94 emit_route_signals ();
96 if (pthread_mutex_trylock (&_rt_emit_mutex) == 0) {
97 pthread_cond_signal (&_rt_emit_cond);
98 pthread_mutex_unlock (&_rt_emit_mutex);
99 _rt_emit_pending = false;
103 _engine.main_thread()->drop_buffers ();
105 /* deliver MIDI clock. Note that we need to use the transport frame
106 * position at the start of process(), not the value at the end of
107 * it. We may already have ticked() because of a transport state
108 * change, for example.
112 if (!_silent && !_engine.freewheeling() && Config->get_send_midi_clock() && (transport_speed() == 1.0f || transport_speed() == 0.0f) && midi_clock->has_midi_port()) {
113 midi_clock->tick (transport_at_start, nframes);
116 _scene_changer->run (transport_at_start, transport_at_start + nframes);
119 /* don't bother with a message */
122 SendFeedback (); /* EMIT SIGNAL */
126 Session::fail_roll (pframes_t nframes)
128 return no_roll (nframes);
132 Session::no_roll (pframes_t nframes)
136 framepos_t end_frame = _transport_frame + nframes; // FIXME: varispeed + no_roll ??
138 int declick = (config.get_use_transport_fades() ? get_transport_declick_required() : false);
139 boost::shared_ptr<RouteList> r = routes.reader ();
142 _click_io->silence (nframes);
145 ltc_tx_send_time_code_for_cycle (_transport_frame, end_frame, _target_transport_speed, _transport_speed, nframes);
147 VCAList v = _vca_manager->vcas ();
148 for (VCAList::const_iterator i = v.begin(); i != v.end(); ++i) {
149 (*i)->automation_run (_transport_frame, nframes);
152 if (_process_graph) {
153 DEBUG_TRACE(DEBUG::ProcessThreads,"calling graph/no-roll\n");
154 _process_graph->routes_no_roll( nframes, _transport_frame, end_frame, non_realtime_work_pending(), declick);
156 PT_TIMING_CHECK (10);
157 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
159 if ((*i)->is_auditioner()) {
163 (*i)->set_pending_declick (declick);
165 if ((*i)->no_roll (nframes, _transport_frame, end_frame, non_realtime_work_pending())) {
166 error << string_compose(_("Session: error in no roll for %1"), (*i)->name()) << endmsg;
171 PT_TIMING_CHECK (11);
178 /** @param need_butler to be set to true by this method if it needs the butler,
179 * otherwise it must be left alone.
182 Session::process_routes (pframes_t nframes, bool& need_butler)
184 int declick = (config.get_use_transport_fades() ? get_transport_declick_required() : false);
185 boost::shared_ptr<RouteList> r = routes.reader ();
187 const framepos_t start_frame = _transport_frame;
188 const framepos_t end_frame = _transport_frame + floor (nframes * _transport_speed);
190 VCAList v = _vca_manager->vcas ();
191 for (VCAList::const_iterator i = v.begin(); i != v.end(); ++i) {
192 (*i)->automation_run (start_frame, nframes);
195 if (_process_graph) {
196 DEBUG_TRACE(DEBUG::ProcessThreads,"calling graph/process-routes\n");
197 if (_process_graph->process_routes (nframes, start_frame, end_frame, declick, need_butler) < 0) {
203 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
207 if ((*i)->is_auditioner()) {
211 (*i)->set_pending_declick (declick);
215 if ((ret = (*i)->roll (nframes, start_frame, end_frame, declick, b)) < 0) {
229 /** @param need_butler to be set to true by this method if it needs the butler,
230 * otherwise it must be left alone.
233 Session::silent_process_routes (pframes_t nframes, bool& need_butler)
235 boost::shared_ptr<RouteList> r = routes.reader ();
237 const framepos_t start_frame = _transport_frame;
238 const framepos_t end_frame = _transport_frame + lrintf(nframes * _transport_speed);
240 VCAList v = _vca_manager->vcas ();
241 for (VCAList::const_iterator i = v.begin(); i != v.end(); ++i) {
242 (*i)->automation_run (start_frame, nframes);
245 if (_process_graph) {
246 _process_graph->silent_process_routes (nframes, start_frame, end_frame, need_butler);
248 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
252 if ((*i)->is_auditioner()) {
258 if ((ret = (*i)->silent_roll (nframes, start_frame, end_frame, b)) < 0) {
273 Session::get_track_statistics ()
278 boost::shared_ptr<RouteList> rl = routes.reader();
279 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
281 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
283 if (!tr || tr->hidden()) {
287 pworst = min (pworst, tr->playback_buffer_load());
288 cworst = min (cworst, tr->capture_buffer_load());
291 g_atomic_int_set (&_playback_load, (uint32_t) floor (pworst * 100.0f));
292 g_atomic_int_set (&_capture_load, (uint32_t) floor (cworst * 100.0f));
294 if (actively_recording()) {
299 /** Process callback used when the auditioner is not active */
301 Session::process_with_events (pframes_t nframes)
306 pframes_t this_nframes;
307 framepos_t end_frame;
308 bool session_needs_butler = false;
309 framecnt_t frames_moved;
311 /* make sure the auditioner is silent */
314 auditioner->silence (nframes);
317 /* handle any pending events */
319 while (pending_events.read (&ev, 1) == 1) {
323 /* if we are not in the middle of a state change,
324 and there are immediate events queued up,
328 while (!non_realtime_work_pending() && !immediate_events.empty()) {
329 SessionEvent *ev = immediate_events.front ();
330 immediate_events.pop_front ();
335 if (_transport_speed != 1.0 && _count_in_samples > 0) {
336 _count_in_samples = 0;
339 if (_count_in_samples > 0) {
340 framecnt_t ns = std::min ((framecnt_t)nframes, _count_in_samples);
343 run_click (_transport_frame - _count_in_samples, ns);
345 _count_in_samples -= ns;
348 /* process events.. */
349 if (!events.empty() && next_event != events.end()) {
350 SessionEvent* this_event = *next_event;
351 Events::iterator the_next_one = next_event;
354 while (this_event && this_event->action_frame == _transport_frame) {
355 process_event (this_event);
356 if (the_next_one == events.end()) {
359 this_event = *the_next_one;
366 check_declick_out ();
371 _engine.split_cycle (ns);
375 /* Decide on what to do with quarter-frame MTC during this cycle */
377 bool const was_sending_qf_mtc = _send_qf_mtc;
378 double const tolerance = Config->get_mtc_qf_speed_tolerance() / 100.0;
380 if (_transport_speed != 0) {
382 Config->get_send_mtc () &&
383 _transport_speed >= (1 - tolerance) &&
384 _transport_speed <= (1 + tolerance)
387 if (_send_qf_mtc && !was_sending_qf_mtc) {
388 /* we will re-start quarter-frame MTC this cycle, so send a full update to set things up */
389 _send_timecode_update = true;
392 if (Config->get_send_mtc() && !_send_qf_mtc && _pframes_since_last_mtc > (frame_rate () / 4)) {
393 /* we're sending MTC, but we're not sending QF MTC at the moment, and it's been
394 a quarter of a second since we sent anything at all, so send a full MTC update
397 _send_timecode_update = true;
400 _pframes_since_last_mtc += nframes;
403 /* Events caused a transport change (or we re-started sending
404 * MTC), so send an MTC Full Frame (Timecode) message. This
405 * is sent whether rolling or not, to give slaves an idea of
406 * ardour time on locates (and allow slow slaves to position
407 * and prepare for rolling)
409 if (_send_timecode_update) {
410 send_full_time_code (_transport_frame, nframes);
413 if (!process_can_proceed()) {
418 if (events.empty() || next_event == events.end()) {
419 try_run_lua (nframes); // also during export ?? ->move to process_without_events()
420 /* lua scripts may inject events */
421 while (_n_lua_scripts > 0 && pending_events.read (&ev, 1) == 1) {
424 if (events.empty() || next_event == events.end()) {
425 process_without_events (nframes);
430 if (_transport_speed == 1.0) {
431 frames_moved = (framecnt_t) nframes;
433 interpolation.set_target_speed (_target_transport_speed);
434 interpolation.set_speed (_transport_speed);
435 frames_moved = (framecnt_t) interpolation.interpolate (0, nframes, 0, 0);
438 end_frame = _transport_frame + frames_moved;
441 SessionEvent* this_event;
442 Events::iterator the_next_one;
444 if (!process_can_proceed()) {
449 if (!_exporting && _slave) {
450 if (!follow_slave (nframes)) {
455 if (_transport_speed == 0) {
460 if (!_exporting && !timecode_transmission_suspended()) {
461 send_midi_time_code_for_cycle (_transport_frame, end_frame, nframes);
464 ltc_tx_send_time_code_for_cycle (_transport_frame, end_frame, _target_transport_speed, _transport_speed, nframes);
466 framepos_t stop_limit = compute_stop_limit ();
468 if (maybe_stop (stop_limit)) {
473 this_event = *next_event;
474 the_next_one = next_event;
477 /* yes folks, here it is, the actual loop where we really truly
483 this_nframes = nframes; /* real (jack) time relative */
484 frames_moved = (framecnt_t) floor (_transport_speed * nframes); /* transport relative */
486 /* running an event, position transport precisely to its time */
487 if (this_event && this_event->action_frame <= end_frame && this_event->action_frame >= _transport_frame) {
488 /* this isn't quite right for reverse play */
489 frames_moved = (framecnt_t) (this_event->action_frame - _transport_frame);
490 this_nframes = abs (floor(frames_moved / _transport_speed));
493 try_run_lua (this_nframes);
497 click (_transport_frame, this_nframes);
499 if (process_routes (this_nframes, session_needs_butler)) {
504 get_track_statistics ();
506 nframes -= this_nframes;
508 if (frames_moved < 0) {
509 decrement_transport_position (-frames_moved);
511 increment_transport_position (frames_moved);
514 maybe_stop (stop_limit);
515 check_declick_out ();
519 _engine.split_cycle (this_nframes);
522 /* now handle this event and all others scheduled for the same time */
524 while (this_event && this_event->action_frame == _transport_frame) {
525 process_event (this_event);
527 if (the_next_one == events.end()) {
530 this_event = *the_next_one;
535 /* if an event left our state changing, do the right thing */
537 if (nframes && non_realtime_work_pending()) {
542 /* this is necessary to handle the case of seamless looping */
543 end_frame = _transport_frame + floor (nframes * _transport_speed);
548 } /* implicit release of route lock */
550 if (session_needs_butler) {
556 Session::reset_slave_state ()
558 average_slave_delta = 1800;
559 delta_accumulator_cnt = 0;
560 have_first_delta_accumulator = false;
561 _slave_state = Stopped;
565 Session::transport_locked () const
569 if (!locate_pending() && (!config.get_external_sync() || (sl && sl->ok() && sl->locked()))) {
577 Session::follow_slave (pframes_t nframes)
580 framepos_t slave_transport_frame;
581 framecnt_t this_delta;
586 config.set_external_sync (false);
590 _slave->speed_and_position (slave_speed, slave_transport_frame);
592 DEBUG_TRACE (DEBUG::Slave, string_compose ("Slave position %1 speed %2\n", slave_transport_frame, slave_speed));
594 if (!_slave->locked()) {
595 DEBUG_TRACE (DEBUG::Slave, "slave not locked\n");
599 if (slave_transport_frame > _transport_frame) {
600 this_delta = slave_transport_frame - _transport_frame;
603 this_delta = _transport_frame - slave_transport_frame;
607 if (_slave->starting()) {
611 if (_slave->is_always_synced() ||
612 (Config->get_timecode_source_is_synced() && (dynamic_cast<TimecodeSlave*>(_slave)) != 0)
615 /* if the TC source is synced, then we assume that its
616 speed is binary: 0.0 or 1.0
619 if (slave_speed != 0.0f) {
625 /* if we are chasing and the average delta between us and the
626 master gets too big, we want to switch to silent
627 motion. so keep track of that here.
630 if (_slave_state == Running) {
631 calculate_moving_average_of_slave_delta(dir, this_delta);
635 track_slave_state (slave_speed, slave_transport_frame, this_delta);
637 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave state %1 @ %2 speed %3 cur delta %4 avg delta %5\n",
638 _slave_state, slave_transport_frame, slave_speed, this_delta, average_slave_delta));
641 if (_slave_state == Running && !_slave->is_always_synced() &&
642 !(Config->get_timecode_source_is_synced() && (dynamic_cast<TimecodeSlave*>(_slave)) != 0)
645 if (_transport_speed != 0.0f) {
648 note that average_dir is +1 or -1
653 if (average_slave_delta == 0) {
657 delta = average_slave_delta;
658 delta *= average_dir;
662 if (slave_speed != 0.0) {
663 DEBUG_TRACE (DEBUG::Slave, string_compose ("delta = %1 speed = %2 ts = %3 M@%4 S@%5 avgdelta %6\n",
664 (int) (dir * this_delta),
668 slave_transport_frame,
669 average_slave_delta));
673 if (_slave->give_slave_full_control_over_transport_speed()) {
674 set_transport_speed (slave_speed, 0, false, false);
675 //std::cout << "set speed = " << slave_speed << "\n";
677 float adjusted_speed = slave_speed + (1.5 * (delta / float(_current_frame_rate)));
678 request_transport_speed (adjusted_speed);
679 DEBUG_TRACE (DEBUG::Slave, string_compose ("adjust using %1 towards %2 ratio %3 current %4 slave @ %5\n",
680 delta, adjusted_speed, adjusted_speed/slave_speed, _transport_speed,
685 if (!actively_recording() && (framecnt_t) abs(average_slave_delta) > _slave->resolution()) {
686 cerr << "average slave delta greater than slave resolution (" << _slave->resolution() << "), going to silent motion\n";
694 if (_slave_state == Running && 0 == (post_transport_work () & ~PostTransportSpeed)) {
695 /* speed is set, we're locked, and good to go */
700 DEBUG_TRACE (DEBUG::Slave, "silent motion\n")
701 follow_slave_silently (nframes, slave_speed);
704 /* don't move at all */
705 DEBUG_TRACE (DEBUG::Slave, "no roll\n")
711 Session::calculate_moving_average_of_slave_delta (int dir, framecnt_t this_delta)
713 if (delta_accumulator_cnt >= delta_accumulator_size) {
714 have_first_delta_accumulator = true;
715 delta_accumulator_cnt = 0;
718 if (delta_accumulator_cnt != 0 || this_delta < _current_frame_rate) {
719 delta_accumulator[delta_accumulator_cnt++] = (framecnt_t) dir * (framecnt_t) this_delta;
722 if (have_first_delta_accumulator) {
723 average_slave_delta = 0L;
724 for (int i = 0; i < delta_accumulator_size; ++i) {
725 average_slave_delta += delta_accumulator[i];
727 average_slave_delta /= (int32_t) delta_accumulator_size;
728 if (average_slave_delta < 0L) {
730 average_slave_delta = abs(average_slave_delta);
738 Session::track_slave_state (float slave_speed, framepos_t slave_transport_frame, framecnt_t /*this_delta*/)
740 if (slave_speed != 0.0f) {
742 /* slave is running */
744 switch (_slave_state) {
746 if (_slave->requires_seekahead()) {
747 slave_wait_end = slave_transport_frame + _slave->seekahead_distance ();
748 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped, but running, requires seekahead to %1\n", slave_wait_end));
749 /* we can call locate() here because we are in process context */
750 locate (slave_wait_end, false, false);
751 _slave_state = Waiting;
755 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped -> running at %1\n", slave_transport_frame));
757 memset (delta_accumulator, 0, sizeof (int32_t) * delta_accumulator_size);
758 average_slave_delta = 0L;
760 Location* al = _locations->auto_loop_location();
762 if (al && play_loop && (slave_transport_frame < al->start() || slave_transport_frame > al->end())) {
764 request_play_loop(false);
767 if (slave_transport_frame != _transport_frame) {
768 DEBUG_TRACE (DEBUG::Slave, string_compose ("require locate to run. eng: %1 -> sl: %2\n", _transport_frame, slave_transport_frame));
769 locate (slave_transport_frame, false, false);
771 _slave_state = Running;
780 if (_slave_state == Waiting) {
782 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave waiting at %1\n", slave_transport_frame));
784 if (slave_transport_frame >= slave_wait_end) {
786 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave start at %1 vs %2\n", slave_transport_frame, _transport_frame));
788 _slave_state = Running;
790 /* now perform a "micro-seek" within the disk buffers to realign ourselves
791 precisely with the master.
796 framecnt_t frame_delta = slave_transport_frame - _transport_frame;
798 boost::shared_ptr<RouteList> rl = routes.reader();
799 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
800 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
801 if (tr && !tr->can_internal_playback_seek (frame_delta)) {
808 for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
809 boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
811 tr->internal_playback_seek (frame_delta);
814 _transport_frame += frame_delta;
817 cerr << "cannot micro-seek\n";
823 if (_slave_state == Running && _transport_speed == 0.0f) {
824 DEBUG_TRACE (DEBUG::Slave, "slave starts transport\n");
828 } else { // slave_speed is 0
830 /* slave has stopped */
832 if (_transport_speed != 0.0f) {
833 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stops transport: %1 frame %2 tf %3\n", slave_speed, slave_transport_frame, _transport_frame));
837 if (slave_transport_frame != _transport_frame) {
838 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped, move to %1\n", slave_transport_frame));
839 force_locate (slave_transport_frame, false);
847 Session::follow_slave_silently (pframes_t nframes, float slave_speed)
849 if (slave_speed && _transport_speed) {
851 /* something isn't right, but we should move with the master
855 bool need_butler = false;
857 silent_process_routes (nframes, need_butler);
859 get_track_statistics ();
865 int32_t frames_moved = (int32_t) floor (_transport_speed * nframes);
867 if (frames_moved < 0) {
868 decrement_transport_position (-frames_moved);
870 increment_transport_position (frames_moved);
873 framepos_t const stop_limit = compute_stop_limit ();
874 maybe_stop (stop_limit);
879 Session::process_without_events (pframes_t nframes)
881 bool session_needs_butler = false;
882 framecnt_t frames_moved;
884 if (!process_can_proceed()) {
889 if (!_exporting && _slave) {
890 if (!follow_slave (nframes)) {
891 ltc_tx_send_time_code_for_cycle (_transport_frame, _transport_frame, 0, 0 , nframes);
896 if (_transport_speed == 0) {
901 if (_transport_speed == 1.0) {
902 frames_moved = (framecnt_t) nframes;
904 interpolation.set_target_speed (_target_transport_speed);
905 interpolation.set_speed (_transport_speed);
906 frames_moved = (framecnt_t) interpolation.interpolate (0, nframes, 0, 0);
909 if (!_exporting && !timecode_transmission_suspended()) {
910 send_midi_time_code_for_cycle (_transport_frame, _transport_frame + frames_moved, nframes);
913 ltc_tx_send_time_code_for_cycle (_transport_frame, _transport_frame + frames_moved, _target_transport_speed, _transport_speed, nframes);
915 framepos_t const stop_limit = compute_stop_limit ();
917 if (maybe_stop (stop_limit)) {
922 if (maybe_sync_start (nframes)) {
926 click (_transport_frame, nframes);
928 if (process_routes (nframes, session_needs_butler)) {
933 get_track_statistics ();
935 if (frames_moved < 0) {
936 decrement_transport_position (-frames_moved);
938 increment_transport_position (frames_moved);
941 maybe_stop (stop_limit);
942 check_declick_out ();
944 if (session_needs_butler) {
949 /** Process callback used when the auditioner is active.
950 * @param nframes number of frames to process.
953 Session::process_audition (pframes_t nframes)
956 boost::shared_ptr<RouteList> r = routes.reader ();
958 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
959 if (!(*i)->is_auditioner()) {
960 (*i)->silence (nframes);
964 /* run the auditioner, and if it says we need butler service, ask for it */
966 if (auditioner->play_audition (nframes) > 0) {
970 /* if using a monitor section, run it because otherwise we don't hear anything */
972 if (_monitor_out && auditioner->needs_monitor()) {
973 _monitor_out->monitor_run (_transport_frame, _transport_frame + nframes, nframes, false);
976 /* handle pending events */
978 while (pending_events.read (&ev, 1) == 1) {
982 /* if we are not in the middle of a state change,
983 and there are immediate events queued up,
987 while (!non_realtime_work_pending() && !immediate_events.empty()) {
988 SessionEvent *ev = immediate_events.front ();
989 immediate_events.pop_front ();
993 if (!auditioner->auditioning()) {
994 /* auditioner no longer active, so go back to the normal process callback */
995 process_function = &Session::process_with_events;
1000 Session::maybe_sync_start (pframes_t & nframes)
1002 pframes_t sync_offset;
1004 if (!waiting_for_sync_offset) {
1008 if (_engine.get_sync_offset (sync_offset) && sync_offset < nframes) {
1010 /* generate silence up to the sync point, then
1011 adjust nframes + offset to reflect whatever
1015 no_roll (sync_offset);
1016 nframes -= sync_offset;
1017 Port::increment_global_port_buffer_offset (sync_offset);
1018 waiting_for_sync_offset = false;
1021 return true; // done, nothing left to process
1026 /* sync offset point is not within this process()
1027 cycle, so just generate silence. and don't bother
1028 with any fancy stuff here, just the minimal silence.
1033 if (Config->get_locate_while_waiting_for_sync()) {
1034 if (micro_locate (nframes)) {
1035 /* XXX ERROR !!! XXX */
1039 return true; // done, nothing left to process
1046 Session::queue_event (SessionEvent* ev)
1048 if (_state_of_the_state & Deletion) {
1050 } else if (_state_of_the_state & Loading) {
1053 Glib::Threads::Mutex::Lock lm (rb_write_lock);
1054 pending_events.write (&ev, 1);
1059 Session::set_next_event ()
1061 if (events.empty()) {
1062 next_event = events.end();
1066 if (next_event == events.end()) {
1067 next_event = events.begin();
1070 if ((*next_event)->action_frame > _transport_frame) {
1071 next_event = events.begin();
1074 for (; next_event != events.end(); ++next_event) {
1075 if ((*next_event)->action_frame >= _transport_frame) {
1082 Session::process_event (SessionEvent* ev)
1087 /* if we're in the middle of a state change (i.e. waiting
1088 for the butler thread to complete the non-realtime
1089 part of the change), we'll just have to queue this
1090 event for a time when the change is complete.
1093 if (non_realtime_work_pending()) {
1095 /* except locates, which we have the capability to handle */
1097 if (ev->type != SessionEvent::Locate) {
1098 immediate_events.insert (immediate_events.end(), ev);
1104 DEBUG_TRACE (DEBUG::SessionEvents, string_compose ("Processing event: %1 @ %2\n", enum_2_string (ev->type), _transport_frame));
1107 case SessionEvent::SetLoop:
1108 set_play_loop (ev->yes_or_no, ev->speed);
1111 case SessionEvent::AutoLoop:
1113 /* roll after locate, do not flush, set "with loop"
1114 true only if we are seamless looping
1116 start_locate (ev->target_frame, true, false, Config->get_seamless_loop());
1122 case SessionEvent::AutoLoopDeclick:
1124 /* Request a declick fade-out and a fade-in; the fade-out will happen
1125 at the end of the loop, and the fade-in at the start.
1127 transport_sub_state |= (PendingLoopDeclickOut | PendingLoopDeclickIn);
1133 case SessionEvent::Locate:
1134 if (ev->yes_or_no) {
1135 /* args: do not roll after locate, do flush, not with loop */
1136 locate (ev->target_frame, false, true, false);
1138 /* args: do not roll after locate, do flush, not with loop */
1139 start_locate (ev->target_frame, false, true, false);
1141 _send_timecode_update = true;
1144 case SessionEvent::LocateRoll:
1145 if (ev->yes_or_no) {
1146 /* args: roll after locate, do flush, not with loop */
1147 locate (ev->target_frame, true, true, false);
1149 /* args: roll after locate, do flush, not with loop */
1150 start_locate (ev->target_frame, true, true, false);
1152 _send_timecode_update = true;
1155 case SessionEvent::Skip:
1156 if (Config->get_skip_playback()) {
1157 start_locate (ev->target_frame, true, true, false);
1158 _send_timecode_update = true;
1164 case SessionEvent::LocateRollLocate:
1165 // locate is handled by ::request_roll_at_and_return()
1166 _requested_return_frame = ev->target_frame;
1167 request_locate (ev->target2_frame, true);
1171 case SessionEvent::SetTransportSpeed:
1172 set_transport_speed (ev->speed, ev->target_frame, ev->yes_or_no, ev->second_yes_or_no, ev->third_yes_or_no);
1175 case SessionEvent::PunchIn:
1176 // cerr << "PunchIN at " << transport_frame() << endl;
1177 if (config.get_punch_in() && record_status() == Enabled && !preroll_record_punch_enabled()) {
1184 case SessionEvent::PunchOut:
1185 // cerr << "PunchOUT at " << transport_frame() << endl;
1186 if (config.get_punch_out() && !preroll_record_punch_enabled()) {
1187 step_back_from_record ();
1193 case SessionEvent::RecordStart:
1194 if (preroll_record_punch_enabled() && record_status() == Enabled) {
1201 case SessionEvent::StopOnce:
1202 if (!non_realtime_work_pending()) {
1203 _clear_event_type (SessionEvent::StopOnce);
1204 stop_transport (ev->yes_or_no);
1210 case SessionEvent::RangeStop:
1211 if (!non_realtime_work_pending()) {
1212 stop_transport (ev->yes_or_no);
1218 case SessionEvent::RangeLocate:
1219 /* args: roll after locate, do flush, not with loop */
1220 start_locate (ev->target_frame, true, true, false);
1225 case SessionEvent::Overwrite:
1226 overwrite_some_buffers (static_cast<Track*>(ev->ptr));
1229 case SessionEvent::SetTrackSpeed:
1230 set_track_speed (static_cast<Track*> (ev->ptr), ev->speed);
1233 case SessionEvent::SetSyncSource:
1234 DEBUG_TRACE (DEBUG::Slave, "seen request for new slave\n");
1235 use_sync_source (ev->slave);
1238 case SessionEvent::Audition:
1239 set_audition (ev->region);
1240 // drop reference to region
1241 ev->region.reset ();
1244 case SessionEvent::InputConfigurationChange:
1245 add_post_transport_work (PostTransportInputChange);
1246 _butler->schedule_transport_work ();
1249 case SessionEvent::SetPlayAudioRange:
1250 set_play_range (ev->audio_range, (ev->speed == 1.0f));
1253 case SessionEvent::CancelPlayAudioRange:
1257 case SessionEvent::RealTimeOperation:
1259 del = false; // other side of RT request needs to clean up
1262 case SessionEvent::AdjustPlaybackBuffering:
1263 schedule_playback_buffering_adjustment ();
1266 case SessionEvent::AdjustCaptureBuffering:
1267 schedule_capture_buffering_adjustment ();
1270 case SessionEvent::SetTimecodeTransmission:
1271 g_atomic_int_set (&_suspend_timecode_transmission, ev->yes_or_no ? 0 : 1);
1275 fatal << string_compose(_("Programming error: illegal event type in process_event (%1)"), ev->type) << endmsg;
1276 abort(); /*NOTREACHED*/
1281 del = del && !_remove_event (ev);
1290 Session::compute_stop_limit () const
1292 if (!Config->get_stop_at_session_end ()) {
1293 return max_framepos;
1297 return max_framepos;
1300 if (preroll_record_punch_enabled ()) {
1301 return max_framepos;
1304 bool const punching_in = (config.get_punch_in () && _locations->auto_punch_location());
1305 bool const punching_out = (config.get_punch_out () && _locations->auto_punch_location());
1307 if (actively_recording ()) {
1308 /* permanently recording */
1309 return max_framepos;
1310 } else if (punching_in && !punching_out) {
1311 /* punching in but never out */
1312 return max_framepos;
1313 } else if (punching_in && punching_out && _locations->auto_punch_location()->end() > current_end_frame()) {
1314 /* punching in and punching out after session end */
1315 return max_framepos;
1318 return current_end_frame ();
1323 /* dedicated thread for signal emission.
1325 * while sending cross-thread signals from the process thread
1326 * is fine in general, PBD::Signal's use of boost::function and
1327 * boost:bind can produce a vast overhead which is not
1328 * acceptable for low latency.
1330 * This works around the issue by moving the boost overhead
1331 * out of the RT thread. The overall load is probably higher but
1332 * the realtime thread remains unaffected.
1336 Session::emit_route_signals ()
1338 // TODO use RAII to allow using these signals in other places
1339 BatchUpdateStart(); /* EMIT SIGNAL */
1340 boost::shared_ptr<RouteList> r = routes.reader ();
1341 for (RouteList::const_iterator ci = r->begin(); ci != r->end(); ++ci) {
1342 (*ci)->emit_pending_signals ();
1344 BatchUpdateEnd(); /* EMIT SIGNAL */
1348 Session::emit_thread_start ()
1350 if (_rt_thread_active) {
1353 _rt_thread_active = true;
1355 if (pthread_create (&_rt_emit_thread, NULL, emit_thread, this)) {
1356 _rt_thread_active = false;
1361 Session::emit_thread_terminate ()
1363 if (!_rt_thread_active) {
1366 _rt_thread_active = false;
1368 if (pthread_mutex_lock (&_rt_emit_mutex) == 0) {
1369 pthread_cond_signal (&_rt_emit_cond);
1370 pthread_mutex_unlock (&_rt_emit_mutex);
1374 pthread_join (_rt_emit_thread, &status);
1378 Session::emit_thread (void *arg)
1380 Session *s = static_cast<Session *>(arg);
1381 s->emit_thread_run ();
1387 Session::emit_thread_run ()
1389 pthread_mutex_lock (&_rt_emit_mutex);
1390 while (_rt_thread_active) {
1391 emit_route_signals();
1392 pthread_cond_wait (&_rt_emit_cond, &_rt_emit_mutex);
1394 pthread_mutex_unlock (&_rt_emit_mutex);