/*
- Copyright (C) 1999-2003 Paul Davis
+ Copyright (C) 1999-2009 Paul Davis
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
- $Id$
*/
#include <cmath>
#include <pbd/undo.h>
#include <pbd/error.h>
-#include <pbd/lockmonitor.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/diskstream.h>
+#include <ardour/audio_diskstream.h>
#include <ardour/auditioner.h>
#include <ardour/slave.h>
#include <ardour/location.h>
using namespace std;
using namespace ARDOUR;
using namespace sigc;
+using namespace PBD;
void
Session::request_input_change_handling ()
{
- Event* ev = new Event (Event::InputConfigurationChange, Event::Add, Event::Immediate, 0, 0.0);
- queue_event (ev);
+ if (!(_state_of_the_state & (InitialConnecting|Deletion))) {
+ Event* ev = new Event (Event::InputConfigurationChange, Event::Add, Event::Immediate, 0, 0.0);
+ queue_event (ev);
+ }
}
void
-Session::request_slave_source (SlaveSource src, jack_nframes_t pos)
+Session::request_slave_source (SlaveSource src)
{
- Event* ev = new Event (Event::SetSlaveSource, Event::Add, Event::Immediate, pos, 0.0);
+ Event* ev = new Event (Event::SetSlaveSource, Event::Add, Event::Immediate, 0, 0.0);
- if (src == Session::JACK) {
- /* could set_seamless_loop() be disposed of entirely?*/
- set_seamless_loop (false);
+ if (src == JACK) {
+ /* could set_seamless_loop() be disposed of entirely?*/
+ Config->set_seamless_loop (false);
} else {
-
- set_seamless_loop (true);
+ Config->set_seamless_loop (true);
}
ev->slave = src;
queue_event (ev);
}
void
-Session::request_diskstream_speed (DiskStream& ds, float speed)
+Session::request_diskstream_speed (Diskstream& ds, float speed)
{
Event* ev = new Event (Event::SetDiskstreamSpeed, Event::Add, Event::Immediate, 0, speed);
ev->set_ptr (&ds);
}
void
-Session::request_locate (jack_nframes_t target_frame, bool with_roll)
+Session::request_locate (nframes_t target_frame, bool with_roll)
{
Event *ev = new Event (with_roll ? Event::LocateRoll : Event::Locate, Event::Add, Event::Immediate, target_frame, 0, false);
queue_event (ev);
}
void
-Session::force_locate (jack_nframes_t target_frame, bool with_roll)
+Session::force_locate (nframes_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_auto_loop (bool yn)
+Session::request_play_loop (bool yn)
{
Event* ev;
Location *location = _locations.auto_loop_location();
ev = new Event (Event::SetLoop, Event::Add, Event::Immediate, 0, 0.0, yn);
queue_event (ev);
-
- if (!yn && seamless_loop && transport_rolling()) {
+
+ if (!yn && Config->get_seamless_loop() && transport_rolling()) {
// request an immediate locate to refresh the diskstreams
// after disabling looping
- request_locate (_transport_frame-1, true);
- }
-}
-
-void
-Session::set_seamless_loop (bool yn)
-{
- if (seamless_loop != yn) {
- seamless_loop = yn;
-
- if (auto_loop && transport_rolling()) {
- // to reset diskstreams etc
- request_auto_loop (true);
- }
-
- ControlChanged (SeamlessLoop); /* EMIT */
+ request_locate (_transport_frame-1, false);
}
}
decrement_transport_position (_worst_output_latency);
#endif
- if (_transport_frame > current_end_frame()) {
-
- /* first capture resets end location; later captures can only extend the length */
-
- if (_end_location_is_free) {
- end_location->set_end (_transport_frame);
- _end_location_is_free = false;
- } else if (_transport_frame > end_location->start()) {
- end_location->set_end (_transport_frame);
- }
+ /* the duration change is not guaranteed to have happened, but is likely */
- post_transport_work = PostTransportWork (post_transport_work | PostTransportDuration);
- }
+ post_transport_work = PostTransportWork (post_transport_work | PostTransportDuration);
}
-
if (abort) {
post_transport_work = PostTransportWork (post_transport_work | PostTransportAbort);
}
_clear_event_type (Event::RangeStop);
_clear_event_type (Event::RangeLocate);
- disable_record ();
+ disable_record (true);
reset_slave_state ();
-
+
_transport_speed = 0;
- transport_sub_state = (auto_return ? AutoReturning : 0);
+
+ 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);
}
void
Session::butler_transport_work ()
{
+ restart:
+ bool finished;
+ 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;
+
if (post_transport_work & PostTransportCurveRealloc) {
- for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
(*i)->curve_reallocate();
}
}
if (post_transport_work & PostTransportInputChange) {
- for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
+ for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
(*i)->non_realtime_input_change ();
}
}
}
if (post_transport_work & PostTransportReverse) {
-
-
+
clear_clicks();
cumulative_rf_motion = 0;
reset_rf_scale (0);
- for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
- if (!(*i)->hidden()) {
- if ((*i)->speed() != 1.0f || (*i)->speed() != -1.0f) {
- (*i)->seek ((jack_nframes_t) (_transport_frame * (double) (*i)->speed()));
+ /* don't seek if locate will take care of that in non_realtime_stop() */
+
+ if (!(post_transport_work & PostTransportLocate)) {
+
+ for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
+ if (!(*i)->hidden()) {
+ if ((*i)->speed() != 1.0f || (*i)->speed() != -1.0f) {
+ (*i)->seek ((nframes_t) (_transport_frame * (double) (*i)->speed()));
+ }
+ else {
+ (*i)->seek (_transport_frame);
+ }
}
- else {
- (*i)->seek (_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);
+ goto restart;
}
}
}
}
if (post_transport_work & (PostTransportStop|PostTransportLocate)) {
- non_realtime_stop (post_transport_work & PostTransportAbort);
+ non_realtime_stop (post_transport_work & PostTransportAbort, on_entry, finished);
+ if (!finished) {
+ g_atomic_int_dec_and_test (&butler_should_do_transport_work);
+ goto restart;
+ }
}
if (post_transport_work & PostTransportOverWrite) {
- non_realtime_overwrite ();
+ non_realtime_overwrite (on_entry, finished);
+ if (!finished) {
+ g_atomic_int_dec_and_test (&butler_should_do_transport_work);
+ goto restart;
+ }
}
if (post_transport_work & PostTransportAudition) {
non_realtime_set_audition ();
}
-
- atomic_dec (&butler_should_do_transport_work);
+
+ g_atomic_int_dec_and_test (&butler_should_do_transport_work);
}
void
Session::non_realtime_set_speed ()
{
- LockMonitor lm (diskstream_lock, __LINE__, __FILE__);
+ boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
- for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
+ for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
(*i)->non_realtime_set_speed ();
}
}
void
-Session::non_realtime_overwrite ()
+Session::non_realtime_overwrite (int on_entry, bool& finished)
{
- LockMonitor lm (diskstream_lock, __LINE__, __FILE__);
+ boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
- for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
+ for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
if ((*i)->pending_overwrite) {
(*i)->overwrite_existing_buffers ();
}
+ if (on_entry != g_atomic_int_get (&butler_should_do_transport_work)) {
+ finished = false;
+ return;
+ }
}
}
void
-Session::non_realtime_stop (bool abort)
+Session::non_realtime_stop (bool abort, int on_entry, bool& finished)
{
struct tm* now;
time_t xnow;
bool did_record;
+ bool saved;
did_record = false;
+ saved = false;
- for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
+ boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
+
+ for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
if ((*i)->get_captured_frames () != 0) {
did_record = true;
break;
if (did_record) {
begin_reversible_command ("capture");
-
+
Location* loc = _locations.end_location();
+ bool change_end = false;
+
+ if (_transport_frame < loc->end()) {
- if (loc && !_have_captured) {
-
- /* first capture.
-
- note: later captures that extend the session length get
- handled because of playlist length changes.
- */
+ /* stopped recording before current end */
+
+ if (_end_location_is_free) {
+
+ /* first capture for this session, move end back to where we are */
+
+ change_end = true;
+ }
+
+ } else if (_transport_frame > loc->end()) {
- add_undo (sigc::retype_return<void>(sigc::bind (mem_fun (*loc, &Location::set_end), loc->end())));
- add_redo (sigc::retype_return<void>(sigc::bind (mem_fun (*loc, &Location::set_end), _transport_frame)));
+ /* stopped recording after the current end, extend it */
+
+ change_end = true;
+ }
+
+ 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));
}
+ _end_location_is_free = false;
_have_captured = true;
}
- for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
+ for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
(*i)->transport_stopped (*now, xnow, abort);
}
- for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
+ boost::shared_ptr<RouteList> r = routes.reader ();
+
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
if (!(*i)->hidden()) {
(*i)->set_pending_declick (0);
}
}
-
+
if (did_record) {
commit_reversible_command ();
}
-
+
if (_engine.running()) {
update_latency_compensation (true, abort);
}
- if (auto_return || (post_transport_work & PostTransportLocate) || synced_to_jack()) {
-
+ if ((Config->get_slave_source() == None && Config->get_auto_return()) ||
+ (post_transport_work & PostTransportLocate) ||
+ (_requested_return_frame >= 0) ||
+ synced_to_jack()) {
+
if (pending_locate_flush) {
flush_all_redirects ();
}
+
+ if (((Config->get_slave_source() == None && Config->get_auto_return()) ||
+ synced_to_jack() ||
+ _requested_return_frame >= 0) &&
+ !(post_transport_work & PostTransportLocate)) {
- if ((auto_return || synced_to_jack()) && !(post_transport_work & PostTransportLocate)) {
+ /* no explicit locate queued */
- _transport_frame = last_stop_frame;
+ bool do_locate = false;
+
+ if (_requested_return_frame >= 0) {
+ _transport_frame = _requested_return_frame;
+ _requested_return_frame = -1;
+ do_locate = true;
+ } else {
+ if (play_loop && !synced_to_jack()) {
+ Location *location = _locations.auto_loop_location();
+
+ if (location != 0) {
+ _transport_frame = location->start();
+ do_locate = true;
+ } else {
+ _transport_frame = last_stop_frame;
+ }
+ } else {
+ _transport_frame = last_stop_frame;
+ }
+ _requested_return_frame = -1;
+ }
- if (synced_to_jack()) {
+ if (synced_to_jack() && !play_loop) {
+ do_locate = true;
+ }
+
+ if (do_locate) {
+ // cerr << "non-realtimestop: transport locate to " << _transport_frame << endl;
_engine.transport_locate (_transport_frame);
}
}
}
#endif
- for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
+ for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
if (!(*i)->hidden()) {
if ((*i)->speed() != 1.0f || (*i)->speed() != -1.0f) {
- (*i)->seek ((jack_nframes_t) (_transport_frame * (double) (*i)->speed()));
+ (*i)->seek ((nframes_t) (_transport_frame * (double) (*i)->speed()));
}
else {
(*i)->seek (_transport_frame);
}
}
+ if (on_entry != g_atomic_int_get (&butler_should_do_transport_work)) {
+ finished = false;
+ /* we will be back */
+ return;
+ }
}
-
- deliver_mmc (MIDI::MachineControl::cmdLocate, _transport_frame);
-
#ifdef LEAVE_TRANSPORT_UNADJUSTED
}
#endif
- last_stop_frame = _transport_frame;
+ if (_requested_return_frame < 0) {
+ last_stop_frame = _transport_frame;
+ } else {
+ last_stop_frame = _requested_return_frame;
+ _requested_return_frame = -1;
+ }
+
+ have_looped = false;
- send_full_time_code ();
+ send_full_time_code ();
deliver_mmc (MIDI::MachineControl::cmdStop, 0);
deliver_mmc (MIDI::MachineControl::cmdLocate, _transport_frame);
if (did_record) {
- atomic_set (&_record_status, Disabled);
- RecordDisabled (); /* EMIT SIGNAL */
+
+ /* 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);
+ }
+ RecordStateChanged (); /* emit signal */
+#endif
}
if ((post_transport_work & PostTransportLocate) && get_record_enabled()) {
/* capture start has been changed, so save pending state */
save_state ("", true);
+ saved = true;
}
- /* save the current state of things if appropriate */
+ /* always try to get rid of this */
+
+ remove_pending_capture_state ();
- if (did_record) {
+ /* save the current state of things if appropriate */
+
+ if (did_record && !saved) {
save_state (_current_snapshot_name);
}
if (post_transport_work & PostTransportStop) {
_play_range = false;
-
- /* do not turn off autoloop on stop */
-
+ play_loop = false;
}
- PositionChanged (_transport_frame); /* EMIT SIGNAL */
+ nframes_t tf = _transport_frame;
+
+ PositionChanged (tf); /* EMIT SIGNAL */
TransportStateChange (); /* EMIT SIGNAL */
/* and start it up again if relevant */
- if ((post_transport_work & PostTransportLocate) && _slave_type == None && pending_locate_roll) {
+ if ((post_transport_work & PostTransportLocate) && Config->get_slave_source() == None && pending_locate_roll) {
request_transport_speed (1.0);
pending_locate_roll = false;
}
}
void
-Session::set_auto_loop (bool yn)
+Session::set_play_loop (bool yn)
{
/* Called from event-handling context */
- if (actively_recording() || _locations.auto_loop_location() == 0) {
+ Location *loc;
+
+ if ((actively_recording() && yn) || (loc = _locations.auto_loop_location()) == 0) {
return;
}
set_dirty();
- if (yn && seamless_loop && synced_to_jack()) {
+ 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;
}
- if ((auto_loop = yn)) {
+ if ((play_loop = yn)) {
- Location *loc;
-
- if ((loc = _locations.auto_loop_location()) != 0) {
+ if (loc) {
- if (seamless_loop) {
+ if (Config->get_seamless_loop()) {
// set all diskstreams to use internal looping
- for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
+ boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
+ for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
if (!(*i)->hidden()) {
(*i)->set_loop (loc);
}
}
else {
// set all diskstreams to NOT use internal looping
- for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
+ boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
+ for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
if (!(*i)->hidden()) {
(*i)->set_loop (0);
}
}
}
- /* 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 */
+ event = new Event (Event::LocateRoll, Event::Add, Event::Immediate, loc->start(), 0, !synced_to_jack());
+ merge_event (event);
}
-
} else {
clear_events (Event::AutoLoop);
// set all diskstreams to NOT use internal looping
- for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
+ boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
+ for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
if (!(*i)->hidden()) {
(*i)->set_loop (0);
}
}
}
-
- ControlChanged (AutoLoop); /* EMIT SIGNAL */
}
void
Session::flush_all_redirects ()
{
- for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
+ boost::shared_ptr<RouteList> r = routes.reader ();
+
+ for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
(*i)->flush_redirects ();
}
}
void
-Session::start_locate (jack_nframes_t target_frame, bool with_roll, bool with_flush, bool with_loop)
+Session::start_locate (nframes_t target_frame, bool with_roll, bool with_flush, bool with_loop)
{
if (synced_to_jack()) {
float sp;
- jack_nframes_t pos;
+ nframes_t pos;
_slave->speed_and_position (sp, pos);
}
}
+int
+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 (jack_nframes_t target_frame, bool with_roll, bool with_flush, bool with_loop)
+Session::locate (nframes_t target_frame, bool with_roll, bool with_flush, bool with_loop)
{
- if (actively_recording()) {
+ if (actively_recording() && !with_loop) {
return;
}
}
}
- if (transport_rolling() && !auto_play && !with_roll && !(synced_to_jack() && auto_loop)) {
+ if (transport_rolling() && (!auto_play_legal || !Config->get_auto_play()) && !with_roll && !(synced_to_jack() && play_loop)) {
realtime_stop (false);
}
if ( !with_loop || loop_changing) {
-
+
post_transport_work = PostTransportWork (post_transport_work | PostTransportLocate);
if (with_roll) {
} else {
- /* XXX i don't know where else to put this. something has to clear the
- current clicks, and without deadlocking. clear_clicks() takes
- the route lock which would deadlock in this context.
- */
+ /* this is functionally what clear_clicks() does but with a tentative lock */
- for (Clicks::iterator i = clicks.begin(); i != clicks.end(); ++i) {
- delete *i;
- }
+ Glib::RWLock::WriterLock clickm (click_lock, Glib::TRY_LOCK);
+
+ if (clickm.locked()) {
+
+ for (Clicks::iterator i = clicks.begin(); i != clicks.end(); ++i) {
+ delete *i;
+ }
- clicks.clear ();
+ clicks.clear ();
+ }
}
+ 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());
+ }
+ }
+ }
+ } 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);
+ }
+ }
+ }
+ }
- /* cancel autoloop if transport pos outside of loop range */
- if (auto_loop) {
+ /* 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_auto_loop(false);
+ set_play_loop (false);
+ }
+ else if (al && _transport_frame == al->start()) {
+ if (with_loop) {
+ // this is only necessary for seamless looping
+
+ boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
+
+ 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);
+ }
+ }
+ }
+ have_looped = true;
+ TransportLooped(); // EMIT SIGNAL
}
}
loop_changing = false;
+
+ _send_smpte_update = true;
}
void
if (transport_rolling() && speed == 0.0) {
+ 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 (synced_to_jack ()) {
_engine.transport_stop ();
} else {
stop_transport (abort);
}
-
+
} else if (transport_stopped() && speed == 1.0) {
+ 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 (synced_to_jack()) {
_engine.transport_start ();
} else {
} else {
+ if (!get_record_enabled() && Config->get_stop_at_session_end() && _transport_frame >= current_end_frame()) {
+ return;
+ }
+
if ((synced_to_jack()) && speed != 0.0 && speed != 1.0) {
warning << _("Global varispeed cannot be supported while Ardour is connected to JACK transport control")
<< endmsg;
before the last stop, then we have to do extra work.
*/
- if ((_transport_speed && speed * _transport_speed < 0.0f) || (_last_transport_speed * speed < 0.0f)) {
+ 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);
+ last_stop_frame = _transport_frame;
}
_last_transport_speed = _transport_speed;
_transport_speed = speed;
-
- for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
+
+ 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 (_transport_speed == 0.0f) {
return;
}
-
+
if (actively_recording() && !(transport_sub_state & StopPendingCapture) &&
_worst_output_latency > current_block_size)
{
return;
}
+
if ((transport_sub_state & PendingDeclickOut) == 0) {
transport_sub_state |= PendingDeclickOut;
/* we'll be called again after the declick */
+ pending_abort = abort;
return;
}
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 (!punch_in) {
+ if (!Config->get_punch_in()) {
enable_record ();
}
break;
case Recording:
- disable_record ();
+ if (!play_loop) {
+ disable_record (false);
+ }
break;
default:
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;
- for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
+ boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
+ for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
(*i)->realtime_set_speed ((*i)->speed(), true);
}
if (post_transport_work & PostTransportLocate) {
- if ((auto_play && !_exporting) || (post_transport_work & PostTransportRoll)) {
-
+ if (((Config->get_slave_source() == None && (auto_play_legal && Config->get_auto_play())) && !_exporting) || (post_transport_work & PostTransportRoll)) {
start_transport ();
} else {
}
void
-Session::set_rf_speed (float speed)
-{
- rf_speed = speed;
- cumulative_rf_motion = 0;
- reset_rf_scale (0);
-}
-
-void
-Session::reset_rf_scale (jack_nframes_t motion)
+Session::reset_rf_scale (nframes_t motion)
{
cumulative_rf_motion += motion;
}
}
-int
-Session::set_slave_source (SlaveSource src, jack_nframes_t frame)
+void
+Session::set_slave_source (SlaveSource src, bool stop_the_transport)
{
bool reverse = false;
bool non_rt_required = false;
if (_transport_speed) {
error << _("please stop the transport before adjusting slave settings") << endmsg;
- /* help out non-MVC friendly UI's by telling them the slave type changed */
- ControlChanged (SlaveType); /* EMIT SIGNAL */
- return 0;
+ return;
}
- if (src == _slave_type) {
- return 0;
- }
-
// if (src == JACK && Config->get_jack_time_master()) {
-// return -1;
+// return;
// }
if (_slave) {
delete _slave;
_slave = 0;
- _slave_type = None;
}
if (_transport_speed < 0.0) {
switch (src) {
case None:
- stop_transport ();
+ if (stop_the_transport) {
+ stop_transport ();
+ }
break;
-
+
case MTC:
if (_mtc_port) {
try {
}
catch (failed_constructor& err) {
- return -1;
+ return;
}
} else {
error << _("No MTC port defined: MTC slaving is impossible.") << endmsg;
- return -1;
+ return;
}
_desired_transport_speed = _transport_speed;
break;
_desired_transport_speed = _transport_speed;
break;
};
-
- _slave_type = src;
- for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
+ Config->set_slave_source (src);
+
+ 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;
}
set_dirty();
- ControlChanged (SlaveType); /* EMIT SIGNAL */
-
- return 0;
}
void
}
void
-Session::set_diskstream_speed (DiskStream* stream, float speed)
+Session::set_diskstream_speed (Diskstream* stream, float speed)
{
if (stream->realtime_set_speed (speed, false)) {
post_transport_work = PostTransportWork (post_transport_work | PostTransportSpeed);
Event* ev = new Event (Event::SetTransportSpeed, Event::Add, Event::Immediate, 0, 0.0f, false);
merge_event (ev);
}
-
- ControlChanged (PlayRange); /* EMIT SIGNAL */
}
}
/* locating/stopping is subject to delays for declicking.
*/
- jack_nframes_t requested_frame = (*i).end;
+ nframes_t requested_frame = (*i).end;
if (requested_frame > current_block_size) {
requested_frame -= current_block_size;
}
void
-Session::request_bounded_roll (jack_nframes_t start, jack_nframes_t end)
+Session::request_roll_at_and_return (nframes_t start, nframes_t return_to)
+{
+ Event *ev = new Event (Event::LocateRollLocate, Event::Add, Event::Immediate, return_to, 1.0);
+ ev->target2_frame = start;
+ queue_event (ev);
+}
+
+void
+Session::request_bounded_roll (nframes_t start, nframes_t end)
{
request_stop ();
- Event *ev = new Event (Event::StopOnce, Event::Replace, Event::Immediate, end, 0.0);
+ Event *ev = new Event (Event::StopOnce, Event::Replace, end, Event::Immediate, 0.0);
queue_event (ev);
request_locate (start, true);
}
void
Session::engine_halted ()
{
+ bool ignored;
+
/* there will be no more calls to process(), so
we'd better clean up for ourselves, right now.
the picture.
*/
- atomic_set (&butler_should_do_transport_work, 0);
+ g_atomic_int_set (&butler_should_do_transport_work, 0);
post_transport_work = PostTransportWork (0);
stop_butler ();
-
+
realtime_stop (false);
- non_realtime_stop (false);
+ non_realtime_stop (false, 0, ignored);
transport_sub_state = 0;
+ if (synced_to_jack()) {
+ /* transport is already stopped, hence the second argument */
+ set_slave_source (None, false);
+ }
+
TransportStateChange (); /* EMIT SIGNAL */
}
void
Session::xrun_recovery ()
{
- if (Config->get_stop_recording_on_xrun() && actively_recording()) {
+ Xrun (transport_frame()); //EMIT SIGNAL
- HaltOnXrun (); /* EMIT SIGNAL */
+ if (Config->get_stop_recording_on_xrun() && actively_recording()) {
/* it didn't actually halt, but we need
to handle things in the same way.
return;
}
- LockMonitor lm (route_lock, __LINE__, __FILE__);
- LockMonitor lm2 (diskstream_lock, __LINE__, __FILE__);
_worst_track_latency = 0;
- for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
+#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)->transport_stopped (abort, (post_transport_work & PostTransportLocate),
- (!(post_transport_work & PostTransportLocate) || pending_locate_flush));
+ (*i)->handle_transport_stopped (abort, (post_transport_work & PostTransportLocate),
+ (!(post_transport_work & PostTransportLocate) || pending_locate_flush));
}
- jack_nframes_t old_latency = (*i)->signal_latency ();
- jack_nframes_t track_latency = (*i)->update_total_latency ();
+ nframes_t old_latency = (*i)->signal_latency ();
+ nframes_t track_latency = (*i)->update_total_latency ();
if (old_latency != track_latency) {
update_jack = true;
}
}
- for (RouteList::iterator i = routes.begin(); i != routes.end(); ++i) {
+#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);
}
_engine.update_total_latencies ();
}
- set_worst_io_latencies (false);
+ set_worst_io_latencies ();
/* reflect any changes in latencies into capture offsets
*/
- for (DiskStreamList::iterator i = diskstreams.begin(); i != diskstreams.end(); ++i) {
+ boost::shared_ptr<DiskstreamList> dsl = diskstreams.reader();
+
+ for (DiskstreamList::iterator i = dsl->begin(); i != dsl->end(); ++i) {
(*i)->set_capture_offset ();
}
}
{
update_latency_compensation (false, false);
}
+
+void
+Session::allow_auto_play (bool yn)
+{
+ 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);
+ }
+}