X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fsession_transport.cc;h=f1486ada78144abc89636c940f4d92d9f0b4a5e0;hb=a6af411af7ade161483ae688f5e1868d481a8fce;hp=3b2060d2ac2b042c65c3e6693ad8ad8e41c3ed08;hpb=34f088576cff12d7bfe1b21a0cebd3e194371a64;p=ardour.git diff --git a/libs/ardour/session_transport.cc b/libs/ardour/session_transport.cc index 3b2060d2ac..f1486ada78 100644 --- a/libs/ardour/session_transport.cc +++ b/libs/ardour/session_transport.cc @@ -109,7 +109,7 @@ void Session::request_transport_speed (double speed, bool as_default) { SessionEvent* ev = new SessionEvent (SessionEvent::SetTransportSpeed, SessionEvent::Add, SessionEvent::Immediate, 0, speed); - ev->third_yes_or_no = true; // as_default + ev->third_yes_or_no = as_default; // as_default DEBUG_TRACE (DEBUG::Transport, string_compose ("Request transport speed = %1 as default = %2\n", speed, as_default)); queue_event (ev); } @@ -163,6 +163,12 @@ Session::force_locate (framepos_t target_frame, bool with_roll) void Session::request_play_loop (bool yn, bool change_transport_roll) { + if (_slave && yn) { + // don't attempt to loop when not using Internal Transport + // see also gtk2_ardour/ardour_ui_options.cc parameter_changed() + return; + } + SessionEvent* ev; Location *location = _locations->auto_loop_location(); double target_speed; @@ -257,11 +263,11 @@ Session::realtime_stop (bool abort, bool clear_state) for (RouteList::iterator i = r->begin (); i != r->end(); ++i) { (*i)->realtime_handle_transport_stopped (); } - + DEBUG_TRACE (DEBUG::Transport, string_compose ("stop complete, auto-return scheduled for return to %1\n", _requested_return_frame)); /* the duration change is not guaranteed to have happened, but is likely */ - + todo = PostTransportWork (todo | PostTransportDuration); if (abort) { @@ -286,7 +292,7 @@ Session::realtime_stop (bool abort, bool clear_state) if (clear_state && !Config->get_loop_is_mode()) { unset_play_loop (); } - + reset_slave_state (); _transport_speed = 0; @@ -314,12 +320,14 @@ Session::realtime_locate () void Session::butler_transport_work () { + /* Note: this function executes in the butler thread context */ + restart: bool finished; PostTransportWork ptw; boost::shared_ptr r = routes.reader (); uint64_t before; - + int on_entry = g_atomic_int_get (&_butler->should_do_transport_work); finished = true; ptw = post_transport_work(); @@ -329,20 +337,27 @@ Session::butler_transport_work () if (ptw & PostTransportLocate) { - if (get_play_loop() && !Config->get_seamless_loop() && actively_recording()) { + if (get_play_loop() && !Config->get_seamless_loop()) { + + DEBUG_TRACE (DEBUG::Butler, "flush loop recording fragment to disk\n"); - /* this locate is happening while we are doing loop - * recording but with seam-ed (non-seamless) looping. - * We must flush any data to disk before resetting - * buffers as part of the pending locate (which happens - * a little later in this method). + /* this locate might be happening while we are + * loop recording. + * + * Non-seamless looping will require a locate (below) that + * will reset capture buffers and throw away data. + * + * Rather than first find all tracks and see if they + * have outstanding data, just do a flush anyway. It + * may be cheaper this way anyway, and is certainly + * more accurate. */ bool more_disk_io_to_do = false; uint32_t errors = 0; do { - more_disk_io_to_do = _butler->flush_tracks_to_disk (r, errors, true); + more_disk_io_to_do = _butler->flush_tracks_to_disk_after_locate (r, errors); if (errors) { break; @@ -508,13 +523,13 @@ Session::non_realtime_locate () } else if (loc) { set_track_loop (false); } - + } else { /* no more looping .. should have been noticed elsewhere */ } - + boost::shared_ptr rl = routes.reader(); for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) { (*i)->non_realtime_locate (_transport_frame); @@ -546,7 +561,7 @@ Session::select_playhead_priority_target (framepos_t& jump_to) // Next stop will put us where we need to be. return false; } - + /* Note that the order of checking each AutoReturnTarget flag defines the priority each flag. @@ -560,7 +575,7 @@ Session::select_playhead_priority_target (framepos_t& jump_to) Region Selection Last Locate */ - + if (autoreturn & RangeSelectionStart) { if (!_range_selection.empty()) { jump_to = _range_selection.from; @@ -574,13 +589,13 @@ Session::select_playhead_priority_target (framepos_t& jump_to) } } } - + if (jump_to < 0 && (autoreturn & Loop) && get_play_loop()) { /* don't try to handle loop play when synced to JACK */ - + if (!synced_to_engine()) { Location *location = _locations->auto_loop_location(); - + if (location) { jump_to = location->start(); @@ -588,20 +603,20 @@ Session::select_playhead_priority_target (framepos_t& jump_to) /* need to get track buffers reloaded */ set_track_loop (true); } - } + } } } - + if (jump_to < 0 && (autoreturn & RegionSelectionStart)) { if (!_object_selection.empty()) { jump_to = _object_selection.from; } - } + } if (jump_to < 0 && (autoreturn & LastLocate)) { jump_to = _last_roll_location; } - + return jump_to >= 0; } #else @@ -609,7 +624,7 @@ Session::select_playhead_priority_target (framepos_t& jump_to) bool Session::select_playhead_priority_target (framepos_t& jump_to) { - if (!config.get_auto_return()) { + if (config.get_external_sync() || !config.get_auto_return()) { return false; } @@ -795,14 +810,14 @@ Session::non_realtime_stop (bool abort, int on_entry, bool& finished) if (_engine.connected() && !_engine.freewheeling()) { // need to queue this in the next RT cycle _send_timecode_update = true; - + if (!dynamic_cast(_slave)) { send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdStop)); /* This (::non_realtime_stop()) gets called by main process thread, which will lead to confusion when calling AsyncMIDIPort::write(). - + Something must be done. XXX */ send_mmc_locate (_transport_frame); @@ -895,8 +910,8 @@ Session::unset_play_loop () clear_events (SessionEvent::AutoLoop); clear_events (SessionEvent::AutoLoopDeclick); set_track_loop (false); - - + + if (Config->get_seamless_loop()) { /* likely need to flush track buffers: this will locate us to wherever we are */ add_post_transport_work (PostTransportLocate); @@ -948,7 +963,7 @@ Session::set_play_loop (bool yn, double speed) play_loop = true; have_looped = false; - + if (loc) { unset_play_range (); @@ -958,8 +973,8 @@ Session::set_play_loop (bool yn, double speed) /* set all tracks to use internal looping */ set_track_loop (true); } else { - /* we will do this in the locate to the start OR when we hit the end - * of the loop for the first time + /* we will do this in the locate to the start OR when we hit the end + * of the loop for the first time */ } } else { @@ -1085,18 +1100,18 @@ void Session::locate (framepos_t target_frame, bool with_roll, bool with_flush, bool for_loop_enabled, bool force, bool with_mmc) { bool need_butler = false; - + /* Locates for seamless looping are fairly different from other * locates. They assume that the diskstream buffers for each track * already have the correct data in them, and thus there is no need to * actually tell the tracks to locate. What does need to be done, * though, is all the housekeeping that is associated with non-linear - * changes in the value of _transport_frame. + * changes in the value of _transport_frame. */ DEBUG_TRACE (DEBUG::Transport, string_compose ("rt-locate to %1, roll %2 flush %3 loop-enabled %4 force %5 mmc %6\n", target_frame, with_roll, with_flush, for_loop_enabled, force, with_mmc)); - + if (!force && _transport_frame == target_frame && !loop_changing && !for_loop_enabled) { /* already at the desired position. Not forced to locate, @@ -1146,7 +1161,7 @@ Session::locate (framepos_t target_frame, bool with_roll, bool with_flush, bool */ bool transport_was_stopped = !transport_rolling(); - + if (!transport_was_stopped && (!auto_play_legal || !config.get_auto_play()) && !with_roll && !(synced_to_engine() && play_loop) && (!Profile->get_trx() || !(config.get_external_sync() && !synced_to_engine()))) { realtime_stop (false, true); // XXX paul - check if the 2nd arg is really correct @@ -1166,7 +1181,7 @@ Session::locate (framepos_t target_frame, bool with_roll, bool with_flush, bool add_post_transport_work (todo); need_butler = true; - + } else { /* this is functionally what clear_clicks() does but with a tentative lock */ @@ -1206,7 +1221,7 @@ Session::locate (framepos_t target_frame, bool with_roll, bool with_flush, bool // located outside the loop: cancel looping directly, this is called from event handling context have_looped = false; - + if (!Config->get_loop_is_mode()) { set_play_loop (false, _transport_speed); } else { @@ -1237,10 +1252,10 @@ Session::locate (framepos_t target_frame, bool with_roll, bool with_flush, bool } boost::shared_ptr rl = routes.reader(); - + for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) { boost::shared_ptr tr = boost::dynamic_pointer_cast (*i); - + if (tr && tr->record_enabled ()) { // tell it we've looped, so it can deal with the record state tr->transport_looped (_transport_frame); @@ -1276,7 +1291,7 @@ Session::locate (framepos_t target_frame, bool with_roll, bool with_flush, bool void Session::set_transport_speed (double speed, framepos_t destination_frame, bool abort, bool clear_state, bool as_default) { - DEBUG_TRACE (DEBUG::Transport, string_compose ("@ %5 Set transport speed to %1, abort = %2 clear_state = %3, current = %4 as_default %6\n", + DEBUG_TRACE (DEBUG::Transport, string_compose ("@ %5 Set transport speed to %1, abort = %2 clear_state = %3, current = %4 as_default %6\n", speed, abort, clear_state, _transport_speed, _transport_frame, as_default)); if (_transport_speed == speed) { @@ -1288,7 +1303,7 @@ Session::set_transport_speed (double speed, framepos_t destination_frame, bool a if (actively_recording() && speed != 1.0 && speed != 0.0) { /* no varispeed during recording */ - DEBUG_TRACE (DEBUG::Transport, string_compose ("No varispeed during recording cur_speed %1, frame %2\n", + DEBUG_TRACE (DEBUG::Transport, string_compose ("No varispeed during recording cur_speed %1, frame %2\n", _transport_speed, _transport_frame)); return; } @@ -1312,7 +1327,7 @@ Session::set_transport_speed (double speed, framepos_t destination_frame, bool a if (Config->get_monitoring_model() == HardwareMonitoring) { set_track_monitor_input_status (true); } - + if (synced_to_engine ()) { if (clear_state) { /* do this here because our response to the slave won't @@ -1333,13 +1348,15 @@ Session::set_transport_speed (double speed, framepos_t destination_frame, bool a } } else if (transport_stopped() && speed == 1.0) { - + if (as_default) { + _default_transport_speed = speed; + } /* we are stopped and we want to start rolling at speed 1 */ if (Config->get_loop_is_mode() && play_loop) { Location *location = _locations->auto_loop_location(); - + if (location != 0) { if (_transport_frame != location->start()) { @@ -1425,13 +1442,13 @@ Session::set_transport_speed (double speed, framepos_t destination_frame, bool a DEBUG_TRACE (DEBUG::Transport, string_compose ("send TSC3 with speed = %1\n", _transport_speed)); - /* throttle signal emissions. + /* throttle signal emissions. * when slaved [_last]_transport_speed * usually changes every cycle (tiny amounts due to DLL). * Emitting a signal every cycle is overkill and unwarranted. * * Using _last_transport_speed is not acceptable, - * since it allows for large changes over a long period + * since it allows for large changes over a long period * of time. Hence we introduce a dedicated variable to keep track * * The 0.2% dead-zone is somewhat arbitrary. Main use-case @@ -1459,7 +1476,7 @@ Session::stop_transport (bool abort, bool clear_state) } DEBUG_TRACE (DEBUG::Transport, string_compose ("stop_transport, declick required? %1\n", get_transport_declick_required())); - + if (!get_transport_declick_required()) { /* stop has not yet been scheduled */ @@ -1475,10 +1492,10 @@ Session::stop_transport (bool abort, bool clear_state) } SubState new_bits; - + if (actively_recording() && /* we are recording */ worst_input_latency() > current_block_size) { /* input latency exceeds block size, so simple 1 cycle delay before stop is not enough */ - + /* we need to capture the audio that is still somewhere in the pipeline between wherever it was generated and the process callback. This means that even though the user (or something else) has asked us to stop, we have to roll @@ -1488,33 +1505,33 @@ Session::stop_transport (bool abort, bool clear_state) we still need playback to "stop" now, however, which is why we schedule a declick below. */ - + DEBUG_TRACE (DEBUG::Transport, string_compose ("stop transport requested @ %1, scheduled for + %2 = %3, abort = %4\n", _transport_frame, _worst_input_latency, _transport_frame + _worst_input_latency, abort)); - + SessionEvent *ev = new SessionEvent (SessionEvent::StopOnce, SessionEvent::Replace, _transport_frame + _worst_input_latency, 0, 0, abort); - + merge_event (ev); /* request a declick at the start of the next process cycle() so that playback ceases. - It will remain silent until we actually stop (at the StopOnce event somewhere in + It will remain silent until we actually stop (at the StopOnce event somewhere in the future). The extra flag (StopPendingCapture) is set to ensure that check_declick_out() does not stop the transport too early. */ new_bits = SubState (PendingDeclickOut|StopPendingCapture); - + } else { - + /* Not recording, schedule a declick in the next process() cycle and then stop at its end */ - + new_bits = PendingDeclickOut; DEBUG_TRACE (DEBUG::Transport, string_compose ("stop scheduled for next process cycle @ %1\n", _transport_frame)); } - + /* we'll be called again after the declick */ transport_sub_state = SubState (transport_sub_state|new_bits); pending_abort = abort; @@ -1524,9 +1541,9 @@ Session::stop_transport (bool abort, bool clear_state) } else { DEBUG_TRACE (DEBUG::Transport, "time to actually stop\n"); - + /* declick was scheduled, but we've been called again, which means it is really time to stop - + XXX: we should probably split this off into its own method and call it explicitly. */ @@ -1700,7 +1717,7 @@ Session::use_sync_source (Slave* new_slave) } DEBUG_TRACE (DEBUG::Slave, string_compose ("set new slave to %1\n", _slave)); - + // need to queue this for next process() cycle _send_timecode_update = true;