class Port;
class PortInsert;
class ProcessThread;
+class Progress;
class Processor;
class Region;
class Return;
/** Ardour Session */
class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::ScopedConnectionList, public SessionEventManager
{
+ 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 {
Disabled = 0,
* @param pd Playlist disposition
* @return list of newly created routes
*/
- RouteList new_route_from_template (uint32_t how_many, const std::string& template_path, const std::string& name, PlaylistDisposition pd = NewPlaylist);
- RouteList new_route_from_template (uint32_t how_many, XMLNode&, const std::string& name, PlaylistDisposition pd = NewPlaylist);
+ RouteList new_route_from_template (uint32_t how_many, PresentationInfo::order_t insert_at, const std::string& template_path, const std::string& name, PlaylistDisposition pd = NewPlaylist);
+ RouteList new_route_from_template (uint32_t how_many, PresentationInfo::order_t insert_at, XMLNode&, const std::string& name, PlaylistDisposition pd = NewPlaylist);
std::vector<std::string> get_paths_for_new_sources (bool allow_replacing, const std::string& import_file_path, uint32_t channels);
int bring_all_sources_into_session (boost::function<void(uint32_t,uint32_t,std::string)> callback);
bool io_name_is_legal (const std::string&) const;
boost::shared_ptr<Route> route_by_name (std::string) const;
boost::shared_ptr<Route> route_by_id (PBD::ID) const;
- boost::shared_ptr<Stripable> get_remote_nth_stripable (uint16_t n, PresentationInfo::Flag) const;
- boost::shared_ptr<Route> get_remote_nth_route (uint16_t n) const;
+ boost::shared_ptr<Stripable> get_remote_nth_stripable (PresentationInfo::order_t n, PresentationInfo::Flag) const;
+ boost::shared_ptr<Route> get_remote_nth_route (PresentationInfo::order_t n) const;
boost::shared_ptr<Route> route_by_selected_count (uint32_t cnt) const;
boost::shared_ptr<Track> track_by_diskstream_id (PBD::ID) const;
void routes_using_input_from (const std::string& str, RouteList& rl);
framepos_t last_transport_start () const { return _last_roll_location; }
void goto_end ();
- void goto_start ();
+ 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_input_change_handling ();
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 transport_locked () const;
int wipe ();
void set_auto_punch_location (Location *);
void set_auto_loop_location (Location *);
void set_session_extents (framepos_t start, framepos_t end);
+ void set_end_is_free (bool);
int location_name(std::string& result, std::string base = std::string(""));
pframes_t get_block_size() const { return current_block_size; }
* @return zero on success
*/
int save_state (std::string snapshot_name, bool pending = false, bool switch_to_snapshot = false, bool template_only = false);
+
+ enum ArchiveEncode {
+ NO_ENCODE,
+ FLAC_16BIT,
+ FLAC_24BIT
+ };
+
+ int archive_session (const std::string&, const std::string&, ArchiveEncode compress_audio = FLAC_16BIT, bool only_used_sources = false, Progress* p = 0);
+
int restore_state (std::string snapshot_name);
int save_template (std::string template_name, bool replace_existing = false);
int save_history (std::string snapshot_name = "");
StateOfTheState state_of_the_state() const { return _state_of_the_state; }
class StateProtector {
- public:
- StateProtector (Session* s) : _session (s) {
- g_atomic_int_inc (&s->_suspend_save);
- }
- ~StateProtector () {
- if (g_atomic_int_dec_and_test (&_session->_suspend_save)) {
- while (_session->_save_queued) {
- _session->_save_queued = false;
- _session->save_state ("");
+ public:
+ StateProtector (Session* s) : _session (s) {
+ g_atomic_int_inc (&s->_suspend_save);
+ }
+ ~StateProtector () {
+ if (g_atomic_int_dec_and_test (&_session->_suspend_save)) {
+ while (_session->_save_queued) {
+ _session->_save_queued = false;
+ _session->save_state ("");
+ }
}
}
- }
- private:
- Session * _session;
+ private:
+ Session * _session;
+ };
+
+ class ProcessorChangeBlocker {
+ public:
+ ProcessorChangeBlocker (Session* s, bool rc = true)
+ : _session (s)
+ , _reconfigure_on_delete (rc)
+ {
+ g_atomic_int_inc (&s->_ignore_route_processor_changes);
+ }
+ ~ProcessorChangeBlocker () {
+ if (g_atomic_int_dec_and_test (&_session->_ignore_route_processor_changes)) {
+ if (_reconfigure_on_delete) {
+ _session->route_processors_changed (RouteProcessorChange ());
+ }
+ }
+ }
+ private:
+ Session* _session;
+ bool _reconfigure_on_delete;
};
void add_route_group (RouteGroup *);
std::list<boost::shared_ptr<MidiTrack> > new_midi_track (
const ChanCount& input, const ChanCount& output,
boost::shared_ptr<PluginInfo> instrument,
- Plugin::PresetRecord* pset = 0,
+ Plugin::PresetRecord* pset,
RouteGroup* route_group, uint32_t how_many, std::string name_template,
PresentationInfo::order_t,
TrackMode mode = Normal
bool synced_to_ltc () const { return config.get_external_sync() && Config->get_sync_source() == LTC && g_atomic_int_get (const_cast<gint*>(&_ltc_active)); }
double transport_speed() const { return _transport_speed; }
- bool transport_stopped() const { return _transport_speed == 0.0f; }
- bool transport_rolling() const { return _transport_speed != 0.0f; }
+ bool transport_stopped() const { return _transport_speed == 0.0; }
+ bool transport_rolling() const { return _transport_speed != 0.0; }
bool silent () { return _silent; }
boost::shared_ptr<ExportHandler> get_export_handler ();
boost::shared_ptr<ExportStatus> get_export_status ();
- int start_audio_export (framepos_t position);
+ int start_audio_export (framepos_t position, bool realtime = false, bool region_export = false, bool comensate_master_latency = false);
PBD::Signal1<int, framecnt_t> ProcessExport;
static PBD::Signal2<void,std::string, std::string> Exported;
bool soloing() const { return _non_soloed_outs_muted; }
bool listening() const { return _listen_cnt > 0; }
bool solo_isolated() const { return _solo_isolated_cnt > 0; }
+ void cancel_all_solo ();
static const SessionEvent::RTeventCallback rt_cleanup;
/** Undo some transactions.
* @param n Number of transactions to undo.
*/
- void undo (uint32_t n) {
- _history.undo (n);
- }
-
- void redo (uint32_t n) {
- _history.redo (n);
- }
+ void undo (uint32_t n);
+ /** Redo some transactions.
+ * @param n Number of transactions to undo.
+ */
+ void redo (uint32_t n);
UndoHistory& history() { return _history; }
SessionConfiguration config;
+ SessionConfiguration* cfg () { return &config; }
+
bool exporting () const {
return _exporting;
}
VCAManager& vca_manager() { return *_vca_manager; }
+ void auto_connect_thread_wakeup ();
+
+
protected:
friend class AudioEngine;
void set_block_size (pframes_t nframes);
static void init_name_id_counter (guint n);
static unsigned int name_id_counter ();
- 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,
- };
-
/* stuff used in process() should be close together to
maximise cache hits
*/
mutable gint _record_status;
framepos_t _transport_frame;
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 _silent;
void process_without_events (pframes_t);
void process_with_events (pframes_t);
void process_audition (pframes_t);
- int process_export (pframes_t);
- int process_export_fw (pframes_t);
+ void process_export (pframes_t);
+ void 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 _exporting;
bool _export_rolling;
+ bool _realtime_export;
+ bool _region_export;
framepos_t _export_preroll;
+ framepos_t _export_latency;
boost::shared_ptr<ExportHandler> export_handler;
boost::shared_ptr<ExportStatus> export_status;
typedef std::queue<AutoConnectRequest> AutoConnectQueue;
Glib::Threads::Mutex _auto_connect_queue_lock;
AutoConnectQueue _auto_connect_queue;
+ guint _latency_recompute_pending;
+
+ void get_physical_ports (std::vector<std::string>& inputs, std::vector<std::string>& outputs, DataType type,
+ MidiPortFlags include = MidiPortFlags (0),
+ MidiPortFlags exclude = MidiPortFlags (0));
void auto_connect (const AutoConnectRequest&);
+ void queue_latency_recompute ();
/* SessionEventManager interface */
*/
GraphEdges _current_route_graph;
- void ensure_presentation_info_gap (PresentationInfo::order_t, uint32_t gap_size);
- bool ignore_route_processor_changes;
+ void ensure_route_presentation_info_gap (PresentationInfo::order_t, uint32_t gap_size);
+
+ friend class ProcessorChangeBlocker;
+ gint _ignore_route_processor_changes; /* atomic */
MidiClockTicker* midi_clock;
VCAManager* _vca_manager;
boost::shared_ptr<Route> get_midi_nth_route_by_id (PresentationInfo::order_t n) const;
+
+ std::string created_with;
+
+ void midi_track_presentation_info_changed (PBD::PropertyChange const &, boost::weak_ptr<MidiTrack>);
+ void rewire_selected_midi (boost::shared_ptr<MidiTrack>);
+ void rewire_midi_selection_ports ();
+ boost::weak_ptr<MidiTrack> current_midi_target;
};
projects / ardour.git / blobdiff