class Butler;
class Click;
class ControllableDescriptor;
-class Diskstream;
+class CoreSelection;
class ExportHandler;
class ExportStatus;
class Graph;
virtual ~Session ();
- static int get_info_from_path (const std::string& xmlpath, float& sample_rate, SampleFormat& data_format, std::string& created_version);
+ static int get_info_from_path (const std::string& xmlpath, float& sample_rate, SampleFormat& data_format, std::string& program_version);
static std::string get_snapshot_from_instant (const std::string& session_dir);
/** a monotonic counter used for naming user-visible things uniquely
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&);
+ std::string new_midi_source_path (const std::string&, bool need_source_lock = true);
/** 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
*/
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,
+ std::vector<std::string> get_paths_for_new_sources (bool allow_replacing, const std::string& import_file_path,
uint32_t channels, std::vector<std::string> const & smf_track_names);
int bring_all_sources_into_session (boost::function<void(uint32_t,uint32_t,std::string)> callback);
void refresh_disk_space ();
- int load_diskstreams_2X (XMLNode const &, int);
-
int load_routes (const XMLNode&, int);
boost::shared_ptr<RouteList> get_routes() const {
return routes.reader ();
}
+ CoreSelection& selection () { return *_selection; }
+
/* 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
*/
void get_stripables (StripableList&) const;
+ StripableList get_stripables () const;
boost::shared_ptr<RouteList> get_tracks() const;
boost::shared_ptr<RouteList> get_routes_with_internal_returns() const;
boost::shared_ptr<RouteList> get_routes_with_regions_at (framepos_t const) const;
+ uint32_t nstripables (bool with_monitor = false) const;
uint32_t nroutes() const { return routes.reader()->size(); }
uint32_t ntracks () const;
uint32_t nbusses () const;
return _bundles.reader ();
}
- struct LIBARDOUR_API RoutePublicOrderSorter {
- bool operator() (boost::shared_ptr<Route>, boost::shared_ptr<Route> b);
- };
-
void notify_presentation_info_change ();
template<class T> void foreach_route (T *obj, void (T::*func)(Route&), bool sort = true);
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> stripable_by_id (PBD::ID) 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);
bool route_name_unique (std::string) const;
void allow_auto_play (bool yn);
void request_transport_speed (double speed, bool as_default = true);
void request_transport_speed_nonzero (double, bool as_default = true);
- void request_overwrite_buffer (Track *);
+ void request_overwrite_buffer (boost::shared_ptr<Route>);
void adjust_playback_buffering();
void adjust_capture_buffering();
- void request_track_speed (Track *, double speed);
- 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)); }
void set_auto_punch_location (Location *);
void set_auto_loop_location (Location *);
void set_session_extents (framepos_t start, framepos_t end);
+ bool end_is_free () const { return _session_range_end_is_free; }
void set_end_is_free (bool);
int location_name(std::string& result, std::string base = std::string(""));
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_template (const std::string& template_name, const std::string& description = "", 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);
framepos_t transport_frame () const {return _transport_frame; }
framepos_t record_location () const {return _last_record_location; }
- framepos_t audible_frame () const;
+ framepos_t audible_frame (bool* latent_locate = NULL) const;
framepos_t requested_return_frame() const { return _requested_return_frame; }
void set_requested_return_frame(framepos_t return_to);
bool synced_to_mtc () const { return config.get_external_sync() && Config->get_sync_source() == MTC && g_atomic_int_get (const_cast<gint*>(&_mtc_active)); }
bool synced_to_ltc () const { return config.get_external_sync() && Config->get_sync_source() == LTC && g_atomic_int_get (const_cast<gint*>(&_ltc_active)); }
- double transport_speed() const { return _transport_speed; }
+ double transport_speed() const { return _count_in_samples > 0 ? 0. : _transport_speed; }
bool transport_stopped() const { return _transport_speed == 0.0; }
- bool transport_rolling() const { return _transport_speed != 0.0; }
+ bool transport_rolling() const { return _transport_speed != 0.0 && _count_in_samples == 0; }
bool silent () { return _silent; }
boost::shared_ptr<Source> source_by_id (const PBD::ID&);
boost::shared_ptr<AudioFileSource> audio_source_by_path_and_channel (const std::string&, uint16_t) const;
- boost::shared_ptr<MidiSource> midi_source_by_path (const std::string&) const;
+ boost::shared_ptr<MidiSource> midi_source_by_path (const std::string&, bool need_source_lock) const;
uint32_t count_sources_by_origin (const std::string&);
void add_playlist (boost::shared_ptr<Playlist>, bool unused = false);
uint32_t registered_lua_function_count () const { return _n_lua_scripts; }
void scripts_changed (); // called from lua, updates _n_lua_scripts
+ PBD::Signal0<void> LuaScriptsChanged;
+
/* flattening stuff */
boost::shared_ptr<Region> write_one_track (Track&, framepos_t start, framepos_t end,
/* session-wide solo/mute/rec-enable */
+ bool muted() const;
+ std::vector<boost::weak_ptr<AutomationControl> > cancel_all_mute ();
+
bool soloing() const { return _non_soloed_outs_muted; }
bool listening() const { return _listen_cnt > 0; }
bool solo_isolated() const { return _solo_isolated_cnt > 0; }
PBD::Signal1<void,bool> SoloActive;
PBD::Signal0<void> SoloChanged;
+ PBD::Signal0<void> MuteChanged;
PBD::Signal0<void> IsolatedChanged;
PBD::Signal0<void> MonitorChanged;
PBD::Signal0<void> session_routes_reconnected;
/* monitor/master out */
+ int add_master_bus (ChanCount const&);
void add_monitor_section ();
void reset_monitor_section ();
boost::shared_ptr<Route> monitor_out() const { return _monitor_out; }
boost::shared_ptr<Route> master_out() const { return _master_out; }
+ PresentationInfo::order_t master_order_key () const { return _master_out ? _master_out->presentation_info ().order () : -1; }
+ bool ensure_stripable_sort_order ();
+
void globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p, bool);
void globally_set_send_gains_from_track (boost::shared_ptr<Route> dest);
void globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest);
void request_preroll_record_punch (framepos_t start, framecnt_t preroll);
void request_preroll_record_trim (framepos_t start, framecnt_t preroll);
+ void request_count_in_record ();
framepos_t preroll_record_punch_pos () const { return _preroll_record_punch_pos; }
bool preroll_record_punch_enabled () const { return _preroll_record_punch_pos >= 0; }
gain_t* gain_automation_buffer () const;
gain_t* trim_automation_buffer () const;
gain_t* send_gain_automation_buffer () const;
+ gain_t* scratch_automation_buffer () const;
pan_t** pan_automation_buffer () const;
void ensure_buffer_set (BufferSet& buffers, const ChanCount& howmany);
boost::shared_ptr<Processor> processor_by_id (PBD::ID) const;
boost::shared_ptr<PBD::Controllable> controllable_by_id (const PBD::ID&);
+ boost::shared_ptr<AutomationControl> automation_control_by_id (const PBD::ID&);
boost::shared_ptr<PBD::Controllable> controllable_by_descriptor (const ARDOUR::ControllableDescriptor&);
void add_controllable (boost::shared_ptr<PBD::Controllable>);
*/
static PBD::Signal3<int,Session*,std::string,DataType> MissingFile;
+ void set_missing_file_replacement (const std::string& mfr) {
+ _missing_file_replacement = mfr;
+ }
+
/** Emitted when the session wants Ardour to quit */
static PBD::Signal0<void> Quit;
void reconnect_ltc_output ();
VCAManager& vca_manager() { return *_vca_manager; }
+ VCAManager* vca_manager_ptr() { return _vca_manager; }
void auto_connect_thread_wakeup ();
bool _under_nsm_control;
unsigned int _xrun_count;
+ std::string _missing_file_replacement;
+
void mtc_status_changed (bool);
PBD::ScopedConnection mtc_status_connection;
void ltc_status_changed (bool);
Glib::Threads::Mutex save_state_lock;
Glib::Threads::Mutex peak_cleanup_lock;
- int load_options (const XMLNode&);
- int load_state (std::string snapshot_name);
+ int load_options (const XMLNode&);
+ int load_state (std::string snapshot_name);
+ static int parse_stateful_loading_version (const std::string&);
framepos_t _last_roll_location;
/** the session frame time at which we last rolled, located, or changed transport direction */
static const PostTransportWork ProcessCannotProceedMask =
PostTransportWork (
PostTransportInputChange|
- PostTransportSpeed|
PostTransportReverse|
PostTransportCurveRealloc|
PostTransportAudition|
void ltc_tx_recalculate_position();
void ltc_tx_parse_offset();
void ltc_tx_send_time_code_for_cycle (framepos_t, framepos_t, double, double, pframes_t nframes);
+ PBD::ScopedConnectionList ltc_tx_connections;
+
void reset_record_status ();
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 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);
void stop_transport (bool abort = false, bool clear_state = false);
void start_transport ();
TempoMap *_tempo_map;
void tempo_map_changed (const PBD::PropertyChange&);
- void gui_tempo_map_changed ();
/* edit/mix groups */
void update_latency (bool playback);
- XMLNode& state(bool);
+ enum snapshot_t {
+ NormalSave,
+ SnapshotKeep,
+ SwitchToSnapshot
+ };
+
+ XMLNode& state(bool, snapshot_t snapshot_type = NormalSave);
/* click track */
typedef std::list<Click*> Clicks;
Clicks clicks;
bool _clicking;
+ bool _click_rec_only;
boost::shared_ptr<IO> _click_io;
boost::shared_ptr<Amp> _click_gain;
Sample* click_data;
void add_click (framepos_t pos, bool emphasis);
framecnt_t _count_in_samples;
- std::vector<Route*> master_outs;
-
/* range playback */
std::list<AudioRange> current_audio_range;
framepos_t _preroll_record_punch_pos;
framecnt_t _preroll_record_trim_len;
+ bool _count_in_once;
/* main outs */
uint32_t main_outs;
void auto_connect_master_bus ();
- /* Windows VST support */
-
- long _windows_vst_callback (
- WindowsVSTPlugin*,
- long opcode,
- long index,
- long value,
- void* ptr,
- float opt
- );
-
int find_all_sources (std::string path, std::set<std::string>& result);
int find_all_sources_across_snapshots (std::set<std::string>& result, bool exclude_this_snapshot);
void rt_set_controls (boost::shared_ptr<ControlList>, double val, PBD::Controllable::GroupControlDisposition group_override);
void rt_clear_all_solo_state (boost::shared_ptr<RouteList>, bool yn, PBD::Controllable::GroupControlDisposition group_override);
- /** temporary list of Diskstreams used only during load of 2.X sessions */
- std::list<boost::shared_ptr<Diskstream> > _diskstreams_2X;
-
void set_session_range_location (framepos_t, framepos_t);
void setup_midi_machine_control ();
void rewire_selected_midi (boost::shared_ptr<MidiTrack>);
void rewire_midi_selection_ports ();
boost::weak_ptr<MidiTrack> current_midi_target;
+
+ CoreSelection* _selection;
};