X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fardour%2Fsession.h;h=082e05a9bdf26584f1699479a64f797ef25ac430;hb=9f4c7a9e9edd260a72f040b036982d4c5da89292;hp=6f12f31f327cdc90a2d392605cadb48a16e96715;hpb=221733e44604b5efec5569c91c377c7896ebed74;p=ardour.git diff --git a/libs/ardour/ardour/session.h b/libs/ardour/ardour/session.h index 6f12f31f32..082e05a9bd 100644 --- a/libs/ardour/ardour/session.h +++ b/libs/ardour/ardour/session.h @@ -1,5 +1,5 @@ /* - Copyright (C) 2000 Paul Davis + 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 @@ -20,42 +20,40 @@ #ifndef __ardour_session_h__ #define __ardour_session_h__ -#include #include #include -#include #include #include +#include +#include +#include +#include #include #include -#include - -#include +#include #include #include -#include -#include -#include -#include -#include - -#include -#include +#include "pbd/error.h" +#include "pbd/pool.h" +#include "pbd/rcu.h" +#include "pbd/statefuldestructible.h" +#include "pbd/undo.h" -#include -#include +#include "midi++/mmc.h" +#include "midi++/types.h" -#include -#include -#include -#include -#include +#include "pbd/destructible.h" +#include "pbd/stateful.h" -#include +#include "ardour/ardour.h" +#include "ardour/chan_count.h" +#include "ardour/configuration.h" +#include "ardour/location.h" +#include "ardour/smpte.h" class XMLTree; class XMLNode; @@ -69,55 +67,57 @@ namespace PBD { class Controllable; } +namespace Evoral { + class Curve; +} + namespace ARDOUR { -class Port; +class AudioDiskstream; class AudioEngine; -class Slave; -class Diskstream; -class Route; -class AuxInput; -class Source; +class AudioFileSource; +class AudioRegion; class AudioSource; +class AudioTrack; +class Auditioner; +class AutomationList; +class AuxInput; class BufferSet; - +class Bundle; +class ControlProtocolInfo; class Diskstream; -class AudioDiskstream; +class ExportHandler; +class ExportStatus; +class IO; +class IOProcessor; class MidiDiskstream; -class AudioFileSource; +class MidiRegion; class MidiSource; -class Auditioner; -class Insert; -class Send; -class Redirect; -class PortInsert; -class PluginInsert; -class Bundle; -class TempoMap; -class AudioTrack; +class MidiTrack; class NamedSelection; -class AudioRegion; - -class Region; class Playlist; -class VSTPlugin; -class ControlProtocolInfo; - -class MidiTrack; -class MidiRegion; +class PluginInsert; +class Port; +class PortInsert; +class Processor; +class Region; +class Route; +class RouteGroup; class SMFSource; - +class Send; class SessionDirectory; - -struct AudioExportSpecification; -struct RouteGroup; +class SessionMetadata; +class Slave; +class Source; +class TempoMap; +class VSTPlugin; using std::vector; using std::string; using std::map; using std::set; -class Session : public PBD::StatefulDestructible +class Session : public PBD::StatefulDestructible, public boost::noncopyable { private: typedef std::pair,bool> RouteBooleanState; @@ -133,121 +133,121 @@ class Session : public PBD::StatefulDestructible }; struct Event { - enum Type { - SetTransportSpeed, - SetDiskstreamSpeed, - Locate, - LocateRoll, - SetLoop, - PunchIn, - PunchOut, - RangeStop, - RangeLocate, - Overwrite, - SetSlaveSource, - Audition, - InputConfigurationChange, - SetAudioRange, - SetPlayRange, - - /* only one of each of these events - can be queued at any one time - */ - - StopOnce, - AutoLoop - }; - - enum Action { - Add, - Remove, - Replace, - Clear - }; + enum Type { + SetTransportSpeed, + SetDiskstreamSpeed, + Locate, + LocateRoll, + LocateRollLocate, + SetLoop, + PunchIn, + PunchOut, + RangeStop, + RangeLocate, + Overwrite, + SetSlaveSource, + Audition, + InputConfigurationChange, + SetAudioRange, + SetPlayRange, + + /* only one of each of these events can be queued at any one time */ + + StopOnce, + AutoLoop + }; + + enum Action { + Add, + Remove, + Replace, + Clear + }; + + Type type; + Action action; + nframes_t action_frame; + nframes_t target_frame; + double speed; + + union { + void* ptr; + bool yes_or_no; + nframes_t target2_frame; + SlaveSource slave; + Route* route; + }; + + list audio_range; + list music_range; - Type type; - Action action; - nframes_t action_frame; - nframes_t target_frame; - float speed; - - union { - void* ptr; - bool yes_or_no; - SlaveSource slave; - Route* route; - }; - - boost::shared_ptr region; - - list audio_range; - list music_range; - - Event(Type t, Action a, nframes_t when, nframes_t where, float spd, bool yn = false) - : type (t), - action (a), - action_frame (when), - target_frame (where), - speed (spd), - yes_or_no (yn) {} - - void set_ptr (void* p) { - ptr = p; - } - - bool before (const Event& other) const { - return action_frame < other.action_frame; - } - - bool after (const Event& other) const { - return action_frame > other.action_frame; - } - - static bool compare (const Event *e1, const Event *e2) { - return e1->before (*e2); - } - - void *operator new (size_t ignored) { - return pool.alloc (); - } - - void operator delete(void *ptr, size_t size) { - pool.release (ptr); - } - - static const nframes_t Immediate = 0; - - private: - static MultiAllocSingleReleasePool pool; + boost::shared_ptr region; + + Event(Type t, Action a, nframes_t when, nframes_t where, double spd, bool yn = false) + : type (t) + , action (a) + , action_frame (when) + , target_frame (where) + , speed (spd) + , yes_or_no (yn) + {} + + void set_ptr (void* p) { + ptr = p; + } + + bool before (const Event& other) const { + return action_frame < other.action_frame; + } + + bool after (const Event& other) const { + return action_frame > other.action_frame; + } + + static bool compare (const Event *e1, const Event *e2) { + return e1->before (*e2); + } + + void *operator new (size_t ignored) { + return pool.alloc (); + } + + void operator delete(void *ptr, size_t size) { + pool.release (ptr); + } + + static const nframes_t Immediate = 0; + + private: + static MultiAllocSingleReleasePool pool; }; /* creating from an XML file */ Session (AudioEngine&, - string fullpath, - string snapshot_name, - string* mix_template = 0); + const string& fullpath, + const string& snapshot_name, + string mix_template = ""); /* creating a new Session */ Session (AudioEngine&, - string fullpath, - string snapshot_name, - AutoConnectOption input_auto_connect, - AutoConnectOption output_auto_connect, - uint32_t control_out_channels, - uint32_t master_out_channels, - uint32_t n_physical_in, - uint32_t n_physical_out, - nframes_t initial_length); - + string fullpath, + string snapshot_name, + AutoConnectOption input_auto_connect, + AutoConnectOption output_auto_connect, + uint32_t control_out_channels, + uint32_t master_out_channels, + uint32_t n_physical_in, + uint32_t n_physical_out, + nframes_t initial_length); + virtual ~Session (); string path() const { return _path; } string name() const { return _name; } string snap_name() const { return _current_snapshot_name; } string raid_path () const; - string export_dir () const; void set_snap_name (); @@ -260,27 +260,35 @@ class Session : public PBD::StatefulDestructible const SessionDirectory& session_directory () const { return *(_session_dir.get()); } + static sigc::signal AutoBindingOn; + static sigc::signal AutoBindingOff; + + static sigc::signal Dialog; + + std::string sound_dir (bool with_path = true) const; + std::string peak_dir () const; + std::string dead_sound_dir () const; std::string automation_dir () const; + std::string analysis_dir() const; + + int ensure_subdirs (); + + Glib::ustring peak_path (Glib::ustring) const; + + static string change_source_path_by_name (string oldpath, string oldname, string newname, bool destructive); - static string suffixed_search_path (std::string suffix, bool data); - static string control_protocol_path (); - static string template_path (); - static string template_dir (); - static void get_template_list (list&); - - static string change_audio_path_by_name (string oldpath, string oldname, string newname, bool destructive); - static string change_midi_path_by_name (string oldpath, string oldname, string newname, bool destructive); - string peak_path_from_audio_path (string) const; - string audio_path_from_name (string, uint32_t nchans, uint32_t chan, bool destructive); - string midi_path_from_name (string); + string new_audio_source_name (const string&, uint32_t nchans, uint32_t chan, bool destructive); + string new_midi_source_name (const string&); + string new_source_path_from_name (DataType type, const string&); + RouteList new_route_from_template (uint32_t how_many, const std::string& template_path); void process (nframes_t nframes); BufferSet& get_silent_buffers (ChanCount count = ChanCount::ZERO); BufferSet& get_scratch_buffers (ChanCount count = ChanCount::ZERO); - BufferSet& get_send_buffers (ChanCount count = ChanCount::ZERO); - + BufferSet& get_mix_buffers (ChanCount count = ChanCount::ZERO); + void add_diskstream (boost::shared_ptr); boost::shared_ptr diskstream_by_id (const PBD::ID& id); boost::shared_ptr diskstream_by_name (string name); @@ -288,26 +296,33 @@ class Session : public PBD::StatefulDestructible bool have_captured() const { return _have_captured; } void refill_all_diskstream_buffers (); - uint32_t diskstream_buffer_size() const { return dstream_buffer_size; } - + uint32_t audio_diskstream_buffer_size() const { return audio_dstream_buffer_size; } + uint32_t midi_diskstream_buffer_size() const { return midi_dstream_buffer_size; } + uint32_t get_next_diskstream_id() const { return n_diskstreams(); } uint32_t n_diskstreams() const; - + typedef std::list > DiskstreamList; - typedef std::list > RouteList; - + + int load_routes (const XMLNode&); boost::shared_ptr get_routes() const { return routes.reader (); } - + uint32_t nroutes() const { return routes.reader()->size(); } uint32_t ntracks () const; uint32_t nbusses () const; + boost::shared_ptr bundles () { + return _bundles.reader (); + } + struct RoutePublicOrderSorter { bool operator() (boost::shared_ptr, boost::shared_ptr b); }; + void sync_order_keys (const char* base); + template void foreach_route (T *obj, void (T::*func)(Route&)); template void foreach_route (T *obj, void (T::*func)(boost::shared_ptr)); template void foreach_route (T *obj, void (T::*func)(Route&, A), A arg); @@ -318,7 +333,7 @@ class Session : public PBD::StatefulDestructible bool route_name_unique (string) const; - bool get_record_enabled() const { + bool get_record_enabled() const { return (record_status () >= Enabled); } @@ -334,7 +349,7 @@ class Session : public PBD::StatefulDestructible void maybe_enable_record (); void disable_record (bool rt_context, bool force = false); void step_back_from_record (); - + void maybe_write_autosave (); /* Proxy signal for region hidden changes */ @@ -342,9 +357,9 @@ class Session : public PBD::StatefulDestructible sigc::signal > RegionHiddenChange; /* Emitted when all i/o connections are complete */ - + sigc::signal IOConnectionsComplete; - + /* Record status signals */ sigc::signal RecordStateChanged; @@ -354,11 +369,15 @@ class Session : public PBD::StatefulDestructible sigc::signal TransportStateChange; /* generic */ sigc::signal PositionChanged; /* sent after any non-sequential motion */ sigc::signal DurationChanged; - sigc::signal HaltOnXrun; + sigc::signal Xrun; + sigc::signal TransportLooped; + + /** emitted when a locate has occurred */ + sigc::signal Located; sigc::signal RouteAdded; - void request_roll (); + void request_roll_at_and_return (nframes_t start, nframes_t return_to); void request_bounded_roll (nframes_t start, nframes_t end); void request_stop (bool abort = false); void request_locate (nframes_t frame, bool with_roll = false); @@ -373,28 +392,34 @@ class Session : public PBD::StatefulDestructible void set_session_end (nframes_t end) { end_location->set_start(end); _end_location_is_free = false; } void use_rf_shuttle_speed (); void allow_auto_play (bool yn); - void request_transport_speed (float speed); + void request_transport_speed (double speed); void request_overwrite_buffer (Diskstream*); - void request_diskstream_speed (Diskstream&, float speed); + void request_diskstream_speed (Diskstream&, double speed); void request_input_change_handling (); bool locate_pending() const { return static_cast(post_transport_work&PostTransportLocate); } bool transport_locked () const; int wipe (); - //int wipe_diskstream (AudioDiskstream *); int remove_region_from_region_list (boost::shared_ptr); nframes_t get_maximum_extent () const; nframes_t current_end_frame() const { return end_location->start(); } nframes_t current_start_frame() const { return start_location->start(); } + /// "actual" sample rate of session, set by current audioengine rate, pullup/down etc. nframes_t frame_rate() const { return _current_frame_rate; } + /// "native" sample rate of session, regardless of current audioengine rate, pullup/down etc + nframes_t nominal_frame_rate() const { return _nominal_frame_rate; } nframes_t frames_per_hour() const { return _frames_per_hour; } double frames_per_smpte_frame() const { return _frames_per_smpte_frame; } nframes_t smpte_frames_per_hour() const { return _smpte_frames_per_hour; } + MIDI::byte get_mtc_smpte_bits() const { + return mtc_smpte_bits; /* encoding of SMTPE type for MTC */ + } + float smpte_frames_per_second() const; bool smpte_drop_frames() const; @@ -416,23 +441,23 @@ class Session : public PBD::StatefulDestructible void remove_event (nframes_t frame, Event::Type type); void clear_events (Event::Type type); - nframes_t get_block_size() const { return current_block_size; } + nframes_t get_block_size() const { return current_block_size; } nframes_t worst_output_latency () const { return _worst_output_latency; } - nframes_t worst_input_latency () const { return _worst_input_latency; } - nframes_t worst_track_latency () const { return _worst_track_latency; } - - int save_state (string snapshot_name, bool pending = false); - int restore_state (string snapshot_name); - int save_template (string template_name); - int save_history (string snapshot_name = ""); - int restore_history (string snapshot_name); - void remove_state (string snapshot_name); - void rename_state (string old_name, string new_name); + nframes_t worst_input_latency () const { return _worst_input_latency; } + nframes_t worst_track_latency () const { return _worst_track_latency; } + + int save_state (std::string snapshot_name, bool pending = false); + int restore_state (std::string snapshot_name); + int save_template (std::string template_name); + 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 (); - static int rename_template (string old_name, string new_name); + static int rename_template (std::string old_name, std::string new_name); + static int delete_template (std::string name); - static int delete_template (string name); - sigc::signal StateSaved; sigc::signal StateReady; @@ -442,8 +467,10 @@ class Session : public PBD::StatefulDestructible XMLNode& get_state(); int set_state(const XMLNode& node); // not idempotent XMLNode& get_template(); - - void add_instant_xml (XMLNode&, const std::string& dir); + + /// The instant xml file is written to the session directory + void add_instant_xml (XMLNode&, bool write_to_config = true); + XMLNode* instant_xml (const std::string& str); enum StateOfTheState { Clean = 0x0, @@ -468,8 +495,8 @@ class Session : public PBD::StatefulDestructible sigc::signal edit_group_added; sigc::signal mix_group_added; - sigc::signal edit_group_removed; - sigc::signal mix_group_removed; + sigc::signal edit_group_removed; + sigc::signal mix_group_removed; void foreach_edit_group (sigc::slot sl) { for (list::iterator i = edit_groups.begin(); i != edit_groups.end(); i++) { @@ -485,19 +512,22 @@ class Session : public PBD::StatefulDestructible /* fundamental operations. duh. */ - std::list > new_audio_track (int input_channels, int output_channels, TrackMode mode = Normal, uint32_t how_many = 1); - RouteList new_audio_route (int input_channels, int output_channels, uint32_t how_many); + std::list > new_audio_track ( + int input_channels, int output_channels, TrackMode mode = Normal, uint32_t how_many = 1); - std::list > new_midi_track (TrackMode mode = Normal, uint32_t how_many = 1); - //boost::shared_ptr new_midi_route (uint32_t how_many = 1); + RouteList new_audio_route (int input_channels, int output_channels, uint32_t how_many); + + std::list > new_midi_track ( + TrackMode mode = Normal, uint32_t how_many = 1); void remove_route (boost::shared_ptr); void resort_routes (); void resort_routes_using (boost::shared_ptr); - - void set_remote_control_ids(); - AudioEngine &engine() { return _engine; }; + void set_remote_control_ids(); + + AudioEngine & engine() { return _engine; } + AudioEngine const & engine () const { return _engine; } int32_t max_level; int32_t min_level; @@ -506,6 +536,7 @@ class Session : public PBD::StatefulDestructible nframes_t transport_frame () const {return _transport_frame; } nframes_t audible_frame () const; + nframes64_t requested_return_frame() const { return _requested_return_frame; } enum PullupFormat { pullup_Plus4Plus1, @@ -523,8 +554,8 @@ class Session : public PBD::StatefulDestructible void sync_time_vars(); void bbt_time (nframes_t when, BBT_Time&); - void smpte_to_sample( SMPTE::Time& smpte, nframes_t& sample, bool use_offset, bool use_subframes ) const; - void sample_to_smpte( nframes_t sample, SMPTE::Time& smpte, bool use_offset, bool use_subframes ) const; + void smpte_to_sample(SMPTE::Time& smpte, nframes_t& sample, bool use_offset, bool use_subframes) const; + void sample_to_smpte(nframes_t sample, SMPTE::Time& smpte, bool use_offset, bool use_subframes) const; void smpte_time (SMPTE::Time &); void smpte_time (nframes_t when, SMPTE::Time&); void smpte_time_subframes (nframes_t when, SMPTE::Time&); @@ -533,38 +564,47 @@ class Session : public PBD::StatefulDestructible void smpte_duration_string (char *, nframes_t) const; void set_smpte_offset (nframes_t); - nframes_t smpte_offset () const { return _smpte_offset; } + nframes_t smpte_offset () const { return _smpte_offset; } void set_smpte_offset_negative (bool); bool smpte_offset_negative () const { return _smpte_offset_negative; } - nframes_t convert_to_frames_at (nframes_t position, AnyTime&); + nframes_t convert_to_frames_at (nframes_t position, AnyTime const &); static sigc::signal StartTimeChanged; static sigc::signal EndTimeChanged; static sigc::signal SMPTEOffsetChanged; - void request_slave_source (SlaveSource); - bool synced_to_jack() const { return Config->get_slave_source() == JACK; } + void request_slave_source (SlaveSource); + bool synced_to_jack() const { return Config->get_slave_source() == JACK; } - float transport_speed() const { return _transport_speed; } - bool transport_stopped() const { return _transport_speed == 0.0f; } - bool transport_rolling() const { return _transport_speed != 0.0f; } + 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; } + + void set_silent (bool yn); + bool silent () { return _silent; } int jack_slave_sync (nframes_t); TempoMap& tempo_map() { return *_tempo_map; } + + /// signals the current transport position in frames, bbt and smpte time (in that order) + sigc::signal tick; /* region info */ - sigc::signal > RegionAdded; - sigc::signal > RegionRemoved; + void add_regions (std::vector >&); - int region_name (string& result, string base = string(""), bool newlevel = false) const; + sigc::signal > RegionAdded; + sigc::signal >& > RegionsAdded; + sigc::signal > RegionRemoved; + + int region_name (string& result, string base = string(""), bool newlevel = false); string new_region_name (string); - string path_from_region_name (string name, string identifier); + string path_from_region_name (DataType type, string name, string identifier); boost::shared_ptr find_whole_file_parent (boost::shared_ptr); - + void find_equivalent_playlist_regions (boost::shared_ptr, std::vector >& result); boost::shared_ptr XMLRegionFactory (const XMLNode&, bool full); @@ -575,36 +615,39 @@ class Session : public PBD::StatefulDestructible /* source management */ - struct import_status : public InterThreadInfo { - string doing_what; - - /* control info */ - bool multichan; - bool sample_convert; - volatile bool freeze; - std::vector paths; - - /* result */ - std::vector > new_regions; + struct ImportStatus : public InterThreadInfo { + string doing_what; + + /* control info */ + uint32_t total; + SrcQuality quality; + volatile bool freeze; + std::vector paths; + bool replace_existing_source; + + /* result */ + SourceList sources; }; - int import_audiofile (import_status&); - bool sample_rate_convert (import_status&, string infile, string& outfile); + void import_audiofiles (ImportStatus&); + bool sample_rate_convert (ImportStatus&, string infile, string& outfile); string build_tmp_convert_name (string file); - SlaveSource post_export_slave; - nframes_t post_export_position; + boost::shared_ptr get_export_handler (); + boost::shared_ptr get_export_status (); - int start_audio_export (ARDOUR::AudioExportSpecification&); - int stop_audio_export (ARDOUR::AudioExportSpecification&); - void finalize_audio_export (); + int start_audio_export (nframes_t position, bool realtime); + + sigc::signal ProcessExport; + sigc::signal ExportReadFinished; + static sigc::signal Exported; void add_source (boost::shared_ptr); void remove_source (boost::weak_ptr); struct cleanup_report { - vector paths; - int64_t space; + vector paths; + int64_t space; }; int cleanup_sources (cleanup_report&); @@ -615,19 +658,21 @@ class Session : public PBD::StatefulDestructible int remove_last_capture (); - /* handlers should return -1 for "stop cleanup", 0 for - "yes, delete this playlist" and 1 for "no, don't delete - this playlist. + /** handlers should return -1 for "stop cleanup", + 0 for "yes, delete this playlist", + 1 for "no, don't delete this playlist". */ - sigc::signal > AskAboutPlaylistDeletion; - /* handlers should return !0 for use pending state, 0 for - ignore it. + /** handlers should return 0 for "ignore the rate mismatch", + !0 for "do not use this session" */ + static sigc::signal AskAboutSampleRateMismatch; + /** handlers should return !0 for use pending state, 0 for ignore it. + */ static sigc::signal AskAboutPendingState; - + boost::shared_ptr create_audio_source_for_session (ARDOUR::AudioDiskstream&, uint32_t which_channel, bool destructive); boost::shared_ptr create_midi_source_for_session (ARDOUR::MidiDiskstream&); @@ -638,7 +683,8 @@ class Session : public PBD::StatefulDestructible /* playlist management */ boost::shared_ptr playlist_by_name (string name); - void add_playlist (boost::shared_ptr); + void unassigned_playlists (std::list > & list); + void add_playlist (boost::shared_ptr, bool unused = false); sigc::signal > PlaylistAdded; sigc::signal > PlaylistRemoved; @@ -657,9 +703,8 @@ class Session : public PBD::StatefulDestructible sigc::signal NamedSelectionAdded; sigc::signal NamedSelectionRemoved; - /* Curves and AutomationLists (TODO when they go away) */ - void add_curve(Curve*); - void add_automation_list(AutomationList*); + /* Curves and AutomationLists (TODO when they go away) */ + void add_automation_list(AutomationList*); /* fade curves */ @@ -674,17 +719,17 @@ class Session : public PBD::StatefulDestructible void audition_region (boost::shared_ptr); void cancel_audition (); bool is_auditioning () const; - + sigc::signal AuditionActive; /* flattening stuff */ - int write_one_audio_track (AudioTrack&, nframes_t start, nframes_t cnt, bool overwrite, vector >&, - InterThreadInfo& wot); + boost::shared_ptr write_one_track (AudioTrack&, nframes_t start, nframes_t end, + bool overwrite, vector >&, InterThreadInfo& wot); int freeze (InterThreadInfo&); /* session-wide solo/mute/rec-enable */ - + bool soloing() const { return currently_soloing; } void set_all_solo (bool); @@ -692,7 +737,7 @@ class Session : public PBD::StatefulDestructible sigc::signal SoloActive; sigc::signal SoloChanged; - + void record_disenable_all (); void record_enable_all (); @@ -702,55 +747,62 @@ class Session : public PBD::StatefulDestructible boost::shared_ptr master_out() const { return _master_out; } /* insert/send management */ - + uint32_t n_port_inserts() const { return _port_inserts.size(); } uint32_t n_plugin_inserts() const { return _plugin_inserts.size(); } uint32_t n_sends() const { return _sends.size(); } + static void set_disable_all_loaded_plugins (bool yn) { + _disable_all_loaded_plugins = yn; + } + static bool get_disable_all_loaded_plugins() { + return _disable_all_loaded_plugins; + } + uint32_t next_send_id(); uint32_t next_insert_id(); void mark_send_id (uint32_t); void mark_insert_id (uint32_t); /* s/w "RAID" management */ - + nframes_t available_capture_duration(); /* I/O bundles */ - template void foreach_bundle (T *obj, void (T::*func)(Bundle *)); - void add_bundle (Bundle *); - void remove_bundle (Bundle *); - Bundle *bundle_by_name (string) const; + void add_bundle (boost::shared_ptr); + void remove_bundle (boost::shared_ptr); + boost::shared_ptr bundle_by_name (string) const; - sigc::signal BundleAdded; - sigc::signal BundleRemoved; + sigc::signal > BundleAdded; + sigc::signal > BundleRemoved; - /* MIDI */ + /* MIDI control */ + void midi_panic(void); int set_mtc_port (string port_tag); int set_mmc_port (string port_tag); int set_midi_port (string port_tag); + int set_midi_clock_port (string port_tag); MIDI::Port *mtc_port() const { return _mtc_port; } MIDI::Port *mmc_port() const { return _mmc_port; } MIDI::Port *midi_port() const { return _midi_port; } + MIDI::Port *midi_clock_port() const { return _midi_clock_port; } sigc::signal MTC_PortChanged; sigc::signal MMC_PortChanged; sigc::signal MIDI_PortChanged; + sigc::signal MIDIClock_PortChanged; void set_trace_midi_input (bool, MIDI::Port* port = 0); void set_trace_midi_output (bool, MIDI::Port* port = 0); bool get_trace_midi_input(MIDI::Port *port = 0); bool get_trace_midi_output(MIDI::Port *port = 0); - - void send_midi_message (MIDI::Port * port, MIDI::eventType ev, MIDI::channel_t, MIDI::EventTwoBytes); - void deliver_midi (MIDI::Port*, MIDI::byte*, int32_t size); + void set_mmc_receive_device_id (uint32_t id); + void set_mmc_send_device_id (uint32_t id); - void set_mmc_device_id (uint32_t id); - /* Scrubbing */ void start_scrub (nframes_t where); @@ -773,13 +825,13 @@ class Session : public PBD::StatefulDestructible } UndoHistory& history() { return _history; } - + uint32_t undo_depth() const { return _history.undo_depth(); } uint32_t redo_depth() const { return _history.redo_depth(); } string next_undo() const { return _history.next_undo(); } string next_redo() const { return _history.next_redo(); } - void begin_reversible_command (string cmd_name); + void begin_reversible_command (const string& cmd_name); void commit_reversible_command (Command* cmd = 0); void add_command (Command *const cmd) { @@ -788,9 +840,9 @@ class Session : public PBD::StatefulDestructible std::map registry; - // these commands are implemented in libs/ardour/session_command.cc + // these commands are implemented in libs/ardour/session_command.cc Command* memento_command_factory(XMLNode* n); - void register_with_memento_command_factory(PBD::ID, PBD::StatefulThingWithGoingAway*); + void register_with_memento_command_factory(PBD::ID, PBD::StatefulThingWithGoingAway*); Command* global_state_command_factory (const XMLNode& n); @@ -806,11 +858,11 @@ class Session : public PBD::StatefulDestructible GlobalRouteBooleanState before, after; Session& sess; void* src; - + }; - class GlobalSoloStateCommand : public GlobalRouteStateCommand - { + class GlobalSoloStateCommand : public GlobalRouteStateCommand + { public: GlobalSoloStateCommand (Session &, void *src); GlobalSoloStateCommand (Session&, const XMLNode&); @@ -818,10 +870,10 @@ class Session : public PBD::StatefulDestructible void undo(); XMLNode &get_state(); void mark(); - }; + }; - class GlobalMuteStateCommand : public GlobalRouteStateCommand - { + class GlobalMuteStateCommand : public GlobalRouteStateCommand + { public: GlobalMuteStateCommand(Session &, void *src); GlobalMuteStateCommand (Session&, const XMLNode&); @@ -829,10 +881,10 @@ class Session : public PBD::StatefulDestructible void undo(); XMLNode &get_state(); void mark(); - }; + }; - class GlobalRecordEnableStateCommand : public GlobalRouteStateCommand - { + class GlobalRecordEnableStateCommand : public GlobalRouteStateCommand + { public: GlobalRecordEnableStateCommand(Session &, void *src); GlobalRecordEnableStateCommand (Session&, const XMLNode&); @@ -840,10 +892,10 @@ class Session : public PBD::StatefulDestructible void undo(); XMLNode &get_state(); void mark(); - }; + }; - class GlobalMeteringStateCommand : public Command - { + class GlobalMeteringStateCommand : public Command + { public: GlobalMeteringStateCommand(Session &, void *src); GlobalMeteringStateCommand (Session&, const XMLNode&); @@ -858,26 +910,11 @@ class Session : public PBD::StatefulDestructible void* src; GlobalRouteMeterState before; GlobalRouteMeterState after; - }; + }; /* clicking */ - boost::shared_ptr click_io() { return _click_io; } - - /* tempo FX */ - - struct TimeStretchRequest { - boost::shared_ptr region; - float fraction; /* session: read ; GUI: write */ - float progress; /* session: write ; GUI: read */ - bool running; /* read/write */ - bool quick_seek; /* GUI: write */ - bool antialias; /* GUI: write */ - - TimeStretchRequest () {} - }; - - boost::shared_ptr tempoize_region (TimeStretchRequest&); + boost::shared_ptr click_io() { return _click_io; } /* disk, buffer loads */ @@ -888,8 +925,8 @@ class Session : public PBD::StatefulDestructible void reset_playback_load_min (); void reset_capture_load_min (); - - float read_data_rate () const; + + float read_data_rate () const; // in usec float write_data_rate () const; /* ranges */ @@ -905,31 +942,26 @@ class Session : public PBD::StatefulDestructible gain_t* gain_automation_buffer () const { return _gain_automation_buffer; } pan_t** pan_automation_buffer () const { return _pan_automation_buffer; } - /* buffers for conversion */ - enum RunContext { - ButlerContext = 0, - TransportContext, - ExportContext - }; - /* VST support */ static long vst_callback (AEffect* effect, - long opcode, - long index, - long value, - void* ptr, - float opt); + long opcode, + long index, + long value, + void* ptr, + float opt); static sigc::signal SendFeedback; /* Controllables */ - PBD::Controllable* controllable_by_id (const PBD::ID&); + boost::shared_ptr controllable_by_id (const PBD::ID&); - void add_controllable (PBD::Controllable*); + void add_controllable (boost::shared_ptr); void remove_controllable (PBD::Controllable*); + SessionMetadata & metadata () { return *_metadata; } + protected: friend class AudioEngine; void set_block_size (nframes_t nframes); @@ -944,14 +976,11 @@ class Session : public PBD::StatefulDestructible friend class Route; void schedule_curve_reallocation (); void update_latency_compensation (bool, bool); - + private: + int create (bool& new_session, const string& mix_template, nframes_t initial_length); void destroy (); - void initialize_start_and_end_locations(nframes_t start, nframes_t end); - bool create_session_file(); - bool create_session_file_from_template (const string& template_path); - nframes_t compute_initial_length (); enum SubState { @@ -969,34 +998,40 @@ class Session : public PBD::StatefulDestructible typedef void (Session::*process_function_type)(nframes_t); - AudioEngine &_engine; - mutable gint processing_prohibited; - /// the function called when the main JACK process callback happens + AudioEngine& _engine; + mutable gint processing_prohibited; process_function_type process_function; process_function_type last_process_function; bool waiting_for_sync_offset; - nframes_t _base_frame_rate; - nframes_t _current_frame_rate; //this includes video pullup offset + nframes_t _base_frame_rate; + nframes_t _current_frame_rate; //this includes video pullup offset + nframes_t _nominal_frame_rate; //ignores audioengine setting, "native" SR int transport_sub_state; - mutable gint _record_status; - nframes_t _transport_frame; + mutable gint _record_status; + volatile nframes_t _transport_frame; Location* end_location; Location* start_location; - Slave *_slave; - volatile float _transport_speed; - volatile float _desired_transport_speed; - float _last_transport_speed; + Slave* _slave; + bool _silent; + volatile double _transport_speed; + double _last_transport_speed; + // fixed point transport speed for varispeed playback + uint64_t phi; + // fixed point target transport speed for varispeed playback when tempo changes + uint64_t target_phi; + // fixed point phase for varispeed playback + uint64_t phase; bool auto_play_legal; - nframes_t _last_slave_transport_frame; - nframes_t maximum_output_latency; - nframes_t last_stop_frame; + nframes_t _last_slave_transport_frame; + nframes_t maximum_output_latency; + volatile nframes64_t _requested_return_frame; BufferSet* _scratch_buffers; BufferSet* _silent_buffers; - BufferSet* _send_buffers; - nframes_t current_block_size; - nframes_t _worst_output_latency; - nframes_t _worst_input_latency; - nframes_t _worst_track_latency; + BufferSet* _mix_buffers; + nframes_t current_block_size; + nframes_t _worst_output_latency; + nframes_t _worst_input_latency; + nframes_t _worst_track_latency; bool _have_captured; float _meter_hold; float _meter_falloff; @@ -1010,13 +1045,14 @@ class Session : public PBD::StatefulDestructible void update_latency_compensation_proxy (void* ignored); void ensure_buffers (ChanCount howmany); - + void process_scrub (nframes_t); void process_without_events (nframes_t); void process_with_events (nframes_t); void process_audition (nframes_t); - int process_export (nframes_t, ARDOUR::AudioExportSpecification*); - + void process_export (nframes_t); + int process_export_fw (nframes_t); + /* slave tracking */ static const int delta_accumulator_size = 25; @@ -1025,22 +1061,42 @@ class Session : public PBD::StatefulDestructible long average_slave_delta; int average_dir; bool have_first_delta_accumulator; - + enum SlaveState { Stopped, Waiting, Running }; - + SlaveState slave_state; nframes_t slave_wait_end; void reset_slave_state (); bool follow_slave (nframes_t, nframes_t); + void calculate_moving_average_of_slave_delta(int dir, nframes_t this_delta); + void track_slave_state( + float slave_speed, + nframes_t slave_transport_frame, + nframes_t this_delta, + bool starting); + void follow_slave_silently(nframes_t nframes, nframes_t offset, float slave_speed); + void set_slave_source (SlaveSource); + SlaveSource post_export_slave; + nframes_t post_export_position; + bool _exporting; - int prepare_to_export (ARDOUR::AudioExportSpecification&); + bool _exporting_realtime; + + boost::shared_ptr export_handler; + boost::shared_ptr export_status; + + int pre_export (); + int stop_audio_export (); + void finalize_audio_export (); + + sigc::connection export_freewheel_connection; void prepare_diskstreams (); void commit_diskstreams (nframes_t, bool& session_requires_butler); @@ -1060,7 +1116,6 @@ class Session : public PBD::StatefulDestructible } int get_transport_declick_required () { - if (transport_sub_state & PendingDeclickIn) { transport_sub_state &= ~PendingDeclickIn; return 1; @@ -1072,7 +1127,8 @@ class Session : public PBD::StatefulDestructible } bool maybe_stop (nframes_t limit) { - if ((_transport_speed > 0.0f && _transport_frame >= limit) || (_transport_speed < 0.0f && _transport_frame == 0)) { + if ( (_transport_speed > 0.0f && _transport_frame >= limit) + || (_transport_speed < 0.0f && _transport_frame == 0) ) { stop_transport (); return true; } @@ -1087,6 +1143,7 @@ class Session : public PBD::StatefulDestructible MIDI::Port* _mmc_port; MIDI::Port* _mtc_port; MIDI::Port* _midi_port; + MIDI::Port* _midi_clock_port; string _path; string _name; bool session_send_mmc; @@ -1094,9 +1151,9 @@ class Session : public PBD::StatefulDestructible bool session_midi_feedback; bool play_loop; bool loop_changing; - nframes_t last_loopend; + nframes_t last_loopend; - boost::scoped_ptr _session_dir; + boost::scoped_ptr _session_dir; RingBuffer pending_events; @@ -1116,33 +1173,35 @@ class Session : public PBD::StatefulDestructible int load_state (string snapshot_name); bool save_config_options_predicate (ConfigVariableBase::Owner owner) const; - nframes_t _last_roll_location; - nframes_t _last_record_location; - bool pending_locate_roll; - nframes_t pending_locate_frame; + nframes_t _last_roll_location; + nframes_t _last_record_location; + bool pending_locate_roll; + nframes_t pending_locate_frame; bool pending_locate_flush; bool pending_abort; bool pending_auto_loop; - + Sample* butler_mixdown_buffer; float* butler_gain_buffer; pthread_t butler_thread; Glib::Mutex butler_request_lock; - Glib::Cond butler_paused; + Glib::Cond butler_paused; bool butler_should_run; mutable gint butler_should_do_transport_work; int butler_request_pipe[2]; - inline bool transport_work_requested() const { return g_atomic_int_get(&butler_should_do_transport_work); } - + inline bool transport_work_requested() const { + return g_atomic_int_get(&butler_should_do_transport_work); + } + struct ButlerRequest { - enum Type { - Wake, - Run, - Pause, - Quit - }; + enum Type { + Wake, + Run, + Pause, + Quit + }; }; enum PostTransportWork { @@ -1162,17 +1221,18 @@ class Session : public PBD::StatefulDestructible PostTransportInputChange = 0x20000, PostTransportCurveRealloc = 0x40000 }; - - static const PostTransportWork ProcessCannotProceedMask = - PostTransportWork (PostTransportInputChange| - PostTransportSpeed| - PostTransportReverse| - PostTransportCurveRealloc| - PostTransportScrub| - PostTransportAudition| - PostTransportLocate| - PostTransportStop); - + + static const PostTransportWork ProcessCannotProceedMask = + PostTransportWork ( + PostTransportInputChange| + PostTransportSpeed| + PostTransportReverse| + PostTransportCurveRealloc| + PostTransportScrub| + PostTransportAudition| + PostTransportLocate| + PostTransportStop); + PostTransportWork post_transport_work; void summon_butler (); @@ -1232,10 +1292,10 @@ class Session : public PBD::StatefulDestructible void remove_empty_sounds (); void setup_midi_control (); - //int midi_read (MIDI::Port *); + int midi_read (MIDI::Port *); void enable_record (); - + void increment_transport_position (uint32_t val) { if (max_frames - val < _transport_frame) { _transport_frame = max_frames; @@ -1263,12 +1323,10 @@ class Session : public PBD::StatefulDestructible /* MIDI Machine Control */ void deliver_mmc (MIDI::MachineControl::Command, nframes_t); - //void deliver_midi_message (MIDI::Port * port, MIDI::eventType ev, MIDI::channel_t, MIDI::EventTwoBytes); - //void deliver_data (MIDI::Port* port, MIDI::byte*, int32_t size); - void spp_start (MIDI::Parser&); - void spp_continue (MIDI::Parser&); - void spp_stop (MIDI::Parser&); + void spp_start (MIDI::Parser&, nframes_t timestamp); + void spp_continue (MIDI::Parser&, nframes_t timestamp); + void spp_stop (MIDI::Parser&, nframes_t timestamp); void mmc_deferred_play (MIDI::MachineControl &); void mmc_stop (MIDI::MachineControl &); @@ -1300,7 +1358,7 @@ class Session : public PBD::StatefulDestructible nframes_t outbound_mtc_smpte_frame; SMPTE::Time transmitting_smpte_time; int next_quarter_frame_to_send; - + double _frames_per_smpte_frame; /* has to be floating point because of drop frame */ nframes_t _frames_per_hour; nframes_t _smpte_frames_per_hour; @@ -1312,86 +1370,57 @@ class Session : public PBD::StatefulDestructible bool last_smpte_valid; nframes_t last_smpte_when; SMPTE::Time last_smpte; - + bool _send_smpte_update; ///< Flag to send a full frame (SMPTE) MTC message this cycle int send_full_time_code(nframes_t nframes); int send_midi_time_code_for_cycle(nframes_t nframes); nframes_t adjust_apparent_position (nframes_t frames); - + void reset_record_status (); - + int no_roll (nframes_t nframes, nframes_t offset); - + bool non_realtime_work_pending() const { return static_cast(post_transport_work); } bool process_can_proceed() const { return !(post_transport_work & ProcessCannotProceedMask); } struct MIDIRequest { - - enum Type { - SendFullMTC, - SendMTC, - SendMMC, - PortChange, - SendMessage, - Deliver, - Quit - }; - - Type type; - MIDI::MachineControl::Command mmc_cmd; - nframes_t locate_frame; - - // for SendMessage type - - MIDI::Port * port; - MIDI::channel_t chan; - union { - MIDI::EventTwoBytes data; - MIDI::byte* buf; - }; - - union { - MIDI::eventType ev; - int32_t size; - }; - - MIDIRequest () {} - - void *operator new(size_t ignored) { - return pool.alloc (); - }; - - void operator delete(void *ptr, size_t size) { - pool.release (ptr); - } - - private: - static MultiAllocSingleReleasePool pool; + enum Type { + PortChange, + Quit + }; + Type type; }; - mutable gint butler_active; - + Glib::Mutex midi_lock; + pthread_t midi_thread; + int midi_request_pipe[2]; + RingBuffer midi_requests; + + int start_midi_thread (); + void terminate_midi_thread (); + void poke_midi_thread (); + static void *_midi_thread_work (void *arg); + void midi_thread_work (); void change_midi_ports (); int use_config_midi_ports (); - bool waiting_to_start; - void set_play_loop (bool yn); void overwrite_some_buffers (Diskstream*); - void flush_all_redirects (); + void flush_all_inserts (); + int micro_locate (nframes_t distance); void locate (nframes_t, bool with_roll, bool with_flush, bool with_loop=false); void start_locate (nframes_t, bool with_roll, bool with_flush, bool with_loop=false); void force_locate (nframes_t frame, bool with_roll = false); - void set_diskstream_speed (Diskstream*, float speed); - void set_transport_speed (float speed, bool abort = false); + void set_diskstream_speed (Diskstream*, double speed); + void set_transport_speed (double speed, bool abort = false); void stop_transport (bool abort = false); void start_transport (); - void actually_start_transport (); void realtime_stop (bool abort); void non_realtime_start_scrub (); void non_realtime_set_speed (); + 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 butler_transport_work (); @@ -1414,39 +1443,43 @@ class Session : public PBD::StatefulDestructible /* disk-streams */ - SerializedRCUManager diskstreams; + SerializedRCUManager diskstreams; - uint32_t dstream_buffer_size; - int load_diskstreams (const XMLNode&); + uint32_t audio_dstream_buffer_size; + uint32_t midi_dstream_buffer_size; + int load_diskstreams (const XMLNode&); /* routes stuff */ SerializedRCUManager routes; - void add_routes (RouteList&, bool save = true); + void add_routes (RouteList&, bool save); uint32_t destructive_index; - int load_routes (const XMLNode&); boost::shared_ptr XMLRouteFactory (const XMLNode&); /* mixer stuff */ bool solo_update_disabled; bool currently_soloing; - + void route_mute_changed (void *src); void route_solo_changed (void *src, boost::weak_ptr); void catch_up_on_solo (); + void catch_up_on_solo_mute_override (); void update_route_solo_state (); void modify_solo_mute (bool, bool); void strip_portname_for_solo (string& portname); /* REGION MANAGEMENT */ + std::map region_name_map; + void update_region_name_map (boost::shared_ptr); + mutable Glib::Mutex region_lock; typedef map > RegionList; RegionList regions; - + void add_region (boost::shared_ptr); void region_changed (Change, boost::weak_ptr); void remove_region (boost::weak_ptr); @@ -1454,19 +1487,23 @@ class Session : public PBD::StatefulDestructible int load_regions (const XMLNode& node); /* SOURCES */ - + mutable Glib::Mutex source_lock; typedef std::map > SourceMap; SourceMap sources; + public: + SourceMap get_sources() { return sources; } + + private: int load_sources (const XMLNode& node); XMLNode& get_sources_as_xml (); boost::shared_ptr XMLSourceFactory (const XMLNode&); /* PLAYLISTS */ - + mutable Glib::Mutex playlist_lock; typedef set > PlaylistList; PlaylistList playlists; @@ -1495,7 +1532,6 @@ class Session : public PBD::StatefulDestructible NamedSelection *XMLNamedSelectionFactory (const XMLNode&); /* CURVES and AUTOMATION LISTS */ - std::map curves; std::map automation_lists; /* DEFAULT FADE CURVES */ @@ -1517,44 +1553,43 @@ class Session : public PBD::StatefulDestructible int flatten_one_track (AudioTrack&, nframes_t start, nframes_t cnt); /* INSERT AND SEND MANAGEMENT */ - - list _port_inserts; - list _plugin_inserts; - list _sends; - boost::dynamic_bitset send_bitset; - boost::dynamic_bitset insert_bitset; - uint32_t send_cnt; - uint32_t insert_cnt; + + list _port_inserts; + list _plugin_inserts; + list _sends; + boost::dynamic_bitset send_bitset; + boost::dynamic_bitset insert_bitset; + uint32_t send_cnt; + uint32_t insert_cnt; - void add_redirect (Redirect *); - void remove_redirect (Redirect *); + void add_processor (Processor *); + void remove_processor (Processor *); /* S/W RAID */ struct space_and_path { - uint32_t blocks; /* 4kB blocks */ - string path; - - space_and_path() { - blocks = 0; - } + uint32_t blocks; /* 4kB blocks */ + string path; + + space_and_path() { + blocks = 0; + } }; struct space_and_path_ascending_cmp { - bool operator() (space_and_path a, space_and_path b) { - return a.blocks > b.blocks; - } + bool operator() (space_and_path a, space_and_path b) { + return a.blocks > b.blocks; + } }; - + void setup_raid_path (string path); vector session_dirs; vector::iterator last_rr_session_dir; uint32_t _total_free_4k_blocks; Glib::Mutex space_lock; - - string old_sound_dir (bool with_path = true) const; + string get_best_session_directory_for_new_source (); void refresh_disk_space (); @@ -1565,10 +1600,9 @@ class Session : public PBD::StatefulDestructible /* I/O bundles */ - typedef list BundleList; - mutable Glib::Mutex bundle_lock; - BundleList _bundles; - int load_bundles (const XMLNode&); + SerializedRCUManager _bundles; + XMLNode* _bundle_xml_node; + int load_bundles (XMLNode const &); void reverse_diskstream_buffers (); @@ -1595,40 +1629,40 @@ class Session : public PBD::StatefulDestructible /* click track */ struct Click { - nframes_t start; - nframes_t duration; - nframes_t offset; - const Sample *data; - - Click (nframes_t s, nframes_t d, const Sample *b) - : start (s), duration (d), data (b) { offset = 0; } - - void *operator new(size_t ignored) { - return pool.alloc (); - }; - - void operator delete(void *ptr, size_t size) { - pool.release (ptr); - } - - private: - static Pool pool; + nframes_t start; + nframes_t duration; + nframes_t offset; + const Sample *data; + + Click (nframes_t s, nframes_t d, const Sample *b) + : start (s), duration (d), data (b) { offset = 0; } + + void *operator new(size_t ignored) { + return pool.alloc (); + }; + + void operator delete(void *ptr, size_t size) { + pool.release (ptr); + } + + private: + static Pool pool; }; - + typedef list Clicks; - Clicks clicks; - bool _clicking; + Clicks clicks; + bool _clicking; boost::shared_ptr _click_io; - Sample* click_data; - Sample* click_emphasis_data; - nframes_t click_length; - nframes_t click_emphasis_length; - mutable Glib::RWLock click_lock; + Sample* click_data; + Sample* click_emphasis_data; + nframes_t click_length; + nframes_t click_emphasis_length; + mutable Glib::RWLock click_lock; - static const Sample default_click[]; + static const Sample default_click[]; static const nframes_t default_click_length; - static const Sample default_click_emphasis[]; + static const Sample default_click_emphasis[]; static const nframes_t default_click_emphasis_length; Click *get_click(); @@ -1637,7 +1671,7 @@ class Session : public PBD::StatefulDestructible void click (nframes_t start, nframes_t nframes, nframes_t offset); vector master_outs; - + /* range playback */ list current_audio_range; @@ -1647,7 +1681,7 @@ class Session : public PBD::StatefulDestructible /* main outs */ uint32_t main_outs; - + boost::shared_ptr _master_out; boost::shared_ptr _control_out; @@ -1659,11 +1693,11 @@ class Session : public PBD::StatefulDestructible /* VST support */ long _vst_callback (VSTPlugin*, - long opcode, - long index, - long value, - void* ptr, - float opt); + long opcode, + long index, + long value, + void* ptr, + float opt); /* number of hardware ports we're using, based on max (requested,available) @@ -1672,7 +1706,11 @@ class Session : public PBD::StatefulDestructible uint32_t n_physical_outputs; uint32_t n_physical_inputs; - void remove_pending_capture_state (); + uint32_t n_physical_audio_outputs; + uint32_t n_physical_audio_inputs; + + uint32_t n_physical_midi_outputs; + uint32_t n_physical_midi_inputs; int find_all_sources (std::string path, std::set& result); int find_all_sources_across_snapshots (std::set& result, bool exclude_this_snapshot); @@ -1680,7 +1718,7 @@ class Session : public PBD::StatefulDestructible LayerModel layer_model; CrossfadeModel xfade_model; - typedef std::set Controllables; + typedef std::set > Controllables; Glib::Mutex controllables_lock; Controllables controllables; @@ -1691,7 +1729,15 @@ class Session : public PBD::StatefulDestructible void config_changed (const char*); 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(*) }; } // namespace ARDOUR