#include "midi++/mmc.h"
#include "midi++/port.h"
-#include "midi++/manager.h"
#include "ardour/audioengine.h"
#include "ardour/auditioner.h"
seamless = Config->get_seamless_loop ();
- if (dynamic_cast<JACK_Slave*>(new_slave)) {
+ if (dynamic_cast<Engine_Slave*>(new_slave)) {
/* JACK cannot support seamless looping at present */
Config->set_seamless_loop (false);
} else {
_was_seamless = seamless;
ev->slave = new_slave;
+ DEBUG_TRACE (DEBUG::Slave, "sent request for new slave\n");
queue_event (ev);
}
if (_transport_speed < 0.0f) {
todo = (PostTransportWork (todo | PostTransportStop | PostTransportReverse));
+ _default_transport_speed = 1.0;
} else {
todo = PostTransportWork (todo | PostTransportStop);
}
g_atomic_int_dec_and_test (&_butler->should_do_transport_work);
DEBUG_TRACE (DEBUG::Transport, X_("Butler transport work all done\n"));
+ DEBUG_TRACE (DEBUG::Transport, X_(string_compose ("Frame %1\n", _transport_frame)));
}
void
boost::shared_ptr<RouteList> r = routes.reader ();
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
- if (!(*i)->is_hidden()) {
+ if (!(*i)->is_auditioner()) {
(*i)->set_pending_declick (0);
}
}
if (auto_return_enabled ||
(ptw & PostTransportLocate) ||
(_requested_return_frame >= 0) ||
- synced_to_jack()) {
+ synced_to_engine()) {
if (pending_locate_flush) {
flush_all_inserts ();
}
- if ((auto_return_enabled || synced_to_jack() || _requested_return_frame >= 0) &&
+ if ((auto_return_enabled || synced_to_engine() || _requested_return_frame >= 0) &&
!(ptw & PostTransportLocate)) {
/* no explicit locate queued */
/* don't try to handle loop play when synced to JACK */
- if (!synced_to_jack()) {
+ if (!synced_to_engine()) {
Location *location = _locations->auto_loop_location();
have_looped = false;
- if (!_engine.freewheeling()) {
- send_full_time_code (_transport_frame);
+ /* don't bother with this stuff if we're disconnected from the engine,
+ because there will be no process callbacks to deliver stuff from
+ */
+
+ if (_engine.connected() && !_engine.freewheeling()) {
+ // need to queue this in the next RT cycle
+ _send_timecode_update = true;
if (!dynamic_cast<MTC_Slave*>(_slave)) {
- MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdStop));
+ _mmc->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdStop));
+
+ /* This (::non_realtime_stop()) gets called by main
+ process thread, which will lead to confusion
+ when calling AsyncMIDIPort::write().
+
+ Something must be done. XXX
+ */
send_mmc_locate (_transport_frame);
}
}
if ((ptw & PostTransportLocate) && get_record_enabled()) {
- /* capture start has been changed, so save pending state */
- save_state ("", true);
- saved = true;
+ /* This is scheduled by realtime_stop(), which is also done
+ * when a slave requests /locate/ for an initial sync.
+ * We can't hold up the slave for long with a save() here,
+ * without breaking its initial sync cycle.
+ *
+ * save state only if there's no slave or if it's not yet locked.
+ */
+ if (!_slave || !_slave->locked()) {
+ DEBUG_TRACE (DEBUG::Transport, X_("Butler PTW: pending save\n"));
+ /* capture start has been changed, so save pending state */
+ save_state ("", true);
+ saved = true;
+ }
}
/* always try to get rid of this */
if ((ptw & 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
return;
}
- if (yn && Config->get_seamless_loop() && synced_to_jack()) {
+ if (yn && Config->get_seamless_loop() && synced_to_engine()) {
warning << string_compose (
_("Seamless looping cannot be supported while %1 is using JACK transport.\n"
"Recommend changing the configured options"), PROGRAM_NAME)
void
Session::start_locate (framepos_t target_frame, bool with_roll, bool with_flush, bool with_loop, bool force)
{
- if (synced_to_jack()) {
+ if (synced_to_engine()) {
double sp;
framepos_t pos;
* 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;
}
bool transport_was_stopped = !transport_rolling();
- if (transport_was_stopped && (!auto_play_legal || !config.get_auto_play()) && !with_roll && !(synced_to_jack() && play_loop)) {
+ if (transport_was_stopped && (!auto_play_legal || !config.get_auto_play()) && !with_roll && !(synced_to_engine() && play_loop)) {
realtime_stop (false, true); // XXX paul - check if the 2nd arg is really correct
transport_was_stopped = true;
} else {
send_mmc_locate (_transport_frame);
}
+ _last_roll_location = _last_roll_or_reversal_location = _transport_frame;
Located (); /* EMIT SIGNAL */
}
if (actively_recording() && speed != 1.0 && speed != 0.0) {
/* no varispeed during recording */
+ DEBUG_TRACE (DEBUG::Transport, string_compose ("No varispeed during recording cur_speed %1, frame %2\n",
+ _transport_speed, _transport_frame));
return;
}
set_track_monitor_input_status (true);
}
- if (synced_to_jack ()) {
+ if (synced_to_engine ()) {
if (clear_state) {
/* do this here because our response to the slave won't
take care of it.
set_track_monitor_input_status (false);
}
- if (synced_to_jack()) {
+ if (synced_to_engine()) {
_engine.transport_start ();
} else {
start_transport ();
/* not zero, not 1.0 ... varispeed */
- if ((synced_to_jack()) && speed != 0.0 && speed != 1.0) {
+ if ((synced_to_engine()) && speed != 0.0 && speed != 1.0) {
warning << string_compose (
_("Global varispeed cannot be supported while %1 is connected to JACK transport control"),
PROGRAM_NAME)
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));
+ _mmc->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdDeferredPlay));
}
}
delete _slave;
_slave = new_slave;
- send_full_time_code (_transport_frame);
+ DEBUG_TRACE (DEBUG::Slave, string_compose ("set new slave to %1\n", _slave));
+
+ // need to queue this for next process() cycle
+ _send_timecode_update = true;
boost::shared_ptr<RouteList> rl = routes.reader();
for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
}
try {
- new_slave = new MTC_Slave (*this, *MIDI::Manager::instance()->mtc_input_port());
+ new_slave = new MTC_Slave (*this, *_midi_ports->mtc_input_port());
}
catch (failed_constructor& err) {
}
break;
+ case LTC:
+ if (_slave && dynamic_cast<LTC_Slave*>(_slave)) {
+ return;
+ }
+
+ try {
+ new_slave = new LTC_Slave (*this);
+ }
+
+ catch (failed_constructor& err) {
+ return;
+ }
+
+ break;
+
case MIDIClock:
if (_slave && dynamic_cast<MIDIClock_Slave*>(_slave)) {
return;
}
try {
- new_slave = new MIDIClock_Slave (*this, *MIDI::Manager::instance()->midi_clock_input_port(), 24);
+ new_slave = new MIDIClock_Slave (*this, *_midi_ports->midi_clock_input_port(), 24);
}
catch (failed_constructor& err) {
}
break;
- case JACK:
- if (_slave && dynamic_cast<JACK_Slave*>(_slave)) {
+ case Engine:
+ if (_slave && dynamic_cast<Engine_Slave*>(_slave)) {
return;
}
return;
}
- new_slave = new JACK_Slave (_engine.jack());
+ new_slave = new Engine_Slave (*AudioEngine::instance());
break;
default:
auto_play_legal = yn;
}
-void
-Session::reset_jack_connection (jack_client_t* jack)
-{
- JACK_Slave* js;
-
- if (_slave && ((js = dynamic_cast<JACK_Slave*> (_slave)) != 0)) {
- js->reset_client (jack);
- }
-}
-
bool
Session::maybe_stop (framepos_t limit)
{
if ((_transport_speed > 0.0f && _transport_frame >= limit) || (_transport_speed < 0.0f && _transport_frame == 0)) {
- if (synced_to_jack () && config.get_jack_time_master ()) {
+ if (synced_to_engine () && config.get_jack_time_master ()) {
_engine.transport_stop ();
- } else if (!synced_to_jack ()) {
+ } else if (!synced_to_engine ()) {
stop_transport ();
}
return true;
if (!_engine.freewheeling()) {
Timecode::Time time;
timecode_time_subframes (t, time);
- MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (time));
+ _mmc->send (MIDI::MachineControlCommand (time));
}
}
projects / ardour.git / blobdiff