#include <sigc++/bind.h>
#include <sigc++/retype.h>
-#include <pbd/undo.h>
-#include <pbd/error.h>
+#include "pbd/undo.h"
+#include "pbd/error.h"
#include <glibmm/thread.h>
-#include <pbd/pthread_utils.h>
-#include <pbd/memento_command.h>
-#include <pbd/stacktrace.h>
-
-#include <midi++/mmc.h>
-#include <midi++/port.h>
-
-#include <ardour/ardour.h>
-#include <ardour/audioengine.h>
-#include <ardour/session.h>
-#include <ardour/audio_diskstream.h>
-#include <ardour/auditioner.h>
-#include <ardour/slave.h>
-#include <ardour/location.h>
+#include "pbd/pthread_utils.h"
+#include "pbd/memento_command.h"
+#include "pbd/stacktrace.h"
+
+#include "midi++/mmc.h"
+#include "midi++/port.h"
+
+#include "ardour/ardour.h"
+#include "ardour/audio_diskstream.h"
+#include "ardour/audioengine.h"
+#include "ardour/auditioner.h"
+#include "ardour/butler.h"
+#include "ardour/location.h"
+#include "ardour/session.h"
+#include "ardour/slave.h"
#include "i18n.h"
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 ()
{
Session::request_slave_source (SlaveSource src)
{
Event* ev = new Event (Event::SetSlaveSource, Event::Add, Event::Immediate, 0, 0.0);
+ bool seamless;
+
+ seamless = Config->get_seamless_loop ();
if (src == JACK) {
- /* could set_seamless_loop() be disposed of entirely?*/
+ /* 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);
}
+
+ /* save value of seamless from before the switch */
+ _was_seamless = seamless;
+
ev->slave = src;
queue_event (ev);
}
void
-Session::request_transport_speed (float speed)
+Session::request_transport_speed (double speed)
{
Event* ev = new Event (Event::SetTransportSpeed, Event::Add, Event::Immediate, 0, speed);
queue_event (ev);
}
void
-Session::request_diskstream_speed (Diskstream& ds, float speed)
+Session::request_diskstream_speed (Diskstream& ds, double speed)
{
Event* ev = new Event (Event::SetDiskstreamSpeed, Event::Add, Event::Immediate, 0, speed);
ev->set_ptr (&ds);
}
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);
+ Event* ev = new Event (Event::SetTransportSpeed, Event::Add, Event::Immediate, 0, 0.0, abort, clear_state);
queue_event (ev);
}
}
void
-Session::force_locate (nframes_t target_frame, bool with_roll)
+Session::force_locate (nframes64_t target_frame, bool with_roll)
{
Event *ev = new Event (with_roll ? Event::LocateRoll : Event::Locate, Event::Add, Event::Immediate, target_frame, 0, true);
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();
return;
}
- ev = new Event (Event::SetLoop, Event::Add, Event::Immediate, 0, 0.0, yn);
+ ev = new Event (Event::SetLoop, Event::Add, Event::Immediate, 0, (leave_rolling ? 1.0 : 0.0), yn);
queue_event (ev);
- if (!yn && Config->get_seamless_loop() && transport_rolling()) {
+ if (!leave_rolling && !yn && Config->get_seamless_loop() && transport_rolling()) {
// request an immediate locate to refresh the diskstreams
// 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)
{
+ Event* ev = new Event (Event::SetPlayAudioRange, Event::Add, Event::Immediate, 0, (leave_rolling ? 1.0 : 0.0));
+ if (range) {
+ ev->audio_range = *range;
+ } else {
+ ev->audio_range.clear ();
+ }
+ queue_event (ev);
+}
+
+void
+Session::realtime_stop (bool abort, bool clear_state)
+{
+ PostTransportWork todo = PostTransportWork (0);
+
/* assume that when we start, we'll be moving forwards */
// FIXME: where should this really be? [DR]
deliver_mmc (MIDI::MachineControl::cmdLocate, _transport_frame);
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);
}
if (actively_recording()) {
past that point to pick up delayed input.
*/
-#ifndef LEAVE_TRANSPORT_UNADJUSTED
decrement_transport_position (_worst_output_latency);
-#endif
/* 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);
+ }
+
+ if (todo) {
+ add_post_transport_work (todo);
}
_clear_event_type (Event::StopOnce);
reset_slave_state ();
_transport_speed = 0;
+ _target_transport_speed = 0;
- if (Config->get_use_video_sync()) {
+ 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 = ((Config->get_slave_source() == None && config.get_auto_return()) ? AutoReturning : 0);
}
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);
+ int on_entry = g_atomic_int_get (&_butler->should_do_transport_work);
finished = true;
-
- if (post_transport_work & PostTransportCurveRealloc) {
+ ptw = post_transport_work();
+ if (ptw & PostTransportCurveRealloc) {
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
(*i)->curve_reallocate();
}
}
- if (post_transport_work & PostTransportInputChange) {
+ if (ptw & PostTransportInputChange) {
for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
(*i)->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 (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)) {
+ 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);
goto restart;
}
}
}
}
- 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);
+ 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);
+ g_atomic_int_dec_and_test (&_butler->should_do_transport_work);
goto restart;
}
}
- if (post_transport_work & PostTransportAudition) {
+ if (ptw & PostTransportAudition) {
non_realtime_set_audition ();
}
- g_atomic_int_dec_and_test (&butler_should_do_transport_work);
+ g_atomic_int_dec_and_test (&_butler->should_do_transport_work);
}
void
if ((*i)->pending_overwrite) {
(*i)->overwrite_existing_buffers ();
}
- if (on_entry != g_atomic_int_get (&butler_should_do_transport_work)) {
+ if (on_entry != g_atomic_int_get (&_butler->should_do_transport_work)) {
finished = false;
return;
}
time_t xnow;
bool did_record;
bool saved;
+ PostTransportWork ptw = post_transport_work();
did_record = false;
saved = false;
/* stopped recording before current end */
- if (_end_location_is_free) {
+ if (config.get_end_marker_is_free()) {
/* first capture for this session, move end back to where we are */
add_command (new MementoCommand<Location>(*loc, &before, &after));
}
- _end_location_is_free = false;
+ config.set_end_marker_is_free (false);
_have_captured = true;
}
update_latency_compensation (true, abort);
}
- if ((Config->get_slave_source() == None && Config->get_auto_return()) ||
- (post_transport_work & PostTransportLocate) ||
+ bool const auto_return_enabled =
+ (Config->get_slave_source() == None && config.get_auto_return());
+
+ if (auto_return_enabled ||
+ (ptw & PostTransportLocate) ||
(_requested_return_frame >= 0) ||
synced_to_jack()) {
flush_all_inserts ();
}
- if (((Config->get_slave_source() == None && Config->get_auto_return()) ||
- synced_to_jack() ||
- _requested_return_frame >= 0) &&
- !(post_transport_work & PostTransportLocate)) {
+ if ((auto_return_enabled || synced_to_jack() || _requested_return_frame >= 0) &&
+ !(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_stop_frame;
- _requested_return_frame = -1;
- }
+ 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);
}
- }
+ }
-#ifndef LEAVE_TRANSPORT_UNADJUSTED
}
-#endif
- 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;
- }
- }
+ /* do this before seeking, because otherwise the Diskstreams will do the wrong thing in seamless loop mode.
+ */
-#ifdef LEAVE_TRANSPORT_UNADJUSTED
+ if (ptw & PostTransportClearSubstate) {
+ _play_range = false;
+ unset_play_loop ();
}
-#endif
- if (_requested_return_frame < 0) {
- last_stop_frame = _transport_frame;
- } else {
- last_stop_frame = _requested_return_frame;
- _requested_return_frame = -1;
- }
+ /* this for() block can be put inside the previous if() and has the effect of ... ??? what */
- if (did_record) {
- /* 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);
+ 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;
}
- RecordStateChanged (); /* emit signal */
-#endif
}
- if ((post_transport_work & PostTransportLocate) && get_record_enabled()) {
+ have_looped = false;
+
+ send_full_time_code (0);
+ deliver_mmc (MIDI::MachineControl::cmdStop, 0);
+ deliver_mmc (MIDI::MachineControl::cmdLocate, _transport_frame);
+
+ if ((ptw & PostTransportLocate) && get_record_enabled()) {
/* capture start has been changed, so save pending state */
save_state ("", true);
saved = true;
save_state (_current_snapshot_name);
}
- if (post_transport_work & PostTransportDuration) {
+ if (ptw & 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 ((nframes64_t) _transport_frame); /* EMIT SIGNAL */
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_slave_source() == None && pending_locate_roll) {
request_transport_speed (1.0);
pending_locate_roll = false;
}
}
}
+void
+Session::unset_play_loop ()
+{
+ play_loop = false;
+ 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);
+ }
+ }
+}
+
void
Session::set_play_loop (bool yn)
{
/* 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")
<< endmsg;
return;
}
+
+ if (yn) {
+ play_loop = true;
- if ((play_loop = yn)) {
-
- Location *loc;
-
+ if (loc) {
- if ((loc = _locations.auto_loop_location()) != 0) {
+ unset_play_range ();
if (Config->get_seamless_loop()) {
// set all diskstreams to use internal looping
}
}
}
-
- /* stick in the loop event */
-
+
+ /* put the loop event into the event list */
+
Event* event = new Event (Event::AutoLoop, Event::Replace, loc->end(), loc->start(), 0.0f);
merge_event (event);
- /* 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. If doing seamless loop, force a
+ locate+buffer refill even if we are positioned there already.
+ */
+ 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 ();
}
-}
+ 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 (nframes64_t target_frame, bool with_roll, bool with_flush, bool with_loop, bool force)
{
if (synced_to_jack()) {
- float sp;
- nframes_t pos;
+ double sp;
+ nframes64_t pos;
_slave->speed_and_position (sp, pos);
}
} else {
-
- locate (target_frame, with_roll, with_flush, with_loop);
+ locate (target_frame, with_roll, with_flush, with_loop, force);
}
}
Session::micro_locate (nframes_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)) {
return -1;
for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
(*i)->internal_playback_seek (distance);
}
-
+
_transport_frame += distance;
return 0;
}
void
-Session::locate (nframes_t target_frame, bool with_roll, bool with_flush, bool with_loop)
+Session::locate (nframes64_t target_frame, bool with_roll, bool with_flush, bool with_loop, bool force)
{
if (actively_recording() && !with_loop) {
return;
}
- if (_transport_frame == target_frame && !loop_changing && !with_loop) {
+ if (!force && _transport_frame == target_frame && !loop_changing && !with_loop) {
if (with_roll) {
set_transport_speed (1.0, false);
}
return;
}
- // Update SMPTE time
+ // Update Timecode time
// [DR] FIXME: find out exactly where this should go below
_transport_frame = target_frame;
- smpte_time(_transport_frame, transmitting_smpte_time);
- outbound_mtc_smpte_frame = _transport_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)) {
}
}
- if (transport_rolling() && (!auto_play_legal || !Config->get_auto_play()) && !with_roll && !(synced_to_jack() && play_loop)) {
- realtime_stop (false);
+ if (transport_rolling() && (!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
}
- if ( !with_loop || loop_changing) {
+ if (force || !with_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);
- }
+ todo = PostTransportWork (todo | PostTransportRoll);
+ }
- schedule_butler_transport_work ();
+ add_post_transport_work (todo);
+ _butler->schedule_transport_work ();
} else {
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());
+ (*i)->monitor_input (!config.get_auto_input());
}
}
}
}
}
}
-
+ have_looped = true;
TransportLooped(); // EMIT SIGNAL
}
}
loop_changing = false;
- _send_smpte_update = true;
+ _send_timecode_update = true;
+
+ Located (); /* EMIT SIGNAL */
}
/** Set the transport speed.
* @param abort
*/
void
-Session::set_transport_speed (float speed, bool abort)
+Session::set_transport_speed (double speed, bool abort, bool clear_state)
{
if (_transport_speed == speed) {
return;
}
+ _target_transport_speed = fabs(speed);
+
+ /* 8.0 max speed is somewhat arbitrary but based on guestimates regarding disk i/o capability
+ and user needs. We really need CD-style "skip" playback for ffwd and rewind.
+ */
+
if (speed > 0) {
- speed = min (8.0f, speed);
+ speed = min (8.0, speed);
} else if (speed < 0) {
- speed = max (-8.0f, speed);
+ speed = max (-8.0, speed);
}
if (transport_rolling() && speed == 0.0) {
}
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);
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 ()) {
+ if (config.get_auto_input() && (*i)->record_enabled ()) {
//cerr << "switching from input" << __FILE__ << __LINE__ << endl << endl;
(*i)->monitor_input (false);
}
return;
}
- if (speed > 0.0f && _transport_frame == current_end_frame()) {
+ if (speed > 0.0 && _transport_frame == current_end_frame()) {
return;
}
- if (speed < 0.0f && _transport_frame == 0) {
+ if (speed < 0.0 && _transport_frame == 0) {
return;
}
/* 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.0f) || (_last_transport_speed * speed < 0.0f) || (_last_transport_speed == 0.0f && speed < 0.0f)) {
- post_transport_work = PostTransportWork (post_transport_work | PostTransportReverse);
+ if ((_transport_speed && speed * _transport_speed < 0.0) || (_last_transport_speed * speed < 0.0) || (_last_transport_speed == 0.0f && speed < 0.0f)) {
+ todo = PostTransportWork (todo | PostTransportReverse);
}
_last_transport_speed = _transport_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);
+ todo = PostTransportWork (todo | PostTransportSpeed);
+ break;
}
}
- if (post_transport_work & (PostTransportSpeed|PostTransportReverse)) {
- schedule_butler_transport_work ();
+ if (todo) {
+ add_post_transport_work (todo);
+ _butler->schedule_transport_work ();
}
}
}
/** Stop the transport. */
void
-Session::stop_transport (bool abort)
+Session::stop_transport (bool abort, bool clear_state)
{
if (_transport_speed == 0.0f) {
return;
return;
}
- realtime_stop (abort);
- schedule_butler_transport_work ();
+ realtime_stop (abort, clear_state);
+ _butler->schedule_transport_work ();
}
void
Session::start_transport ()
{
_last_roll_location = _transport_frame;
+ have_looped = false;
/* if record status is Enabled, move it to Recording. if its
already Recording, move it to Disabled.
switch (record_status()) {
case Enabled:
- if (!Config->get_punch_in()) {
+ if (!config.get_punch_in()) {
enable_record ();
}
break;
break;
}
- if (!synced_to_jack() || _exporting) {
- actually_start_transport ();
- } else {
- waiting_to_start = true;
- }
-}
-
-void
-Session::actually_start_transport ()
-{
- waiting_to_start = false;
-
transport_sub_state |= PendingDeclickIn;
+
_transport_speed = 1.0;
+ _target_transport_speed = 1.0;
boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
void
Session::post_transport ()
{
- if (post_transport_work & PostTransportAudition) {
+ PostTransportWork ptw = post_transport_work ();
+
+ if (ptw & PostTransportAudition) {
if (auditioner && auditioner->active()) {
process_function = &Session::process_audition;
} else {
}
}
- 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_slave_source() == None && (auto_play_legal && config.get_auto_play())) && !_exporting) || (ptw & PostTransportRoll)) {
start_transport ();
} else {
}
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
return;
}
-// if (src == JACK && Config->get_jack_time_master()) {
-// return;
-// }
+// if (src == JACK && Config->get_jack_time_master()) {
+// return;
+// }
- if (_slave) {
- delete _slave;
- _slave = 0;
- }
+ delete _slave;
+ _slave = 0;
if (_transport_speed < 0.0) {
reverse = true;
error << _("No MTC port defined: MTC slaving is impossible.") << endmsg;
return;
}
- _desired_transport_speed = _transport_speed;
break;
case MIDIClock:
error << _("No MIDI Clock port defined: MIDI Clock slaving is impossible.") << endmsg;
return;
}
- _desired_transport_speed = _transport_speed;
break;
case JACK:
_slave = new JACK_Slave (_engine.jack());
- _desired_transport_speed = _transport_speed;
break;
};
}
if (non_rt_required) {
- post_transport_work = PostTransportWork (post_transport_work | PostTransportSpeed);
- schedule_butler_transport_work ();
+ add_post_transport_work (PostTransportSpeed);
+ _butler->schedule_transport_work ();
}
set_dirty();
void
Session::reverse_diskstream_buffers ()
{
- post_transport_work = PostTransportWork (post_transport_work | PostTransportReverse);
- schedule_butler_transport_work ();
+ add_post_transport_work (PostTransportReverse);
+ _butler->schedule_transport_work ();
}
void
-Session::set_diskstream_speed (Diskstream* stream, float speed)
+Session::set_diskstream_speed (Diskstream* stream, double speed)
{
if (stream->realtime_set_speed (speed, false)) {
- post_transport_work = PostTransportWork (post_transport_work | PostTransportSpeed);
- schedule_butler_transport_work ();
+ 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 (Event::RangeStop);
+ _clear_event_type (Event::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);
-}
+ Event* ev;
-void
-Session::set_play_range (bool yn)
-{
/* Called from event-processing context */
- if (_play_range != yn) {
- _play_range = yn;
- setup_auto_play ();
-
- if (!_play_range) {
+ unset_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);
merge_event (ev);
}
- }
-}
-
-void
-Session::setup_auto_play ()
-{
- /* Called from event-processing context */
-
- Event* ev;
-
- _clear_event_type (Event::RangeStop);
- _clear_event_type (Event::RangeLocate);
-
- if (!_play_range) {
return;
}
- list<AudioRange>::size_type sz = current_audio_range.size();
+ _play_range = true;
- if (sz > 1) {
+ /* cancel loop play */
+ unset_play_loop ();
- list<AudioRange>::iterator i = current_audio_range.begin();
+ list<AudioRange>::size_type sz = range.size();
+
+ if (sz > 1) {
+
+ 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;
-
+
if (requested_frame > current_block_size) {
requested_frame -= current_block_size;
} else {
requested_frame = 0;
}
-
- if (next == current_audio_range.end()) {
+
+ if (next == range.end()) {
ev = new Event (Event::RangeStop, Event::Add, requested_frame, 0, 0.0f);
} else {
ev = new Event (Event::RangeLocate, Event::Add, requested_frame, (*next).start, 0.0f);
}
-
+
merge_event (ev);
-
+
i = next;
}
-
+
} else if (sz == 1) {
- ev = new Event (Event::RangeStop, Event::Add, current_audio_range.front().end, 0, 0.0f);
+ ev = new Event (Event::RangeStop, Event::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 Event (Event::LocateRoll, Event::Add, Event::Immediate, range.front().start, 0.0f, false);
merge_event (ev);
+
+ TransportStateChange ();
}
void
-Session::request_roll_at_and_return (nframes_t start, nframes_t return_to)
+Session::request_bounded_roll (nframes_t start, nframes_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 (nframes_t start, nframes_t return_to)
{
- request_stop ();
- Event *ev = new Event (Event::StopOnce, Event::Replace, end, Event::Immediate, 0.0);
+ Event *ev = new Event (Event::LocateRollLocate, Event::Add, Event::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);
- stop_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;
void
Session::xrun_recovery ()
{
- Xrun (transport_frame()); //EMIT SIGNAL
+ Xrun ((nframes64_t)_transport_frame); //EMIT SIGNAL
if (Config->get_stop_recording_on_xrun() && actively_recording()) {
Session::update_latency_compensation (bool with_stop, bool abort)
{
bool update_jack = false;
+ PostTransportWork ptw;
if (_state_of_the_state & Deletion) {
return;
}
_worst_track_latency = 0;
+ ptw = post_transport_work();
#undef DEBUG_LATENCY
#ifdef DEBUG_LATENCY
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));
+ (*i)->handle_transport_stopped (abort, (ptw & PostTransportLocate), (!(ptw & PostTransportLocate) || pending_locate_flush));
}
- nframes_t old_latency = (*i)->signal_latency ();
+ nframes_t old_latency = (*i)->output()->signal_latency ();
nframes_t track_latency = (*i)->update_total_latency ();
if (old_latency != track_latency) {
- (*i)->update_port_total_latencies ();
+ (*i)->input()->update_port_total_latencies ();
+ (*i)->output()->update_port_total_latencies ();
update_jack = true;
}
- if (!(*i)->is_hidden() && ((*i)->active())) {
+ if (!(*i)->is_hidden() && ((*i)->active())) {
_worst_track_latency = max (_worst_track_latency, track_latency);
}
}
js->reset_client (jack);
}
}
+
+bool
+Session::maybe_stop (nframes_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;
+}
projects / ardour.git / blobdiff