#include "libardour-config.h"
+#include <exception>
#include <list>
#include <map>
#include <set>
#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 "lua/luastate.h"
+
#include "evoral/types.hpp"
#include "midi++/types.h"
#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/rc_configuration.h"
#include "ardour/session_configuration.h"
#include "ardour/session_event.h"
-#include "ardour/location.h"
#include "ardour/interpolation.h"
+#include "ardour/route.h"
#include "ardour/route_graph.h"
class ControllableDescriptor;
}
+namespace luabridge {
+ class LuaRef;
+}
+
namespace Evoral {
class Curve;
}
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;
+};
+
class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::ScopedConnectionList, public SessionEventManager
{
public:
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);
std::string path() const { return _path; }
std::string name() const { return _name; }
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 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; }
PBD::Signal0<void> DirtyChanged;
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);
+ 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<std::string> get_paths_for_new_sources (bool allow_replacing, const std::string& import_file_path, uint32_t channels);
int bring_all_sources_into_session (boost::function<void(uint32_t,uint32_t,std::string)> callback);
boost::shared_ptr<Route> route_by_name (std::string);
boost::shared_ptr<Route> route_by_id (PBD::ID);
boost::shared_ptr<Route> route_by_remote_id (uint32_t id);
+ boost::shared_ptr<Route> route_by_selected_count (uint32_t cnt);
boost::shared_ptr<Track> track_by_diskstream_id (PBD::ID);
void routes_using_input_from (const std::string& str, RouteList& rl);
void maybe_enable_record ();
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 ();
/* Timecode status signals */
PBD::Signal1<void, bool> MTCSyncStateChanged;
- PBD::Signal1<void, bool> LTCSyncStateChanged;
+ PBD::Signal1<void, bool> LTCSyncStateChanged;
/* Record status signals */
/* Timecode state signals */
PBD::Signal0<void> MtcOrLtcInputPortChanged;
-
+
void queue_event (SessionEvent*);
void request_roll_at_and_return (framepos_t start, framepos_t return_to);
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();
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 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:
*
int save_as (SaveAs&);
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);
*
* Argument is the snapshot name to use when saving.
*/
- PBD::Signal1<void,std::string> SaveSessionRequested;
+ PBD::Signal1<void,std::string> 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<void> SessionSaveUnderway;
Deletion = 0x4,
InitialConnecting = 0x8,
Loading = 0x10,
- InCleanup = 0x20
+ InCleanup = 0x20,
+ PeakCleanup = 0x40
};
StateOfTheState state_of_the_state() const { return _state_of_the_state; }
std::list<boost::shared_ptr<MidiTrack> > new_midi_track (
const ChanCount& input, const ChanCount& output,
boost::shared_ptr<PluginInfo> instrument = boost::shared_ptr<PluginInfo>(),
- TrackMode mode = Normal,
+ TrackMode mode = Normal,
RouteGroup* route_group = 0, uint32_t how_many = 1, std::string name_template = ""
);
AudioEngine const & engine () const { return _engine; }
static std::string default_track_name_pattern (DataType);
-
+
/* Time */
framepos_t transport_frame () const {return _transport_frame; }
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<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; }
bool transport_stopped() const { return _transport_speed == 0.0f; }
bool transport_rolling() const { return _transport_speed != 0.0f; }
void add_source (boost::shared_ptr<Source>);
void remove_source (boost::weak_ptr<Source>);
- void cleanup_regions();
+ void cleanup_regions();
+ bool can_cleanup_peakfiles () const;
+ int cleanup_peakfiles ();
int cleanup_sources (CleanupReport&);
int cleanup_trash_sources (CleanupReport&);
PBD::Signal1<void,bool> 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<std::string> 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<Region> write_one_track (Track&, framepos_t start, framepos_t end,
static const SessionEvent::RTeventCallback rt_cleanup;
- void set_solo (boost::shared_ptr<RouteList>, bool, SessionEvent::RTeventCallback after = rt_cleanup, bool group_override = false);
+ void set_solo (boost::shared_ptr<RouteList>, bool, SessionEvent::RTeventCallback after = rt_cleanup, PBD::Controllable::GroupControlDisposition group_override = PBD::Controllable::UseGroup);
+ void clear_all_solo_state (boost::shared_ptr<RouteList>);
void set_just_one_solo (boost::shared_ptr<Route>, bool, SessionEvent::RTeventCallback after = rt_cleanup);
- void cancel_solo_after_disconnect (boost::shared_ptr<Route>, bool upstream, SessionEvent::RTeventCallback after = rt_cleanup);
- void set_mute (boost::shared_ptr<RouteList>, bool, SessionEvent::RTeventCallback after = rt_cleanup, bool group_override = false);
- void set_listen (boost::shared_ptr<RouteList>, bool, SessionEvent::RTeventCallback after = rt_cleanup, bool group_override = false);
- void set_record_enabled (boost::shared_ptr<RouteList>, bool, SessionEvent::RTeventCallback after = rt_cleanup, bool group_override = false);
- void set_record_safe (boost::shared_ptr<RouteList>, bool yn, SessionEvent::RTeventCallback after = rt_cleanup, bool group_override = false);
- void set_solo_isolated (boost::shared_ptr<RouteList>, bool, SessionEvent::RTeventCallback after = rt_cleanup, bool group_override = false);
- void set_monitoring (boost::shared_ptr<RouteList>, MonitorChoice, SessionEvent::RTeventCallback after = rt_cleanup, bool group_override = false);
- void set_exclusive_input_active (boost::shared_ptr<RouteList> rt, bool onoff, bool flip_others=false);
+ void set_mute (boost::shared_ptr<RouteList>, bool, SessionEvent::RTeventCallback after = rt_cleanup, PBD::Controllable::GroupControlDisposition group_override = PBD::Controllable::UseGroup);
+ void set_listen (boost::shared_ptr<RouteList>, bool, SessionEvent::RTeventCallback after = rt_cleanup, PBD::Controllable::GroupControlDisposition group_override = PBD::Controllable::UseGroup);
+ void set_record_enabled (boost::shared_ptr<RouteList>, bool, SessionEvent::RTeventCallback after = rt_cleanup, PBD::Controllable::GroupControlDisposition group_override = PBD::Controllable::UseGroup);
+ void set_record_safe (boost::shared_ptr<RouteList>, bool yn, SessionEvent::RTeventCallback after = rt_cleanup, PBD::Controllable::GroupControlDisposition group_override = PBD::Controllable::UseGroup);
+ void set_solo_isolated (boost::shared_ptr<RouteList>, bool, SessionEvent::RTeventCallback after = rt_cleanup, PBD::Controllable::GroupControlDisposition group_override = PBD::Controllable::UseGroup);
+ void set_monitoring (boost::shared_ptr<RouteList>, MonitorChoice, SessionEvent::RTeventCallback after = rt_cleanup, PBD::Controllable::GroupControlDisposition group_override = PBD::Controllable::UseGroup);
+ void set_exclusive_input_active (boost::shared_ptr<RouteList> rt, bool onoff, bool flip_others = false);
PBD::Signal1<void,bool> SoloActive;
PBD::Signal0<void> SoloChanged;
PBD::Signal0<void> IsolatedChanged;
+ PBD::Signal0<void> MonitorChanged;
PBD::Signal0<void> session_routes_reconnected;
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<Route> monitor_out() const { return _monitor_out; }
boost::shared_ptr<Route> master_out() const { return _master_out; }
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;
void* ptr,
float opt
);
-
+
static PBD::Signal0<void> SendFeedback;
/* Speakers */
/* Controllables */
+ boost::shared_ptr<Processor> processor_by_id (PBD::ID) const;
+
boost::shared_ptr<PBD::Controllable> controllable_by_id (const PBD::ID&);
boost::shared_ptr<PBD::Controllable> controllable_by_descriptor (const PBD::ControllableDescriptor&);
SceneChanger* scene_changer() const { return _scene_changer; }
- boost::shared_ptr<Port> ltc_input_port() const;
- boost::shared_ptr<Port> ltc_output_port() const;
+ /* asynchronous MIDI control ports */
- boost::shared_ptr<IO> ltc_input_io() { return _ltc_input; }
- boost::shared_ptr<IO> ltc_output_io() { return _ltc_output; }
+ boost::shared_ptr<Port> midi_input_port () const;
+ boost::shared_ptr<Port> midi_output_port () const;
+ boost::shared_ptr<Port> mmc_output_port () const;
+ boost::shared_ptr<Port> mmc_input_port () const;
+ boost::shared_ptr<Port> scene_input_port () const;
+ boost::shared_ptr<Port> 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<MidiPort> scene_in () const;
- boost::shared_ptr<MidiPort> scene_out () const;
-
boost::shared_ptr<MidiPort> midi_clock_output_port () const;
boost::shared_ptr<MidiPort> midi_clock_input_port () const;
boost::shared_ptr<MidiPort> mtc_output_port () const;
boost::shared_ptr<MidiPort> mtc_input_port () const;
-
+ boost::shared_ptr<Port> ltc_input_port() const;
+ boost::shared_ptr<Port> ltc_output_port() const;
+
+ boost::shared_ptr<IO> ltc_input_io() { return _ltc_input; }
+ boost::shared_ptr<IO> ltc_output_io() { return _ltc_output; }
+
MIDI::MachineControl& mmc() { return *_mmc; }
void reconnect_midi_scene_ports (bool);
void reconnect_ltc_input ();
void reconnect_ltc_output ();
-
+
protected:
friend class AudioEngine;
void set_block_size (pframes_t nframes);
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;
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 ();
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;
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);
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 =
void consolidate_skips (Location*);
void sync_locations_to_skips ();
void _sync_locations_to_skips ();
-
+
PBD::ScopedConnectionList skip_update_connections;
bool _ignore_skips_updates;
int post_engine_init ();
int immediately_post_engine ();
void remove_empty_sounds ();
-
+
void session_loaded ();
void setup_midi_control ();
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);
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
*/
/* mixer stuff */
- bool solo_update_disabled;
-
- void route_listen_changed (void *src, boost::weak_ptr<Route>);
- void route_mute_changed (void *src);
- void route_solo_changed (bool self_solo_change, void *src, boost::weak_ptr<Route>);
- void routes_solo_changed (boost::shared_ptr<RouteList> solo_change_routes);
- void route_solo_isolated_changed (void *src, boost::weak_ptr<Route>);
+ void route_listen_changed (PBD::Controllable::GroupControlDisposition, boost::weak_ptr<Route>);
+ void route_mute_changed ();
+ void route_solo_changed (bool self_solo_change, PBD::Controllable::GroupControlDisposition group_override, boost::weak_ptr<Route>);
+ void route_solo_isolated_changed (boost::weak_ptr<Route>);
void update_route_solo_state (boost::shared_ptr<RouteList> r = boost::shared_ptr<RouteList>());
void listen_position_changed ();
*/
Evoral::Range<framepos_t> _range_selection;
Evoral::Range<framepos_t> _object_selection;
-
+
/* main outs */
uint32_t main_outs;
/* realtime "apply to set of routes" operations */
template<typename T> SessionEvent*
- get_rt_event (boost::shared_ptr<RouteList> rl, T targ, SessionEvent::RTeventCallback after, bool group_override,
- void (Session::*method) (boost::shared_ptr<RouteList>, T, bool)) {
+ get_rt_event (boost::shared_ptr<RouteList> rl, T targ, SessionEvent::RTeventCallback after, PBD::Controllable::GroupControlDisposition group_override,
+ void (Session::*method) (boost::shared_ptr<RouteList>, 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;
}
- void rt_cancel_solo_after_disconnect (boost::shared_ptr<RouteList>, bool upstream, bool /* ignored*/ );
- void rt_set_solo (boost::shared_ptr<RouteList>, bool yn, bool group_override);
- void rt_set_just_one_solo (boost::shared_ptr<RouteList>, bool yn, bool /* ignored*/ );
- void rt_set_mute (boost::shared_ptr<RouteList>, bool yn, bool group_override);
- void rt_set_listen (boost::shared_ptr<RouteList>, bool yn, bool group_override);
- void rt_set_solo_isolated (boost::shared_ptr<RouteList>, bool yn, bool group_override);
- void rt_set_record_enabled (boost::shared_ptr<RouteList>, bool yn, bool group_override);
- void rt_set_record_safe (boost::shared_ptr<RouteList>, bool yn, bool group_override);
- void rt_set_monitoring (boost::shared_ptr<RouteList>, MonitorChoice, bool group_override);
+ void rt_set_solo (boost::shared_ptr<RouteList>, bool yn, PBD::Controllable::GroupControlDisposition group_override);
+ void rt_clear_all_solo_state (boost::shared_ptr<RouteList>, bool yn, PBD::Controllable::GroupControlDisposition group_override);
+ void rt_set_just_one_solo (boost::shared_ptr<RouteList>, bool yn, PBD::Controllable::GroupControlDisposition /* ignored*/ );
+ void rt_set_mute (boost::shared_ptr<RouteList>, bool yn, PBD::Controllable::GroupControlDisposition group_override);
+ void rt_set_listen (boost::shared_ptr<RouteList>, bool yn, PBD::Controllable::GroupControlDisposition group_override);
+ void rt_set_solo_isolated (boost::shared_ptr<RouteList>, bool yn, PBD::Controllable::GroupControlDisposition group_override);
+ void rt_set_record_enabled (boost::shared_ptr<RouteList>, bool yn, PBD::Controllable::GroupControlDisposition group_override);
+ void rt_set_record_safe (boost::shared_ptr<RouteList>, bool yn, PBD::Controllable::GroupControlDisposition group_override);
+ void rt_set_monitoring (boost::shared_ptr<RouteList>, MonitorChoice, 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;
/* 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;
};
projects / ardour.git / blobdiff