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::cleanup_event (SessionEvent* ev, int status)
990 case SessionEvent::SetRecordEnable:
999 Session::process_event (SessionEvent* ev)
1004 /* if we're in the middle of a state change (i.e. waiting
1005 for the butler thread to complete the non-realtime
1006 part of the change), we'll just have to queue this
1007 event for a time when the change is complete.
1010 if (non_realtime_work_pending()) {
1012 /* except locates, which we have the capability to handle */
1014 if (ev->type != SessionEvent::Locate) {
1015 immediate_events.insert (immediate_events.end(), ev);
1021 DEBUG_TRACE (DEBUG::SessionEvents, string_compose ("Processing event: %1 @ %2\n", enum_2_string (ev->type), _transport_frame));
1024 case SessionEvent::SetLoop:
1025 set_play_loop (ev->yes_or_no);
1028 case SessionEvent::AutoLoop:
1030 start_locate (ev->target_frame, true, false, Config->get_seamless_loop());
1036 case SessionEvent::Locate:
1037 if (ev->yes_or_no) {
1038 // cerr << "forced locate to " << ev->target_frame << endl;
1039 locate (ev->target_frame, false, true, false);
1041 // cerr << "soft locate to " << ev->target_frame << endl;
1042 start_locate (ev->target_frame, false, true, false);
1044 _send_timecode_update = true;
1047 case SessionEvent::LocateRoll:
1048 if (ev->yes_or_no) {
1049 // cerr << "forced locate to+roll " << ev->target_frame << endl;
1050 locate (ev->target_frame, true, true, false);
1052 // cerr << "soft locate to+roll " << ev->target_frame << endl;
1053 start_locate (ev->target_frame, true, true, false);
1055 _send_timecode_update = true;
1058 case SessionEvent::LocateRollLocate:
1059 // locate is handled by ::request_roll_at_and_return()
1060 _requested_return_frame = ev->target_frame;
1061 request_locate (ev->target2_frame, true);
1065 case SessionEvent::SetTransportSpeed:
1066 set_transport_speed (ev->speed, ev->yes_or_no, ev->second_yes_or_no);
1069 case SessionEvent::PunchIn:
1070 // cerr << "PunchIN at " << transport_frame() << endl;
1071 if (config.get_punch_in() && record_status() == Enabled) {
1078 case SessionEvent::PunchOut:
1079 // cerr << "PunchOUT at " << transport_frame() << endl;
1080 if (config.get_punch_out()) {
1081 step_back_from_record ();
1087 case SessionEvent::StopOnce:
1088 if (!non_realtime_work_pending()) {
1089 stop_transport (ev->yes_or_no);
1090 _clear_event_type (SessionEvent::StopOnce);
1096 case SessionEvent::RangeStop:
1097 if (!non_realtime_work_pending()) {
1098 stop_transport (ev->yes_or_no);
1104 case SessionEvent::RangeLocate:
1105 start_locate (ev->target_frame, true, true, false);
1110 case SessionEvent::Overwrite:
1111 overwrite_some_buffers (static_cast<Diskstream*>(ev->ptr));
1114 case SessionEvent::SetDiskstreamSpeed:
1115 set_diskstream_speed (static_cast<Diskstream*> (ev->ptr), ev->speed);
1118 case SessionEvent::SetSyncSource:
1119 use_sync_source (ev->slave);
1122 case SessionEvent::Audition:
1123 set_audition (ev->region);
1124 // drop reference to region
1125 ev->region.reset ();
1128 case SessionEvent::InputConfigurationChange:
1129 add_post_transport_work (PostTransportInputChange);
1130 _butler->schedule_transport_work ();
1133 case SessionEvent::SetPlayAudioRange:
1134 set_play_range (ev->audio_range, (ev->speed == 1.0f));
1137 case SessionEvent::SetRecordEnable:
1138 do_record_enable_change_all (ev->routes, ev->yes_or_no);
1142 fatal << string_compose(_("Programming error: illegal event type in process_event (%1)"), ev->type) << endmsg;
1148 del = del && !_remove_event (ev);
1151 ev->Complete (ev, 0); /* EMIT SIGNAL */