/*
- Copyright (C) 2000 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
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
-
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
-
- You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
-
-*/
+ * Copyright (C) 2000-2019 Paul Davis <paul@linuxaudiosystems.com>
+ * Copyright (C) 2005-2009 Taybin Rutkin <taybin@taybin.com>
+ * Copyright (C) 2006-2007 Jesse Chappell <jesse@essej.net>
+ * Copyright (C) 2006-2009 Sampo Savolainen <v2@iki.fi>
+ * Copyright (C) 2006-2015 David Robillard <d@drobilla.net>
+ * Copyright (C) 2007-2012 Carl Hetherington <carl@carlh.net>
+ * Copyright (C) 2007-2015 Tim Mayberry <mojofunk@gmail.com>
+ * Copyright (C) 2008-2009 Hans Baier <hansfbaier@googlemail.com>
+ * Copyright (C) 2008-2009 Sakari Bergen <sakari.bergen@beatwaves.net>
+ * Copyright (C) 2012-2019 Robin Gareus <robin@gareus.org>
+ * Copyright (C) 2013-2017 Nick Mainsbridge <mainsbridge@gmail.com>
+ * Copyright (C) 2013-2018 John Emmas <john@creativepost.co.uk>
+ * Copyright (C) 2014-2018 Ben Loftis <ben@harrisonconsoles.com>
+ * Copyright (C) 2015-2018 Len Ovens <len@ovenwerks.net>
+ *
+ * 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
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program; if not, write to the Free Software Foundation, Inc.,
+ * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
+ */
#ifndef __ardour_session_h__
#define __ardour_session_h__
#include "ardour/presentation_info.h"
#include "ardour/route.h"
#include "ardour/route_graph.h"
-
+#include "ardour/transport_api.h"
class XMLTree;
class XMLNode;
struct _AEffect;
typedef struct _AEffect AEffect;
+class PTFFormat;
+
namespace MIDI {
class Port;
class MachineControl;
class Bundle;
class Butler;
class Click;
-class ControllableDescriptor;
class CoreSelection;
class ExportHandler;
class ExportStatus;
class SessionDirectory;
class SessionMetadata;
class SessionPlaylists;
-class Slave;
class Source;
class Speakers;
class TempoMap;
+class TransportMaster;
+struct TransportFSM;
class Track;
+class UI_TransportMaster;
class VCAManager;
class WindowsVSTPlugin;
};
/** Ardour Session */
-class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::ScopedConnectionList, public SessionEventManager
+class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::ScopedConnectionList, public SessionEventManager, public TransportAPI
{
private:
- enum SubState {
- PendingDeclickIn = 0x1, ///< pending de-click fade-in for start
- PendingDeclickOut = 0x2, ///< pending de-click fade-out for stop
- StopPendingCapture = 0x4,
- PendingLoopDeclickIn = 0x8, ///< pending de-click fade-in at the start of a loop
- PendingLoopDeclickOut = 0x10, ///< pending de-click fade-out at the end of a loop
- PendingLocate = 0x20,
- };
public:
enum RecordState {
bool path_is_within_session (const std::string&);
bool writable() const { return _writable; }
- void set_dirty ();
- void set_clean ();
- bool dirty() const { return _state_of_the_state & Dirty; }
- void set_deletion_in_progress ();
- void clear_deletion_in_progress ();
- bool reconnection_in_progress() const { return _reconnecting_routes_in_progress; }
- bool deletion_in_progress() const { return _state_of_the_state & Deletion; }
- bool routes_deletion_in_progress() const { return _route_deletion_in_progress; }
- bool peaks_cleanup_in_progres() const { return _state_of_the_state & PeakCleanup; }
- bool loading () const { return _state_of_the_state & Loading; }
+ void set_clean (); // == Clean and emit DirtyChanged IFF session was Dirty
+ void set_dirty (); // |= Dirty and emit DirtyChanged (unless already dirty or Loading, Deletion)
+ void unset_dirty (bool emit_dirty_changed = false); // &= ~Dirty
+ void set_deletion_in_progress (); // |= Deletion
+ void clear_deletion_in_progress (); // &= ~Deletion
+
+ bool reconnection_in_progress () const { return _reconnecting_routes_in_progress; }
+ bool routes_deletion_in_progress () const { return _route_deletion_in_progress; }
+ bool dirty () const { return _state_of_the_state & Dirty; }
+ bool deletion_in_progress () const { return _state_of_the_state & Deletion; }
+ bool peaks_cleanup_in_progres () const { return _state_of_the_state & PeakCleanup; }
+ bool loading () const { return _state_of_the_state & Loading; }
+ bool cannot_save () const { return _state_of_the_state & CannotSave; }
+ bool in_cleanup () const { return _state_of_the_state & InCleanup; }
+ bool inital_connect_or_deletion_in_progress () { return _state_of_the_state & (InitialConnecting | Deletion); }
PBD::Signal0<void> DirtyChanged;
boost::shared_ptr<RTTaskList> rt_tasklist () { return _rt_tasklist; }
+ RouteList get_routelist (bool mixer_order = false, PresentationInfo::Flag fl = PresentationInfo::MixerRoutes) const;
+
CoreSelection& selection () { return *_selection; }
/* because the set of Stripables consists of objects managed
* with get_routes()
*/
- void get_stripables (StripableList&) const;
+ void get_stripables (StripableList&, PresentationInfo::Flag fl = PresentationInfo::MixerStripables) const;
StripableList get_stripables () const;
boost::shared_ptr<RouteList> get_tracks() const;
boost::shared_ptr<RouteList> get_routes_with_internal_returns() const;
boost::shared_ptr<RouteList> get_routes_with_regions_at (samplepos_t const) const;
+ boost::shared_ptr<AudioTrack> get_nth_audio_track (int nth) const;
+
uint32_t nstripables (bool with_monitor = false) const;
uint32_t nroutes() const { return routes.reader()->size(); }
uint32_t ntracks () const;
uint32_t nbusses () const;
+ bool plot_process_graph (std::string const& file_name) const;
+
boost::shared_ptr<BundleList> bundles () {
return _bundles.reader ();
}
PBD::Signal0<void> IOConnectionsComplete;
- /* Timecode status signals */
- PBD::Signal1<void, bool> MTCSyncStateChanged;
- PBD::Signal1<void, bool> LTCSyncStateChanged;
-
/* Record status signals */
PBD::Signal0<void> RecordStateChanged; /* signals changes in recording state (i.e. are we recording) */
*/
PBD::Signal2<void, RouteGroup *, boost::weak_ptr<Route> > RouteRemovedFromRouteGroup;
+ /** Emitted when a foldback send is created or deleted
+ */
+ PBD::Signal0<void> FBSendsChanged;
+
/* Step Editing status changed */
PBD::Signal1<void,bool> StepEditStatusChange;
void request_roll_at_and_return (samplepos_t start, samplepos_t return_to);
void request_bounded_roll (samplepos_t start, samplepos_t end);
- void request_stop (bool abort = false, bool clear_state = false);
- void request_locate (samplepos_t sample, bool with_roll = false);
+ void request_stop (bool abort = false, bool clear_state = false, TransportRequestSource origin = TRS_UI);
+ void request_locate (samplepos_t sample, bool with_roll = false, TransportRequestSource origin = TRS_UI);
void request_play_loop (bool yn, bool leave_rolling = false);
bool get_play_loop () const { return play_loop; }
void goto_start (bool and_roll = false);
void use_rf_shuttle_speed ();
void allow_auto_play (bool yn);
- void request_transport_speed (double speed, bool as_default = true);
- void request_transport_speed_nonzero (double, bool as_default = true);
+ void request_transport_speed (double speed, bool as_default = true, TransportRequestSource origin = TRS_UI);
+ void request_transport_speed_nonzero (double, bool as_default = true, TransportRequestSource origin = TRS_UI);
void request_overwrite_buffer (boost::shared_ptr<Route>);
void adjust_playback_buffering();
void adjust_capture_buffering();
bool global_locate_pending() const { return _global_locate_pending; }
- bool locate_pending() const { return static_cast<bool>(post_transport_work()&PostTransportLocate); }
- bool declick_out_pending() const { return static_cast<bool>(transport_sub_state&(PendingDeclickOut)); }
+ bool locate_pending() const;
+ bool declick_in_progress () const;
bool transport_locked () const;
int wipe ();
void set_auto_punch_location (Location *);
void set_auto_loop_location (Location *);
void set_session_extents (samplepos_t start, samplepos_t end);
- bool end_is_free () const { return _session_range_end_is_free; }
- void set_end_is_free (bool);
+ bool session_range_is_free () const { return _session_range_is_free; }
+ void set_session_range_is_free (bool);
pframes_t get_block_size () const { return current_block_size; }
samplecnt_t worst_output_latency () const { return _worst_output_latency; }
PeakCleanup = 0x40
};
- StateOfTheState state_of_the_state() const { return _state_of_the_state; }
-
class StateProtector {
public:
StateProtector (Session* s) : _session (s) {
samplepos_t requested_return_sample() const { return _requested_return_sample; }
void set_requested_return_sample(samplepos_t return_to);
+ bool compute_audible_delta (samplepos_t& pos_and_delta) const;
samplecnt_t remaining_latency_preroll () const { return _remaining_latency_preroll; }
enum PullupFormat {
static PBD::Signal1<void, samplepos_t> StartTimeChanged;
static PBD::Signal1<void, samplepos_t> EndTimeChanged;
- void request_sync_source (Slave*);
- bool synced_to_engine() const { return _slave && config.get_external_sync() && Config->get_sync_source() == Engine; }
- bool synced_to_mtc () const { return config.get_external_sync() && Config->get_sync_source() == MTC && g_atomic_int_get (const_cast<gint*>(&_mtc_active)); }
- bool synced_to_ltc () const { return config.get_external_sync() && Config->get_sync_source() == LTC && g_atomic_int_get (const_cast<gint*>(&_ltc_active)); }
+ void request_sync_source (boost::shared_ptr<TransportMaster>);
+ bool synced_to_engine() const;
double engine_speed() const { return _engine_speed; }
double actual_speed() const {
return 0;
}
double transport_speed() const { return _count_in_samples > 0 ? 0. : _transport_speed; }
- bool transport_stopped() const { return _transport_speed == 0.0; }
- bool transport_rolling() const { return _transport_speed != 0.0 && _count_in_samples == 0 && _remaining_latency_preroll == 0; }
+ bool transport_stopped() const;
+ bool transport_rolling() const;
bool silent () { return _silent; }
TempoMap& tempo_map() { return *_tempo_map; }
const TempoMap& tempo_map() const { return *_tempo_map; }
+ void maybe_update_tempo_from_midiclock_tempo (float bpm);
unsigned int get_xrun_count () const {return _xrun_count; }
void reset_xrun_count () {_xrun_count = 0; }
int destroy_sources (std::list<boost::shared_ptr<Source> >);
int remove_last_capture ();
+ void get_last_capture_sources (std::list<boost::shared_ptr<Source> >&);
/** handlers should return 0 for "everything OK", and any other value for
* "cannot setup audioengine".
PBD::Signal0<void> MuteChanged;
PBD::Signal0<void> IsolatedChanged;
PBD::Signal0<void> MonitorChanged;
+ PBD::Signal0<void> MonitorBusAddedOrRemoved;
PBD::Signal0<void> session_routes_reconnected;
/* monitor/master out */
int add_master_bus (ChanCount const&);
- void add_monitor_section ();
void reset_monitor_section ();
- void remove_monitor_section ();
bool monitor_active() const { return (_monitor_out && _monitor_out->monitor_control () && _monitor_out->monitor_control ()->monitor_active()); }
boost::shared_ptr<Route> monitor_out() const { return _monitor_out; }
boost::shared_ptr<PBD::Controllable> controllable_by_id (const PBD::ID&);
boost::shared_ptr<AutomationControl> automation_control_by_id (const PBD::ID&);
- boost::shared_ptr<PBD::Controllable> controllable_by_descriptor (const ARDOUR::ControllableDescriptor&);
void add_controllable (boost::shared_ptr<PBD::Controllable>);
- void remove_controllable (PBD::Controllable*);
boost::shared_ptr<PBD::Controllable> solo_cut_control() const;
enum PostTransportWork {
PostTransportStop = 0x1,
- PostTransportDuration = 0x2,
+ /* PostTransportDuration */
PostTransportLocate = 0x4,
PostTransportRoll = 0x8,
PostTransportAbort = 0x10,
PostTransportOverWrite = 0x20,
- PostTransportSpeed = 0x40,
+ /* PostTransportSpeed = 0x40, */
PostTransportAudition = 0x80,
PostTransportReverse = 0x100,
- PostTransportInputChange = 0x200,
- PostTransportCurveRealloc = 0x400,
+ /* PostTransportInputChange = 0x200, */
+ /*PostTransportCurveRealloc = 0x400, */
PostTransportClearSubstate = 0x800,
PostTransportAdjustPlaybackBuffering = 0x1000,
PostTransportAdjustCaptureBuffering = 0x2000
};
- enum SlaveState {
- Stopped,
- Waiting,
- Running
- };
-
- SlaveState slave_state() const { return _slave_state; }
- Slave* slave() const { return _slave; }
-
- boost::shared_ptr<SessionPlaylists> playlists;
+ boost::shared_ptr<SessionPlaylists> playlists () const { return _playlists; }
void send_mmc_locate (samplepos_t);
void queue_full_time_code () { _send_timecode_update = true; }
/* synchronous MIDI ports used for synchronization */
boost::shared_ptr<MidiPort> midi_clock_output_port () const;
- boost::shared_ptr<MidiPort> midi_clock_input_port () const;
boost::shared_ptr<MidiPort> mtc_output_port () const;
- boost::shared_ptr<MidiPort> mtc_input_port () const;
- boost::shared_ptr<Port> ltc_input_port() const;
boost::shared_ptr<Port> ltc_output_port() const;
- boost::shared_ptr<IO> ltc_input_io() { return _ltc_input; }
boost::shared_ptr<IO> ltc_output_io() { return _ltc_output; }
MIDI::MachineControl& mmc() { return *_mmc; }
void reconnect_midi_scene_ports (bool);
- void reconnect_mtc_ports ();
void reconnect_mmc_ports (bool);
- void reconnect_ltc_input ();
void reconnect_ltc_output ();
VCAManager& vca_manager() { return *_vca_manager; }
void auto_connect_thread_wakeup ();
+ double compute_speed_from_master (pframes_t nframes);
+ bool transport_master_is_external() const;
+ bool transport_master_no_external_or_using_engine() const;
+ boost::shared_ptr<TransportMaster> transport_master() const;
+
+ void import_pt (PTFFormat& ptf, ImportStatus& status);
+ bool import_sndfile_as_region (std::string path, SrcQuality quality, samplepos_t& pos, SourceList& sources, ImportStatus& status);
protected:
friend class AudioEngine;
#endif
friend class Route;
- void schedule_curve_reallocation ();
void update_latency_compensation (bool force = false);
+ /* transport API */
+
+ void locate (samplepos_t, bool with_roll, bool with_flush, bool with_loop=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 ();
+ void post_locate ();
+ void schedule_butler_for_transport_work ();
+ bool should_roll_after_locate () const;
+
private:
int create (const std::string& mix_template, BusProfile*);
void destroy ();
static void init_name_id_counter (guint n);
static unsigned int name_id_counter ();
+ boost::shared_ptr<SessionPlaylists> _playlists;
+
/* stuff used in process() should be close together to
maximise cache hits
*/
process_function_type last_process_function;
bool _bounce_processing_active;
bool waiting_for_sync_offset;
- samplecnt_t _base_sample_rate; // sample-rate of the session at creation time, "native" SR
+ samplecnt_t _base_sample_rate; // sample-rate of the session at creation time, "native" SR
samplecnt_t _nominal_sample_rate; // overridden by audioengine setting
samplecnt_t _current_sample_rate; // this includes video pullup offset
- int transport_sub_state;
mutable gint _record_status;
samplepos_t _transport_sample;
gint _seek_counter;
Location* _session_range_location; ///< session range, or 0 if there is nothing in the session yet
- bool _session_range_end_is_free;
- Slave* _slave;
+ bool _session_range_is_free;
bool _silent;
samplecnt_t _remaining_latency_preroll;
- // varispeed playback
+ // varispeed playback -- TODO: move out of session to backend.
double _engine_speed;
- double _transport_speed;
+ double _transport_speed; // only: -1, 0, +1
double _default_transport_speed;
double _last_transport_speed;
double _signalled_varispeed;
double _target_transport_speed;
- CubicInterpolation interpolation;
bool auto_play_legal;
- samplepos_t _last_slave_transport_sample;
samplepos_t _requested_return_sample;
pframes_t current_block_size;
samplecnt_t _worst_output_latency;
std::string _missing_file_replacement;
- void mtc_status_changed (bool);
- PBD::ScopedConnection mtc_status_connection;
- void ltc_status_changed (bool);
- PBD::ScopedConnection ltc_status_connection;
+ void add_monitor_section ();
+ void remove_monitor_section ();
void initialize_latencies ();
void update_latency (bool playback);
static const samplecnt_t bounce_chunk_size;
- /* slave tracking */
+ /* Transport master DLL */
- static const int delta_accumulator_size = 25;
- int delta_accumulator_cnt;
- int32_t delta_accumulator[delta_accumulator_size];
- int32_t average_slave_delta;
- int average_dir;
- bool have_first_delta_accumulator;
+ enum TransportMasterState {
+ Stopped, /* no incoming or invalid signal/data for master to run with */
+ Waiting, /* waiting to get full lock on incoming signal/data */
+ Running /* lock achieved, master is generating meaningful speed & position */
+ };
- SlaveState _slave_state;
- gint _mtc_active;
- gint _ltc_active;
- samplepos_t slave_wait_end;
+ TransportMasterState transport_master_tracking_state;
+ samplepos_t master_wait_end;
+ void track_transport_master (float slave_speed, samplepos_t slave_transport_sample);
+ bool follow_transport_master (pframes_t nframes);
+ void sync_source_changed (SyncSource, samplepos_t pos, pframes_t cycle_nframes);
void reset_slave_state ();
- bool follow_slave (pframes_t);
- void calculate_moving_average_of_slave_delta (int dir, samplecnt_t this_delta);
- void track_slave_state (float slave_speed, samplepos_t slave_transport_sample, samplecnt_t this_delta);
-
- void switch_to_sync_source (SyncSource); /* !RT context */
- void drop_sync_source (); /* !RT context */
- void use_sync_source (Slave*); /* RT context */
bool post_export_sync;
samplepos_t post_export_position;
int pre_export ();
int stop_audio_export ();
- void finalize_audio_export ();
+ void finalize_audio_export (TransportRequestSource trs);
void finalize_export_internal (bool stop_freewheel);
bool _pre_export_mmc_enabled;
-1 if there is a pending declick fade-out,
0 if there is no pending declick.
*/
- int get_transport_declick_required () {
- if (transport_sub_state & PendingDeclickIn) {
- transport_sub_state &= ~PendingDeclickIn;
- return 1;
- } else if (transport_sub_state & PendingDeclickOut) {
- /* XXX: not entirely sure why we don't clear this */
- return -1;
- } else if (transport_sub_state & PendingLoopDeclickOut) {
- /* Return the declick out first ... */
- transport_sub_state &= ~PendingLoopDeclickOut;
- return -1;
- } else if (transport_sub_state & PendingLoopDeclickIn) {
- /* ... then the declick in on the next call */
- transport_sub_state &= ~PendingLoopDeclickIn;
- return 1;
- } else {
- return 0;
- }
- }
-
bool maybe_stop (samplepos_t limit);
bool maybe_sync_start (pframes_t &);
- void check_declick_out ();
-
std::string _path;
std::string _name;
bool _is_new;
pframes_t _pframes_since_last_mtc;
bool play_loop;
bool loop_changing;
- samplepos_t last_loopend;
+ samplepos_t last_loopend;
boost::scoped_ptr<SessionDirectory> _session_dir;
samplepos_t _last_roll_or_reversal_location;
samplepos_t _last_record_location;
- bool pending_locate_roll;
- samplepos_t pending_locate_sample;
- bool pending_locate_flush;
bool pending_abort;
bool pending_auto_loop;
Butler* _butler;
+ TransportFSM* _transport_fsm;
+
static const PostTransportWork ProcessCannotProceedMask =
PostTransportWork (
- PostTransportInputChange|
- PostTransportReverse|
- PostTransportCurveRealloc|
PostTransportAudition|
- PostTransportStop|
PostTransportClearSubstate);
gint _post_transport_work; /* accessed only atomic ops */
void schedule_playback_buffering_adjustment ();
void schedule_capture_buffering_adjustment ();
- uint32_t cumulative_rf_motion;
- uint32_t rf_scale;
-
- void set_rf_speed (float speed);
- void reset_rf_scale (samplecnt_t samples_moved);
-
Locations* _locations;
void location_added (Location*);
void location_removed (Location*);
ChanCount output_offset;
};
+ Glib::Threads::Mutex _update_latency_lock;
+
typedef std::queue<AutoConnectRequest> AutoConnectQueue;
Glib::Threads::Mutex _auto_connect_queue_lock;
AutoConnectQueue _auto_connect_queue;
double ltc_speed;
int32_t ltc_enc_byte;
- samplepos_t ltc_enc_pos;
+ samplepos_t ltc_enc_pos;
double ltc_enc_cnt;
- samplepos_t ltc_enc_off;
+ samplepos_t ltc_enc_off;
bool restarting;
- samplepos_t ltc_prev_cycle;
+ samplepos_t ltc_prev_cycle;
- samplepos_t ltc_timecode_offset;
+ samplepos_t ltc_timecode_offset;
bool ltc_timecode_negative_offset;
LatencyRange ltc_out_latency;
int start_midi_thread ();
+ bool should_ignore_transport_request (TransportRequestSource, TransportRequestType) const;
+
void set_play_loop (bool yn, double speed);
void unset_play_loop ();
void overwrite_some_buffers (Track *);
void flush_all_inserts ();
int micro_locate (samplecnt_t distance);
- void locate (samplepos_t, bool with_roll, bool with_flush, bool with_loop=false, bool force=false, bool with_mmc=true);
- void start_locate (samplepos_t, bool with_roll, bool with_flush, bool for_loop_enabled=false, bool force=false);
+
+ void do_locate (samplepos_t, bool with_roll, bool with_flush, bool for_loop_enabled, bool force, bool with_mmc);
void force_locate (samplepos_t sample, bool with_roll = false);
void set_transport_speed (double speed, samplepos_t destination_sample, bool abort = false, bool clear_state = false, bool as_default = false);
- void stop_transport (bool abort = false, bool clear_state = false);
- void start_transport ();
void realtime_stop (bool abort, bool clear_state);
void realtime_locate ();
void non_realtime_start_scrub ();
void non_realtime_locate ();
void non_realtime_stop (bool abort, int entry_request_count, bool& finished);
void non_realtime_overwrite (int entry_request_count, bool& finished);
- void post_transport ();
void engine_halted ();
+ void engine_running ();
void xrun_recovery ();
void set_track_loop (bool);
bool select_playhead_priority_target (samplepos_t&);
mutable Glib::Threads::Mutex source_lock;
public:
+
+ /* Emited when a new source is added to the session */
+ PBD::Signal1< void, boost::shared_ptr<Source> > SourceAdded;
+ PBD::Signal1< void, boost::shared_ptr<Source> > SourceRemoved;
+
typedef std::map<PBD::ID,boost::shared_ptr<Source> > SourceMap;
+ void foreach_source (boost::function<void( boost::shared_ptr<Source> )> f) {
+ Glib::Threads::Mutex::Lock ls (source_lock);
+ for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
+ f ( (*i).second );
+ }
+ }
+
+ bool playlist_is_active( boost::shared_ptr<Playlist>);
+
private:
void reset_write_sources (bool mark_write_complete, bool force = false);
SourceMap sources;
XMLNode& get_template ();
/* click track */
- typedef std::list<Click*> Clicks;
- Clicks clicks;
- bool _clicking;
- bool _click_rec_only;
- boost::shared_ptr<IO> _click_io;
- boost::shared_ptr<Amp> _click_gain;
- Sample* click_data;
- Sample* click_emphasis_data;
- samplecnt_t click_length;
- samplecnt_t click_emphasis_length;
- mutable Glib::Threads::RWLock click_lock;
+ typedef std::list<Click*> Clicks;
+ Clicks clicks;
+ bool _clicking;
+ bool _click_rec_only;
+ boost::shared_ptr<IO> _click_io;
+ boost::shared_ptr<Amp> _click_gain;
+ Sample* click_data;
+ Sample* click_emphasis_data;
+ samplecnt_t click_length;
+ samplecnt_t click_emphasis_length;
+ mutable Glib::Threads::RWLock click_lock;
static const Sample default_click[];
static const samplecnt_t default_click_length;
static const Sample default_click_emphasis[];
static const samplecnt_t default_click_emphasis_length;
- Click *get_click();
+ Click* get_click();
samplepos_t _clicks_cleared;
- void setup_click_sounds (int which);
- void setup_click_sounds (Sample**, Sample const *, samplecnt_t*, samplecnt_t, std::string const &);
- void clear_clicks ();
- void click (samplepos_t start, samplecnt_t nframes);
- void run_click (samplepos_t start, samplecnt_t nframes);
- void add_click (samplepos_t pos, bool emphasis);
samplecnt_t _count_in_samples;
+ void setup_click_sounds (int which);
+ void setup_click_sounds (Sample**, Sample const *, samplecnt_t*, samplecnt_t, std::string const &);
+ void clear_clicks ();
+ void click (samplepos_t start, samplecnt_t nframes);
+ void run_click (samplepos_t start, samplecnt_t nframes);
+ void add_click (samplepos_t pos, bool emphasis);
/* range playback */
MidiClockTicker* midi_clock;
- boost::shared_ptr<IO> _ltc_input;
boost::shared_ptr<IO> _ltc_output;
boost::shared_ptr<RTTaskList> _rt_tasklist;
projects / ardour.git / blobdiff