smokephil/ardour
1
0
Fork 0
mirror of https://github.com/Ardour/ardour.git synced 2025-12-06 14:54:56 +01:00
Code Issues Projects Releases Wiki Activity

remove "flush" argument from Session and TransportFSM locate APIs (it does nothing)

Browse source
This commit is contained in:
Paul Davis 2021-04-28 19:54:51 -06:00
parent 825c299feb
commit c7c5379fac
6 changed files with 28 additions and 32 deletions
Download patch file Download diff file Expand all files Collapse all files

2
libs/ardour/ardour/session.h
View file

@ -1337,7 +1337,7 @@ protected:
/* transport API */
void locate (samplepos_t, bool with_roll, bool with_flush, bool for_loop_end=false, bool force=false, bool with_mmc=true);
void locate (samplepos_t, bool with_roll, bool for_loop_end=false, bool force=false, bool with_mmc=true);
void stop_transport (bool abort = false, bool clear_state = false);
void start_transport ();
void butler_completed_transport_work ();

3
libs/ardour/ardour/transport_api.h
View file

@ -34,7 +34,8 @@ class LIBARDOUR_API TransportAPI
private:
friend struct TransportFSM;
virtual void locate (samplepos_t, bool with_roll, bool with_flush, bool with_loop=false, bool force=false, bool with_mmc=true) = 0;
virtual void locate (samplepos_t, bool with_roll, bool with_loop=false, bool force=false, bool with_mmc=true) = 0;
virtual bool should_stop_before_locate () const = 0;
virtual void stop_transport (bool abort = false, bool clear_state = false) = 0;
virtual void start_transport () = 0;
virtual void butler_completed_transport_work () = 0;

6
libs/ardour/ardour/transport_fsm.h
View file

@ -50,7 +50,6 @@ struct TransportFSM
bool clear_state;
/* for locate */
LocateTransportDisposition ltd;
bool with_flush;
samplepos_t target;
bool for_loop_end;
bool force;
@ -63,7 +62,6 @@ struct TransportFSM
, abort_capture (false)
, clear_state (false)
, ltd (MustStop)
, with_flush (false)
, target (0)
, for_loop_end (false)
, force (false)
@ -76,19 +74,17 @@ struct TransportFSM
, abort_capture (ab)
, clear_state (cl)
, ltd (MustStop)
, with_flush (false)
, target (0)
, for_loop_end (false)
, force (false)
{
assert (t == StopTransport);
}
Event (EventType t, samplepos_t pos, LocateTransportDisposition l, bool fl, bool lp, bool f4c)
Event (EventType t, samplepos_t pos, LocateTransportDisposition l, bool lp, bool f4c)
: type (t)
, abort_capture (false)
, clear_state (false)
, ltd (l)
, with_flush (fl)
, target (pos)
, for_loop_end (lp)
, force (f4c)

20
libs/ardour/session_process.cc
View file

@ -64,7 +64,7 @@ using namespace std;
#define TFSM_ROLL() { _transport_fsm->enqueue (new TransportFSM::Event (TransportFSM::StartTransport)); }
#define TFSM_STOP(abort,clear) { _transport_fsm->enqueue (new TransportFSM::Event (TransportFSM::StopTransport,abort,clear)); }
#define TFSM_SPEED(speed,as_default) { _transport_fsm->enqueue (new TransportFSM::Event (speed,as_default)); }
#define TFSM_LOCATE(target,ltd,flush,loop,force) { _transport_fsm->enqueue (new TransportFSM::Event (TransportFSM::Locate,target,ltd,flush,loop,force)); }
#define TFSM_LOCATE(target,ltd,loop,force) { _transport_fsm->enqueue (new TransportFSM::Event (TransportFSM::Locate,target,ltd,loop,force)); }
/** Called by the audio engine when there is work to be done with JACK.
@ -873,9 +873,9 @@ Session::process_event (SessionEvent* ev)
loop range.
*/
if (play_loop) {
/* roll after locate, do not flush, set "for loop end" true
/* roll after locate, set "for loop end" true
*/
TFSM_LOCATE (ev->target_sample, MustRoll, false, true, false);
TFSM_LOCATE (ev->target_sample, MustRoll, true, false);
}
remove = false;
del = false;
@ -884,19 +884,19 @@ Session::process_event (SessionEvent* ev)
case SessionEvent::Locate:
/* args: do not roll after locate, clear state, not for loop, force */
DEBUG_TRACE (DEBUG::Transport, string_compose ("sending locate to %1 to tfsm\n", ev->target_sample));
TFSM_LOCATE (ev->target_sample, ev->locate_transport_disposition, true, false, ev->yes_or_no);
TFSM_LOCATE (ev->target_sample, ev->locate_transport_disposition, false, ev->yes_or_no);
_send_timecode_update = true;
break;
case SessionEvent::LocateRoll:
/* args: roll after locate, clear state if not looping, not for loop, force */
TFSM_LOCATE (ev->target_sample, MustRoll, !play_loop, false, ev->yes_or_no);
TFSM_LOCATE (ev->target_sample, MustRoll, false, ev->yes_or_no);
_send_timecode_update = true;
break;
case SessionEvent::Skip:
if (Config->get_skip_playback()) {
TFSM_LOCATE (ev->target_sample, MustRoll, true, false, false);
TFSM_LOCATE (ev->target_sample, MustRoll, false, false);
_send_timecode_update = true;
}
remove = false;
@ -906,7 +906,7 @@ Session::process_event (SessionEvent* ev)
case SessionEvent::LocateRollLocate:
// locate is handled by ::request_roll_at_and_return()
_requested_return_sample = ev->target_sample;
TFSM_LOCATE (ev->target2_sample, MustRoll, true, false, false);
TFSM_LOCATE (ev->target2_sample, MustRoll, false, false);
_send_timecode_update = true;
break;
@ -957,8 +957,8 @@ Session::process_event (SessionEvent* ev)
break;
case SessionEvent::RangeLocate:
/* args: roll after locate, do flush, not with loop */
TFSM_LOCATE (ev->target_sample, MustRoll, true, false, false);
/* args: roll after locate, not with loop */
TFSM_LOCATE (ev->target_sample, MustRoll, false, false);
remove = false;
del = false;
break;
@ -1520,7 +1520,7 @@ Session::implement_master_strategy ()
break;
case TransportMasterLocate:
transport_master_strategy.action = TransportMasterWait;
TFSM_LOCATE(transport_master_strategy.target, transport_master_strategy.roll_disposition, true, false, false);
TFSM_LOCATE(transport_master_strategy.target, transport_master_strategy.roll_disposition, false, false);
break;
case TransportMasterStart:
TFSM_EVENT (TransportFSM::StartTransport);

14
libs/ardour/session_transport.cc
View file

@ -85,7 +85,7 @@ using namespace PBD;
#define TFSM_EVENT(evtype) { _transport_fsm->enqueue (new TransportFSM::Event (evtype)); }
#define TFSM_STOP(abort,clear) { _transport_fsm->enqueue (new TransportFSM::Event (TransportFSM::StopTransport,abort,clear)); }
#define TFSM_LOCATE(target,ltd,flush,loop,force) { _transport_fsm->enqueue (new TransportFSM::Event (TransportFSM::Locate,target,ltd,flush,loop,force)); }
#define TFSM_LOCATE(target,ltd,loop,force) { _transport_fsm->enqueue (new TransportFSM::Event (TransportFSM::Locate,target,ltd,loop,force)); }
#define TFSM_SPEED(speed,as_default) { _transport_fsm->enqueue (new TransportFSM::Event (speed,as_default)); }
/* *****************************************************************************
@ -195,7 +195,7 @@ Session::realtime_stop (bool abort, bool clear_state)
/** @param with_mmc true to send a MMC locate command when the locate is done */
void
Session::locate (samplepos_t target_sample, bool with_roll, bool with_flush, bool for_loop_end, bool force, bool with_mmc)
Session::locate (samplepos_t target_sample, bool with_roll, bool for_loop_end, bool force, bool with_mmc)
{
ENSURE_PROCESS_THREAD;
@ -214,8 +214,8 @@ Session::locate (samplepos_t target_sample, bool with_roll, bool with_flush, boo
* changes in the value of _transport_sample.
*/
DEBUG_TRACE (DEBUG::Transport, string_compose ("rt-locate to %1 ts = %7, roll %2 flush %3 for loop end %4 force %5 mmc %6\n",
target_sample, with_roll, with_flush, for_loop_end, force, with_mmc, _transport_sample));
DEBUG_TRACE (DEBUG::Transport, string_compose ("rt-locate to %1 ts = %7, roll %2 for loop end %3 force %4 mmc %5\n",
target_sample, with_roll, for_loop_end, force, with_mmc, _transport_sample));
if (!force && (_transport_sample == target_sample) && !for_loop_end) {
@ -1639,12 +1639,12 @@ Session::set_play_loop (bool yn, bool change_transport_state)
/* set loop_changing to ensure that non_realtime_stop does not unset_play_loop */
loop_changing = true;
}
/* args: position, disposition, flush=true, for_loop_end=false, force=true */
TFSM_LOCATE (loc->start(), MustRoll, true, false, true);
/* args: position, disposition, for_loop_end=false, force=true */
TFSM_LOCATE (loc->start(), MustRoll, false, true);
} else {
if (!transport_rolling()) {
/* loop-is-mode: not rolling, just locate to loop start */
TFSM_LOCATE (loc->start(), MustStop, true, false, true);
TFSM_LOCATE (loc->start(), MustStop, false, true);
}
}
TransportStateChange (); /* EMIT SIGNAL */

15
libs/ardour/transport_fsm.cc
View file

@ -56,7 +56,7 @@ TransportFSM::Event::operator delete (void *ptr, size_t /*size*/)
}
TransportFSM::TransportFSM (TransportAPI& tapi)
: _last_locate (Locate, 0, MustRoll, false, false, false) /* all but first argument don't matter */
: _last_locate (Locate, 0, MustRoll, false, false) /* all but first argument don't matter */
, last_speed_request (0, false) /* SetSpeed request */
, api (&tapi)
, processing (0)
@ -292,9 +292,8 @@ TransportFSM::process_event (Event& ev, bool already_deferred, bool& deferred)
break;
case Locate:
DEBUG_TRACE (DEBUG::TFSMEvents, string_compose ("locate, ltd = %1 flush = %2 target = %3 loop %4 force %5\n",
DEBUG_TRACE (DEBUG::TFSMEvents, string_compose ("locate, ltd = %1 target = %2 loop %3 force %4\n",
enum_2_string (ev.ltd),
ev.with_flush,
ev.target,
ev.for_loop_end,
ev.force));
@ -490,7 +489,7 @@ TransportFSM::start_locate_while_stopped (Event const & l) const
set_roll_after (compute_should_roll (l.ltd));
api->locate (l.target, current_roll_after_locate_status.get(), l.with_flush, l.for_loop_end, l.force);
api->locate (l.target, current_roll_after_locate_status.get(), l.for_loop_end, l.force);
}
bool
@ -525,7 +524,7 @@ TransportFSM::locate_for_loop (Event const & l)
const bool should_roll = compute_should_roll (l.ltd);
current_roll_after_locate_status = should_roll;
_last_locate = l;
api->locate (l.target, should_roll, l.with_flush, l.for_loop_end, l.force);
api->locate (l.target, should_roll, l.for_loop_end, l.force);
}
void
@ -535,7 +534,7 @@ TransportFSM::start_locate_after_declick () const
current_roll_after_locate_status ? current_roll_after_locate_status.get() : compute_should_roll (_last_locate.ltd)));
const bool roll = current_roll_after_locate_status ? current_roll_after_locate_status.get() : compute_should_roll (_last_locate.ltd);
api->locate (_last_locate.target, roll, _last_locate.with_flush, _last_locate.for_loop_end, _last_locate.force);
api->locate (_last_locate.target, roll, _last_locate.for_loop_end, _last_locate.force);
}
void
@ -564,7 +563,7 @@ TransportFSM::interrupt_locate (Event const & l) const
* we are interrupting the locate to start a new one.
*/
_last_locate = l;
api->locate (l.target, false, l.with_flush, l.for_loop_end, l.force);
api->locate (l.target, false, l.for_loop_end, l.force);
}
void
@ -705,7 +704,7 @@ TransportFSM::set_speed (Event const & ev)
last_speed_request = ev;
transition (Reversing);
Event lev (Locate, api->position(), must_roll ? MustRoll : MustStop, false, false, true);
Event lev (Locate, api->position(), must_roll ? MustRoll : MustStop, false, true);
transition (DeclickToLocate);
start_declick_for_locate (lev);