X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fardour%2Fsession.h;h=ebafdd82f67d97ca815b198edfc4288e12ec56d5;hb=d514cd2fbf81e99e91bf6c9ae68346eefb021828;hp=594b85f29c0a70491266f28d685257115ab620d4;hpb=cd63d97f65133d9c34f5ee36bc1a5a7bec530e21;p=ardour.git diff --git a/libs/ardour/ardour/session.h b/libs/ardour/ardour/session.h index 594b85f29c..ebafdd82f6 100644 --- a/libs/ardour/ardour/session.h +++ b/libs/ardour/ardour/session.h @@ -22,11 +22,13 @@ #include "libardour-config.h" +#include #include #include #include #include #include +#include #include #include @@ -41,11 +43,14 @@ #include "pbd/error.h" #include "pbd/event_loop.h" #include "pbd/rcu.h" +#include "pbd/reallocpool.h" #include "pbd/statefuldestructible.h" #include "pbd/signals.h" #include "pbd/undo.h" -#include "evoral/types.hpp" +#include "lua/luastate.h" + +#include "evoral/Range.hpp" #include "midi++/types.h" #include "midi++/mmc.h" @@ -56,11 +61,17 @@ #include "ardour/chan_count.h" #include "ardour/delivery.h" #include "ardour/interthread_info.h" +#include "ardour/luascripting.h" +#include "ardour/location.h" +#include "ardour/monitor_processor.h" +#include "ardour/presentation_info.h" #include "ardour/rc_configuration.h" #include "ardour/session_configuration.h" #include "ardour/session_event.h" -#include "ardour/location.h" #include "ardour/interpolation.h" +#include "ardour/plugin.h" +#include "ardour/presentation_info.h" +#include "ardour/route.h" #include "ardour/route_graph.h" @@ -77,7 +88,10 @@ class Parser; namespace PBD { class Controllable; -class ControllableDescriptor; +} + +namespace luabridge { + class LuaRef; } namespace Evoral { @@ -99,6 +113,7 @@ class BufferSet; class Bundle; class Butler; class Click; +class ControllableDescriptor; class Diskstream; class ExportHandler; class ExportStatus; @@ -135,10 +150,23 @@ class Source; class Speakers; class TempoMap; class Track; +class VCAManager; class WindowsVSTPlugin; extern void setup_enum_writer (); +class LIBARDOUR_API SessionException: public std::exception { +public: + explicit SessionException(const std::string msg) : _message(msg) {} + virtual ~SessionException() throw() {} + + virtual const char* what() const throw() { return _message.c_str(); } + +private: + std::string _message; +}; + +/** Ardour Session */ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::ScopedConnectionList, public SessionEventManager { public: @@ -161,6 +189,13 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop virtual ~Session (); static int get_info_from_path (const std::string& xmlpath, float& sample_rate, SampleFormat& data_format); + static std::string get_snapshot_from_instant (const std::string& session_dir); + + /** a monotonic counter used for naming user-visible things uniquely + * (curently the sidechain port). + * Use sparingly to keep the numbers low, prefer PBD::ID for all + * internal, not user-visible IDs */ + static unsigned int next_name_id (); std::string path() const { return _path; } std::string name() const { return _name; } @@ -168,21 +203,27 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop std::string raid_path () const; bool path_is_within_session (const std::string&); - void set_snap_name (); - 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; } + PBD::Signal0 DirtyChanged; const SessionDirectory& session_directory () const { return *(_session_dir.get()); } static PBD::Signal1 Dialog; + PBD::Signal0 BatchUpdateStart; + PBD::Signal0 BatchUpdateEnd; + int ensure_subdirs (); std::string automation_dir () const; ///< Automation data @@ -190,15 +231,22 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop 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 construct_peak_filepath (const std::string& audio_path, const bool in_session = false, const bool old_peak_name = false) const; - std::string peak_path_from_audio_path (std::string) const; bool audio_source_name_is_unique (const std::string& name); std::string format_audio_source_name (const std::string& legalized_base, uint32_t nchan, uint32_t chan, bool destructive, bool take_required, uint32_t cnt, bool related_exists); std::string new_audio_source_path_for_embedded (const std::string& existing_path); std::string new_audio_source_path (const std::string&, uint32_t nchans, uint32_t chan, bool destructive, bool take_required); std::string new_midi_source_path (const std::string&); - RouteList new_route_from_template (uint32_t how_many, const std::string& template_path, const std::string& name); + /** create a new track or bus from a template (XML path) + * @param how_many how many tracks or busses to create + * @param template_path path to xml template file + * @param name name (prefix) of the route to create + * @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); std::vector 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 callback); @@ -206,11 +254,13 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop void process (pframes_t nframes); BufferSet& get_silent_buffers (ChanCount count = ChanCount::ZERO); - BufferSet& get_scratch_buffers (ChanCount count = ChanCount::ZERO, bool silence = true ); + BufferSet& get_noinplace_buffers (ChanCount count = ChanCount::ZERO); + BufferSet& get_scratch_buffers (ChanCount count = ChanCount::ZERO, bool silence = true); BufferSet& get_route_buffers (ChanCount count = ChanCount::ZERO, bool silence = true); BufferSet& get_mix_buffers (ChanCount count = ChanCount::ZERO); bool have_rec_enabled_track () const; + bool have_rec_disabled_track () const; bool have_captured() const { return _have_captured; } @@ -227,6 +277,14 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop return routes.reader (); } + /* because the set of Stripables consists of objects managed + * independently, in multiple containers within the Session (or objects + * owned by the session), we fill out a list in-place rather than + * return a pointer to a copy of the (RCU) managed list, as happens + * with get_routes() + */ + + void get_stripables (StripableList&) const; boost::shared_ptr get_tracks() const; boost::shared_ptr get_routes_with_internal_returns() const; boost::shared_ptr get_routes_with_regions_at (framepos_t const) const; @@ -243,20 +301,20 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop bool operator() (boost::shared_ptr, boost::shared_ptr b); }; - void set_order_hint (int32_t order_hint) {_order_hint = order_hint;}; - void notify_remote_id_change (); - void sync_order_keys (); + void notify_presentation_info_change (); template void foreach_route (T *obj, void (T::*func)(Route&), bool sort = true); template void foreach_route (T *obj, void (T::*func)(boost::shared_ptr), bool sort = true); template void foreach_route (T *obj, void (T::*func)(Route&, A), A arg, bool sort = true); static char session_name_is_legal (const std::string&); - bool io_name_is_legal (const std::string&); - boost::shared_ptr route_by_name (std::string); - boost::shared_ptr route_by_id (PBD::ID); - boost::shared_ptr route_by_remote_id (uint32_t id); - boost::shared_ptr track_by_diskstream_id (PBD::ID); + bool io_name_is_legal (const std::string&) const; + boost::shared_ptr route_by_name (std::string) const; + boost::shared_ptr route_by_id (PBD::ID) const; + boost::shared_ptr get_remote_nth_stripable (PresentationInfo::order_t n, PresentationInfo::Flag) const; + boost::shared_ptr get_remote_nth_route (PresentationInfo::order_t n) const; + boost::shared_ptr route_by_selected_count (uint32_t cnt) const; + boost::shared_ptr track_by_diskstream_id (PBD::ID) const; void routes_using_input_from (const std::string& str, RouteList& rl); bool route_name_unique (std::string) const; @@ -283,15 +341,28 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop void disable_record (bool rt_context, bool force = false); void step_back_from_record (); + void set_all_tracks_record_enabled(bool); + void maybe_write_autosave (); /* Emitted when all i/o connections are complete */ PBD::Signal0 IOConnectionsComplete; + /* Timecode status signals */ + PBD::Signal1 MTCSyncStateChanged; + PBD::Signal1 LTCSyncStateChanged; + /* Record status signals */ - PBD::Signal0 RecordStateChanged; + PBD::Signal0 RecordStateChanged; /* signals changes in recording state (i.e. are we recording) */ + /* XXX may 2015: paul says: it isn't clear to me that this has semantics that cannot be inferrred + from the previous signal and session state. + */ + PBD::Signal0 RecordArmStateChanged; /* signals changes in recording arming */ + + /* Emited when session is loaded */ + PBD::Signal0 SessionLoaded; /* Transport mechanism signals */ @@ -328,6 +399,9 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop /* Step Editing status changed */ PBD::Signal1 StepEditStatusChange; + /* Timecode state signals */ + PBD::Signal0 MtcOrLtcInputPortChanged; + void queue_event (SessionEvent*); void request_roll_at_and_return (framepos_t start, framepos_t return_to); @@ -343,8 +417,8 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop void goto_start (); void use_rf_shuttle_speed (); void allow_auto_play (bool yn); - void request_transport_speed (double speed, bool as_default = false); - void request_transport_speed_nonzero (double, bool as_default = false); + void request_transport_speed (double speed, bool as_default = true); + void request_transport_speed_nonzero (double, bool as_default = true); void request_overwrite_buffer (Track *); void adjust_playback_buffering(); void adjust_capture_buffering(); @@ -392,14 +466,17 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop framecnt_t worst_input_latency () const { return _worst_input_latency; } framecnt_t worst_track_latency () const { return _worst_track_latency; } framecnt_t worst_playback_latency () const { return _worst_output_latency + _worst_track_latency; } - + struct SaveAs { std::string new_parent_folder; /* parent folder where new session folder will be created */ std::string new_name; /* name of newly saved session */ bool switch_to; /* true if we should be working on newly saved session after save-as; false otherwise */ + bool include_media; /* true if the newly saved session should contain references to media */ bool copy_media; /* true if media files (audio, media, etc) should be copied into newly saved session; false otherwise */ bool copy_external; /* true if external media should be consolidated into the newly saved session; false otherwise */ - + + std::string final_session_folder_name; /* filled in by * Session::save_as(), provides full path to newly saved session */ + /* emitted as we make progress. 3 arguments passed to signal * handler: * @@ -419,15 +496,22 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop }; int save_as (SaveAs&); - int save_state (std::string snapshot_name, bool pending = false, bool switch_to_snapshot = false); + /** save session + * @param snapshot_name name of the session (use an empty string for the current name) + * @param pending save a 'recovery', not full state (default: false) + * @param switch_to_snapshot switch to given snapshot after saving (default: false) + * @param template_only save a session template (default: false) + * @return zero on success + */ + int save_state (std::string snapshot_name, bool pending = false, bool switch_to_snapshot = false, bool template_only = false); int restore_state (std::string snapshot_name); - int save_template (std::string template_name); + int save_template (std::string template_name, bool replace_existing = false); int save_history (std::string snapshot_name = ""); int restore_history (std::string snapshot_name); void remove_state (std::string snapshot_name); void rename_state (std::string old_name, std::string new_name); void remove_pending_capture_state (); - int rename (const std::string&, bool after_copy = false); + int rename (const std::string&); bool get_nsm_state () const { return _under_nsm_control; } void set_nsm_state (bool state) { _under_nsm_control = state; } bool save_default_options (); @@ -443,10 +527,10 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop * * Argument is the snapshot name to use when saving. */ - PBD::Signal1 SaveSessionRequested; + PBD::Signal1 SaveSessionRequested; /* emitted during a session save to allow other entities to add state, via - * extra XML, to the session state + * extra XML, to the session state */ PBD::Signal0 SessionSaveUnderway; @@ -468,7 +552,8 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop Deletion = 0x4, InitialConnecting = 0x8, Loading = 0x10, - InCleanup = 0x20 + InCleanup = 0x20, + PeakCleanup = 0x40 }; StateOfTheState state_of_the_state() const { return _state_of_the_state; } @@ -516,30 +601,36 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop std::list > new_audio_track ( int input_channels, int output_channels, - TrackMode mode = Normal, - RouteGroup* route_group = 0, - uint32_t how_many = 1, - std::string name_template = "" - ); - - RouteList new_audio_route ( - int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many, std::string name_template = "" + RouteGroup* route_group, + uint32_t how_many, + std::string name_template, + PresentationInfo::order_t order, + TrackMode mode = Normal ); std::list > new_midi_track ( const ChanCount& input, const ChanCount& output, - boost::shared_ptr instrument = boost::shared_ptr(), - TrackMode mode = Normal, - RouteGroup* route_group = 0, uint32_t how_many = 1, std::string name_template = "" + boost::shared_ptr instrument, + Plugin::PresetRecord* pset, + RouteGroup* route_group, uint32_t how_many, std::string name_template, + PresentationInfo::order_t, + TrackMode mode = Normal ); - void remove_route (boost::shared_ptr); - void resort_routes (); - void resort_routes_using (boost::shared_ptr); + RouteList new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many, std::string name_template, PresentationInfo::Flag, PresentationInfo::order_t); + RouteList new_midi_route (RouteGroup* route_group, uint32_t how_many, std::string name_template, boost::shared_ptr instrument, Plugin::PresetRecord*, PresentationInfo::Flag, PresentationInfo::order_t); + + void remove_routes (boost::shared_ptr); + void remove_route (boost::shared_ptr); + + void resort_routes (); + void resort_routes_using (boost::shared_ptr); AudioEngine & engine() { return _engine; } AudioEngine const & engine () const { return _engine; } + static std::string default_track_name_pattern (DataType); + /* Time */ framepos_t transport_frame () const {return _transport_frame; } @@ -580,10 +671,12 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop 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(&_mtc_active)); } + bool synced_to_ltc () const { return config.get_external_sync() && Config->get_sync_source() == LTC && g_atomic_int_get (const_cast(&_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; } @@ -618,7 +711,9 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop void add_source (boost::shared_ptr); void remove_source (boost::weak_ptr); - void cleanup_regions(); + void cleanup_regions(); + bool can_cleanup_peakfiles () const; + int cleanup_peakfiles (); int cleanup_sources (CleanupReport&); int cleanup_trash_sources (CleanupReport&); @@ -642,6 +737,9 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop */ static PBD::Signal2 AskAboutSampleRateMismatch; + /** non interactive message */ + static PBD::Signal2 NotifyAboutSampleRateMismatch; + /** handlers should return !0 for use pending state, 0 for ignore it. */ static PBD::Signal0 AskAboutPendingState; @@ -672,6 +770,13 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop PBD::Signal1 AuditionActive; + /* session script */ + void register_lua_function (const std::string&, const std::string&, const LuaScriptParamList&); + void unregister_lua_function (const std::string& name); + std::vector registered_lua_functions (); + uint32_t registered_lua_function_count () const { return _n_lua_scripts; } + void scripts_changed (); // called from lua, updates _n_lua_scripts + /* flattening stuff */ boost::shared_ptr write_one_track (Track&, framepos_t start, framepos_t end, @@ -688,25 +793,28 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop static const SessionEvent::RTeventCallback rt_cleanup; - void set_solo (boost::shared_ptr, bool, SessionEvent::RTeventCallback after = rt_cleanup, bool group_override = false); - void set_just_one_solo (boost::shared_ptr, bool, SessionEvent::RTeventCallback after = rt_cleanup); - void cancel_solo_after_disconnect (boost::shared_ptr, bool upstream, SessionEvent::RTeventCallback after = rt_cleanup); - void set_mute (boost::shared_ptr, bool, SessionEvent::RTeventCallback after = rt_cleanup, bool group_override = false); - void set_listen (boost::shared_ptr, bool, SessionEvent::RTeventCallback after = rt_cleanup, bool group_override = false); - void set_record_enabled (boost::shared_ptr, bool, SessionEvent::RTeventCallback after = rt_cleanup, bool group_override = false); - void set_solo_isolated (boost::shared_ptr, bool, SessionEvent::RTeventCallback after = rt_cleanup, bool group_override = false); - void set_monitoring (boost::shared_ptr, MonitorChoice, SessionEvent::RTeventCallback after = rt_cleanup, bool group_override = false); - void set_exclusive_input_active (boost::shared_ptr rt, bool onoff, bool flip_others=false); + void clear_all_solo_state (boost::shared_ptr); + + /* Control-based methods */ + + void set_controls (boost::shared_ptr, double val, PBD::Controllable::GroupControlDisposition); + void set_control (boost::shared_ptr, double val, PBD::Controllable::GroupControlDisposition); + + void set_exclusive_input_active (boost::shared_ptr rt, bool onoff, bool flip_others = false); PBD::Signal1 SoloActive; PBD::Signal0 SoloChanged; PBD::Signal0 IsolatedChanged; + PBD::Signal0 MonitorChanged; + + PBD::Signal0 session_routes_reconnected; /* monitor/master out */ 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 monitor_out() const { return _monitor_out; } boost::shared_ptr master_out() const { return _master_out; } @@ -725,6 +833,12 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop static bool get_disable_all_loaded_plugins() { return _disable_all_loaded_plugins; } + static void set_bypass_all_loaded_plugins (bool yn) { + _bypass_all_loaded_plugins = yn; + } + static bool get_bypass_all_loaded_plugins() { + return _bypass_all_loaded_plugins; + } uint32_t next_send_id(); uint32_t next_aux_send_id(); @@ -773,15 +887,37 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop std::string next_undo() const { return _history.next_undo(); } std::string next_redo() const { return _history.next_redo(); } + /** begin collecting undo information + * + * This call must always be followed by either + * begin_reversible_command() or commit_reversible_command() + * + * @param cmd_name human readable name for the undo operation + */ void begin_reversible_command (const std::string& cmd_name); void begin_reversible_command (GQuark); + /** abort an open undo command + * This must only be called after begin_reversible_command () + */ void abort_reversible_command (); + /** finalize an undo command and commit pending transactions + * + * This must only be called after begin_reversible_command () + * @param cmd (additional) command to add + */ void commit_reversible_command (Command* cmd = 0); - void add_command (Command *const cmd) { - assert (_current_trans); - _current_trans->add_command (cmd); - } + void add_command (Command *const cmd); + + /** create an StatefulDiffCommand from the given object and add it to the stack. + * + * This function must only be called after begin_reversible_command. + * Failing to do so may lead to a crash. + * + * @param sfd the object to diff + * @returns the allocated StatefulDiffCommand (already added via add_command) + */ + PBD::StatefulDiffCommand* add_stateful_diff_command (boost::shared_ptr sfd); /** @return The list of operations that are currently in progress */ std::list const & current_operations () { @@ -817,6 +953,14 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop void maybe_update_session_range (framepos_t, framepos_t); + /* temporary hacks to allow selection to be pushed from GUI into backend. + Whenever we move the selection object into libardour, these will go away. + */ + void set_range_selection (framepos_t start, framepos_t end); + void set_object_selection (framepos_t start, framepos_t end); + void clear_range_selection (); + void clear_object_selection (); + /* buffers for gain and pan */ gain_t* gain_automation_buffer () const; @@ -840,7 +984,7 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop void* ptr, float opt ); - + static PBD::Signal0 SendFeedback; /* Speakers */ @@ -849,8 +993,10 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop /* Controllables */ + boost::shared_ptr processor_by_id (PBD::ID) const; + boost::shared_ptr controllable_by_id (const PBD::ID&); - boost::shared_ptr controllable_by_descriptor (const PBD::ControllableDescriptor&); + boost::shared_ptr controllable_by_descriptor (const ARDOUR::ControllableDescriptor&); void add_controllable (boost::shared_ptr); void remove_controllable (PBD::Controllable*); @@ -948,35 +1094,45 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop SceneChanger* scene_changer() const { return _scene_changer; } - boost::shared_ptr ltc_input_port() const; - boost::shared_ptr ltc_output_port() const; + /* asynchronous MIDI control ports */ - boost::shared_ptr ltc_input_io() { return _ltc_input; } - boost::shared_ptr ltc_output_io() { return _ltc_output; } + boost::shared_ptr midi_input_port () const; + boost::shared_ptr midi_output_port () const; + boost::shared_ptr mmc_output_port () const; + boost::shared_ptr mmc_input_port () const; + boost::shared_ptr scene_input_port () const; + boost::shared_ptr scene_output_port () const; - MIDI::Port* midi_input_port () const; - MIDI::Port* midi_output_port () const; - MIDI::Port* mmc_output_port () const; - MIDI::Port* mmc_input_port () const; + /* synchronous MIDI ports used for synchronization */ - MIDI::Port* scene_input_port () const; - MIDI::Port* scene_output_port () const; - - boost::shared_ptr scene_in () const; - boost::shared_ptr scene_out () const; - boost::shared_ptr midi_clock_output_port () const; boost::shared_ptr midi_clock_input_port () const; boost::shared_ptr mtc_output_port () const; boost::shared_ptr mtc_input_port () const; - + boost::shared_ptr ltc_input_port() const; + boost::shared_ptr ltc_output_port() const; + + boost::shared_ptr ltc_input_io() { return _ltc_input; } + boost::shared_ptr 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; } + protected: friend class AudioEngine; void set_block_size (pframes_t nframes); void set_frame_rate (framecnt_t nframes); +#ifdef USE_TRACKS_CODE_FEATURES void reconnect_existing_routes (bool withLock, bool reconnect_master = true, bool reconnect_inputs = true, bool reconnect_outputs = true); +#endif protected: friend class Route; @@ -987,6 +1143,10 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop int create (const std::string& mix_template, BusProfile*); void destroy (); + static guint _name_id_counter; + 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 @@ -1008,9 +1168,9 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop process_function_type last_process_function; bool _bounce_processing_active; bool waiting_for_sync_offset; - framecnt_t _base_frame_rate; - framecnt_t _current_frame_rate; //this includes video pullup offset - framecnt_t _nominal_frame_rate; //ignores audioengine setting, "native" SR + framecnt_t _base_frame_rate; // sample-rate of the session at creation time, "native" SR + framecnt_t _nominal_frame_rate; // overridden by audioengine setting + framecnt_t _current_frame_rate; // this includes video pullup offset int transport_sub_state; mutable gint _record_status; framepos_t _transport_frame; @@ -1036,6 +1196,7 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop framecnt_t _worst_track_latency; bool _have_captured; bool _non_soloed_outs_muted; + bool _listening; uint32_t _listen_cnt; uint32_t _solo_isolated_cnt; bool _writable; @@ -1043,6 +1204,11 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop bool _under_nsm_control; unsigned int _xrun_count; + void mtc_status_changed (bool); + PBD::ScopedConnection mtc_status_connection; + void ltc_status_changed (bool); + PBD::ScopedConnection ltc_status_connection; + void initialize_latencies (); void set_worst_io_latencies (); void set_worst_playback_latency (); @@ -1080,6 +1246,8 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop bool have_first_delta_accumulator; SlaveState _slave_state; + gint _mtc_active; + gint _ltc_active; framepos_t slave_wait_end; void reset_slave_state (); @@ -1096,8 +1264,8 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop framepos_t post_export_position; bool _exporting; - bool _export_started; bool _export_rolling; + framepos_t _export_preroll; boost::shared_ptr export_handler; boost::shared_ptr export_status; @@ -1162,6 +1330,8 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop void graph_reordered (); /** current snapshot name, without the .ardour suffix */ + void set_snapshot_name (const std::string &); + void save_snapshot_name (const std::string &); std::string _current_snapshot_name; XMLTree* state_tree; @@ -1172,6 +1342,7 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop gint _suspend_save; /* atomic */ volatile bool _save_queued; Glib::Threads::Mutex save_state_lock; + Glib::Threads::Mutex peak_cleanup_lock; int load_options (const XMLNode&); int load_state (std::string snapshot_name); @@ -1187,6 +1358,21 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop bool pending_abort; bool pending_auto_loop; + PBD::ReallocPool _mempool; + LuaState lua; + Glib::Threads::Mutex lua_lock; + luabridge::LuaRef * _lua_run; + luabridge::LuaRef * _lua_add; + luabridge::LuaRef * _lua_del; + luabridge::LuaRef * _lua_list; + luabridge::LuaRef * _lua_load; + luabridge::LuaRef * _lua_save; + luabridge::LuaRef * _lua_cleanup; + uint32_t _n_lua_scripts; + + void setup_lua (); + void try_run_lua (pframes_t); + Butler* _butler; static const PostTransportWork ProcessCannotProceedMask = @@ -1222,11 +1408,10 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop void update_skips (Location*, bool consolidate); void update_marks (Location* loc); - void update_loop (Location* loc); void consolidate_skips (Location*); void sync_locations_to_skips (); void _sync_locations_to_skips (); - + PBD::ScopedConnectionList skip_update_connections; bool _ignore_skips_updates; @@ -1239,12 +1424,14 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop void auto_loop_changed (Location *); void auto_loop_declick_range (Location *, framepos_t &, framepos_t &); - int ensure_engine (uint32_t desired_sample_rate); + int ensure_engine (uint32_t desired_sample_rate, bool); void pre_engine_init (std::string path); int post_engine_init (); int immediately_post_engine (); void remove_empty_sounds (); + void session_loaded (); + void setup_midi_control (); int midi_read (MIDI::Port *); @@ -1272,7 +1459,7 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop void *do_work(); /* Signal Forwarding */ - void emit_route_signals () const; + void emit_route_signals (); void emit_thread_run (); static void *emit_thread (void *); void emit_thread_start (); @@ -1285,6 +1472,45 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop pthread_cond_t _rt_emit_cond; bool _rt_emit_pending; + /* Auto Connect Thread */ + static void *auto_connect_thread (void *); + void auto_connect_thread_run (); + void auto_connect_thread_start (); + void auto_connect_thread_terminate (); + + pthread_t _auto_connect_thread; + bool _ac_thread_active; + pthread_mutex_t _auto_connect_mutex; + pthread_cond_t _auto_connect_cond; + + struct AutoConnectRequest { + public: + AutoConnectRequest (boost::shared_ptr r, bool ci, + const ChanCount& is, + const ChanCount& os, + const ChanCount& io, + const ChanCount& oo) + : route (boost::weak_ptr (r)) + , connect_inputs (ci) + , input_start (is) + , output_start (os) + , input_offset (io) + , output_offset (oo) + {} + + boost::weak_ptr route; + bool connect_inputs; + ChanCount input_start; + ChanCount output_start; + ChanCount input_offset; + ChanCount output_offset; + }; + + typedef std::queue AutoConnectQueue; + Glib::Threads::Mutex _auto_connect_queue_lock; + AutoConnectQueue _auto_connect_queue; + + void auto_connect (const AutoConnectRequest&); /* SessionEventManager interface */ @@ -1389,7 +1615,7 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop void flush_all_inserts (); int micro_locate (framecnt_t distance); void locate (framepos_t, bool with_roll, bool with_flush, bool with_loop=false, bool force=false, bool with_mmc=true); - void start_locate (framepos_t, bool with_roll, bool with_flush, bool with_loop=false, bool force=false); + void start_locate (framepos_t, bool with_roll, bool with_flush, bool for_loop_enabled=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, framepos_t destination_frame, bool abort = false, bool clear_state = false, bool as_default = false); @@ -1406,7 +1632,9 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop void engine_halted (); void xrun_recovery (); void set_track_loop (bool); - + bool select_playhead_priority_target (framepos_t&); + void follow_playhead_priority (); + /* These are synchronous and so can only be called from within the process * cycle */ @@ -1416,6 +1644,7 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop TempoMap *_tempo_map; void tempo_map_changed (const PBD::PropertyChange&); + void gui_tempo_map_changed (); /* edit/mix groups */ @@ -1430,9 +1659,12 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop SerializedRCUManager routes; - 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); + void add_routes (RouteList&, bool input_auto_connect, bool output_auto_connect, bool save, PresentationInfo::order_t); + void add_routes_inner (RouteList&, bool input_auto_connect, bool output_auto_connect, PresentationInfo::order_t); bool _adding_routes_in_progress; + bool _reconnecting_routes_in_progress; + bool _route_deletion_in_progress; + uint32_t destructive_index; boost::shared_ptr XMLRouteFactory (const XMLNode&, int); @@ -1440,11 +1672,9 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop void route_processors_changed (RouteProcessorChange); - bool find_route_name (std::string const &, uint32_t& id, char* name, size_t name_len, bool); + bool find_route_name (std::string const &, uint32_t& id, std::string& name, bool); void count_existing_track_channels (ChanCount& in, ChanCount& out); - void auto_connect_route (boost::shared_ptr route, ChanCount& existing_inputs, ChanCount& existing_outputs, - bool with_lock, bool connect_inputs = true, - ChanCount input_start = ChanCount (), ChanCount output_start = ChanCount ()); + void auto_connect_route (boost::shared_ptr, bool, const ChanCount&, const ChanCount&, const ChanCount& io = ChanCount(), const ChanCount& oo = ChanCount()); void midi_output_change_handler (IOChange change, void* /*src*/, boost::weak_ptr midi_track); /* track numbering */ @@ -1452,14 +1682,13 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop void reassign_track_numbers (); uint32_t _track_number_decimals; - /* mixer stuff */ + /* solo/mute/notifications */ - bool solo_update_disabled; + void route_listen_changed (PBD::Controllable::GroupControlDisposition, boost::weak_ptr); + void route_mute_changed (); + void route_solo_changed (bool self_solo_change, PBD::Controllable::GroupControlDisposition group_override, boost::weak_ptr); + void route_solo_isolated_changed (boost::weak_ptr); - void route_listen_changed (void *src, boost::weak_ptr); - void route_mute_changed (void *src); - void route_solo_changed (bool self_solo_change, void *src, boost::weak_ptr); - void route_solo_isolated_changed (void *src, boost::weak_ptr); void update_route_solo_state (boost::shared_ptr r = boost::shared_ptr()); void listen_position_changed (); @@ -1627,6 +1856,12 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop void set_play_range (std::list&, bool leave_rolling); void unset_play_range (); + /* temporary hacks to allow selection to be pushed from GUI into backend + Whenever we move the selection object into libardour, these will go away. + */ + Evoral::Range _range_selection; + Evoral::Range _object_selection; + /* main outs */ uint32_t main_outs; @@ -1666,39 +1901,57 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop void set_history_depth (uint32_t depth); static bool _disable_all_loaded_plugins; + static bool _bypass_all_loaded_plugins; mutable bool have_looped; ///< Used in ::audible_frame(*) - void update_have_rec_enabled_track (); + void update_route_record_state (); gint _have_rec_enabled_track; + gint _have_rec_disabled_track; static int ask_about_playlist_deletion (boost::shared_ptr); /* realtime "apply to set of routes" operations */ template SessionEvent* - get_rt_event (boost::shared_ptr rl, T targ, SessionEvent::RTeventCallback after, bool group_override, - void (Session::*method) (boost::shared_ptr, T, bool)) { + get_rt_event (boost::shared_ptr rl, T targ, SessionEvent::RTeventCallback after, PBD::Controllable::GroupControlDisposition group_override, + void (Session::*method) (boost::shared_ptr, T, PBD::Controllable::GroupControlDisposition)) { SessionEvent* ev = new SessionEvent (SessionEvent::RealTimeOperation, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0); ev->rt_slot = boost::bind (method, this, rl, targ, group_override); ev->rt_return = after; ev->event_loop = PBD::EventLoop::get_event_loop_for_thread (); - + + return ev; + } + + /* specialized version realtime "apply to set of routes" operations */ + template SessionEvent* + get_rt_event (boost::shared_ptr rl, T1 t1arg, T2 t2arg, SessionEvent::RTeventCallback after, PBD::Controllable::GroupControlDisposition group_override, + void (Session::*method) (boost::shared_ptr, T1, T2, PBD::Controllable::GroupControlDisposition)) { + SessionEvent* ev = new SessionEvent (SessionEvent::RealTimeOperation, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0); + ev->rt_slot = boost::bind (method, this, rl, t1arg, t2arg, group_override); + ev->rt_return = after; + ev->event_loop = PBD::EventLoop::get_event_loop_for_thread (); + return ev; } - void rt_cancel_solo_after_disconnect (boost::shared_ptr, bool upstream, bool /* ignored*/ ); - void rt_set_solo (boost::shared_ptr, bool yn, bool group_override); - void rt_set_just_one_solo (boost::shared_ptr, bool yn, bool /* ignored*/ ); - void rt_set_mute (boost::shared_ptr, bool yn, bool group_override); - void rt_set_listen (boost::shared_ptr, bool yn, bool group_override); - void rt_set_solo_isolated (boost::shared_ptr, bool yn, bool group_override); - void rt_set_record_enabled (boost::shared_ptr, bool yn, bool group_override); - void rt_set_monitoring (boost::shared_ptr, MonitorChoice, bool group_override); + /* specialized version realtime "apply to set of controls" operations */ + SessionEvent* get_rt_event (boost::shared_ptr cl, double arg, PBD::Controllable::GroupControlDisposition group_override) { + SessionEvent* ev = new SessionEvent (SessionEvent::RealTimeOperation, SessionEvent::Add, SessionEvent::Immediate, 0, 0.0); + ev->rt_slot = boost::bind (&Session::rt_set_controls, this, cl, arg, group_override); + ev->rt_return = Session::rt_cleanup; + ev->event_loop = PBD::EventLoop::get_event_loop_for_thread (); + + return ev; + } + + void rt_set_controls (boost::shared_ptr, double val, PBD::Controllable::GroupControlDisposition group_override); + void rt_clear_all_solo_state (boost::shared_ptr, bool yn, PBD::Controllable::GroupControlDisposition group_override); /** temporary list of Diskstreams used only during load of 2.X sessions */ std::list > _diskstreams_2X; - void add_session_range_location (framepos_t, framepos_t); + void set_session_range_location (framepos_t, framepos_t); void setup_midi_machine_control (); @@ -1724,8 +1977,7 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop */ GraphEdges _current_route_graph; - uint32_t next_control_id () const; - int32_t _order_hint; + void ensure_route_presentation_info_gap (PresentationInfo::order_t, uint32_t gap_size); bool ignore_route_processor_changes; MidiClockTicker* midi_clock; @@ -1733,24 +1985,30 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop boost::shared_ptr _ltc_input; boost::shared_ptr _ltc_output; - void reconnect_ltc_input (); - void reconnect_ltc_output (); - /* Scene Changing */ SceneChanger* _scene_changer; - + /* persistent, non-track related MIDI ports */ MidiPortManager* _midi_ports; MIDI::MachineControl* _mmc; - + void setup_ltc (); void setup_click (); void setup_click_state (const XMLNode*); void setup_bundles (); - + void save_as_bring_callback (uint32_t, uint32_t, std::string); static int get_session_info_from_path (XMLTree& state_tree, const std::string& xmlpath); + static const uint32_t session_end_shift; + + std::string _template_state_dir; + + VCAManager* _vca_manager; + + boost::shared_ptr get_midi_nth_route_by_id (PresentationInfo::order_t n) const; + + std::string created_with; };