*/
-#include <cmath>
-#include <cerrno>
-#include <unistd.h>
-
#ifdef WAF_BUILD
#include "libardour-config.h"
#endif
+#include <cmath>
+#include <cerrno>
+#include <unistd.h>
#include "pbd/undo.h"
#include "pbd/error.h"
#include "pbd/enumwriter.h"
#include "pbd/pthread_utils.h"
#include "pbd/memento_command.h"
+#include "pbd/stacktrace.h"
#include "midi++/mmc.h"
#include "midi++/port.h"
-#include "midi++/manager.h"
-#include "ardour/ardour.h"
#include "ardour/audioengine.h"
#include "ardour/auditioner.h"
#include "ardour/butler.h"
+#include "ardour/click.h"
#include "ardour/debug.h"
#include "ardour/location.h"
+#include "ardour/profile.h"
#include "ardour/session.h"
#include "ardour/slave.h"
#include "ardour/operations.h"
seamless = Config->get_seamless_loop ();
- if (dynamic_cast<JACK_Slave*>(new_slave)) {
+ if (dynamic_cast<Engine_Slave*>(new_slave)) {
/* JACK cannot support seamless looping at present */
Config->set_seamless_loop (false);
} else {
_was_seamless = seamless;
ev->slave = new_slave;
+ DEBUG_TRACE (DEBUG::Slave, "sent request for new slave\n");
queue_event (ev);
}
void
-Session::request_transport_speed (double speed)
+Session::request_transport_speed (double speed, bool as_default)
{
SessionEvent* ev = new SessionEvent (SessionEvent::SetTransportSpeed, SessionEvent::Add, SessionEvent::Immediate, 0, speed);
- DEBUG_TRACE (DEBUG::Transport, string_compose ("Request transport speed = %1\n", speed));
+ ev->third_yes_or_no = true;
+ DEBUG_TRACE (DEBUG::Transport, string_compose ("Request transport speed = %1 as default = %2\n", speed, as_default));
queue_event (ev);
}
* be used by callers who are varying transport speed but don't ever want to stop it.
*/
void
-Session::request_transport_speed_nonzero (double speed)
+Session::request_transport_speed_nonzero (double speed, bool as_default)
{
if (speed == 0) {
speed = DBL_EPSILON;
}
- request_transport_speed (speed);
+ request_transport_speed (speed, as_default);
}
void
}
void
-Session::request_play_loop (bool yn, bool leave_rolling)
+Session::request_play_loop (bool yn, bool change_transport_roll)
{
SessionEvent* ev;
Location *location = _locations->auto_loop_location();
+ double target_speed;
if (location == 0 && yn) {
error << _("Cannot loop - no loop range defined")
return;
}
- ev = new SessionEvent (SessionEvent::SetLoop, SessionEvent::Add, SessionEvent::Immediate, 0, (leave_rolling ? 1.0 : 0.0), yn);
- DEBUG_TRACE (DEBUG::Transport, string_compose ("Request set loop = %1, leave rolling ? %2\n", yn, leave_rolling));
+ if (change_transport_roll) {
+ if (transport_rolling()) {
+ /* start looping at current speed */
+ target_speed = transport_speed ();
+ } else {
+ /* currently stopped */
+ if (yn) {
+ /* start looping at normal speed */
+ target_speed = 1.0;
+ } else {
+ target_speed = 0.0;
+ }
+ }
+ } else {
+ /* leave the speed alone */
+ target_speed = transport_speed ();
+ }
+
+ ev = new SessionEvent (SessionEvent::SetLoop, SessionEvent::Add, SessionEvent::Immediate, 0, target_speed, yn);
+ DEBUG_TRACE (DEBUG::Transport, string_compose ("Request set loop = %1, change roll state ? %2\n", yn, change_transport_roll));
queue_event (ev);
- if (!leave_rolling && !yn && Config->get_seamless_loop() && transport_rolling()) {
- // request an immediate locate to refresh the tracks
- // after disabling looping
- request_locate (_transport_frame-1, false);
+ if (yn) {
+ if (!change_transport_roll) {
+ if (!transport_rolling()) {
+ /* we're not changing transport state, but we do want
+ to set up position for the new loop. Don't
+ do this if we're rolling already.
+ */
+ request_locate (location->start(), false);
+ }
+ }
+ } else {
+ if (!change_transport_roll && Config->get_seamless_loop() && transport_rolling()) {
+ // request an immediate locate to refresh the tracks
+ // after disabling looping
+ request_locate (_transport_frame-1, false);
+ }
}
}
void
Session::realtime_stop (bool abort, bool clear_state)
{
- DEBUG_TRACE (DEBUG::Transport, "realtime stop\n");
+ DEBUG_TRACE (DEBUG::Transport, string_compose ("realtime stop @ %1\n", _transport_frame));
PostTransportWork todo = PostTransportWork (0);
/* assume that when we start, we'll be moving forwards */
if (_transport_speed < 0.0f) {
todo = (PostTransportWork (todo | PostTransportStop | PostTransportReverse));
+ _default_transport_speed = 1.0;
} else {
todo = PostTransportWork (todo | PostTransportStop);
}
/* we rolled past the stop point to pick up data that had
not yet arrived. move back to where the stop occured.
*/
- decrement_transport_position (current_block_size + (worst_playback_latency() - current_block_size));
+ decrement_transport_position (current_block_size + (worst_input_latency() - current_block_size));
} else {
decrement_transport_position (current_block_size);
}
transport_sub_state = 0;
}
+void
+Session::realtime_locate ()
+{
+ boost::shared_ptr<RouteList> r = routes.reader ();
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ (*i)->realtime_locate ();
+ }
+}
+
void
Session::butler_transport_work ()
{
if (tr) {
tr->adjust_playback_buffering ();
/* and refill those buffers ... */
- tr->non_realtime_locate (_transport_frame);
}
+ (*i)->non_realtime_locate (_transport_frame);
}
}
if (!(ptw & PostTransportLocate)) {
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
- if (tr && !tr->hidden()) {
- tr->non_realtime_locate (_transport_frame);
- }
+ (*i)->non_realtime_locate (_transport_frame);
+
if (on_entry != g_atomic_int_get (&_butler->should_do_transport_work)) {
/* new request, stop seeking, and start again */
g_atomic_int_dec_and_test (&_butler->should_do_transport_work);
g_atomic_int_dec_and_test (&_butler->should_do_transport_work);
DEBUG_TRACE (DEBUG::Transport, X_("Butler transport work all done\n"));
+ DEBUG_TRACE (DEBUG::Transport, X_(string_compose ("Frame %1\n", _transport_frame)));
}
void
{
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->non_realtime_locate (_transport_frame);
- }
+ (*i)->non_realtime_locate (_transport_frame);
}
+
+ /* XXX: it would be nice to generate the new clicks here (in the non-RT thread)
+ rather than clearing them so that the RT thread has to spend time constructing
+ them (in Session::click).
+ */
+ clear_clicks ();
}
auditioner->cancel_audition ();
}
- clear_clicks();
cumulative_rf_motion = 0;
reset_rf_scale (0);
}
if (abort && did_record) {
- _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
+ _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
}
boost::shared_ptr<RouteList> r = routes.reader ();
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if (!(*i)->is_hidden()) {
+ if (!(*i)->is_auditioner()) {
(*i)->set_pending_declick (0);
}
}
if (auto_return_enabled ||
(ptw & PostTransportLocate) ||
(_requested_return_frame >= 0) ||
- synced_to_jack()) {
+ synced_to_engine()) {
if (pending_locate_flush) {
flush_all_inserts ();
}
- if ((auto_return_enabled || synced_to_jack() || _requested_return_frame >= 0) &&
+ if ((auto_return_enabled || synced_to_engine() || _requested_return_frame >= 0) &&
!(ptw & PostTransportLocate)) {
/* no explicit locate queued */
if (_requested_return_frame >= 0) {
/* explicit return request pre-queued in event list. overrides everything else */
-
- cerr << "explicit auto-return to " << _requested_return_frame << endl;
_transport_frame = _requested_return_frame;
do_locate = true;
/* don't try to handle loop play when synced to JACK */
- if (!synced_to_jack()) {
+ if (!synced_to_engine()) {
Location *location = _locations->auto_loop_location();
-
+
if (location != 0) {
_transport_frame = location->start();
} else {
}
} else {
-
+
/* regular auto-return */
-
+
_transport_frame = _last_roll_location;
do_locate = true;
}
- }
+ }
}
- _requested_return_frame = -1;
+ _requested_return_frame = -1;
if (do_locate) {
_engine.transport_locate (_transport_frame);
}
- }
+ }
}
+ clear_clicks();
+
/* do this before seeking, because otherwise the tracks will do the wrong thing in seamless loop mode.
*/
if (ptw & PostTransportClearSubstate) {
- _play_range = false;
- unset_play_loop ();
+ unset_play_range ();
+ if (!Config->get_loop_is_mode()) {
+ unset_play_loop ();
+ }
}
/* this for() block can be put inside the previous if() and has the effect of ... ??? what */
DEBUG_TRACE (DEBUG::Transport, X_("Butler PTW: locate\n"));
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
DEBUG_TRACE (DEBUG::Transport, string_compose ("Butler PTW: locate on %1\n", (*i)->name()));
- boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
- if (tr && !tr->hidden()) {
- tr->non_realtime_locate (_transport_frame);
- }
+ (*i)->non_realtime_locate (_transport_frame);
if (on_entry != g_atomic_int_get (&_butler->should_do_transport_work)) {
finished = false;
have_looped = false;
- send_full_time_code (_transport_frame);
+ /* don't bother with this stuff if we're disconnected from the engine,
+ because there will be no process callbacks to deliver stuff from
+ */
- if (!dynamic_cast<MTC_Slave*>(_slave)) {
- MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdStop));
- send_mmc_locate (_transport_frame);
+ if (_engine.connected() && !_engine.freewheeling()) {
+ // need to queue this in the next RT cycle
+ _send_timecode_update = true;
+
+ if (!dynamic_cast<MTC_Slave*>(_slave)) {
+ _mmc->send (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);
+ }
}
if ((ptw & PostTransportLocate) && get_record_enabled()) {
- /* capture start has been changed, so save pending state */
- save_state ("", true);
- saved = true;
+ /* This is scheduled by realtime_stop(), which is also done
+ * when a slave requests /locate/ for an initial sync.
+ * We can't hold up the slave for long with a save() here,
+ * without breaking its initial sync cycle.
+ *
+ * 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);
+ saved = true;
+ }
}
/* always try to get rid of this */
}
if (ptw & PostTransportStop) {
- _play_range = false;
- play_loop = false;
+ unset_play_range ();
+ if (!Config->get_loop_is_mode()) {
+ unset_play_loop ();
+ }
}
PositionChanged (_transport_frame); /* EMIT SIGNAL */
+ DEBUG_TRACE (DEBUG::Transport, string_compose ("send TSC with speed = %1\n", _transport_speed));
TransportStateChange (); /* EMIT SIGNAL */
/* and start it up again if relevant */
if ((ptw & PostTransportLocate) && !config.get_external_sync() && pending_locate_roll) {
request_transport_speed (1.0);
- pending_locate_roll = false;
}
+
+ /* Even if we didn't do a pending locate roll this time, we don't want it hanging
+ around for next time.
+ */
+ pending_locate_roll = false;
}
void
/* this is called after a process() iteration. if PendingDeclickOut was set,
it means that we were waiting to declick the output (which has just been
- done) before doing something else. this is where we do that "something else".
+ done) before maybe doing something else. this is where we do that "something else".
note: called from the audio thread.
*/
stop_transport (pending_abort);
transport_sub_state &= ~(PendingDeclickOut|PendingLocate);
}
+
+ } else if (transport_sub_state & PendingLoopDeclickOut) {
+ /* Nothing else to do here; we've declicked, and the loop event will be along shortly */
+ transport_sub_state &= ~PendingLoopDeclickOut;
}
}
{
play_loop = false;
clear_events (SessionEvent::AutoLoop);
-
+ clear_events (SessionEvent::AutoLoopDeclick);
+
// 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) {
}
void
-Session::set_play_loop (bool yn)
+Session::set_play_loop (bool yn, double speed)
{
/* Called from event-handling context */
/* nothing to do, or can't change loop status while recording */
return;
}
-
- if (yn && Config->get_seamless_loop() && synced_to_jack()) {
+
+ if (yn && Config->get_seamless_loop() && synced_to_engine()) {
warning << string_compose (
_("Seamless looping cannot be supported while %1 is using JACK transport.\n"
"Recommend changing the configured options"), PROGRAM_NAME)
<< endmsg;
return;
}
-
+
if (yn) {
play_loop = true;
}
}
}
-
- /* put the loop event into the event list */
-
- SessionEvent* event = new SessionEvent (SessionEvent::AutoLoop, SessionEvent::Replace, loc->end(), loc->start(), 0.0f);
- merge_event (event);
- /* locate to start of loop and roll. If doing seamless loop, force a
- locate+buffer refill even if we are positioned there already.
+ /* Put the delick and loop events in into the event list. The declick event will
+ cause a de-clicking fade-out just before the end of the loop, and it will also result
+ in a fade-in when the loop restarts. The AutoLoop event will peform the actual loop.
+ */
+
+ framepos_t dcp;
+ framecnt_t dcl;
+ auto_loop_declick_range (loc, dcp, dcl);
+ merge_event (new SessionEvent (SessionEvent::AutoLoopDeclick, SessionEvent::Replace, dcp, dcl, 0.0f));
+ merge_event (new SessionEvent (SessionEvent::AutoLoop, SessionEvent::Replace, loc->end(), loc->start(), 0.0f));
+
+ /* if requested to roll, locate to start of loop and
+ * roll but ONLY if we're not already rolling.
+
+ args: positition, roll=true, flush=true, with_loop=false, force buffer refill if seamless looping
*/
- start_locate (loc->start(), true, true, false, Config->get_seamless_loop());
+ if (Config->get_loop_is_mode()) {
+ /* loop IS a transport mode: if already
+ rolling, do not locate to loop start.
+ */
+ if (!transport_rolling() && (speed != 0.0)) {
+ start_locate (loc->start(), true, true, false, Config->get_seamless_loop());
+ }
+ } else {
+ if (speed != 0.0) {
+ start_locate (loc->start(), true, true, false, Config->get_seamless_loop());
+ }
+ }
}
} else {
unset_play_loop ();
}
+ DEBUG_TRACE (DEBUG::Transport, string_compose ("send TSC2 with speed = %1\n", _transport_speed));
TransportStateChange ();
}
void
void
Session::start_locate (framepos_t target_frame, bool with_roll, bool with_flush, bool with_loop, bool force)
{
- if (synced_to_jack()) {
+ if (synced_to_engine()) {
double sp;
framepos_t pos;
if (target_frame != pos) {
+ if (config.get_jack_time_master()) {
+ /* actually locate now, since otherwise jack_timebase_callback
+ will use the incorrect _transport_frame and report an old
+ and incorrect time to Jack transport
+ */
+ locate (target_frame, with_roll, with_flush, with_loop, force);
+ }
+
/* tell JACK to change transport position, and we will
follow along later in ::follow_slave()
*/
/** @param with_mmc true to send a MMC locate command when the locate is done */
void
-Session::locate (framepos_t target_frame, bool with_roll, bool with_flush, bool with_loop, bool force, bool with_mmc)
+Session::locate (framepos_t target_frame, bool with_roll, bool with_flush, bool for_seamless_loop, bool force, bool with_mmc)
{
- if (actively_recording() && !with_loop) {
+ /* 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.
+ */
+
+ if (actively_recording() && !for_seamless_loop) {
return;
}
- if (!force && _transport_frame == target_frame && !loop_changing && !with_loop) {
+ if (!force && _transport_frame == target_frame && !loop_changing && !for_seamless_loop) {
if (with_roll) {
set_transport_speed (1.0, false);
}
return;
}
- if (_transport_speed) {
- /* schedule a declick. we'll be called again when its done */
+ if (_transport_speed && !for_seamless_loop) {
+ /* Schedule a declick. We'll be called again when its done.
+ We only do it this way for ordinary locates, not those
+ due to **seamless** loops.
+ */
if (!(transport_sub_state & PendingDeclickOut)) {
transport_sub_state |= (PendingDeclickOut|PendingLocate);
// Update Timecode time
// [DR] FIXME: find out exactly where this should go below
_transport_frame = target_frame;
+ _last_roll_or_reversal_location = target_frame;
timecode_time(_transport_frame, transmitting_timecode_time);
outbound_mtc_timecode_frame = _transport_frame;
next_quarter_frame_to_send = 0;
- if (transport_rolling() && (!auto_play_legal || !config.get_auto_play()) && !with_roll && !(synced_to_jack() && play_loop)) {
+ /* do "stopped" stuff if:
+ *
+ * we are rolling AND
+ * no autoplay in effect AND
+ * we're not going to keep rolling after the locate AND
+ * !(playing a loop with JACK sync)
+ *
+ */
+
+ 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;
+ } else {
+ /* otherwise tell the world that we located */
+ realtime_locate ();
}
- if (force || !with_loop || loop_changing) {
+ if (force || !for_seamless_loop || loop_changing) {
PostTransportWork todo = PostTransportLocate;
- if (with_roll) {
+ if (with_roll && transport_was_stopped) {
todo = PostTransportWork (todo | PostTransportRoll);
- }
+ }
add_post_transport_work (todo);
_butler->schedule_transport_work ();
/* this is functionally what clear_clicks() does but with a tentative lock */
- Glib::RWLock::WriterLock clickm (click_lock, Glib::TRY_LOCK);
+ Glib::Threads::RWLock::WriterLock clickm (click_lock, Glib::Threads::TRY_LOCK);
if (clickm.locked()) {
/* cancel looped playback if transport pos outside of loop range */
if (play_loop) {
+
Location* al = _locations->auto_loop_location();
- if (al && (_transport_frame < al->start() || _transport_frame > al->end())) {
- // cancel looping directly, this is called from event handling context
- set_play_loop (false);
- }
- else if (al && _transport_frame == al->start()) {
- if (with_loop) {
- // this is only necessary for seamless looping
+ if (al) {
+ if (_transport_frame < al->start() || _transport_frame > al->end()) {
- 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->record_enabled ()) {
- // tell it we've looped, so it can deal with the record state
- tr->transport_looped(_transport_frame);
+ // located outside the loop: cancel looping directly, this is called from event handling context
+
+ if (!Config->get_loop_is_mode()) {
+ set_play_loop (false, _transport_speed);
+ }
+
+ } else if (_transport_frame == al->start()) {
+
+ // located to start of loop - this is looping, basically
+
+ if (for_seamless_loop) {
+
+ // this is only necessary for seamless 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->record_enabled ()) {
+ // tell it we've looped, so it can deal with the record state
+ tr->transport_looped (_transport_frame);
+ }
}
}
+
+ have_looped = true;
+ TransportLooped(); // EMIT SIGNAL
}
- have_looped = true;
- TransportLooped(); // EMIT SIGNAL
}
}
send_mmc_locate (_transport_frame);
}
+ _last_roll_location = _last_roll_or_reversal_location = _transport_frame;
Located (); /* EMIT SIGNAL */
}
/** Set the transport speed.
- * @param speed New speed
- * @param abort
+ * Called from the process thread.
+ * @param speed New speed
*/
void
-Session::set_transport_speed (double speed, bool abort, bool clear_state)
+Session::set_transport_speed (double speed, bool abort, bool clear_state, bool as_default)
{
- DEBUG_TRACE (DEBUG::Transport, string_compose ("Set transport speed to %1, abort = %2 clear_state = %3, current = %4\n", speed, abort, clear_state, _transport_speed));
+ 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) {
+ if (as_default && speed == 0.0) { // => reset default transport speed. hacky or what?
+ _default_transport_speed = 1.0;
+ }
+ return;
+ }
+
+ 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",
+ _transport_speed, _transport_frame));
return;
}
set_track_monitor_input_status (true);
}
- if (synced_to_jack ()) {
+ if (synced_to_engine ()) {
if (clear_state) {
- /* do this here because our response to the slave won't
+ /* do this here because our response to the slave won't
take care of it.
*/
_play_range = false;
} else {
stop_transport (abort);
}
-
- unset_play_loop ();
+
+ if (!Config->get_loop_is_mode()) {
+ unset_play_loop ();
+ }
} else if (transport_stopped() && speed == 1.0) {
/* 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()) {
+ /* jump to start and then roll from there */
+ request_locate (location->start(), true);
+ return;
+ }
+ }
+ }
+
if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
set_track_monitor_input_status (false);
}
- if (synced_to_jack()) {
+ if (synced_to_engine()) {
_engine.transport_start ();
} else {
start_transport ();
} else {
- if ((synced_to_jack()) && speed != 0.0 && speed != 1.0) {
+ /* not zero, not 1.0 ... varispeed */
+
+ if ((synced_to_engine()) && speed != 0.0 && speed != 1.0) {
warning << string_compose (
_("Global varispeed cannot be supported while %1 is connected to JACK transport control"),
PROGRAM_NAME)
/* if we are reversing relative to the current speed, or relative to the speed
before the last stop, then we have to do extra work.
*/
-
+
PostTransportWork todo = PostTransportWork (0);
if ((_transport_speed && speed * _transport_speed < 0.0) || (_last_transport_speed * speed < 0.0) || (_last_transport_speed == 0.0f && speed < 0.0f)) {
_last_transport_speed = _transport_speed;
_transport_speed = speed;
+ if (as_default) {
+ _default_transport_speed = speed;
+ }
+
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);
add_post_transport_work (todo);
_butler->schedule_transport_work ();
}
+
+ DEBUG_TRACE (DEBUG::Transport, string_compose ("send TSC3 with speed = %1\n", _transport_speed));
+ TransportStateChange (); /* EMIT SIGNAL */
}
}
return;
}
- if (actively_recording() && !(transport_sub_state & StopPendingCapture) && worst_playback_latency() > current_block_size) {
+ if (actively_recording() && !(transport_sub_state & StopPendingCapture) && worst_input_latency() > current_block_size) {
boost::shared_ptr<RouteList> rl = routes.reader();
for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
and then we'll really be stopped.
*/
+ DEBUG_TRACE (DEBUG::Transport, string_compose ("stop transport requested @ %1, scheduled for + %2 - %3 = %4, abort = %5\n",
+ _transport_frame, _worst_input_latency, current_block_size,
+ _transport_frame - _worst_input_latency - current_block_size,
+ abort));
+
SessionEvent *ev = new SessionEvent (SessionEvent::StopOnce, SessionEvent::Replace,
_transport_frame + _worst_input_latency - current_block_size,
0, 0, abort);
return;
}
-
if ((transport_sub_state & PendingDeclickOut) == 0) {
if (!(transport_sub_state & StopPendingCapture)) {
_butler->schedule_transport_work ();
}
+/** Called from the process thread */
void
Session::start_transport ()
{
+ DEBUG_TRACE (DEBUG::Transport, "start_transport\n");
+
_last_roll_location = _transport_frame;
_last_roll_or_reversal_location = _transport_frame;
-
+
have_looped = false;
/* if record status is Enabled, move it to Recording. if its
transport_sub_state |= PendingDeclickIn;
- _transport_speed = 1.0;
- _target_transport_speed = 1.0;
+ _transport_speed = _default_transport_speed;
+ _target_transport_speed = _transport_speed;
boost::shared_ptr<RouteList> rl = routes.reader();
for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
if (tr) {
tr->realtime_set_speed (tr->speed(), true);
}
- (*i)->automation_snapshot (_transport_frame, true);
}
- Timecode::Time time;
- timecode_time_subframes (_transport_frame, time);
- if (!dynamic_cast<MTC_Slave*>(_slave)) {
- MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdDeferredPlay));
+ if (!_engine.freewheeling()) {
+ Timecode::Time time;
+ timecode_time_subframes (_transport_frame, time);
+ if (!dynamic_cast<MTC_Slave*>(_slave)) {
+ _mmc->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdDeferredPlay));
+ }
}
+ DEBUG_TRACE (DEBUG::Transport, string_compose ("send TSC4 with speed = %1\n", _transport_speed));
TransportStateChange (); /* EMIT SIGNAL */
}
if (((!config.get_external_sync() && (auto_play_legal && config.get_auto_play())) && !_exporting) || (ptw & PostTransportRoll)) {
start_transport ();
-
} else {
transport_sub_state = 0;
}
delete _slave;
_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;
+
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);
}
try {
- new_slave = new MTC_Slave (*this, *MIDI::Manager::instance()->mtc_input_port());
+ new_slave = new MTC_Slave (*this, *_midi_ports->mtc_input_port());
+ }
+
+ catch (failed_constructor& err) {
+ return;
+ }
+ break;
+
+ case LTC:
+ if (_slave && dynamic_cast<LTC_Slave*>(_slave)) {
+ return;
+ }
+
+ try {
+ new_slave = new LTC_Slave (*this);
}
catch (failed_constructor& err) {
return;
}
+
break;
case MIDIClock:
}
try {
- new_slave = new MIDIClock_Slave (*this, *MIDI::Manager::instance()->midi_clock_input_port(), 24);
+ new_slave = new MIDIClock_Slave (*this, *_midi_ports->midi_clock_input_port(), 24);
}
-
+
catch (failed_constructor& err) {
return;
}
break;
- case JACK:
- if (_slave && dynamic_cast<JACK_Slave*>(_slave)) {
+ case Engine:
+ if (_slave && dynamic_cast<Engine_Slave*>(_slave)) {
return;
}
return;
}
- new_slave = new JACK_Slave (_engine.jack());
+ new_slave = new Engine_Slave (*AudioEngine::instance());
break;
-
+
default:
new_slave = 0;
break;
request_sync_source (new_slave);
}
-void
-Session::reverse_track_buffers ()
-{
- add_post_transport_work (PostTransportReverse);
- _butler->schedule_transport_work ();
-}
-
void
Session::set_track_speed (Track* track, double speed)
{
/* Called from event-processing context */
unset_play_range ();
-
+
if (range.empty()) {
/* _play_range set to false in unset_play_range()
*/
unset_play_loop ();
list<AudioRange>::size_type sz = range.size();
-
+
if (sz > 1) {
-
- list<AudioRange>::iterator i = range.begin();
+
+ list<AudioRange>::iterator i = range.begin();
list<AudioRange>::iterator next;
-
+
while (i != range.end()) {
-
+
next = i;
++next;
-
+
/* locating/stopping is subject to delays for declicking.
*/
-
+
framepos_t requested_frame = i->end;
-
+
if (requested_frame > current_block_size) {
requested_frame -= current_block_size;
} else {
requested_frame = 0;
}
-
+
if (next == range.end()) {
ev = new SessionEvent (SessionEvent::RangeStop, SessionEvent::Add, requested_frame, 0, 0.0f);
} else {
ev = new SessionEvent (SessionEvent::RangeLocate, SessionEvent::Add, requested_frame, (*next).start, 0.0f);
}
-
+
merge_event (ev);
-
+
i = next;
}
-
+
} else if (sz == 1) {
ev = new SessionEvent (SessionEvent::RangeStop, SessionEvent::Add, range.front().end, 0, 0.0f);
merge_event (ev);
-
- }
+
+ }
/* save range so we can do auto-return etc. */
ev = new SessionEvent (SessionEvent::LocateRoll, SessionEvent::Add, SessionEvent::Immediate, range.front().start, 0.0f, false);
merge_event (ev);
-
+
+ DEBUG_TRACE (DEBUG::Transport, string_compose ("send TSC5 with speed = %1\n", _transport_speed));
TransportStateChange ();
}
the picture.
*/
- g_atomic_int_set (&_butler->should_do_transport_work, 0);
- set_post_transport_work (PostTransportWork (0));
- _butler->stop ();
+ if (_butler) {
+ g_atomic_int_set (&_butler->should_do_transport_work, 0);
+ set_post_transport_work (PostTransportWork (0));
+ _butler->stop ();
+ }
realtime_stop (false, true);
non_realtime_stop (false, 0, ignored);
transport_sub_state = 0;
+ DEBUG_TRACE (DEBUG::Transport, string_compose ("send TSC6 with speed = %1\n", _transport_speed));
TransportStateChange (); /* EMIT SIGNAL */
}
void
Session::xrun_recovery ()
{
- Xrun (_transport_frame); //EMIT SIGNAL
+ Xrun (_transport_frame); /* EMIT SIGNAL */
if (Config->get_stop_recording_on_xrun() && actively_recording()) {
void
Session::route_processors_changed (RouteProcessorChange c)
{
+ if (ignore_route_processor_changes) {
+ return;
+ }
+
if (c.type == RouteProcessorChange::MeterPointChange) {
return;
}
update_latency_compensation ();
resort_routes ();
+
+ set_dirty ();
}
void
auto_play_legal = yn;
}
-void
-Session::reset_jack_connection (jack_client_t* jack)
-{
- JACK_Slave* js;
-
- if (_slave && ((js = dynamic_cast<JACK_Slave*> (_slave)) != 0)) {
- js->reset_client (jack);
- }
-}
-
bool
Session::maybe_stop (framepos_t limit)
{
if ((_transport_speed > 0.0f && _transport_frame >= limit) || (_transport_speed < 0.0f && _transport_frame == 0)) {
- if (synced_to_jack () && config.get_jack_time_master ()) {
+ if (synced_to_engine () && config.get_jack_time_master ()) {
_engine.transport_stop ();
- } else if (!synced_to_jack ()) {
+ } else if (!synced_to_engine ()) {
stop_transport ();
}
return true;
void
Session::send_mmc_locate (framepos_t t)
{
- Timecode::Time time;
- timecode_time_subframes (t, time);
- MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (time));
+ if (!_engine.freewheeling()) {
+ Timecode::Time time;
+ timecode_time_subframes (t, time);
+ _mmc->send (MIDI::MachineControlCommand (time));
+ }
}
/** Ask the transport to not send timecode until further notice. The suspension
projects / ardour.git / blobdiff