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/thread.h>
30 #include "ardour/ardour.h"
31 #include "ardour/audio_diskstream.h"
32 #include "ardour/audioengine.h"
33 #include "ardour/auditioner.h"
34 #include "ardour/butler.h"
35 #include "ardour/debug.h"
36 #include "ardour/session.h"
37 #include "ardour/slave.h"
38 #include "ardour/timestamps.h"
40 #include "midi++/manager.h"
44 using namespace ARDOUR;
48 /** Called by the audio engine when there is work to be done with JACK.
49 * @param nframes Number of frames to process.
52 Session::process (nframes_t nframes)
54 // This is no more the appropriate place to call cycle
55 // start. cycle_start needs to be called at the Route::roll()
56 // where the signals which we want to mixdown have been calculated.
58 MIDI::Manager::instance()->cycle_start(nframes);
62 if (processing_blocked()) {
67 if (non_realtime_work_pending()) {
68 if (!_butler->transport_work_requested ()) {
73 (this->*process_function) (nframes);
75 // the ticker is for sending time information like MidiClock
76 nframes_t transport_frames = transport_frame();
77 BBT_Time transport_bbt;
78 bbt_time(transport_frames, transport_bbt);
79 Timecode::Time transport_timecode;
80 timecode_time(transport_frames, transport_timecode);
81 tick (transport_frames, transport_bbt, transport_timecode); /* EMIT SIGNAL */
83 SendFeedback (); /* EMIT SIGNAL */
85 MIDI::Manager::instance()->cycle_end();
89 Session::prepare_diskstreams ()
91 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
92 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
98 Session::fail_roll (nframes_t nframes)
100 return no_roll (nframes);
104 Session::no_roll (nframes_t nframes)
106 nframes_t end_frame = _transport_frame + nframes; // FIXME: varispeed + no_roll ??
108 bool declick = get_transport_declick_required();
109 boost::shared_ptr<RouteList> r = routes.reader ();
112 _click_io->silence (nframes);
115 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
117 if ((*i)->is_hidden()) {
121 (*i)->set_pending_declick (declick);
123 if ((*i)->no_roll (nframes, _transport_frame, end_frame, non_realtime_work_pending(),
124 actively_recording(), declick)) {
125 error << string_compose(_("Session: error in no roll for %1"), (*i)->name()) << endmsg;
135 Session::process_routes (nframes_t nframes)
138 int declick = get_transport_declick_required();
139 bool rec_monitors = get_rec_monitors_input();
140 boost::shared_ptr<RouteList> r = routes.reader ();
142 if (transport_sub_state & StopPendingCapture) {
143 /* force a declick out */
147 record_active = actively_recording(); // || (get_record_enabled() && get_punch_in());
149 const nframes_t start_frame = _transport_frame;
150 const nframes_t end_frame = _transport_frame + (nframes_t)floor(nframes * _transport_speed);
152 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
156 if ((*i)->is_hidden()) {
160 (*i)->set_pending_declick (declick);
162 if ((ret = (*i)->roll (nframes, start_frame, end_frame, declick, record_active, rec_monitors)) < 0) {
164 /* we have to do this here. Route::roll() for an AudioTrack will have called AudioDiskstream::process(),
165 and the DS will expect AudioDiskstream::commit() to be called. but we're aborting from that
166 call path, so make sure we release any outstanding locks here before we return failure.
169 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
170 for (DiskstreamList::iterator ids = dsl->begin(); ids != dsl->end(); ++ids) {
183 Session::silent_process_routes (nframes_t nframes)
185 bool record_active = actively_recording();
186 int declick = get_transport_declick_required();
187 bool rec_monitors = get_rec_monitors_input();
188 boost::shared_ptr<RouteList> r = routes.reader ();
190 if (transport_sub_state & StopPendingCapture) {
191 /* force a declick out */
195 const nframes_t start_frame = _transport_frame;
196 const nframes_t end_frame = _transport_frame + lrintf(nframes * _transport_speed);
198 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
202 if ((*i)->is_hidden()) {
206 if ((ret = (*i)->silent_roll (nframes, start_frame, end_frame, record_active, rec_monitors)) < 0) {
208 /* we have to do this here. Route::roll() for an AudioTrack will have called AudioDiskstream::process(),
209 and the DS will expect AudioDiskstream::commit() to be called. but we're aborting from that
210 call path, so make sure we release any outstanding locks here before we return failure.
213 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
214 for (DiskstreamList::iterator ids = dsl->begin(); ids != dsl->end(); ++ids) {
227 Session::commit_diskstreams (nframes_t nframes, bool &needs_butler)
233 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
234 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
236 if ((*i)->hidden()) {
240 /* force all diskstreams not handled by a Route to call do their stuff.
241 Note: the diskstreams that were handled by a route will just return zero
242 from this call, because they know they were processed. So in fact, this
243 also runs commit() for every diskstream.
246 if ((dret = (*i)->process (_transport_frame, nframes, actively_recording(), get_rec_monitors_input())) == 0) {
247 if ((*i)->commit (nframes)) {
251 } else if (dret < 0) {
255 pworst = min (pworst, (*i)->playback_buffer_load());
256 cworst = min (cworst, (*i)->capture_buffer_load());
259 uint32_t pmin = g_atomic_int_get (&_playback_load);
260 uint32_t pminold = g_atomic_int_get (&_playback_load_min);
261 uint32_t cmin = g_atomic_int_get (&_capture_load);
262 uint32_t cminold = g_atomic_int_get (&_capture_load_min);
264 g_atomic_int_set (&_playback_load, (uint32_t) floor (pworst * 100.0f));
265 g_atomic_int_set (&_capture_load, (uint32_t) floor (cworst * 100.0f));
266 g_atomic_int_set (&_playback_load_min, min (pmin, pminold));
267 g_atomic_int_set (&_capture_load_min, min (cmin, cminold));
269 if (actively_recording()) {
274 /** Process callback used when the auditioner is not active */
276 Session::process_with_events (nframes_t nframes)
279 nframes_t this_nframes;
281 bool session_needs_butler = false;
282 nframes_t stop_limit;
285 /* make sure the auditioner is silent */
288 auditioner->silence (nframes);
291 /* handle any pending events */
293 while (pending_events.read (&ev, 1) == 1) {
297 /* if we are not in the middle of a state change,
298 and there are immediate events queued up,
302 while (!non_realtime_work_pending() && !immediate_events.empty()) {
303 SessionEvent *ev = immediate_events.front ();
304 immediate_events.pop_front ();
308 /* Events caused a transport change, send an MTC Full Frame (Timecode) message.
309 * This is sent whether rolling or not, to give slaves an idea of ardour time
310 * on locates (and allow slow slaves to position and prepare for rolling)
312 if (_send_timecode_update) {
313 send_full_time_code(nframes);
314 deliver_mmc (MIDI::MachineControl::cmdLocate, _transport_frame);
317 if (!process_can_proceed()) {
322 if (events.empty() || next_event == events.end()) {
323 process_without_events (nframes);
327 if (_transport_speed == 1.0) {
328 frames_moved = (long) nframes;
330 interpolation.set_target_speed (fabs(_target_transport_speed));
331 interpolation.set_speed (fabs(_transport_speed));
332 frames_moved = (long) interpolation.interpolate (0, nframes, 0, 0);
335 end_frame = _transport_frame + (nframes_t)frames_moved;
338 SessionEvent* this_event;
339 Events::iterator the_next_one;
341 if (!process_can_proceed()) {
346 if (!_exporting && _slave) {
347 if (!follow_slave (nframes)) {
352 if (_transport_speed == 0) {
358 send_midi_time_code_for_cycle (nframes);
361 if (actively_recording()) {
362 stop_limit = max_frames;
365 if (Config->get_stop_at_session_end()) {
366 stop_limit = current_end_frame();
368 stop_limit = max_frames;
372 if (maybe_stop (stop_limit)) {
377 this_event = *next_event;
378 the_next_one = next_event;
381 /* yes folks, here it is, the actual loop where we really truly
387 this_nframes = nframes; /* real (jack) time relative */
388 frames_moved = (long) floor (_transport_speed * nframes); /* transport relative */
390 /* running an event, position transport precisely to its time */
391 if (this_event && this_event->action_frame <= end_frame && this_event->action_frame >= _transport_frame) {
392 /* this isn't quite right for reverse play */
393 frames_moved = (long) (this_event->action_frame - _transport_frame);
394 this_nframes = (nframes_t) abs( floor(frames_moved / _transport_speed) );
399 click (_transport_frame, this_nframes);
401 /* now process frames between now and the first event in this block */
402 prepare_diskstreams ();
404 if (process_routes (this_nframes)) {
409 commit_diskstreams (this_nframes, session_needs_butler);
411 nframes -= this_nframes;
413 if (frames_moved < 0) {
414 decrement_transport_position (-frames_moved);
416 increment_transport_position (frames_moved);
419 maybe_stop (stop_limit);
420 check_declick_out ();
423 _engine.split_cycle (this_nframes);
425 /* now handle this event and all others scheduled for the same time */
427 while (this_event && this_event->action_frame == _transport_frame) {
428 process_event (this_event);
430 if (the_next_one == events.end()) {
433 this_event = *the_next_one;
438 /* if an event left our state changing, do the right thing */
440 if (nframes && non_realtime_work_pending()) {
445 /* this is necessary to handle the case of seamless looping */
446 end_frame = _transport_frame + (nframes_t) floor (nframes * _transport_speed);
452 } /* implicit release of route lock */
454 if (session_needs_butler) {
460 Session::reset_slave_state ()
462 average_slave_delta = 1800;
463 delta_accumulator_cnt = 0;
464 have_first_delta_accumulator = false;
465 _slave_state = Stopped;
469 Session::transport_locked () const
473 if (!locate_pending() && (!config.get_external_sync() || (sl && sl->ok() && sl->locked()))) {
481 Session::follow_slave (nframes_t nframes)
484 nframes64_t slave_transport_frame;
485 nframes_t this_delta;
490 config.set_external_sync (false);
494 _slave->speed_and_position (slave_speed, slave_transport_frame);
496 DEBUG_TRACE (DEBUG::Slave, string_compose ("Slave position %1 speed %2\n", slave_transport_frame, slave_speed));
498 if (!_slave->locked()) {
499 DEBUG_TRACE (DEBUG::Slave, "slave not locked\n");
503 if (slave_transport_frame > _transport_frame) {
504 this_delta = slave_transport_frame - _transport_frame;
507 this_delta = _transport_frame - slave_transport_frame;
511 if (_slave->starting()) {
515 if (_slave->is_always_synced() || config.get_timecode_source_is_synced()) {
517 /* if the TC source is synced, then we assume that its
518 speed is binary: 0.0 or 1.0
521 if (slave_speed != 0.0f) {
527 /* if we are chasing and the average delta between us and the
528 master gets too big, we want to switch to silent
529 motion. so keep track of that here.
532 if (_slave_state == Running) {
533 calculate_moving_average_of_slave_delta(dir, this_delta);
537 track_slave_state (slave_speed, slave_transport_frame, this_delta);
539 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave state %1 @ %2 speed %3 cur delta %4 avg delta %5\n",
540 _slave_state, slave_transport_frame, slave_speed, this_delta, average_slave_delta));
543 if (_slave_state == Running && !_slave->is_always_synced() && !config.get_timecode_source_is_synced()) {
545 if (_transport_speed != 0.0f) {
548 note that average_dir is +1 or -1
553 if (average_slave_delta == 0) {
557 delta = average_slave_delta;
558 delta *= average_dir;
562 if (slave_speed != 0.0) {
563 DEBUG_TRACE (DEBUG::Slave, string_compose ("delta = %1 speed = %2 ts = %3 M@%4 S@%5 avgdelta %6\n",
564 (int) (dir * this_delta),
568 slave_transport_frame,
569 average_slave_delta));
573 if (_slave->give_slave_full_control_over_transport_speed()) {
574 set_transport_speed (slave_speed, false, false);
576 float adjusted_speed = slave_speed + (1.5 * (delta / float(_current_frame_rate)));
577 request_transport_speed (adjusted_speed);
578 DEBUG_TRACE (DEBUG::Slave, string_compose ("adjust using %1 towards %2 ratio %3 current %4 slave @ %5\n",
579 delta, adjusted_speed, adjusted_speed/slave_speed, _transport_speed,
583 if (abs(average_slave_delta) > _slave->resolution()) {
584 cerr << "average slave delta greater than slave resolution (" << _slave->resolution() << "), going to silent motion\n";
591 if (_slave_state == Running && !non_realtime_work_pending()) {
592 /* speed is set, we're locked, and good to go */
597 DEBUG_TRACE (DEBUG::Slave, "silent motion\n")
598 follow_slave_silently (nframes, slave_speed);
601 /* don't move at all */
602 DEBUG_TRACE (DEBUG::Slave, "no roll\n")
608 Session::calculate_moving_average_of_slave_delta(int dir, nframes_t this_delta)
610 if (delta_accumulator_cnt >= delta_accumulator_size) {
611 have_first_delta_accumulator = true;
612 delta_accumulator_cnt = 0;
615 if (delta_accumulator_cnt != 0 || this_delta < _current_frame_rate) {
616 delta_accumulator[delta_accumulator_cnt++] = long(dir) * long(this_delta);
619 if (have_first_delta_accumulator) {
620 average_slave_delta = 0L;
621 for (int i = 0; i < delta_accumulator_size; ++i) {
622 average_slave_delta += delta_accumulator[i];
624 average_slave_delta /= long(delta_accumulator_size);
625 if (average_slave_delta < 0L) {
627 average_slave_delta = abs(average_slave_delta);
635 Session::track_slave_state (float slave_speed, nframes_t slave_transport_frame, nframes_t this_delta)
637 if (slave_speed != 0.0f) {
639 /* slave is running */
641 switch (_slave_state) {
643 if (_slave->requires_seekahead()) {
644 slave_wait_end = slave_transport_frame + _slave->seekahead_distance ();
645 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped, but running, requires seekahead to %1\n", slave_wait_end));
646 /* we can call locate() here because we are in process context */
647 locate (slave_wait_end, false, false);
648 _slave_state = Waiting;
652 _slave_state = Running;
654 Location* al = _locations.auto_loop_location();
656 if (al && play_loop && (slave_transport_frame < al->start() || slave_transport_frame > al->end())) {
658 request_play_loop(false);
661 if (slave_transport_frame != _transport_frame) {
662 locate (slave_transport_frame, false, false);
672 if (_slave_state == Waiting) {
674 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave waiting at %1\n", slave_transport_frame));
676 if (slave_transport_frame >= slave_wait_end) {
678 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave start at %1 vs %2\n", slave_transport_frame, _transport_frame));
680 _slave_state = Running;
682 /* now perform a "micro-seek" within the disk buffers to realign ourselves
683 precisely with the master.
688 nframes_t frame_delta = slave_transport_frame - _transport_frame;
690 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
692 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
693 if (!(*i)->can_internal_playback_seek (frame_delta)) {
700 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
701 (*i)->internal_playback_seek (frame_delta);
703 _transport_frame += frame_delta;
706 cerr << "cannot micro-seek\n";
710 memset (delta_accumulator, 0, sizeof (long) * delta_accumulator_size);
711 average_slave_delta = 0L;
716 if (_slave_state == Running && _transport_speed == 0.0f) {
717 DEBUG_TRACE (DEBUG::Slave, "slave starts transport\n");
721 } else { // slave_speed is 0
723 /* slave has stopped */
725 if (_transport_speed != 0.0f) {
726 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stops transport: %1 frame %2 tf %3\n", slave_speed, slave_transport_frame, _transport_frame));
730 if (slave_transport_frame != _transport_frame) {
731 DEBUG_TRACE (DEBUG::Slave, string_compose ("slave stopped, move to %1\n", slave_transport_frame));
732 force_locate (slave_transport_frame, false);
735 _slave_state = Stopped;
740 Session::follow_slave_silently (nframes_t nframes, float slave_speed)
742 if (slave_speed && _transport_speed) {
744 /* something isn't right, but we should move with the master
750 prepare_diskstreams ();
751 silent_process_routes (nframes);
752 commit_diskstreams (nframes, need_butler);
758 int32_t frames_moved = (int32_t) floor (_transport_speed * nframes);
760 if (frames_moved < 0) {
761 decrement_transport_position (-frames_moved);
763 increment_transport_position (frames_moved);
766 nframes_t stop_limit;
768 if (actively_recording()) {
769 stop_limit = max_frames;
771 if (Config->get_stop_at_session_end()) {
772 stop_limit = current_end_frame();
774 stop_limit = max_frames;
778 maybe_stop (stop_limit);
783 Session::process_without_events (nframes_t nframes)
785 bool session_needs_butler = false;
786 nframes_t stop_limit;
789 if (!process_can_proceed()) {
794 if (!_exporting && _slave) {
795 if (!follow_slave (nframes)) {
800 if (_transport_speed == 0) {
806 send_midi_time_code_for_cycle (nframes);
809 if (actively_recording()) {
810 stop_limit = max_frames;
812 if (Config->get_stop_at_session_end()) {
813 stop_limit = current_end_frame();
815 stop_limit = max_frames;
819 if (maybe_stop (stop_limit)) {
824 if (maybe_sync_start (nframes)) {
828 click (_transport_frame, nframes);
830 prepare_diskstreams ();
832 if (_transport_speed == 1.0) {
833 frames_moved = (long) nframes;
835 interpolation.set_target_speed (fabs(_target_transport_speed));
836 interpolation.set_speed (fabs(_transport_speed));
837 frames_moved = (long) interpolation.interpolate (0, nframes, 0, 0);
840 if (process_routes (nframes)) {
845 commit_diskstreams (nframes, session_needs_butler);
847 if (frames_moved < 0) {
848 decrement_transport_position (-frames_moved);
850 increment_transport_position (frames_moved);
853 maybe_stop (stop_limit);
854 check_declick_out ();
856 if (session_needs_butler) {
861 /** Process callback used when the auditioner is active.
862 * @param nframes number of frames to process.
865 Session::process_audition (nframes_t nframes)
868 boost::shared_ptr<RouteList> r = routes.reader ();
870 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
871 if (!(*i)->is_hidden()) {
872 (*i)->silence (nframes);
876 /* run the auditioner, and if it says we need butler service, ask for it */
878 if (auditioner->play_audition (nframes) > 0) {
882 /* handle pending events */
884 while (pending_events.read (&ev, 1) == 1) {
888 /* if we are not in the middle of a state change,
889 and there are immediate events queued up,
893 while (!non_realtime_work_pending() && !immediate_events.empty()) {
894 SessionEvent *ev = immediate_events.front ();
895 immediate_events.pop_front ();
899 if (!auditioner->active()) {
900 /* auditioner no longer active, so go back to the normal process callback */
901 process_function = &Session::process_with_events;
906 Session::maybe_sync_start (nframes_t& nframes)
908 nframes_t sync_offset;
910 if (!waiting_for_sync_offset) {
914 if (_engine.get_sync_offset (sync_offset) && sync_offset < nframes) {
916 /* generate silence up to the sync point, then
917 adjust nframes + offset to reflect whatever
921 no_roll (sync_offset);
922 nframes -= sync_offset;
923 Port::increment_port_offset (sync_offset);
924 waiting_for_sync_offset = false;
927 return true; // done, nothing left to process
932 /* sync offset point is not within this process()
933 cycle, so just generate silence. and don't bother
934 with any fancy stuff here, just the minimal silence.
939 if (Config->get_locate_while_waiting_for_sync()) {
940 if (micro_locate (nframes)) {
941 /* XXX ERROR !!! XXX */
945 return true; // done, nothing left to process
952 Session::queue_event (SessionEvent* ev)
954 if (_state_of_the_state & Deletion) {
956 } else if (_state_of_the_state & Loading) {
959 pending_events.write (&ev, 1);
964 Session::set_next_event ()
966 if (events.empty()) {
967 next_event = events.end();
971 if (next_event == events.end()) {
972 next_event = events.begin();
975 if ((*next_event)->action_frame > _transport_frame) {
976 next_event = events.begin();
979 for (; next_event != events.end(); ++next_event) {
980 if ((*next_event)->action_frame >= _transport_frame) {
987 Session::process_event (SessionEvent* ev)
992 /* if we're in the middle of a state change (i.e. waiting
993 for the butler thread to complete the non-realtime
994 part of the change), we'll just have to queue this
995 event for a time when the change is complete.
998 if (non_realtime_work_pending()) {
1000 /* except locates, which we have the capability to handle */
1002 if (ev->type != SessionEvent::Locate) {
1003 immediate_events.insert (immediate_events.end(), ev);
1009 DEBUG_TRACE (DEBUG::SessionEvents, string_compose ("Processing event: %1 @ %2\n", enum_2_string (ev->type), _transport_frame));
1012 case SessionEvent::SetLoop:
1013 set_play_loop (ev->yes_or_no);
1016 case SessionEvent::AutoLoop:
1018 start_locate (ev->target_frame, true, false, Config->get_seamless_loop());
1024 case SessionEvent::Locate:
1025 if (ev->yes_or_no) {
1026 // cerr << "forced locate to " << ev->target_frame << endl;
1027 locate (ev->target_frame, false, true, false);
1029 // cerr << "soft locate to " << ev->target_frame << endl;
1030 start_locate (ev->target_frame, false, true, false);
1032 _send_timecode_update = true;
1035 case SessionEvent::LocateRoll:
1036 if (ev->yes_or_no) {
1037 // cerr << "forced locate to+roll " << ev->target_frame << endl;
1038 locate (ev->target_frame, true, true, false);
1040 // cerr << "soft locate to+roll " << ev->target_frame << endl;
1041 start_locate (ev->target_frame, true, true, false);
1043 _send_timecode_update = true;
1046 case SessionEvent::LocateRollLocate:
1047 // locate is handled by ::request_roll_at_and_return()
1048 _requested_return_frame = ev->target_frame;
1049 request_locate (ev->target2_frame, true);
1053 case SessionEvent::SetTransportSpeed:
1054 set_transport_speed (ev->speed, ev->yes_or_no, ev->second_yes_or_no);
1057 case SessionEvent::PunchIn:
1058 // cerr << "PunchIN at " << transport_frame() << endl;
1059 if (config.get_punch_in() && record_status() == Enabled) {
1066 case SessionEvent::PunchOut:
1067 // cerr << "PunchOUT at " << transport_frame() << endl;
1068 if (config.get_punch_out()) {
1069 step_back_from_record ();
1075 case SessionEvent::StopOnce:
1076 if (!non_realtime_work_pending()) {
1077 stop_transport (ev->yes_or_no);
1078 _clear_event_type (SessionEvent::StopOnce);
1084 case SessionEvent::RangeStop:
1085 if (!non_realtime_work_pending()) {
1086 stop_transport (ev->yes_or_no);
1092 case SessionEvent::RangeLocate:
1093 start_locate (ev->target_frame, true, true, false);
1098 case SessionEvent::Overwrite:
1099 overwrite_some_buffers (static_cast<Diskstream*>(ev->ptr));
1102 case SessionEvent::SetDiskstreamSpeed:
1103 set_diskstream_speed (static_cast<Diskstream*> (ev->ptr), ev->speed);
1106 case SessionEvent::SetSyncSource:
1107 use_sync_source (ev->slave);
1110 case SessionEvent::Audition:
1111 set_audition (ev->region);
1112 // drop reference to region
1113 ev->region.reset ();
1116 case SessionEvent::InputConfigurationChange:
1117 add_post_transport_work (PostTransportInputChange);
1118 _butler->schedule_transport_work ();
1121 case SessionEvent::SetPlayAudioRange:
1122 set_play_range (ev->audio_range, (ev->speed == 1.0f));
1125 case SessionEvent::RealTimeOperation:
1127 del = false; // other side of RT request needs to clean up
1131 fatal << string_compose(_("Programming error: illegal event type in process_event (%1)"), ev->type) << endmsg;
1137 del = del && !_remove_event (ev);
1146 Session::process_rtop (SessionEvent* ev)