2 Copyright (C) 1999-2003 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.
24 #include <sigc++/bind.h>
25 #include <sigc++/retype.h>
28 #include "pbd/error.h"
29 #include <glibmm/thread.h>
30 #include "pbd/pthread_utils.h"
31 #include "pbd/memento_command.h"
32 #include "pbd/stacktrace.h"
34 #include "midi++/mmc.h"
35 #include "midi++/port.h"
37 #include "ardour/ardour.h"
38 #include "ardour/audioengine.h"
39 #include "ardour/session.h"
40 #include "ardour/audio_diskstream.h"
41 #include "ardour/auditioner.h"
42 #include "ardour/slave.h"
43 #include "ardour/location.h"
48 using namespace ARDOUR;
53 Session::request_input_change_handling ()
55 if (!(_state_of_the_state & (InitialConnecting|Deletion))) {
56 Event* ev = new Event (Event::InputConfigurationChange, Event::Add, Event::Immediate, 0, 0.0);
62 Session::request_slave_source (SlaveSource src)
64 Event* ev = new Event (Event::SetSlaveSource, Event::Add, Event::Immediate, 0, 0.0);
67 /* could set_seamless_loop() be disposed of entirely?*/
68 Config->set_seamless_loop (false);
70 Config->set_seamless_loop (true);
77 Session::request_transport_speed (double speed)
79 Event* ev = new Event (Event::SetTransportSpeed, Event::Add, Event::Immediate, 0, speed);
84 Session::request_diskstream_speed (Diskstream& ds, double speed)
86 Event* ev = new Event (Event::SetDiskstreamSpeed, Event::Add, Event::Immediate, 0, speed);
92 Session::request_stop (bool abort)
94 Event* ev = new Event (Event::SetTransportSpeed, Event::Add, Event::Immediate, 0, 0.0, abort);
99 Session::request_locate (nframes_t target_frame, bool with_roll)
101 Event *ev = new Event (with_roll ? Event::LocateRoll : Event::Locate, Event::Add, Event::Immediate, target_frame, 0, false);
106 Session::force_locate (nframes_t target_frame, bool with_roll)
108 Event *ev = new Event (with_roll ? Event::LocateRoll : Event::Locate, Event::Add, Event::Immediate, target_frame, 0, true);
113 Session::request_play_loop (bool yn)
116 Location *location = _locations.auto_loop_location();
118 if (location == 0 && yn) {
119 error << _("Cannot loop - no loop range defined")
124 ev = new Event (Event::SetLoop, Event::Add, Event::Immediate, 0, 0.0, yn);
127 if (!yn && Config->get_seamless_loop() && transport_rolling()) {
128 // request an immediate locate to refresh the diskstreams
129 // after disabling looping
130 request_locate (_transport_frame-1, false);
135 Session::realtime_stop (bool abort)
137 /* assume that when we start, we'll be moving forwards */
139 // FIXME: where should this really be? [DR]
140 //send_full_time_code();
141 deliver_mmc (MIDI::MachineControl::cmdStop, 0);
142 deliver_mmc (MIDI::MachineControl::cmdLocate, _transport_frame);
144 if (_transport_speed < 0.0f) {
145 post_transport_work = PostTransportWork (post_transport_work | PostTransportStop | PostTransportReverse);
147 post_transport_work = PostTransportWork (post_transport_work | PostTransportStop);
150 if (actively_recording()) {
152 /* move the transport position back to where the
153 request for a stop was noticed. we rolled
154 past that point to pick up delayed input.
157 #ifndef LEAVE_TRANSPORT_UNADJUSTED
158 decrement_transport_position (_worst_output_latency);
161 /* the duration change is not guaranteed to have happened, but is likely */
163 post_transport_work = PostTransportWork (post_transport_work | PostTransportDuration);
167 post_transport_work = PostTransportWork (post_transport_work | PostTransportAbort);
170 _clear_event_type (Event::StopOnce);
171 _clear_event_type (Event::RangeStop);
172 _clear_event_type (Event::RangeLocate);
174 disable_record (true);
176 reset_slave_state ();
178 _transport_speed = 0;
179 _target_transport_speed = 0;
181 if (config.get_use_video_sync()) {
182 waiting_for_sync_offset = true;
185 transport_sub_state = ((Config->get_slave_source() == None && config.get_auto_return()) ? AutoReturning : 0);
189 Session::butler_transport_work ()
193 boost::shared_ptr<RouteList> r = routes.reader ();
194 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
196 int on_entry = g_atomic_int_get (&butler_should_do_transport_work);
199 if (post_transport_work & PostTransportCurveRealloc) {
200 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
201 (*i)->curve_reallocate();
205 if (post_transport_work & PostTransportInputChange) {
206 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
207 (*i)->non_realtime_input_change ();
211 if (post_transport_work & PostTransportSpeed) {
212 non_realtime_set_speed ();
215 if (post_transport_work & PostTransportReverse) {
218 cumulative_rf_motion = 0;
221 /* don't seek if locate will take care of that in non_realtime_stop() */
223 if (!(post_transport_work & PostTransportLocate)) {
225 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
226 if (!(*i)->hidden()) {
227 (*i)->non_realtime_locate (_transport_frame);
229 if (on_entry != g_atomic_int_get (&butler_should_do_transport_work)) {
230 /* new request, stop seeking, and start again */
231 g_atomic_int_dec_and_test (&butler_should_do_transport_work);
238 if (post_transport_work & PostTransportLocate) {
239 non_realtime_locate ();
242 if (post_transport_work & PostTransportStop) {
243 non_realtime_stop (post_transport_work & PostTransportAbort, on_entry, finished);
245 g_atomic_int_dec_and_test (&butler_should_do_transport_work);
250 if (post_transport_work & PostTransportOverWrite) {
251 non_realtime_overwrite (on_entry, finished);
253 g_atomic_int_dec_and_test (&butler_should_do_transport_work);
258 if (post_transport_work & PostTransportAudition) {
259 non_realtime_set_audition ();
262 g_atomic_int_dec_and_test (&butler_should_do_transport_work);
266 Session::non_realtime_set_speed ()
268 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
270 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
271 (*i)->non_realtime_set_speed ();
276 Session::non_realtime_overwrite (int on_entry, bool& finished)
278 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
280 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
281 if ((*i)->pending_overwrite) {
282 (*i)->overwrite_existing_buffers ();
284 if (on_entry != g_atomic_int_get (&butler_should_do_transport_work)) {
293 Session::non_realtime_locate ()
295 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
297 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
298 (*i)->non_realtime_locate (_transport_frame);
304 Session::non_realtime_stop (bool abort, int on_entry, bool& finished)
314 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
316 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
317 if ((*i)->get_captured_frames () != 0) {
323 /* stop and locate are merged here because they share a lot of common stuff */
326 now = localtime (&xnow);
329 auditioner->cancel_audition ();
333 cumulative_rf_motion = 0;
337 begin_reversible_command ("capture");
339 Location* loc = _locations.end_location();
340 bool change_end = false;
342 if (_transport_frame < loc->end()) {
344 /* stopped recording before current end */
346 if (config.get_end_marker_is_free()) {
348 /* first capture for this session, move end back to where we are */
353 } else if (_transport_frame > loc->end()) {
355 /* stopped recording after the current end, extend it */
361 XMLNode &before = loc->get_state();
362 loc->set_end(_transport_frame);
363 XMLNode &after = loc->get_state();
364 add_command (new MementoCommand<Location>(*loc, &before, &after));
367 config.set_end_marker_is_free (false);
368 _have_captured = true;
371 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
372 (*i)->transport_stopped (*now, xnow, abort);
375 boost::shared_ptr<RouteList> r = routes.reader ();
377 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
378 if (!(*i)->is_hidden()) {
379 (*i)->set_pending_declick (0);
384 commit_reversible_command ();
387 if (_engine.running()) {
388 update_latency_compensation (true, abort);
391 bool const auto_return_enabled =
392 (Config->get_slave_source() == None && config.get_auto_return());
394 if (auto_return_enabled ||
395 (post_transport_work & PostTransportLocate) ||
396 (_requested_return_frame >= 0) ||
399 if (pending_locate_flush) {
400 flush_all_inserts ();
403 if ((auto_return_enabled || synced_to_jack() || _requested_return_frame >= 0) &&
404 !(post_transport_work & PostTransportLocate)) {
406 bool do_locate = false;
408 if (_requested_return_frame >= 0) {
409 _transport_frame = _requested_return_frame;
410 _requested_return_frame = -1;
413 _transport_frame = _last_roll_location;
416 if (synced_to_jack() && !play_loop) {
421 // cerr << "non-realtimestop: transport locate to " << _transport_frame << endl;
422 _engine.transport_locate (_transport_frame);
426 #ifndef LEAVE_TRANSPORT_UNADJUSTED
430 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
431 if (!(*i)->hidden()) {
432 (*i)->non_realtime_locate (_transport_frame);
434 if (on_entry != g_atomic_int_get (&butler_should_do_transport_work)) {
436 /* we will be back */
441 #ifdef LEAVE_TRANSPORT_UNADJUSTED
447 send_full_time_code (0);
448 deliver_mmc (MIDI::MachineControl::cmdStop, 0);
449 deliver_mmc (MIDI::MachineControl::cmdLocate, _transport_frame);
453 /* XXX its a little odd that we're doing this here
454 when realtime_stop(), which has already executed,
456 JLC - so let's not because it seems unnecessary and breaks loop record
459 if (!Config->get_latched_record_enable()) {
460 g_atomic_int_set (&_record_status, Disabled);
462 g_atomic_int_set (&_record_status, Enabled);
464 RecordStateChanged (); /* emit signal */
468 if ((post_transport_work & PostTransportLocate) && get_record_enabled()) {
469 /* capture start has been changed, so save pending state */
470 save_state ("", true);
474 /* always try to get rid of this */
476 remove_pending_capture_state ();
478 /* save the current state of things if appropriate */
480 if (did_record && !saved) {
481 save_state (_current_snapshot_name);
484 if (post_transport_work & PostTransportDuration) {
485 DurationChanged (); /* EMIT SIGNAL */
488 if (post_transport_work & PostTransportStop) {
491 /* do not turn off autoloop on stop */
495 nframes_t tf = _transport_frame;
497 PositionChanged (tf); /* EMIT SIGNAL */
498 TransportStateChange (); /* EMIT SIGNAL */
500 /* and start it up again if relevant */
502 if ((post_transport_work & PostTransportLocate) && Config->get_slave_source() == None && pending_locate_roll) {
503 request_transport_speed (1.0);
504 pending_locate_roll = false;
509 Session::check_declick_out ()
511 bool locate_required = transport_sub_state & PendingLocate;
513 /* this is called after a process() iteration. if PendingDeclickOut was set,
514 it means that we were waiting to declick the output (which has just been
515 done) before doing something else. this is where we do that "something else".
517 note: called from the audio thread.
520 if (transport_sub_state & PendingDeclickOut) {
522 if (locate_required) {
523 start_locate (pending_locate_frame, pending_locate_roll, pending_locate_flush);
524 transport_sub_state &= ~(PendingDeclickOut|PendingLocate);
526 stop_transport (pending_abort);
527 transport_sub_state &= ~(PendingDeclickOut|PendingLocate);
533 Session::set_play_loop (bool yn)
535 /* Called from event-handling context */
537 if ((actively_recording() && yn) || _locations.auto_loop_location() == 0) {
543 if (yn && Config->get_seamless_loop() && synced_to_jack()) {
544 warning << _("Seamless looping cannot be supported while Ardour is using JACK transport.\n"
545 "Recommend changing the configured options")
551 if ((play_loop = yn)) {
556 if ((loc = _locations.auto_loop_location()) != 0) {
558 if (Config->get_seamless_loop()) {
559 // set all diskstreams to use internal looping
560 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
561 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
562 if (!(*i)->hidden()) {
563 (*i)->set_loop (loc);
568 // set all diskstreams to NOT use internal looping
569 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
570 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
571 if (!(*i)->hidden()) {
577 /* stick in the loop event */
579 Event* event = new Event (Event::AutoLoop, Event::Replace, loc->end(), loc->start(), 0.0f);
582 /* locate to start of loop and roll if current pos is outside of the loop range */
583 if (_transport_frame < loc->start() || _transport_frame > loc->end()) {
584 event = new Event (Event::LocateRoll, Event::Add, Event::Immediate, loc->start(), 0, !synced_to_jack());
588 // locate to current position (+ 1 to force reload)
589 event = new Event (Event::LocateRoll, Event::Add, Event::Immediate, _transport_frame + 1, 0, !synced_to_jack());
597 clear_events (Event::AutoLoop);
599 // set all diskstreams to NOT use internal looping
600 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
601 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
602 if (!(*i)->hidden()) {
611 Session::flush_all_inserts ()
613 boost::shared_ptr<RouteList> r = routes.reader ();
615 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
616 (*i)->flush_processors ();
621 Session::start_locate (nframes_t target_frame, bool with_roll, bool with_flush, bool with_loop)
623 if (synced_to_jack()) {
628 _slave->speed_and_position (sp, pos);
630 if (target_frame != pos) {
632 /* tell JACK to change transport position, and we will
633 follow along later in ::follow_slave()
636 _engine.transport_locate (target_frame);
638 if (sp != 1.0f && with_roll) {
639 _engine.transport_start ();
645 locate (target_frame, with_roll, with_flush, with_loop);
648 /* XXX: not sure if this should be emitted here in the synced_to_jack () case;
649 * perhaps it should happen when the slave is actually followed */
650 Located (); /* EMIT SIGNAL */
654 Session::micro_locate (nframes_t distance)
656 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
658 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
659 if (!(*i)->can_internal_playback_seek (distance)) {
664 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
665 (*i)->internal_playback_seek (distance);
668 _transport_frame += distance;
673 Session::locate (nframes_t target_frame, bool with_roll, bool with_flush, bool with_loop)
675 if (actively_recording() && !with_loop) {
679 if (_transport_frame == target_frame && !loop_changing && !with_loop) {
681 set_transport_speed (1.0, false);
683 loop_changing = false;
688 // [DR] FIXME: find out exactly where this should go below
689 _transport_frame = target_frame;
690 smpte_time(_transport_frame, transmitting_smpte_time);
691 outbound_mtc_smpte_frame = _transport_frame;
692 next_quarter_frame_to_send = 0;
694 if (_transport_speed && (!with_loop || loop_changing)) {
695 /* schedule a declick. we'll be called again when its done */
697 if (!(transport_sub_state & PendingDeclickOut)) {
698 transport_sub_state |= (PendingDeclickOut|PendingLocate);
699 pending_locate_frame = target_frame;
700 pending_locate_roll = with_roll;
701 pending_locate_flush = with_flush;
706 if (transport_rolling() && (!auto_play_legal || !config.get_auto_play()) && !with_roll && !(synced_to_jack() && play_loop)) {
707 realtime_stop (false);
710 if ( !with_loop || loop_changing) {
712 post_transport_work = PostTransportWork (post_transport_work | PostTransportLocate);
715 post_transport_work = PostTransportWork (post_transport_work | PostTransportRoll);
718 schedule_butler_transport_work ();
722 /* this is functionally what clear_clicks() does but with a tentative lock */
724 Glib::RWLock::WriterLock clickm (click_lock, Glib::TRY_LOCK);
726 if (clickm.locked()) {
728 for (Clicks::iterator i = clicks.begin(); i != clicks.end(); ++i) {
737 /* switch from input if we're going to roll */
738 if (Config->get_monitoring_model() == HardwareMonitoring) {
740 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
742 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
743 if ((*i)->record_enabled ()) {
744 //cerr << "switching from input" << __FILE__ << __LINE__ << endl << endl;
745 (*i)->monitor_input (!config.get_auto_input());
750 /* otherwise we're going to stop, so do the opposite */
751 if (Config->get_monitoring_model() == HardwareMonitoring) {
752 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
754 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
755 if ((*i)->record_enabled ()) {
756 //cerr << "switching to input" << __FILE__ << __LINE__ << endl << endl;
757 (*i)->monitor_input (true);
763 /* cancel looped playback if transport pos outside of loop range */
765 Location* al = _locations.auto_loop_location();
767 if (al && (_transport_frame < al->start() || _transport_frame > al->end())) {
768 // cancel looping directly, this is called from event handling context
769 set_play_loop (false);
771 else if (al && _transport_frame == al->start()) {
773 // this is only necessary for seamless looping
775 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
777 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
778 if ((*i)->record_enabled ()) {
779 // tell it we've looped, so it can deal with the record state
780 (*i)->transport_looped(_transport_frame);
785 TransportLooped(); // EMIT SIGNAL
789 loop_changing = false;
791 _send_smpte_update = true;
794 /** Set the transport speed.
795 * @param speed New speed
799 Session::set_transport_speed (double speed, bool abort)
801 if (_transport_speed == speed) {
805 _target_transport_speed = fabs(speed);
807 /* 8.0 max speed is somewhat arbitrary but based on guestimates regarding disk i/o capability
808 and user needs. We really need CD-style "skip" playback for ffwd and rewind.
812 speed = min (8.0, speed);
813 } else if (speed < 0) {
814 speed = max (-8.0, speed);
817 if (transport_rolling() && speed == 0.0) {
819 /* we are rolling and we want to stop */
821 if (Config->get_monitoring_model() == HardwareMonitoring)
823 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
825 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
826 if ((*i)->record_enabled ()) {
827 //cerr << "switching to input" << __FILE__ << __LINE__ << endl << endl;
828 (*i)->monitor_input (true);
833 if (synced_to_jack ()) {
834 _engine.transport_stop ();
836 stop_transport (abort);
839 } else if (transport_stopped() && speed == 1.0) {
841 /* we are stopped and we want to start rolling at speed 1 */
843 if (!get_record_enabled() && Config->get_stop_at_session_end() && _transport_frame >= current_end_frame()) {
847 if (Config->get_monitoring_model() == HardwareMonitoring) {
849 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
851 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
852 if (config.get_auto_input() && (*i)->record_enabled ()) {
853 //cerr << "switching from input" << __FILE__ << __LINE__ << endl << endl;
854 (*i)->monitor_input (false);
859 if (synced_to_jack()) {
860 _engine.transport_start ();
867 if (!get_record_enabled() && Config->get_stop_at_session_end() && _transport_frame >= current_end_frame()) {
871 if ((synced_to_jack()) && speed != 0.0 && speed != 1.0) {
872 warning << _("Global varispeed cannot be supported while Ardour is connected to JACK transport control")
877 if (actively_recording()) {
881 if (speed > 0.0 && _transport_frame == current_end_frame()) {
885 if (speed < 0.0 && _transport_frame == 0) {
891 /* if we are reversing relative to the current speed, or relative to the speed
892 before the last stop, then we have to do extra work.
895 if ((_transport_speed && speed * _transport_speed < 0.0) || (_last_transport_speed * speed < 0.0) || (_last_transport_speed == 0.0f && speed < 0.0f)) {
896 post_transport_work = PostTransportWork (post_transport_work | PostTransportReverse);
899 _last_transport_speed = _transport_speed;
900 _transport_speed = speed;
902 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
903 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
904 if ((*i)->realtime_set_speed ((*i)->speed(), true)) {
905 post_transport_work = PostTransportWork (post_transport_work | PostTransportSpeed);
909 if (post_transport_work & (PostTransportSpeed|PostTransportReverse)) {
910 schedule_butler_transport_work ();
916 /** Stop the transport. */
918 Session::stop_transport (bool abort)
920 if (_transport_speed == 0.0f) {
924 if (actively_recording() && !(transport_sub_state & StopPendingCapture) &&
925 _worst_output_latency > current_block_size)
928 /* we need to capture the audio that has still not yet been received by the system
929 at the time the stop is requested, so we have to roll past that time.
931 we want to declick before stopping, so schedule the autostop for one
932 block before the actual end. we'll declick in the subsequent block,
933 and then we'll really be stopped.
936 Event *ev = new Event (Event::StopOnce, Event::Replace,
937 _transport_frame + _worst_output_latency - current_block_size,
941 transport_sub_state |= StopPendingCapture;
942 pending_abort = abort;
947 if ((transport_sub_state & PendingDeclickOut) == 0) {
948 transport_sub_state |= PendingDeclickOut;
949 /* we'll be called again after the declick */
950 pending_abort = abort;
954 realtime_stop (abort);
955 schedule_butler_transport_work ();
959 Session::start_transport ()
961 _last_roll_location = _transport_frame;
964 /* if record status is Enabled, move it to Recording. if its
965 already Recording, move it to Disabled.
968 switch (record_status()) {
970 if (!config.get_punch_in()) {
977 disable_record (false);
985 transport_sub_state |= PendingDeclickIn;
987 _transport_speed = 1.0;
988 _target_transport_speed = 1.0;
990 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
991 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
992 (*i)->realtime_set_speed ((*i)->speed(), true);
995 deliver_mmc(MIDI::MachineControl::cmdDeferredPlay, _transport_frame);
997 TransportStateChange (); /* EMIT SIGNAL */
1000 /** Do any transport work in the audio thread that needs to be done after the
1001 * transport thread is finished. Audio thread, realtime safe.
1004 Session::post_transport ()
1006 if (post_transport_work & PostTransportAudition) {
1007 if (auditioner && auditioner->active()) {
1008 process_function = &Session::process_audition;
1010 process_function = &Session::process_with_events;
1014 if (post_transport_work & PostTransportStop) {
1016 transport_sub_state = 0;
1019 if (post_transport_work & PostTransportLocate) {
1021 if (((Config->get_slave_source() == None && (auto_play_legal && config.get_auto_play())) && !_exporting) || (post_transport_work & PostTransportRoll)) {
1025 transport_sub_state = 0;
1031 post_transport_work = PostTransportWork (0);
1035 Session::reset_rf_scale (nframes_t motion)
1037 cumulative_rf_motion += motion;
1039 if (cumulative_rf_motion < 4 * _current_frame_rate) {
1041 } else if (cumulative_rf_motion < 8 * _current_frame_rate) {
1043 } else if (cumulative_rf_motion < 16 * _current_frame_rate) {
1055 Session::set_slave_source (SlaveSource src)
1057 bool reverse = false;
1058 bool non_rt_required = false;
1060 if (_transport_speed) {
1061 error << _("please stop the transport before adjusting slave settings") << endmsg;
1065 // if (src == JACK && Config->get_jack_time_master()) {
1072 if (_transport_speed < 0.0) {
1084 _slave = new MTC_Slave (*this, *_mtc_port);
1087 catch (failed_constructor& err) {
1092 error << _("No MTC port defined: MTC slaving is impossible.") << endmsg;
1098 if (_midi_clock_port) {
1100 _slave = new MIDIClock_Slave (*this, *_midi_clock_port, 24);
1103 catch (failed_constructor& err) {
1108 error << _("No MIDI Clock port defined: MIDI Clock slaving is impossible.") << endmsg;
1114 _slave = new JACK_Slave (_engine.jack());
1119 Config->set_slave_source (src);
1121 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
1122 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
1123 if (!(*i)->hidden()) {
1124 if ((*i)->realtime_set_speed ((*i)->speed(), true)) {
1125 non_rt_required = true;
1127 (*i)->set_slaved (_slave);
1132 reverse_diskstream_buffers ();
1135 if (non_rt_required) {
1136 post_transport_work = PostTransportWork (post_transport_work | PostTransportSpeed);
1137 schedule_butler_transport_work ();
1144 Session::reverse_diskstream_buffers ()
1146 post_transport_work = PostTransportWork (post_transport_work | PostTransportReverse);
1147 schedule_butler_transport_work ();
1151 Session::set_diskstream_speed (Diskstream* stream, double speed)
1153 if (stream->realtime_set_speed (speed, false)) {
1154 post_transport_work = PostTransportWork (post_transport_work | PostTransportSpeed);
1155 schedule_butler_transport_work ();
1161 Session::set_audio_range (list<AudioRange>& range)
1163 Event *ev = new Event (Event::SetAudioRange, Event::Add, Event::Immediate, 0, 0.0f);
1164 ev->audio_range = range;
1169 Session::request_play_range (bool yn)
1171 Event* ev = new Event (Event::SetPlayRange, Event::Add, Event::Immediate, 0, 0.0f, yn);
1176 Session::set_play_range (bool yn)
1178 /* Called from event-processing context */
1180 if (_play_range != yn) {
1185 /* stop transport */
1186 Event* ev = new Event (Event::SetTransportSpeed, Event::Add, Event::Immediate, 0, 0.0f, false);
1193 Session::setup_auto_play ()
1195 /* Called from event-processing context */
1199 _clear_event_type (Event::RangeStop);
1200 _clear_event_type (Event::RangeLocate);
1206 list<AudioRange>::size_type sz = current_audio_range.size();
1210 list<AudioRange>::iterator i = current_audio_range.begin();
1211 list<AudioRange>::iterator next;
1213 while (i != current_audio_range.end()) {
1218 /* locating/stopping is subject to delays for declicking.
1221 nframes_t requested_frame = (*i).end;
1223 if (requested_frame > current_block_size) {
1224 requested_frame -= current_block_size;
1226 requested_frame = 0;
1229 if (next == current_audio_range.end()) {
1230 ev = new Event (Event::RangeStop, Event::Add, requested_frame, 0, 0.0f);
1232 ev = new Event (Event::RangeLocate, Event::Add, requested_frame, (*next).start, 0.0f);
1240 } else if (sz == 1) {
1242 ev = new Event (Event::RangeStop, Event::Add, current_audio_range.front().end, 0, 0.0f);
1247 /* now start rolling at the right place */
1249 ev = new Event (Event::LocateRoll, Event::Add, Event::Immediate, current_audio_range.front().start, 0.0f, false);
1254 Session::request_roll_at_and_return (nframes_t start, nframes_t return_to)
1256 Event *ev = new Event (Event::LocateRollLocate, Event::Add, Event::Immediate, return_to, 1.0);
1257 ev->target2_frame = start;
1262 Session::request_bounded_roll (nframes_t start, nframes_t end)
1265 Event *ev = new Event (Event::StopOnce, Event::Replace, end, Event::Immediate, 0.0);
1267 request_locate (start, true);
1271 Session::engine_halted ()
1275 /* there will be no more calls to process(), so
1276 we'd better clean up for ourselves, right now.
1278 but first, make sure the butler is out of
1282 g_atomic_int_set (&butler_should_do_transport_work, 0);
1283 post_transport_work = PostTransportWork (0);
1286 realtime_stop (false);
1287 non_realtime_stop (false, 0, ignored);
1288 transport_sub_state = 0;
1290 TransportStateChange (); /* EMIT SIGNAL */
1295 Session::xrun_recovery ()
1297 Xrun (transport_frame()); //EMIT SIGNAL
1299 if (Config->get_stop_recording_on_xrun() && actively_recording()) {
1301 /* it didn't actually halt, but we need
1302 to handle things in the same way.
1310 Session::update_latency_compensation (bool with_stop, bool abort)
1312 bool update_jack = false;
1314 if (_state_of_the_state & Deletion) {
1318 _worst_track_latency = 0;
1320 #undef DEBUG_LATENCY
1321 #ifdef DEBUG_LATENCY
1322 cerr << "\n---------------------------------\nUPDATE LATENCY\n";
1325 boost::shared_ptr<RouteList> r = routes.reader ();
1327 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1330 (*i)->handle_transport_stopped (abort, (post_transport_work & PostTransportLocate),
1331 (!(post_transport_work & PostTransportLocate) || pending_locate_flush));
1334 nframes_t old_latency = (*i)->output()->signal_latency ();
1335 nframes_t track_latency = (*i)->update_total_latency ();
1337 if (old_latency != track_latency) {
1338 (*i)->input()->update_port_total_latencies ();
1339 (*i)->output()->update_port_total_latencies ();
1343 if (!(*i)->is_hidden() && ((*i)->active())) {
1344 _worst_track_latency = max (_worst_track_latency, track_latency);
1349 _engine.update_total_latencies ();
1352 #ifdef DEBUG_LATENCY
1353 cerr << "\tworst was " << _worst_track_latency << endl;
1356 for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
1357 (*i)->set_latency_delay (_worst_track_latency);
1360 set_worst_io_latencies ();
1362 /* reflect any changes in latencies into capture offsets
1365 boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
1367 for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
1368 (*i)->set_capture_offset ();
1373 Session::allow_auto_play (bool yn)
1375 auto_play_legal = yn;
1379 Session::reset_jack_connection (jack_client_t* jack)
1383 if (_slave && ((js = dynamic_cast<JACK_Slave*> (_slave)) != 0)) {
1384 js->reset_client (jack);