*/
+#ifdef WAF_BUILD
+#include "libardour-config.h"
+#endif
+
#include <cmath>
#include <cerrno>
#include <unistd.h>
-#include <sigc++/bind.h>
-#include <sigc++/retype.h>
-
#include "pbd/undo.h"
#include "pbd/error.h"
-#include <glibmm/thread.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/audio_diskstream.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/session.h"
#include "ardour/slave.h"
+#include "ardour/operations.h"
#include "i18n.h"
using namespace std;
using namespace ARDOUR;
-using namespace sigc;
using namespace PBD;
+void
+Session::add_post_transport_work (PostTransportWork ptw)
+{
+ PostTransportWork oldval;
+ PostTransportWork newval;
+ int tries = 0;
+
+ while (tries < 8) {
+ oldval = (PostTransportWork) g_atomic_int_get (&_post_transport_work);
+ newval = PostTransportWork (oldval | ptw);
+ if (g_atomic_int_compare_and_exchange (&_post_transport_work, oldval, newval)) {
+ /* success */
+ return;
+ }
+ }
+
+ error << "Could not set post transport work! Crazy thread madness, call the programmers" << endmsg;
+}
+
void
Session::request_input_change_handling ()
{
if (!(_state_of_the_state & (InitialConnecting|Deletion))) {
- Event* ev = new Event (Event::InputConfigurationChange, Event::Add, Event::Immediate, 0, 0.0);
+ SessionEvent* ev = new SessionEvent (SessionEvent::InputConfigurationChange, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
queue_event (ev);
}
}
void
-Session::request_slave_source (SlaveSource src)
+Session::request_sync_source (Slave* new_slave)
{
- Event* ev = new Event (Event::SetSlaveSource, Event::Add, Event::Immediate, 0, 0.0);
+ SessionEvent* ev = new SessionEvent (SessionEvent::SetSyncSource, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0);
+ bool seamless;
+
+ seamless = Config->get_seamless_loop ();
- if (src == JACK) {
- /* could set_seamless_loop() be disposed of entirely?*/
+ if (dynamic_cast<JACK_Slave*>(new_slave)) {
+ /* JACK cannot support seamless looping at present */
Config->set_seamless_loop (false);
} else {
- Config->set_seamless_loop (true);
+ /* reset to whatever the value was before we last switched slaves */
+ Config->set_seamless_loop (_was_seamless);
}
- ev->slave = src;
+
+ /* save value of seamless from before the switch */
+ _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)
{
- Event* ev = new Event (Event::SetTransportSpeed, Event::Add, Event::Immediate, 0, speed);
+ SessionEvent* ev = new SessionEvent (SessionEvent::SetTransportSpeed, SessionEvent::Add, SessionEvent::Immediate, 0, 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);
}
+/** Request a new transport speed, but if the speed parameter is exactly zero then use
+ * a very small +ve value to prevent the transport actually stopping. This method should
+ * 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, bool as_default)
+{
+ if (speed == 0) {
+ speed = DBL_EPSILON;
+ }
+
+ request_transport_speed (speed, as_default);
+}
+
void
-Session::request_diskstream_speed (Diskstream& ds, double speed)
+Session::request_track_speed (Track* tr, double speed)
{
- Event* ev = new Event (Event::SetDiskstreamSpeed, Event::Add, Event::Immediate, 0, speed);
- ev->set_ptr (&ds);
+ SessionEvent* ev = new SessionEvent (SessionEvent::SetTrackSpeed, SessionEvent::Add, SessionEvent::Immediate, 0, speed);
+ ev->set_ptr (tr);
queue_event (ev);
}
void
-Session::request_stop (bool abort)
+Session::request_stop (bool abort, bool clear_state)
{
- Event* ev = new Event (Event::SetTransportSpeed, Event::Add, Event::Immediate, 0, 0.0, abort);
+ SessionEvent* ev = new SessionEvent (SessionEvent::SetTransportSpeed, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0, abort, clear_state);
+ DEBUG_TRACE (DEBUG::Transport, string_compose ("Request transport stop, abort = %1, clear state = %2\n", abort, clear_state));
queue_event (ev);
}
void
-Session::request_locate (nframes_t target_frame, bool with_roll)
+Session::request_locate (framepos_t target_frame, bool with_roll)
{
- Event *ev = new Event (with_roll ? Event::LocateRoll : Event::Locate, Event::Add, Event::Immediate, target_frame, 0, false);
+ SessionEvent *ev = new SessionEvent (with_roll ? SessionEvent::LocateRoll : SessionEvent::Locate, SessionEvent::Add, SessionEvent::Immediate, target_frame, 0, false);
+ DEBUG_TRACE (DEBUG::Transport, string_compose ("Request locate to %1\n", target_frame));
queue_event (ev);
}
void
-Session::force_locate (nframes_t target_frame, bool with_roll)
+Session::force_locate (framepos_t target_frame, bool with_roll)
{
- Event *ev = new Event (with_roll ? Event::LocateRoll : Event::Locate, Event::Add, Event::Immediate, target_frame, 0, true);
+ SessionEvent *ev = new SessionEvent (with_roll ? SessionEvent::LocateRoll : SessionEvent::Locate, SessionEvent::Add, SessionEvent::Immediate, target_frame, 0, true);
+ DEBUG_TRACE (DEBUG::Transport, string_compose ("Request forced locate to %1\n", target_frame));
queue_event (ev);
}
void
-Session::request_play_loop (bool yn)
+Session::request_play_loop (bool yn, bool leave_rolling)
{
- Event* ev;
- Location *location = _locations.auto_loop_location();
+ SessionEvent* ev;
+ Location *location = _locations->auto_loop_location();
if (location == 0 && yn) {
error << _("Cannot loop - no loop range defined")
return;
}
- ev = new Event (Event::SetLoop, Event::Add, Event::Immediate, 0, 0.0, yn);
+ 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));
queue_event (ev);
- if (!yn && Config->get_seamless_loop() && transport_rolling()) {
- // request an immediate locate to refresh the diskstreams
+ 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);
}
}
void
-Session::realtime_stop (bool abort)
+Session::request_play_range (list<AudioRange>* range, bool leave_rolling)
{
- /* assume that when we start, we'll be moving forwards */
+ SessionEvent* ev = new SessionEvent (SessionEvent::SetPlayAudioRange, SessionEvent::Add, SessionEvent::Immediate, 0, (leave_rolling ? 1.0 : 0.0));
+ if (range) {
+ ev->audio_range = *range;
+ } else {
+ ev->audio_range.clear ();
+ }
+ DEBUG_TRACE (DEBUG::Transport, string_compose ("Request play range, leave rolling ? %1\n", leave_rolling));
+ queue_event (ev);
+}
- // FIXME: where should this really be? [DR]
- //send_full_time_code();
- deliver_mmc (MIDI::MachineControl::cmdStop, 0);
- deliver_mmc (MIDI::MachineControl::cmdLocate, _transport_frame);
+void
+Session::realtime_stop (bool abort, bool clear_state)
+{
+ 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) {
- post_transport_work = PostTransportWork (post_transport_work | PostTransportStop | PostTransportReverse);
+ todo = (PostTransportWork (todo | PostTransportStop | PostTransportReverse));
} else {
- post_transport_work = PostTransportWork (post_transport_work | PostTransportStop);
+ todo = PostTransportWork (todo | PostTransportStop);
+ }
+
+ /* call routes */
+
+ boost::shared_ptr<RouteList> r = routes.reader ();
+
+ for (RouteList::iterator i = r->begin (); i != r->end(); ++i) {
+ (*i)->realtime_handle_transport_stopped ();
}
if (actively_recording()) {
/* move the transport position back to where the
request for a stop was noticed. we rolled
- past that point to pick up delayed input.
+ past that point to pick up delayed input (and/or to delick)
*/
-#ifndef LEAVE_TRANSPORT_UNADJUSTED
- decrement_transport_position (_worst_output_latency);
-#endif
+ if (worst_playback_latency() > current_block_size) {
+ /* 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_input_latency() - current_block_size));
+ } else {
+ decrement_transport_position (current_block_size);
+ }
/* the duration change is not guaranteed to have happened, but is likely */
- post_transport_work = PostTransportWork (post_transport_work | PostTransportDuration);
+ todo = PostTransportWork (todo | PostTransportDuration);
}
if (abort) {
- post_transport_work = PostTransportWork (post_transport_work | PostTransportAbort);
+ todo = PostTransportWork (todo | PostTransportAbort);
+ }
+
+ if (clear_state) {
+ todo = PostTransportWork (todo | PostTransportClearSubstate);
}
- _clear_event_type (Event::StopOnce);
- _clear_event_type (Event::RangeStop);
- _clear_event_type (Event::RangeLocate);
+ if (todo) {
+ add_post_transport_work (todo);
+ }
+
+ _clear_event_type (SessionEvent::StopOnce);
+ _clear_event_type (SessionEvent::RangeStop);
+ _clear_event_type (SessionEvent::RangeLocate);
- disable_record (true);
+ /* if we're going to clear loop state, then force disabling record BUT only if we're not doing latched rec-enable */
+ disable_record (true, (!Config->get_latched_record_enable() && clear_state));
reset_slave_state ();
_transport_speed = 0;
_target_transport_speed = 0;
+ g_atomic_int_set (&_playback_load, 100);
+ g_atomic_int_set (&_capture_load, 100);
+
if (config.get_use_video_sync()) {
waiting_for_sync_offset = true;
}
- transport_sub_state = ((Config->get_slave_source() == None && config.get_auto_return()) ? AutoReturning : 0);
+ 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
{
restart:
bool finished;
+ PostTransportWork ptw;
boost::shared_ptr<RouteList> r = routes.reader ();
- boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
int on_entry = g_atomic_int_get (&_butler->should_do_transport_work);
finished = true;
+ ptw = post_transport_work();
- if (post_transport_work & PostTransportCurveRealloc) {
+ DEBUG_TRACE (DEBUG::Transport, string_compose ("Butler transport work, todo = %1\n", enum_2_string (ptw)));
+
+ if (ptw & PostTransportAdjustPlaybackBuffering) {
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
+ if (tr) {
+ tr->adjust_playback_buffering ();
+ /* and refill those buffers ... */
+ }
+ (*i)->non_realtime_locate (_transport_frame);
+ }
+
+ }
+
+ if (ptw & PostTransportAdjustCaptureBuffering) {
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
+ if (tr) {
+ tr->adjust_capture_buffering ();
+ }
+ }
+ }
+
+ if (ptw & PostTransportCurveRealloc) {
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
(*i)->curve_reallocate();
}
}
- if (post_transport_work & PostTransportInputChange) {
- for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
- (*i)->non_realtime_input_change ();
+ if (ptw & PostTransportInputChange) {
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
+ if (tr) {
+ tr->non_realtime_input_change ();
+ }
}
}
- if (post_transport_work & PostTransportSpeed) {
+ if (ptw & PostTransportSpeed) {
non_realtime_set_speed ();
}
- if (post_transport_work & PostTransportReverse) {
+ if (ptw & PostTransportReverse) {
clear_clicks();
cumulative_rf_motion = 0;
/* don't seek if locate will take care of that in non_realtime_stop() */
- if (!(post_transport_work & PostTransportLocate)) {
+ if (!(ptw & PostTransportLocate)) {
+
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ (*i)->non_realtime_locate (_transport_frame);
- for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
- if (!(*i)->hidden()) {
- (*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);
}
}
- if (post_transport_work & PostTransportLocate) {
+ if (ptw & PostTransportLocate) {
non_realtime_locate ();
}
- if (post_transport_work & PostTransportStop) {
- non_realtime_stop (post_transport_work & PostTransportAbort, on_entry, finished);
+ if (ptw & PostTransportStop) {
+ non_realtime_stop (ptw & PostTransportAbort, on_entry, finished);
if (!finished) {
g_atomic_int_dec_and_test (&_butler->should_do_transport_work);
goto restart;
}
}
- if (post_transport_work & PostTransportOverWrite) {
+ if (ptw & PostTransportOverWrite) {
non_realtime_overwrite (on_entry, finished);
if (!finished) {
g_atomic_int_dec_and_test (&_butler->should_do_transport_work);
}
}
- if (post_transport_work & PostTransportAudition) {
+ if (ptw & PostTransportAudition) {
non_realtime_set_audition ();
}
g_atomic_int_dec_and_test (&_butler->should_do_transport_work);
+
+ DEBUG_TRACE (DEBUG::Transport, X_("Butler transport work all done\n"));
}
void
Session::non_realtime_set_speed ()
{
- boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
-
- for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
- (*i)->non_realtime_set_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);
+ if (tr) {
+ tr->non_realtime_set_speed ();
+ }
}
}
void
Session::non_realtime_overwrite (int on_entry, bool& finished)
{
- boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
-
- for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
- if ((*i)->pending_overwrite) {
- (*i)->overwrite_existing_buffers ();
+ 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->pending_overwrite ()) {
+ tr->overwrite_existing_buffers ();
}
if (on_entry != g_atomic_int_get (&_butler->should_do_transport_work)) {
finished = false;
void
Session::non_realtime_locate ()
{
- boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
-
- for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
+ boost::shared_ptr<RouteList> rl = routes.reader();
+ for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
(*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 ();
}
time_t xnow;
bool did_record;
bool saved;
+ PostTransportWork ptw = post_transport_work();
did_record = false;
saved = false;
- boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
-
- for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
- if ((*i)->get_captured_frames () != 0) {
+ 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->get_captured_frames () != 0) {
did_record = true;
break;
}
auditioner->cancel_audition ();
}
- clear_clicks();
cumulative_rf_motion = 0;
reset_rf_scale (0);
if (did_record) {
- begin_reversible_command ("capture");
-
- Location* loc = _locations.end_location();
- bool change_end = false;
-
- if (_transport_frame < loc->end()) {
-
- /* stopped recording before current end */
-
- if (config.get_end_marker_is_free()) {
-
- /* first capture for this session, move end back to where we are */
-
- change_end = true;
- }
-
- } else if (_transport_frame > loc->end()) {
+ begin_reversible_command (Operations::capture);
+ _have_captured = true;
+ }
- /* stopped recording after the current end, extend it */
+ DEBUG_TRACE (DEBUG::Transport, X_("Butler PTW: DS stop\n"));
- change_end = true;
- }
+ if (abort && did_record) {
+ /* no reason to save the session file when we remove sources
+ */
+ _state_of_the_state = StateOfTheState (_state_of_the_state|InCleanup);
+ }
- if (change_end) {
- XMLNode &before = loc->get_state();
- loc->set_end(_transport_frame);
- XMLNode &after = loc->get_state();
- add_command (new MementoCommand<Location>(*loc, &before, &after));
+ for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
+ boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
+ if (tr) {
+ tr->transport_stopped_wallclock (*now, xnow, abort);
}
-
- config.set_end_marker_is_free (false);
- _have_captured = true;
}
- for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
- (*i)->transport_stopped (*now, xnow, abort);
+ if (abort && did_record) {
+ _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
}
boost::shared_ptr<RouteList> r = routes.reader ();
}
if (_engine.running()) {
- update_latency_compensation (true, abort);
+ PostTransportWork ptw = post_transport_work ();
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
+ (*i)->nonrealtime_handle_transport_stopped (abort, (ptw & PostTransportLocate), (!(ptw & PostTransportLocate) || pending_locate_flush));
+ }
+ update_latency_compensation ();
}
bool const auto_return_enabled =
- (Config->get_slave_source() == None && config.get_auto_return());
+ (!config.get_external_sync() && config.get_auto_return());
if (auto_return_enabled ||
- (post_transport_work & PostTransportLocate) ||
+ (ptw & PostTransportLocate) ||
(_requested_return_frame >= 0) ||
synced_to_jack()) {
}
if ((auto_return_enabled || synced_to_jack() || _requested_return_frame >= 0) &&
- !(post_transport_work & PostTransportLocate)) {
+ !(ptw & PostTransportLocate)) {
+
+ /* no explicit locate queued */
bool do_locate = false;
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;
- _requested_return_frame = -1;
do_locate = true;
+
} else {
- _transport_frame = _last_roll_location;
- }
+ if (config.get_auto_return()) {
- if (synced_to_jack() && !play_loop) {
- do_locate = true;
+ if (play_loop) {
+
+ /* don't try to handle loop play when synced to JACK */
+
+ if (!synced_to_jack()) {
+
+ Location *location = _locations->auto_loop_location();
+
+ if (location != 0) {
+ _transport_frame = location->start();
+ } else {
+ _transport_frame = _last_roll_location;
+ }
+ do_locate = true;
+ }
+
+ } else if (_play_range) {
+
+ /* return to start of range */
+
+ if (!current_audio_range.empty()) {
+ _transport_frame = current_audio_range.front().start;
+ do_locate = true;
+ }
+
+ } else {
+
+ /* regular auto-return */
+
+ _transport_frame = _last_roll_location;
+ do_locate = true;
+ }
+ }
}
+ _requested_return_frame = -1;
+
if (do_locate) {
- // cerr << "non-realtimestop: transport locate to " << _transport_frame << endl;
_engine.transport_locate (_transport_frame);
}
}
-#ifdef LEAVE_TRANSPORT_UNADJUSTED
- for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
- if (!(*i)->hidden()) {
- (*i)->non_realtime_locate (_transport_frame);
- }
- if (on_entry != g_atomic_int_get (&_butler->should_do_transport_work)) {
- finished = false;
- /* we will be back */
- return;
- }
- }
-#endif
}
- have_looped = false;
+ clear_clicks();
- send_full_time_code (0);
- deliver_mmc (MIDI::MachineControl::cmdStop, 0);
- deliver_mmc (MIDI::MachineControl::cmdLocate, _transport_frame);
+ /* do this before seeking, because otherwise the tracks will do the wrong thing in seamless loop mode.
+ */
- if (did_record) {
+ if (ptw & PostTransportClearSubstate) {
+ _play_range = false;
+ unset_play_loop ();
+ }
- /* XXX its a little odd that we're doing this here
- when realtime_stop(), which has already executed,
- will have done this.
- JLC - so let's not because it seems unnecessary and breaks loop record
- */
-#if 0
- if (!Config->get_latched_record_enable()) {
- g_atomic_int_set (&_record_status, Disabled);
- } else {
- g_atomic_int_set (&_record_status, Enabled);
+ /* 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()));
+ (*i)->non_realtime_locate (_transport_frame);
+
+ if (on_entry != g_atomic_int_get (&_butler->should_do_transport_work)) {
+ finished = false;
+ /* we will be back */
+ return;
+ }
+ }
+
+ have_looped = false;
+
+ if (!_engine.freewheeling()) {
+ send_full_time_code (_transport_frame);
+
+ if (!dynamic_cast<MTC_Slave*>(_slave)) {
+ MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdStop));
+ send_mmc_locate (_transport_frame);
}
- RecordStateChanged (); /* emit signal */
-#endif
}
- if ((post_transport_work & PostTransportLocate) && get_record_enabled()) {
+ if ((ptw & PostTransportLocate) && get_record_enabled()) {
/* capture start has been changed, so save pending state */
save_state ("", true);
saved = true;
}
- /* always try to get rid of this */
+ /* always try to get rid of this */
- remove_pending_capture_state ();
+ remove_pending_capture_state ();
/* save the current state of things if appropriate */
save_state (_current_snapshot_name);
}
- if (post_transport_work & PostTransportDuration) {
- DurationChanged (); /* EMIT SIGNAL */
- }
-
- if (post_transport_work & PostTransportStop) {
+ if (ptw & PostTransportStop) {
_play_range = false;
-
- /* do not turn off autoloop on stop */
-
+ play_loop = false;
}
- nframes_t tf = _transport_frame;
-
- PositionChanged (tf); /* EMIT SIGNAL */
+ 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 ((post_transport_work & PostTransportLocate) && Config->get_slave_source() == None && pending_locate_roll) {
+ 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;
+ }
+}
+
+void
+Session::unset_play_loop ()
+{
+ 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) {
+ boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
+ if (tr && !tr->hidden()) {
+ tr->set_loop (0);
+ }
}
}
{
/* Called from event-handling context */
- if ((actively_recording() && yn) || _locations.auto_loop_location() == 0) {
+ Location *loc;
+
+ if (yn == play_loop || (actively_recording() && yn) || (loc = _locations->auto_loop_location()) == 0) {
+ /* nothing to do, or can't change loop status while recording */
return;
}
- set_dirty();
-
if (yn && Config->get_seamless_loop() && synced_to_jack()) {
- warning << _("Seamless looping cannot be supported while Ardour is using JACK transport.\n"
- "Recommend changing the configured options")
+ 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) {
- if ((play_loop = yn)) {
-
- Location *loc;
+ play_loop = true;
+ if (loc) {
- if ((loc = _locations.auto_loop_location()) != 0) {
+ unset_play_range ();
if (Config->get_seamless_loop()) {
- // set all diskstreams to use internal looping
- boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
- for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
- if (!(*i)->hidden()) {
- (*i)->set_loop (loc);
+ // 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 diskstreams to NOT use internal looping
- boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
- for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
- if (!(*i)->hidden()) {
- (*i)->set_loop (0);
+ // 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);
}
}
}
- /* stick in the loop event */
+ /* 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.
+ */
- Event* event = new Event (Event::AutoLoop, Event::Replace, loc->end(), loc->start(), 0.0f);
- merge_event (event);
+ 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));
- /* locate to start of loop and roll if current pos is outside of the loop range */
- if (_transport_frame < loc->start() || _transport_frame > loc->end()) {
- event = new Event (Event::LocateRoll, Event::Add, Event::Immediate, loc->start(), 0, !synced_to_jack());
- merge_event (event);
- }
- else {
- // locate to current position (+ 1 to force reload)
- event = new Event (Event::LocateRoll, Event::Add, Event::Immediate, _transport_frame + 1, 0, !synced_to_jack());
- merge_event (event);
- }
- }
+ /* locate to start of loop and roll.
+ 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());
+ }
} else {
- clear_events (Event::AutoLoop);
-
- // set all diskstreams to NOT use internal looping
- boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
- for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
- if (!(*i)->hidden()) {
- (*i)->set_loop (0);
- }
- }
+ unset_play_loop ();
}
-}
+ DEBUG_TRACE (DEBUG::Transport, string_compose ("send TSC2 with speed = %1\n", _transport_speed));
+ TransportStateChange ();
+}
void
Session::flush_all_inserts ()
{
}
void
-Session::start_locate (nframes_t target_frame, bool with_roll, bool with_flush, bool with_loop)
+Session::start_locate (framepos_t target_frame, bool with_roll, bool with_flush, bool with_loop, bool force)
{
if (synced_to_jack()) {
double sp;
- nframes_t pos;
+ framepos_t pos;
_slave->speed_and_position (sp, 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()
*/
}
} else {
- locate (target_frame, with_roll, with_flush, with_loop);
+ locate (target_frame, with_roll, with_flush, with_loop, force);
}
}
int
-Session::micro_locate (nframes_t distance)
+Session::micro_locate (framecnt_t distance)
{
- boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
-
- for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
- if (!(*i)->can_internal_playback_seek (distance)) {
+ 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->can_internal_playback_seek (distance)) {
return -1;
}
}
- for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
- (*i)->internal_playback_seek (distance);
+ for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
+ boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
+ if (tr) {
+ tr->internal_playback_seek (distance);
+ }
}
_transport_frame += distance;
return 0;
}
+/** @param with_mmc true to send a MMC locate command when the locate is done */
void
-Session::locate (nframes_t target_frame, bool with_roll, bool with_flush, bool with_loop)
+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 (_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);
}
loop_changing = false;
+ Located (); /* EMIT SIGNAL */
return;
}
- // Update Timecode time
- // [DR] FIXME: find out exactly where this should go below
- _transport_frame = target_frame;
- timecode_time(_transport_frame, transmitting_timecode_time);
- outbound_mtc_timecode_frame = _transport_frame;
- next_quarter_frame_to_send = 0;
-
- if (_transport_speed && (!with_loop || loop_changing)) {
- /* 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);
}
}
- if (transport_rolling() && (!auto_play_legal || !config.get_auto_play()) && !with_roll && !(synced_to_jack() && play_loop)) {
- realtime_stop (false);
+ // 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;
+
+ /* 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_jack() && 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 ( !with_loop || loop_changing) {
+ if (force || !for_seamless_loop || loop_changing) {
- post_transport_work = PostTransportWork (post_transport_work | PostTransportLocate);
+ PostTransportWork todo = PostTransportLocate;
- if (with_roll) {
- post_transport_work = PostTransportWork (post_transport_work | PostTransportRoll);
+ if (with_roll && transport_was_stopped) {
+ todo = PostTransportWork (todo | PostTransportRoll);
}
+ add_post_transport_work (todo);
_butler->schedule_transport_work ();
} else {
/* 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()) {
if (with_roll) {
/* switch from input if we're going to roll */
if (Config->get_monitoring_model() == HardwareMonitoring) {
-
- boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
-
- for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
- if ((*i)->record_enabled ()) {
- //cerr << "switching from input" << __FILE__ << __LINE__ << endl << endl;
- (*i)->monitor_input (!config.get_auto_input());
- }
- }
+ set_track_monitor_input_status (!config.get_auto_input());
}
} else {
/* otherwise we're going to stop, so do the opposite */
if (Config->get_monitoring_model() == HardwareMonitoring) {
- boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
-
- for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
- if ((*i)->record_enabled ()) {
- //cerr << "switching to input" << __FILE__ << __LINE__ << endl << endl;
- (*i)->monitor_input (true);
- }
- }
+ set_track_monitor_input_status (true);
}
}
/* 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
+ Location* al = _locations->auto_loop_location();
- boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
+ if (al) {
+ if (_transport_frame < al->start() || _transport_frame > al->end()) {
- for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
- if ((*i)->record_enabled ()) {
- // tell it we've looped, so it can deal with the record state
- (*i)->transport_looped(_transport_frame);
+ // located outside the loop: cancel looping directly, this is called from event handling context
+
+ set_play_loop (false);
+
+ } 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_timecode_update = true;
+ if (with_mmc) {
+ send_mmc_locate (_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)
+Session::set_transport_speed (double speed, 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",
+ 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;
}
/* we are rolling and we want to stop */
- if (Config->get_monitoring_model() == HardwareMonitoring)
- {
- boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
-
- for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
- if ((*i)->record_enabled ()) {
- //cerr << "switching to input" << __FILE__ << __LINE__ << endl << endl;
- (*i)->monitor_input (true);
- }
- }
+ if (Config->get_monitoring_model() == HardwareMonitoring) {
+ set_track_monitor_input_status (true);
}
if (synced_to_jack ()) {
+ if (clear_state) {
+ /* do this here because our response to the slave won't
+ take care of it.
+ */
+ _play_range = false;
+ unset_play_loop ();
+ }
_engine.transport_stop ();
} else {
stop_transport (abort);
}
+ unset_play_loop ();
+
} else if (transport_stopped() && speed == 1.0) {
/* we are stopped and we want to start rolling at speed 1 */
- if (!get_record_enabled() && Config->get_stop_at_session_end() && _transport_frame >= current_end_frame()) {
- return;
- }
-
- if (Config->get_monitoring_model() == HardwareMonitoring) {
-
- boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
-
- for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
- if (config.get_auto_input() && (*i)->record_enabled ()) {
- //cerr << "switching from input" << __FILE__ << __LINE__ << endl << endl;
- (*i)->monitor_input (false);
- }
- }
+ if (Config->get_monitoring_model() == HardwareMonitoring && config.get_auto_input()) {
+ set_track_monitor_input_status (false);
}
if (synced_to_jack()) {
} else {
- if (!get_record_enabled() && Config->get_stop_at_session_end() && _transport_frame >= current_end_frame()) {
- return;
- }
+ /* not zero, not 1.0 ... varispeed */
if ((synced_to_jack()) && speed != 0.0 && speed != 1.0) {
- warning << _("Global varispeed cannot be supported while Ardour is connected to JACK transport control")
+ warning << string_compose (
+ _("Global varispeed cannot be supported while %1 is connected to JACK transport control"),
+ PROGRAM_NAME)
<< endmsg;
return;
}
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)) {
- post_transport_work = PostTransportWork (post_transport_work | PostTransportReverse);
+ todo = PostTransportWork (todo | PostTransportReverse);
+ _last_roll_or_reversal_location = _transport_frame;
}
_last_transport_speed = _transport_speed;
_transport_speed = speed;
- boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
- for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
- if ((*i)->realtime_set_speed ((*i)->speed(), true)) {
- post_transport_work = PostTransportWork (post_transport_work | PostTransportSpeed);
+ 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);
+ if (tr && tr->realtime_set_speed (tr->speed(), true)) {
+ todo = PostTransportWork (todo | PostTransportSpeed);
}
}
- if (post_transport_work & (PostTransportSpeed|PostTransportReverse)) {
+ if (todo) {
+ 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 */
}
}
/** Stop the transport. */
void
-Session::stop_transport (bool abort)
+Session::stop_transport (bool abort, bool clear_state)
{
if (_transport_speed == 0.0f) {
return;
}
- if (actively_recording() && !(transport_sub_state & StopPendingCapture) &&
- _worst_output_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) {
+ boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
+ if (tr) {
+ tr->prepare_to_stop (_transport_frame);
+ }
+ }
/* we need to capture the audio that has still not yet been received by the system
at the time the stop is requested, so we have to roll past that time.
and then we'll really be stopped.
*/
- Event *ev = new Event (Event::StopOnce, Event::Replace,
- _transport_frame + _worst_output_latency - current_block_size,
- 0, 0, abort);
+ 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);
merge_event (ev);
transport_sub_state |= StopPendingCapture;
return;
}
-
if ((transport_sub_state & PendingDeclickOut) == 0) {
+
+ if (!(transport_sub_state & StopPendingCapture)) {
+ 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->prepare_to_stop (_transport_frame);
+ }
+ }
+ }
+
transport_sub_state |= PendingDeclickOut;
/* we'll be called again after the declick */
pending_abort = abort;
return;
}
- realtime_stop (abort);
+ realtime_stop (abort, clear_state);
_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<DiskstreamList> dsl = diskstreams.reader();
- for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
- (*i)->realtime_set_speed ((*i)->speed(), 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);
+ if (tr) {
+ tr->realtime_set_speed (tr->speed(), true);
+ }
}
- deliver_mmc(MIDI::MachineControl::cmdDeferredPlay, _transport_frame);
+ if (!_engine.freewheeling()) {
+ 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));
+ }
+ }
+ DEBUG_TRACE (DEBUG::Transport, string_compose ("send TSC4 with speed = %1\n", _transport_speed));
TransportStateChange (); /* EMIT SIGNAL */
}
void
Session::post_transport ()
{
- if (post_transport_work & PostTransportAudition) {
- if (auditioner && auditioner->active()) {
+ PostTransportWork ptw = post_transport_work ();
+
+ if (ptw & PostTransportAudition) {
+ if (auditioner && auditioner->auditioning()) {
process_function = &Session::process_audition;
} else {
process_function = &Session::process_with_events;
}
}
- if (post_transport_work & PostTransportStop) {
+ if (ptw & PostTransportStop) {
transport_sub_state = 0;
}
- if (post_transport_work & PostTransportLocate) {
+ if (ptw & PostTransportLocate) {
- if (((Config->get_slave_source() == None && (auto_play_legal && config.get_auto_play())) && !_exporting) || (post_transport_work & PostTransportRoll)) {
+ if (((!config.get_external_sync() && (auto_play_legal && config.get_auto_play())) && !_exporting) || (ptw & PostTransportRoll)) {
start_transport ();
-
} else {
transport_sub_state = 0;
}
}
set_next_event ();
-
- post_transport_work = PostTransportWork (0);
+ /* XXX is this really safe? shouldn't we just be unsetting the bits that we actually
+ know were handled ?
+ */
+ set_post_transport_work (PostTransportWork (0));
}
void
-Session::reset_rf_scale (nframes_t motion)
+Session::reset_rf_scale (framecnt_t motion)
{
cumulative_rf_motion += motion;
}
void
-Session::set_slave_source (SlaveSource src)
+Session::use_sync_source (Slave* new_slave)
{
- bool reverse = false;
- bool non_rt_required = false;
+ /* Runs in process() context */
- if (_transport_speed) {
- error << _("please stop the transport before adjusting slave settings") << endmsg;
- return;
- }
+ bool non_rt_required = false;
-// if (src == JACK && Config->get_jack_time_master()) {
-// return;
-// }
+ /* XXX this deletion is problematic because we're in RT context */
delete _slave;
- _slave = 0;
+ _slave = new_slave;
- if (_transport_speed < 0.0) {
- reverse = true;
+ DEBUG_TRACE (DEBUG::Slave, string_compose ("set new slave to %1\n", _slave));
+
+ send_full_time_code (_transport_frame);
+
+ 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()) {
+ if (tr->realtime_set_speed (tr->speed(), true)) {
+ non_rt_required = true;
+ }
+ tr->set_slaved (_slave != 0);
+ }
}
- switch (src) {
- case None:
- stop_transport ();
- break;
+ if (non_rt_required) {
+ add_post_transport_work (PostTransportSpeed);
+ _butler->schedule_transport_work ();
+ }
+
+ set_dirty();
+}
+
+void
+Session::drop_sync_source ()
+{
+ request_sync_source (0);
+}
+void
+Session::switch_to_sync_source (SyncSource src)
+{
+ Slave* new_slave;
+
+ DEBUG_TRACE (DEBUG::Slave, string_compose ("Setting up sync source %1\n", enum_2_string (src)));
+
+ switch (src) {
case MTC:
- if (_mtc_port) {
- try {
- _slave = new MTC_Slave (*this, *_mtc_port);
- }
+ if (_slave && dynamic_cast<MTC_Slave*>(_slave)) {
+ return;
+ }
- catch (failed_constructor& err) {
- return;
- }
+ try {
+ new_slave = new MTC_Slave (*this, *MIDI::Manager::instance()->mtc_input_port());
+ }
- } else {
- error << _("No MTC port defined: MTC slaving is impossible.") << endmsg;
+ catch (failed_constructor& err) {
return;
}
break;
- case MIDIClock:
- if (_midi_clock_port) {
- try {
- _slave = new MIDIClock_Slave (*this, *_midi_clock_port, 24);
- }
+ case LTC:
+#ifdef HAVE_LTC
+ if (_slave && dynamic_cast<LTC_Slave*>(_slave)) {
+ return;
+ }
- catch (failed_constructor& err) {
- return;
- }
+ try {
+ new_slave = new LTC_Slave (*this);
+ }
- } else {
- error << _("No MIDI Clock port defined: MIDI Clock slaving is impossible.") << endmsg;
+ catch (failed_constructor& err) {
return;
}
+#else
+ return;
+#endif
break;
- case JACK:
- _slave = new JACK_Slave (_engine.jack());
- break;
+ case MIDIClock:
+ if (_slave && dynamic_cast<MIDIClock_Slave*>(_slave)) {
+ return;
+ }
- };
+ try {
+ new_slave = new MIDIClock_Slave (*this, *MIDI::Manager::instance()->midi_clock_input_port(), 24);
+ }
- Config->set_slave_source (src);
+ catch (failed_constructor& err) {
+ return;
+ }
+ break;
- boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
- for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
- if (!(*i)->hidden()) {
- if ((*i)->realtime_set_speed ((*i)->speed(), true)) {
- non_rt_required = true;
- }
- (*i)->set_slaved (_slave);
+ case JACK:
+ if (_slave && dynamic_cast<JACK_Slave*>(_slave)) {
+ return;
}
- }
- if (reverse) {
- reverse_diskstream_buffers ();
- }
+ if (config.get_video_pullup() != 0.0f) {
+ return;
+ }
- if (non_rt_required) {
- post_transport_work = PostTransportWork (post_transport_work | PostTransportSpeed);
- _butler->schedule_transport_work ();
- }
+ new_slave = new JACK_Slave (_engine.jack());
+ break;
- set_dirty();
-}
+ default:
+ new_slave = 0;
+ break;
+ };
-void
-Session::reverse_diskstream_buffers ()
-{
- post_transport_work = PostTransportWork (post_transport_work | PostTransportReverse);
- _butler->schedule_transport_work ();
+ request_sync_source (new_slave);
}
void
-Session::set_diskstream_speed (Diskstream* stream, double speed)
+Session::set_track_speed (Track* track, double speed)
{
- if (stream->realtime_set_speed (speed, false)) {
- post_transport_work = PostTransportWork (post_transport_work | PostTransportSpeed);
+ if (track->realtime_set_speed (speed, false)) {
+ add_post_transport_work (PostTransportSpeed);
_butler->schedule_transport_work ();
set_dirty ();
}
}
void
-Session::set_audio_range (list<AudioRange>& range)
+Session::unset_play_range ()
{
- Event *ev = new Event (Event::SetAudioRange, Event::Add, Event::Immediate, 0, 0.0f);
- ev->audio_range = range;
- queue_event (ev);
+ _play_range = false;
+ _clear_event_type (SessionEvent::RangeStop);
+ _clear_event_type (SessionEvent::RangeLocate);
}
void
-Session::request_play_range (bool yn)
+Session::set_play_range (list<AudioRange>& range, bool leave_rolling)
{
- Event* ev = new Event (Event::SetPlayRange, Event::Add, Event::Immediate, 0, 0.0f, yn);
- queue_event (ev);
-}
+ SessionEvent* ev;
-void
-Session::set_play_range (bool yn)
-{
/* Called from event-processing context */
- if (_play_range != yn) {
- _play_range = yn;
- setup_auto_play ();
+ unset_play_range ();
- if (!_play_range) {
+ if (range.empty()) {
+ /* _play_range set to false in unset_play_range()
+ */
+ if (!leave_rolling) {
/* stop transport */
- Event* ev = new Event (Event::SetTransportSpeed, Event::Add, Event::Immediate, 0, 0.0f, false);
+ SessionEvent* ev = new SessionEvent (SessionEvent::SetTransportSpeed, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0f, false);
merge_event (ev);
}
+ return;
}
-}
-void
-Session::setup_auto_play ()
-{
- /* Called from event-processing context */
+ _play_range = true;
- Event* ev;
+ /* cancel loop play */
+ unset_play_loop ();
- _clear_event_type (Event::RangeStop);
- _clear_event_type (Event::RangeLocate);
-
- if (!_play_range) {
- return;
- }
-
- list<AudioRange>::size_type sz = current_audio_range.size();
+ list<AudioRange>::size_type sz = range.size();
if (sz > 1) {
- list<AudioRange>::iterator i = current_audio_range.begin();
+ list<AudioRange>::iterator i = range.begin();
list<AudioRange>::iterator next;
- while (i != current_audio_range.end()) {
+ while (i != range.end()) {
next = i;
++next;
/* locating/stopping is subject to delays for declicking.
*/
- nframes_t requested_frame = (*i).end;
+ framepos_t requested_frame = i->end;
if (requested_frame > current_block_size) {
requested_frame -= current_block_size;
requested_frame = 0;
}
- if (next == current_audio_range.end()) {
- ev = new Event (Event::RangeStop, Event::Add, requested_frame, 0, 0.0f);
+ if (next == range.end()) {
+ ev = new SessionEvent (SessionEvent::RangeStop, SessionEvent::Add, requested_frame, 0, 0.0f);
} else {
- ev = new Event (Event::RangeLocate, Event::Add, requested_frame, (*next).start, 0.0f);
+ ev = new SessionEvent (SessionEvent::RangeLocate, SessionEvent::Add, requested_frame, (*next).start, 0.0f);
}
merge_event (ev);
} else if (sz == 1) {
- ev = new Event (Event::RangeStop, Event::Add, current_audio_range.front().end, 0, 0.0f);
+ 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. */
+
+ current_audio_range = range;
+
/* now start rolling at the right place */
- ev = new Event (Event::LocateRoll, Event::Add, Event::Immediate, current_audio_range.front().start, 0.0f, false);
+ 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 ();
}
void
-Session::request_roll_at_and_return (nframes_t start, nframes_t return_to)
+Session::request_bounded_roll (framepos_t start, framepos_t end)
{
- Event *ev = new Event (Event::LocateRollLocate, Event::Add, Event::Immediate, return_to, 1.0);
- ev->target2_frame = start;
- queue_event (ev);
-}
+ AudioRange ar (start, end, 0);
+ list<AudioRange> lar;
+ lar.push_back (ar);
+ request_play_range (&lar, true);
+}
void
-Session::request_bounded_roll (nframes_t start, nframes_t end)
+Session::request_roll_at_and_return (framepos_t start, framepos_t return_to)
{
- request_stop ();
- Event *ev = new Event (Event::StopOnce, Event::Replace, end, Event::Immediate, 0.0);
+ SessionEvent *ev = new SessionEvent (SessionEvent::LocateRollLocate, SessionEvent::Add, SessionEvent::Immediate, return_to, 1.0);
+ ev->target2_frame = start;
queue_event (ev);
- request_locate (start, true);
}
void
the picture.
*/
- g_atomic_int_set (&_butler->should_do_transport_work, 0);
- 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);
+ 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::update_latency_compensation (bool with_stop, bool abort)
+Session::route_processors_changed (RouteProcessorChange c)
{
- bool update_jack = false;
-
- if (_state_of_the_state & Deletion) {
+ if (ignore_route_processor_changes) {
return;
}
- _worst_track_latency = 0;
-
-#undef DEBUG_LATENCY
-#ifdef DEBUG_LATENCY
- cerr << "\n---------------------------------\nUPDATE LATENCY\n";
-#endif
-
- boost::shared_ptr<RouteList> r = routes.reader ();
-
- for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
-
- if (with_stop) {
- (*i)->handle_transport_stopped (abort, (post_transport_work & PostTransportLocate),
- (!(post_transport_work & PostTransportLocate) || pending_locate_flush));
- }
-
- nframes_t old_latency = (*i)->output()->signal_latency ();
- nframes_t track_latency = (*i)->update_total_latency ();
-
- if (old_latency != track_latency) {
- (*i)->input()->update_port_total_latencies ();
- (*i)->output()->update_port_total_latencies ();
- update_jack = true;
- }
-
- if (!(*i)->is_hidden() && ((*i)->active())) {
- _worst_track_latency = max (_worst_track_latency, track_latency);
- }
- }
-
- if (update_jack) {
- _engine.update_total_latencies ();
- }
-
-#ifdef DEBUG_LATENCY
- cerr << "\tworst was " << _worst_track_latency << endl;
-#endif
-
- for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- (*i)->set_latency_delay (_worst_track_latency);
+ if (c.type == RouteProcessorChange::MeterPointChange) {
+ return;
}
- set_worst_io_latencies ();
-
- /* reflect any changes in latencies into capture offsets
- */
-
- boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
+ update_latency_compensation ();
+ resort_routes ();
- for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
- (*i)->set_capture_offset ();
- }
+ set_dirty ();
}
void
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 ()) {
+ _engine.transport_stop ();
+ } else if (!synced_to_jack ()) {
+ stop_transport ();
+ }
+ return true;
+ }
+ return false;
+}
+
+void
+Session::send_mmc_locate (framepos_t t)
+{
+ if (!_engine.freewheeling()) {
+ Timecode::Time time;
+ timecode_time_subframes (t, time);
+ MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (time));
+ }
+}
+
+/** Ask the transport to not send timecode until further notice. The suspension
+ * will come into effect some finite time after this call, and timecode_transmission_suspended()
+ * should be checked by the caller to find out when.
+ */
+void
+Session::request_suspend_timecode_transmission ()
+{
+ SessionEvent* ev = new SessionEvent (SessionEvent::SetTimecodeTransmission, SessionEvent::Add, SessionEvent::Immediate, 0, 0, false);
+ queue_event (ev);
+}
+
+void
+Session::request_resume_timecode_transmission ()
+{
+ SessionEvent* ev = new SessionEvent (SessionEvent::SetTimecodeTransmission, SessionEvent::Add, SessionEvent::Immediate, 0, 0, true);
+ queue_event (ev);
+}
+
+bool
+Session::timecode_transmission_suspended () const
+{
+ return g_atomic_int_get (&_suspend_timecode_transmission) == 1;
+}
projects / ardour.git / blobdiff