#include <boost/weak_ptr.hpp>
#include <boost/utility.hpp>
-#include <glibmm/thread.h>
+#include <glibmm/threads.h>
#include "pbd/error.h"
#include "pbd/event_loop.h"
#include "midi++/types.h"
#include "timecode/time.h"
+#include "ltc/ltc.h"
#include "ardour/ardour.h"
#include "ardour/chan_count.h"
+#include "ardour/delivery.h"
+#include "ardour/interthread_info.h"
#include "ardour/rc_configuration.h"
#include "ardour/session_configuration.h"
#include "ardour/session_event.h"
#include <jack/session.h>
#endif
+
class XMLTree;
class XMLNode;
struct _AEffect;
namespace ARDOUR {
+class Amp;
class AudioEngine;
class AudioFileSource;
class AudioRegion;
class IO;
class IOProcessor;
class ImportStatus;
+class MidiClockTicker;
class MidiControlUI;
class MidiRegion;
class MidiSource;
class MidiTrack;
-class NamedSelection;
class Playlist;
class PluginInsert;
+class PluginInfo;
class Port;
class PortInsert;
class ProcessThread;
const SessionDirectory& session_directory () const { return *(_session_dir.get()); }
- static PBD::Signal0<void> AutoBindingOn;
- static PBD::Signal0<void> AutoBindingOff;
-
static PBD::Signal1<void,std::string> Dialog;
int ensure_subdirs ();
- std::string automation_dir () const;
- std::string analysis_dir() const;
- std::string plugins_dir() const;
+ std::string automation_dir () const; ///< Automation data
+ std::string analysis_dir () const; ///< Analysis data
+ std::string plugins_dir () const; ///< Plugin state
+ std::string externals_dir () const; ///< Links to external files
std::string peak_path (std::string) const;
std::string new_audio_source_name (const std::string&, uint32_t nchans, uint32_t chan, bool destructive);
std::string new_midi_source_name (const std::string&);
std::string new_source_path_from_name (DataType type, const std::string&);
- RouteList new_route_from_template (uint32_t how_many, const std::string& template_path);
+ RouteList new_route_from_template (uint32_t how_many, const std::string& template_path, const std::string& name);
void process (pframes_t nframes);
bool operator() (boost::shared_ptr<Route>, boost::shared_ptr<Route> b);
};
- void sync_order_keys (std::string const &);
+ void notify_remote_id_change ();
+ void sync_order_keys (RouteSortOrderKey);
template<class T> void foreach_route (T *obj, void (T::*func)(Route&));
template<class T> void foreach_route (T *obj, void (T::*func)(boost::shared_ptr<Route>));
boost::shared_ptr<Route> route_by_name (std::string);
boost::shared_ptr<Route> route_by_id (PBD::ID);
boost::shared_ptr<Route> route_by_remote_id (uint32_t id);
- void routes_using_input_from (const std::string& str, RouteList& rl);
+ boost::shared_ptr<Track> track_by_diskstream_id (PBD::ID);
+ void routes_using_input_from (const std::string& str, RouteList& rl);
bool route_name_unique (std::string) const;
bool route_name_internal (std::string) const;
void goto_start ();
void use_rf_shuttle_speed ();
void allow_auto_play (bool yn);
- void request_transport_speed (double speed);
- void request_transport_speed_nonzero (double);
+ void request_transport_speed (double speed, bool as_default = false);
+ void request_transport_speed_nonzero (double, bool as_default = false);
void request_overwrite_buffer (Track *);
void adjust_playback_buffering();
void adjust_capture_buffering();
return mtc_timecode_bits; /* encoding of SMTPE type for MTC */
}
- float timecode_frames_per_second() const;
+ double timecode_frames_per_second() const;
bool timecode_drop_frames() const;
/* Locations */
void set_auto_loop_location (Location *);
int location_name(std::string& result, std::string base = std::string(""));
- void reset_input_monitor_state ();
-
pframes_t get_block_size() const { return current_block_size; }
framecnt_t worst_output_latency () const { return _worst_output_latency; }
framecnt_t worst_input_latency () const { return _worst_input_latency; }
void rename_state (std::string old_name, std::string new_name);
void remove_pending_capture_state ();
int rename (const std::string&);
-
- static int rename_template (std::string old_name, std::string new_name);
- static int delete_template (std::string name);
+ bool get_nsm_state () const { return _under_nsm_control; }
+ void set_nsm_state (bool state) { _under_nsm_control = state; }
PBD::Signal1<void,std::string> StateSaved;
PBD::Signal0<void> StateReady;
+ PBD::Signal0<void> SaveSession;
std::vector<std::string*>* possible_states() const;
static std::vector<std::string*>* possible_states (std::string path);
);
std::list<boost::shared_ptr<MidiTrack> > new_midi_track (
- TrackMode mode = Normal, RouteGroup* route_group = 0, uint32_t how_many = 1, std::string name_template = ""
+ const ChanCount& input, const ChanCount& output,
+ boost::shared_ptr<PluginInfo> instrument = boost::shared_ptr<PluginInfo>(),
+ TrackMode mode = Normal,
+ RouteGroup* route_group = 0, uint32_t how_many = 1, std::string name_template = ""
);
void remove_route (boost::shared_ptr<Route>);
void resort_routes ();
void resort_routes_using (boost::shared_ptr<RouteList>);
- void set_remote_control_ids();
-
AudioEngine & engine() { return _engine; }
AudioEngine const & engine () const { return _engine; }
static PBD::Signal1<void, framepos_t> StartTimeChanged;
static PBD::Signal1<void, framepos_t> EndTimeChanged;
- std::vector<SyncSource> get_available_sync_options() const;
void request_sync_source (Slave*);
- bool synced_to_jack() const { return config.get_external_sync() && config.get_sync_source() == JACK; }
+ bool synced_to_jack() const { return config.get_external_sync() && Config->get_sync_source() == JACK; }
double transport_speed() const { return _transport_speed; }
bool transport_stopped() const { return _transport_speed == 0.0f; }
TempoMap& tempo_map() { return *_tempo_map; }
- /// signals the current transport position in frames, bbt and timecode time (in that order)
- PBD::Signal3<void, const framepos_t &, const Timecode::BBT_Time&, const Timecode::Time&> tick;
-
/* region info */
boost::shared_ptr<Region> find_whole_file_parent (boost::shared_ptr<Region const>) const;
/* source management */
- void import_audiofiles (ImportStatus&);
+ void import_files (ImportStatus&);
bool sample_rate_convert (ImportStatus&, std::string infile, std::string& outfile);
std::string build_tmp_convert_name (std::string file);
boost::shared_ptr<ExportHandler> get_export_handler ();
boost::shared_ptr<ExportStatus> get_export_status ();
- int start_audio_export (framepos_t position, bool realtime);
+ int start_audio_export (framepos_t position);
PBD::Signal1<int, framecnt_t> ProcessExport;
static PBD::Signal2<void,std::string, std::string> Exported;
void add_playlist (boost::shared_ptr<Playlist>, bool unused = false);
- /* named selections */
-
- boost::shared_ptr<NamedSelection> named_selection_by_name (std::string name);
- void add_named_selection (boost::shared_ptr<NamedSelection>);
- void remove_named_selection (boost::shared_ptr<NamedSelection>);
-
- template<class T> void foreach_named_selection (T& obj, void (T::*func)(boost::shared_ptr<NamedSelection>));
- PBD::Signal0<void> NamedSelectionAdded;
- PBD::Signal0<void> NamedSelectionRemoved;
-
/* Curves and AutomationLists (TODO when they go away) */
void add_automation_list(AutomationList*);
/* flattening stuff */
boost::shared_ptr<Region> write_one_track (AudioTrack&, framepos_t start, framepos_t end,
- bool overwrite, std::vector<boost::shared_ptr<Source> >&, InterThreadInfo& wot,
- bool enable_processing = true);
+ bool overwrite, std::vector<boost::shared_ptr<Source> >&, InterThreadInfo& wot,
+ boost::shared_ptr<Processor> endpoint, bool include_endpoint, bool for_export);
int freeze_all (InterThreadInfo&);
/* session-wide solo/mute/rec-enable */
void set_solo (boost::shared_ptr<RouteList>, bool, SessionEvent::RTeventCallback after = rt_cleanup, bool group_override = false);
void set_just_one_solo (boost::shared_ptr<Route>, bool, SessionEvent::RTeventCallback after = rt_cleanup);
+ void cancel_solo_after_disconnect (boost::shared_ptr<Route>, bool upstream, SessionEvent::RTeventCallback after = rt_cleanup);
void set_mute (boost::shared_ptr<RouteList>, bool, SessionEvent::RTeventCallback after = rt_cleanup, bool group_override = false);
void set_listen (boost::shared_ptr<RouteList>, bool, SessionEvent::RTeventCallback after = rt_cleanup, bool group_override = false);
void set_record_enabled (boost::shared_ptr<RouteList>, bool, SessionEvent::RTeventCallback after = rt_cleanup, bool group_override = false);
void set_solo_isolated (boost::shared_ptr<RouteList>, bool, SessionEvent::RTeventCallback after = rt_cleanup, bool group_override = false);
- void set_exclusive_input_active (boost::shared_ptr<Route> rt, bool others_on);
void set_monitoring (boost::shared_ptr<RouteList>, MonitorChoice, SessionEvent::RTeventCallback after = rt_cleanup, bool group_override = false);
+ void set_exclusive_input_active (boost::shared_ptr<RouteList> rt, bool onoff, bool flip_others=false);
PBD::Signal1<void,bool> SoloActive;
PBD::Signal0<void> SoloChanged;
PBD::Signal0<void> IsolatedChanged;
- /* control/master out */
+ /* monitor/master out */
+
+ void add_monitor_section ();
+ void remove_monitor_section ();
boost::shared_ptr<Route> monitor_out() const { return _monitor_out; }
boost::shared_ptr<Route> master_out() const { return _master_out; }
void globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest);
void globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest);
void add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders);
+ void add_internal_send (boost::shared_ptr<Route>, int, boost::shared_ptr<Route>);
+ void add_internal_send (boost::shared_ptr<Route>, boost::shared_ptr<Processor>, boost::shared_ptr<Route>);
static void set_disable_all_loaded_plugins (bool yn) {
_disable_all_loaded_plugins = yn;
}
uint32_t next_send_id();
+ uint32_t next_aux_send_id();
uint32_t next_return_id();
uint32_t next_insert_id();
void mark_send_id (uint32_t);
+ void mark_aux_send_id (uint32_t);
void mark_return_id (uint32_t);
void mark_insert_id (uint32_t);
void unmark_send_id (uint32_t);
+ void unmark_aux_send_id (uint32_t);
void unmark_return_id (uint32_t);
void unmark_insert_id (uint32_t);
/* s/w "RAID" management */
- framecnt_t available_capture_duration();
+ boost::optional<framecnt_t> available_capture_duration();
/* I/O bundles */
return _current_trans_quarks;
}
+ bool operation_in_progress (GQuark) const;
+
void add_commands (std::vector<Command*> const & cmds);
std::map<PBD::ID,PBD::StatefulDestructible*> registry;
/* clicking */
boost::shared_ptr<IO> click_io() { return _click_io; }
+ boost::shared_ptr<Amp> click_gain() { return _click_gain; }
/* disk, buffer loads */
void request_play_range (std::list<AudioRange>*, bool leave_rolling = false);
bool get_play_range () const { return _play_range; }
+ void maybe_update_session_range (framepos_t, framepos_t);
+
/* buffers for gain and pan */
gain_t* gain_automation_buffer () const;
+ gain_t* send_gain_automation_buffer () const;
pan_t** pan_automation_buffer () const;
void ensure_buffer_set (BufferSet& buffers, const ChanCount& howmany);
boost::shared_ptr<PBD::Controllable> solo_cut_control() const;
- SessionMetadata & metadata () { return *_metadata; }
-
SessionConfiguration config;
bool exporting () const {
};
SlaveState slave_state() const { return _slave_state; }
+ Slave* slave() const { return _slave; }
boost::shared_ptr<SessionPlaylists> playlists;
void send_mmc_locate (framepos_t);
int send_full_time_code (framepos_t);
- PBD::Signal0<void> RouteOrderKeyChanged;
-
bool step_editing() const { return (_step_editors > 0); }
void request_suspend_timecode_transmission ();
/** Emitted when the session wants Ardour to quit */
static PBD::Signal0<void> Quit;
+ /** Emitted when Ardour is asked to load a session in an older session
+ * format, and makes a backup copy.
+ */
+ static PBD::Signal2<void,std::string,std::string> VersionMismatch;
+
+ 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; }
+
protected:
friend class AudioEngine;
void set_block_size (pframes_t nframes);
void destroy ();
enum SubState {
- PendingDeclickIn = 0x1,
- PendingDeclickOut = 0x2,
- StopPendingCapture = 0x4,
- PendingLocate = 0x20,
+ 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,
};
/* stuff used in process() should be close together to
Slave* _slave;
bool _silent;
- void maybe_update_session_range (framepos_t, framepos_t);
-
// varispeed playback
double _transport_speed;
+ double _default_transport_speed;
double _last_transport_speed;
double _target_transport_speed;
CubicInterpolation interpolation;
uint32_t _solo_isolated_cnt;
bool _writable;
bool _was_seamless;
+ bool _under_nsm_control;
void initialize_latencies ();
void set_worst_io_latencies ();
void process_without_events (pframes_t);
void process_with_events (pframes_t);
void process_audition (pframes_t);
- void process_export (pframes_t);
+ int process_export (pframes_t);
int process_export_fw (pframes_t);
void block_processing() { g_atomic_int_set (&processing_prohibited, 1); }
void unblock_processing() { g_atomic_int_set (&processing_prohibited, 0); }
bool processing_blocked() const { return g_atomic_int_get (&processing_prohibited); }
- Glib::Mutex process_thread_lock;
- std::list<ProcessThread*> process_threads;
-
/* slave tracking */
static const int delta_accumulator_size = 25;
framepos_t post_export_position;
bool _exporting;
+ bool _export_started;
bool _export_rolling;
boost::shared_ptr<ExportHandler> export_handler;
int pre_export ();
int stop_audio_export ();
void finalize_audio_export ();
+ void finalize_export_internal (bool stop_freewheel);
+ bool _pre_export_mmc_enabled;
PBD::ScopedConnection export_freewheel_connection;
int process_routes (pframes_t, bool& need_butler);
int silent_process_routes (pframes_t, bool& need_butler);
+ /** @return 1 if there is a pending declick fade-in,
+ -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;
}
int load_state (std::string snapshot_name);
framepos_t _last_roll_location;
+ /** the session frame time at which we last rolled, located, or changed transport direction */
framepos_t _last_roll_or_reversal_location;
framepos_t _last_record_location;
PostTransportClearSubstate);
gint _post_transport_work; /* accessed only atomic ops */
- PostTransportWork post_transport_work() const { return (PostTransportWork) g_atomic_int_get (&_post_transport_work); }
+ PostTransportWork post_transport_work() const { return (PostTransportWork) g_atomic_int_get (const_cast<gint*>(&_post_transport_work)); }
void set_post_transport_work (PostTransportWork ptw) { g_atomic_int_set (&_post_transport_work, (gint) ptw); }
void add_post_transport_work (PostTransportWork ptw);
PBD::ScopedConnectionList loop_connections;
void auto_loop_changed (Location *);
+ void auto_loop_declick_range (Location *, framepos_t &, framepos_t &);
void first_stage_init (std::string path, std::string snapshot_name);
int second_stage_init ();
/* MIDI Machine Control */
- void spp_start (MIDI::Parser&, framepos_t timestamp);
- void spp_continue (MIDI::Parser&, framepos_t timestamp);
- void spp_stop (MIDI::Parser&, framepos_t timestamp);
+ void spp_start ();
+ void spp_continue ();
+ void spp_stop ();
void mmc_deferred_play (MIDI::MachineControl &);
void mmc_stop (MIDI::MachineControl &);
MIDI::byte mtc_msg[16];
MIDI::byte mtc_timecode_bits; /* encoding of SMTPE type for MTC */
MIDI::byte midi_msg[16];
- framepos_t outbound_mtc_timecode_frame;
+ double outbound_mtc_timecode_frame;
Timecode::Time transmitting_timecode_time;
int next_quarter_frame_to_send;
int send_midi_time_code_for_cycle (framepos_t, framepos_t, pframes_t nframes);
+ LTCEncoder* ltc_encoder;
+ ltcsnd_sample_t* ltc_enc_buf;
+
+ Timecode::TimecodeFormat ltc_enc_tcformat;
+ int32_t ltc_buf_off;
+ int32_t ltc_buf_len;
+
+ double ltc_speed;
+ int32_t ltc_enc_byte;
+ framepos_t ltc_enc_pos;
+ double ltc_enc_cnt;
+ framepos_t ltc_enc_off;
+ bool restarting;
+
+ framepos_t ltc_timecode_offset;
+ bool ltc_timecode_negative_offset;
+
+ LatencyRange ltc_out_latency;
+
+ void ltc_tx_initialize();
+ void ltc_tx_cleanup();
+ void ltc_tx_reset();
+ void ltc_tx_resync_latency();
+ void ltc_tx_recalculate_position();
+ void ltc_tx_parse_offset();
+ void ltc_tx_send_time_code_for_cycle (framepos_t, framepos_t, double, double, pframes_t nframes);
+
void reset_record_status ();
int no_roll (pframes_t nframes);
MidiControlUI* midi_control_ui;
int start_midi_thread ();
- void terminate_midi_thread ();
void set_play_loop (bool yn);
void unset_play_loop ();
void start_locate (framepos_t, bool with_roll, bool with_flush, bool with_loop=false, bool force=false);
void force_locate (framepos_t frame, bool with_roll = false);
void set_track_speed (Track *, double speed);
- void set_transport_speed (double speed, bool abort = false, bool clear_state = false);
+ void set_transport_speed (double speed, 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);
SerializedRCUManager<RouteList> routes;
- void add_routes (RouteList&, bool auto_connect, bool save);
+ void add_routes (RouteList&, bool input_auto_connect, bool output_auto_connect, bool save);
+ void add_routes_inner (RouteList&, bool input_auto_connect, bool output_auto_connect);
+ bool _adding_routes_in_progress;
uint32_t destructive_index;
boost::shared_ptr<Route> XMLRouteFactory (const XMLNode&, int);
/* REGION MANAGEMENT */
- mutable Glib::Mutex region_lock;
+ mutable Glib::Threads::Mutex region_lock;
int load_regions (const XMLNode& node);
int load_compounds (const XMLNode& node);
/* SOURCES */
- mutable Glib::Mutex source_lock;
+ mutable Glib::Threads::Mutex source_lock;
public:
typedef std::map<PBD::ID,boost::shared_ptr<Source> > SourceMap;
void playlist_ranges_moved (std::list<Evoral::RangeMove<framepos_t> > const &);
void playlist_regions_extended (std::list<Evoral::Range<framepos_t> > const &);
- /* NAMED SELECTIONS */
-
- mutable Glib::Mutex named_selection_lock;
- typedef std::set<boost::shared_ptr<NamedSelection> > NamedSelectionList;
- NamedSelectionList named_selections;
-
- int load_named_selections (const XMLNode&);
-
- NamedSelection *named_selection_factory (std::string name);
- NamedSelection *XMLNamedSelectionFactory (const XMLNode&);
-
/* CURVES and AUTOMATION LISTS */
std::map<PBD::ID, AutomationList*> automation_lists;
/* INSERT AND SEND MANAGEMENT */
boost::dynamic_bitset<uint32_t> send_bitset;
+ boost::dynamic_bitset<uint32_t> aux_send_bitset;
boost::dynamic_bitset<uint32_t> return_bitset;
boost::dynamic_bitset<uint32_t> insert_bitset;
/* S/W RAID */
struct space_and_path {
- uint32_t blocks; /* 4kB blocks */
+ uint32_t blocks; ///< 4kB blocks
+ bool blocks_unknown; ///< true if blocks is unknown
std::string path;
- space_and_path() {
- blocks = 0;
- }
+ space_and_path ()
+ : blocks (0)
+ , blocks_unknown (true)
+ {}
};
struct space_and_path_ascending_cmp {
bool operator() (space_and_path a, space_and_path b) {
+ if (a.blocks_unknown != b.blocks_unknown) {
+ return !a.blocks_unknown;
+ }
return a.blocks > b.blocks;
}
};
std::vector<space_and_path> session_dirs;
std::vector<space_and_path>::iterator last_rr_session_dir;
uint32_t _total_free_4k_blocks;
- Glib::Mutex space_lock;
+ /** If this is true, _total_free_4k_blocks is not definite,
+ as one or more of the session directories' filesystems
+ could not report free space.
+ */
+ bool _total_free_4k_blocks_uncertain;
+ Glib::Threads::Mutex space_lock;
bool no_questions_about_missing_files;
XMLNode* _bundle_xml_node;
int load_bundles (XMLNode const &);
- void reverse_track_buffers ();
-
UndoHistory _history;
/** current undo transaction, or 0 */
UndoTransaction* _current_trans;
/* click track */
typedef std::list<Click*> Clicks;
- Clicks clicks;
- bool _clicking;
- boost::shared_ptr<IO> _click_io;
- Sample* click_data;
- Sample* click_emphasis_data;
- framecnt_t click_length;
- framecnt_t click_emphasis_length;
- mutable Glib::RWLock click_lock;
+ Clicks clicks;
+ bool _clicking;
+ boost::shared_ptr<IO> _click_io;
+ boost::shared_ptr<Amp> _click_gain;
+ Sample* click_data;
+ Sample* click_emphasis_data;
+ framecnt_t click_length;
+ framecnt_t click_emphasis_length;
+ mutable Glib::Threads::RWLock click_lock;
static const Sample default_click[];
static const framecnt_t default_click_length;
static const framecnt_t default_click_emphasis_length;
Click *get_click();
+ framepos_t _clicks_cleared;
void setup_click_sounds (int which);
void setup_click_sounds (Sample**, Sample const *, framecnt_t*, framecnt_t, std::string const &);
void clear_clicks ();
boost::shared_ptr<Route> _master_out;
boost::shared_ptr<Route> _monitor_out;
+ void auto_connect_master_bus ();
+
/* Windows VST support */
long _windows_vst_callback (
int find_all_sources_across_snapshots (std::set<std::string>& result, bool exclude_this_snapshot);
typedef std::set<boost::shared_ptr<PBD::Controllable> > Controllables;
- Glib::Mutex controllables_lock;
+ Glib::Threads::Mutex controllables_lock;
Controllables controllables;
boost::shared_ptr<PBD::Controllable> _solo_cut_control;
XMLNode& get_control_protocol_state ();
void set_history_depth (uint32_t depth);
- void sync_order_keys ();
static bool _disable_all_loaded_plugins;
- SessionMetadata * _metadata;
-
mutable bool have_looped; ///< Used in ::audible_frame(*)
void update_have_rec_enabled_track ();
return ev;
}
+ void rt_cancel_solo_after_disconnect (boost::shared_ptr<RouteList>, bool upstream, bool /* ignored*/ );
void rt_set_solo (boost::shared_ptr<RouteList>, bool yn, bool group_override);
void rt_set_just_one_solo (boost::shared_ptr<RouteList>, bool yn, bool /* ignored*/ );
void rt_set_mute (boost::shared_ptr<RouteList>, bool yn, bool group_override);
void setup_midi_machine_control ();
- void route_order_key_changed ();
-
void step_edit_status_change (bool);
uint32_t _step_editors;
and solo/mute computations.
*/
GraphEdges _current_route_graph;
+
+ uint32_t next_control_id () const;
+ bool ignore_route_processor_changes;
+
+ MidiClockTicker* midi_clock;
+
+ boost::shared_ptr<IO> _ltc_input;
+ boost::shared_ptr<IO> _ltc_output;
+
+ void reconnect_ltc_input ();
+ void reconnect_ltc_output ();
};
} // namespace ARDOUR
projects / ardour.git / blobdiff