}
if (ptw & PostTransportLocate) {
+ DEBUG_TRACE (DEBUG::Transport, "nonrealtime locate invoked from BTW\n");
non_realtime_locate ();
}
void
Session::non_realtime_locate ()
{
+ DEBUG_TRACE (DEBUG::Transport, string_compose ("locate tracks to %1\n", _transport_frame));
+
+ if (Config->get_loop_is_mode() && get_play_loop()) {
+
+ Location *loc = _locations->auto_loop_location();
+
+ if (!loc || (_transport_frame < loc->start() || _transport_frame >= loc->end())) {
+ /* jumped out of loop range: stop tracks from looping,
+ but leave loop (mode) enabled.
+ */
+ set_track_loop (false);
+
+ } else if (loc && Config->get_seamless_loop() &&
+ ((loc->start() <= _transport_frame) ||
+ (loc->end() > _transport_frame) ) ) {
+
+ /* jumping to start of loop. This might have been done before but it is
+ * idempotent and cheap. Doing it here ensures that when we start playback
+ * outside the loop we still flip tracks into the magic seamless mode
+ * when needed.
+ */
+ set_track_loop (true);
+
+ } else if (loc) {
+ set_track_loop (false);
+ }
+
+ } else {
+
+ /* no more looping .. should have been noticed elsewhere */
+ }
+
+
boost::shared_ptr<RouteList> rl = routes.reader();
for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
(*i)->non_realtime_locate (_transport_frame);
clear_clicks ();
}
-
void
Session::non_realtime_stop (bool abort, int on_entry, bool& finished)
{
_send_timecode_update = true;
if (!dynamic_cast<MTC_Slave*>(_slave)) {
- _mmc->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdStop));
+ send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdStop));
/* This (::non_realtime_stop()) gets called by main
process thread, which will lead to confusion
* save state only if there's no slave or if it's not yet locked.
*/
if (!_slave || !_slave->locked()) {
- DEBUG_TRACE (DEBUG::Transport, X_("Butler PTW: pending save\n"));
- /* capture start has been changed, so save pending state */
- save_state ("", true);
+ DEBUG_TRACE (DEBUG::Transport, X_("Butler PTW: requests save\n"));
+ SaveSessionRequested (_current_snapshot_name);
saved = true;
}
}
/* save the current state of things if appropriate */
if (did_record && !saved) {
- save_state (_current_snapshot_name);
+ SaveSessionRequested (_current_snapshot_name);
}
if (ptw & PostTransportStop) {
void
Session::unset_play_loop ()
{
- play_loop = false;
- clear_events (SessionEvent::AutoLoop);
- clear_events (SessionEvent::AutoLoopDeclick);
+ if (play_loop) {
+ play_loop = false;
+ 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);
+ _butler->schedule_transport_work ();
+ }
+ }
+}
+
+void
+Session::set_track_loop (bool yn)
+{
+ Location* loc = _locations->auto_loop_location ();
+
+ if (!loc) {
+ yn = false;
+ }
- // set all tracks to NOT use internal looping
boost::shared_ptr<RouteList> rl = routes.reader ();
+
for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
if (tr && !tr->hidden()) {
- tr->set_loop (0);
+ tr->set_loop (yn ? loc : 0);
}
}
}
if (yn) {
play_loop = true;
-
+ have_looped = false;
+
if (loc) {
unset_play_range ();
if (Config->get_seamless_loop()) {
- // set all tracks to use internal looping
- boost::shared_ptr<RouteList> rl = routes.reader ();
- for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
- boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
- if (tr && !tr->hidden()) {
- tr->set_loop (loc);
- }
- }
- }
- else {
- // set all tracks to NOT use internal looping
- boost::shared_ptr<RouteList> rl = routes.reader ();
- for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
- boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
- if (tr && !tr->hidden()) {
- tr->set_loop (0);
- }
+ if (!Config->get_loop_is_mode()) {
+ /* 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
+ */
}
+ } else {
+ /* set all tracks to NOT use internal looping */
+ set_track_loop (false);
}
/* Put the delick and loop events in into the event list. The declick event will
void
Session::locate (framepos_t target_frame, bool with_roll, bool with_flush, bool for_seamless_loop, 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
* changes in the value of _transport_frame.
*/
+ DEBUG_TRACE (DEBUG::Transport, string_compose ("rt-locate to %1, roll %2 flush %3 seamless %4 force %5 mmc %6\n",
+ target_frame, with_roll, with_flush, for_seamless_loop, force, with_mmc));
+
if (actively_recording() && !for_seamless_loop) {
return;
}
*/
bool transport_was_stopped = !transport_rolling();
-
+
if (transport_was_stopped && (!auto_play_legal || !config.get_auto_play()) && !with_roll && !(synced_to_engine() && play_loop)) {
realtime_stop (false, true); // XXX paul - check if the 2nd arg is really correct
transport_was_stopped = true;
}
add_post_transport_work (todo);
- _butler->schedule_transport_work ();
-
+ need_butler = true;
+
} else {
/* this is functionally what clear_clicks() does but with a tentative lock */
// 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 {
+ if (Config->get_seamless_loop()) {
+ /* this will make the non_realtime_locate() in the butler
+ which then causes seek() in tracks actually do the right
+ thing.
+ */
+ set_track_loop (false);
+ }
}
} else if (_transport_frame == al->start()) {
if (for_seamless_loop) {
+ if (!have_looped) {
+ /* first time */
+ if (_last_roll_location != al->start()) {
+ /* didn't start at loop start - playback must have
+ * started before loop since we've now hit the loop
+ * end.
+ */
+ add_post_transport_work (PostTransportLocate);
+ need_butler = true;
+ }
+
+ }
+
// this is only necessary for seamless looping
boost::shared_ptr<RouteList> rl = routes.reader();
}
}
+ if (need_butler) {
+ _butler->schedule_transport_work ();
+ }
+
loop_changing = false;
_send_timecode_update = true;
if (location != 0) {
if (_transport_frame != location->start()) {
+
+ if (Config->get_seamless_loop()) {
+ /* force tracks to do their thing */
+ set_track_loop (true);
+ }
+
/* jump to start and then roll from there */
+
request_locate (location->start(), true);
return;
}
}
DEBUG_TRACE (DEBUG::Transport, string_compose ("send TSC3 with speed = %1\n", _transport_speed));
- TransportStateChange (); /* EMIT SIGNAL */
+
+ /* 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
+ * of time. Hence we introduce a dedicated variable to keep track
+ *
+ * The 0.2% dead-zone is somewhat arbitrary. Main use-case
+ * for TransportStateChange() here is the ShuttleControl display.
+ */
+ if (fabsf(_signalled_varispeed - speed) > .002f
+ // still, signal hard changes to 1.0 and 0.0:
+ || ( speed == 1.f && _signalled_varispeed != 1.f)
+ || ( speed == 0.f && _signalled_varispeed != 0.f)
+ )
+ {
+ TransportStateChange (); /* EMIT SIGNAL */
+ _signalled_varispeed = speed;
+ }
}
}
Timecode::Time time;
timecode_time_subframes (_transport_frame, time);
if (!dynamic_cast<MTC_Slave*>(_slave)) {
- _mmc->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdDeferredPlay));
+ send_immediate_mmc (MIDI::MachineControlCommand (MIDI::MachineControl::cmdDeferredPlay));
}
}
}
if (c.type == RouteProcessorChange::MeterPointChange) {
+ set_dirty ();
+ return;
+ }
+
+ if (c.type == RouteProcessorChange::RealTimeChange) {
+ set_dirty ();
return;
}
if (!_engine.freewheeling()) {
Timecode::Time time;
timecode_time_subframes (t, time);
- _mmc->send (MIDI::MachineControlCommand (time));
+ send_immediate_mmc (MIDI::MachineControlCommand (time));
}
}
projects / ardour.git / blobdiff