#include "midi++/mmc.h"
#include "midi++/port.h"
+#include "midi++/manager.h"
#include "ardour/ardour.h"
#include "ardour/audioengine.h"
}
void
-Session::request_locate (nframes_t target_frame, bool with_roll)
+Session::request_locate (framepos_t target_frame, bool with_roll)
{
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));
}
void
-Session::force_locate (nframes64_t target_frame, bool with_roll)
+Session::force_locate (framepos_t target_frame, bool with_roll)
{
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));
Session::request_play_loop (bool yn, bool leave_rolling)
{
SessionEvent* ev;
- Location *location = _locations.auto_loop_location();
+ Location *location = _locations->auto_loop_location();
if (location == 0 && yn) {
error << _("Cannot loop - no loop range defined")
/* assume that when we start, we'll be moving forwards */
- // FIXME: where should this really be? [DR]
- //send_full_time_code();
- Timecode::Time time;
- timecode_time_subframes (_transport_frame, time);
-
- _mmc->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdStop));
- _mmc->send (MIDI::MachineControlCommand (time));
-
if (_transport_speed < 0.0f) {
todo = (PostTransportWork (todo | PostTransportStop | PostTransportReverse));
} else {
waiting_for_sync_offset = true;
}
- transport_sub_state = ((!config.get_external_sync()&& config.get_auto_return()) ? AutoReturning : 0);
+ transport_sub_state = 0;
}
void
}
DEBUG_TRACE (DEBUG::Transport, X_("Butler PTW: DS stop\n"));
+
+ 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);
+ }
+
for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
boost::shared_ptr<Track> tr = boost::dynamic_pointer_cast<Track> (*i);
if (tr) {
}
}
+ if (abort && did_record) {
+ _state_of_the_state = StateOfTheState (_state_of_the_state & ~InCleanup);
+ }
+
boost::shared_ptr<RouteList> r = routes.reader ();
for (RouteList::iterator i = r->begin(); i != r->end(); ++i) {
if (!synced_to_jack()) {
- Location *location = _locations.auto_loop_location();
+ Location *location = _locations->auto_loop_location();
if (location != 0) {
_transport_frame = location->start();
have_looped = false;
- send_full_time_code (0);
+ send_full_time_code (_transport_frame);
+ MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdStop));
+ send_mmc_locate (_transport_frame);
if ((ptw & PostTransportLocate) && get_record_enabled()) {
/* capture start has been changed, so save pending state */
play_loop = false;
}
- // can't cast away volatile so copy and emit that
- nframes64_t tframe = _transport_frame;
- PositionChanged (tframe); /* EMIT SIGNAL */
+ PositionChanged (_transport_frame); /* EMIT SIGNAL */
TransportStateChange (); /* EMIT SIGNAL */
/* and start it up again if relevant */
Location *loc;
- if (yn == play_loop || (actively_recording() && yn) || (loc = _locations.auto_loop_location()) == 0) {
+ 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 << 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 (nframes64_t target_frame, bool with_roll, bool with_flush, bool with_loop, bool force)
+Session::start_locate (framepos_t target_frame, bool with_roll, bool with_flush, bool with_loop, bool force)
{
if (synced_to_jack()) {
double sp;
- nframes64_t pos;
+ framepos_t pos;
_slave->speed_and_position (sp, pos);
}
int
-Session::micro_locate (nframes_t distance)
+Session::micro_locate (framecnt_t distance)
{
boost::shared_ptr<RouteList> rl = routes.reader();
for (RouteList::iterator i = rl->begin(); i != rl->end(); ++i) {
/** @param with_mmc true to send a MMC locate command when the locate is done */
void
-Session::locate (nframes64_t target_frame, bool with_roll, bool with_flush, bool with_loop, bool force, bool with_mmc)
+Session::locate (framepos_t target_frame, bool with_roll, bool with_flush, bool with_loop, bool force, bool with_mmc)
{
if (actively_recording() && !with_loop) {
return;
/* cancel looped playback if transport pos outside of loop range */
if (play_loop) {
- Location* al = _locations.auto_loop_location();
+ 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
_send_timecode_update = true;
if (with_mmc) {
- Timecode::Time time;
- timecode_time_subframes (_transport_frame, time);
- _mmc->send (MIDI::MachineControlCommand (time));
+ send_mmc_locate (_transport_frame);
}
Located (); /* EMIT SIGNAL */
if (tr) {
tr->realtime_set_speed (tr->speed(), true);
}
+ (*i)->automation_snapshot (_transport_frame, true);
}
Timecode::Time time;
timecode_time_subframes (_transport_frame, time);
- _mmc->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdDeferredPlay));
+ MIDI::Manager::instance()->mmc()->send (MIDI::MachineControlCommand (MIDI::MachineControl::cmdDeferredPlay));
TransportStateChange (); /* EMIT SIGNAL */
}
}
void
-Session::reset_rf_scale (nframes_t motion)
+Session::reset_rf_scale (framecnt_t motion)
{
cumulative_rf_motion += motion;
return;
}
- if (_mtc_port) {
- try {
- new_slave = new MTC_Slave (*this, *_mtc_port);
- }
-
- 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;
return;
}
- if (_midi_clock_port) {
- try {
- new_slave = new MIDIClock_Slave (*this, *_midi_clock_port, 24);
- }
-
- catch (failed_constructor& err) {
- return;
- }
-
- } else {
- error << _("No MIDI Clock port defined: MIDI Clock slaving is impossible.") << endmsg;
+ try {
+ new_slave = new MIDIClock_Slave (*this, *MIDI::Manager::instance()->midi_clock_input_port(), 24);
+ }
+
+ catch (failed_constructor& err) {
return;
}
break;
return;
}
+ if (config.get_video_pullup() != 0.0f) {
+ return;
+ }
+
new_slave = new JACK_Slave (_engine.jack());
break;
/* 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;
}
void
-Session::request_bounded_roll (nframes_t start, nframes_t end)
+Session::request_bounded_roll (framepos_t start, framepos_t end)
{
AudioRange ar (start, end, 0);
list<AudioRange> lar;
request_play_range (&lar, true);
}
void
-Session::request_roll_at_and_return (nframes_t start, nframes_t return_to)
+Session::request_roll_at_and_return (framepos_t start, framepos_t return_to)
{
SessionEvent *ev = new SessionEvent (SessionEvent::LocateRollLocate, SessionEvent::Add, SessionEvent::Immediate, return_to, 1.0);
ev->target2_frame = start;
void
Session::xrun_recovery ()
{
- // can't cast away volatile so copy and emit that
- nframes64_t tframe = _transport_frame;
- Xrun (tframe); //EMIT SIGNAL
+ Xrun (_transport_frame); //EMIT SIGNAL
if (Config->get_stop_recording_on_xrun() && actively_recording()) {
(*i)->handle_transport_stopped (abort, (ptw & PostTransportLocate), (!(ptw & PostTransportLocate) || pending_locate_flush));
}
- nframes_t old_latency = (*i)->output()->signal_latency ();
- nframes_t track_latency = (*i)->update_total_latency ();
+ framecnt_t old_latency = (*i)->output()->signal_latency ();
+ framecnt_t track_latency = (*i)->update_total_latency ();
if (old_latency != track_latency) {
(*i)->input()->update_port_total_latencies ();
}
bool
-Session::maybe_stop (nframes_t limit)
+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 ()) {
}
return false;
}
+
+void
+Session::send_mmc_locate (framepos_t t)
+{
+ 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