projects / ardour.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Implement Lua session-scripts
[ardour.git] / libs / ardour / ardour / session.h
diff --git a/libs/ardour/ardour/session.h b/libs/ardour/ardour/session.h
index 144b3c8670923ebdd45a36901ecef1dfb3e3abb9..d25f856b1fce7464c4eae59d81a43aa777658fa8 100644 (file)
--- a/libs/ardour/ardour/session.h
+++ b/libs/ardour/ardour/session.h
@@ -42,10 +42,13 @@
 #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"
@@ -57,11 +60,14 @@
 #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"
 
 
@@ -81,6 +87,10 @@ class Controllable;
 class ControllableDescriptor;
 }
 
+namespace luabridge {
+       class LuaRef;
+}
+
 namespace Evoral {
 class Curve;
 }
@@ -173,6 +183,7 @@ 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);
 
        std::string path() const { return _path; }
        std::string name() const { return _name; }
@@ -180,8 +191,6 @@ 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 ();
@@ -218,7 +227,8 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
        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);
@@ -277,6 +287,7 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
        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);
 
@@ -303,6 +314,8 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
        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 ();
 
@@ -378,8 +391,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();
@@ -459,7 +472,7 @@ 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, 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);
@@ -719,6 +732,13 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 
        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,
@@ -735,20 +755,21 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 
        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 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;
 
@@ -757,6 +778,7 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
        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; }
@@ -910,6 +932,8 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 
        /* 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&);
 
@@ -1009,27 +1033,26 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 
        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; }
-
-       MIDI::Port* midi_input_port () const;
-       MIDI::Port* midi_output_port () const;
-       MIDI::Port* mmc_output_port () const;
-       MIDI::Port* mmc_input_port () const;
-
-       MIDI::Port* scene_input_port () const;
-       MIDI::Port* scene_output_port () const;
+       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;
 
-       boost::shared_ptr<MidiPort> scene_in () const;
-       boost::shared_ptr<MidiPort> scene_out () const;
+       /* synchronous MIDI ports used for synchronization */
 
        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; }
 
@@ -1104,6 +1127,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;
@@ -1237,6 +1261,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;
@@ -1263,6 +1289,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 =
@@ -1536,10 +1577,10 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 
        /* mixer stuff */
 
-       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 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 ();
@@ -1764,8 +1805,8 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 
        /* 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;
@@ -1774,15 +1815,15 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
                return ev;
        }
 
-       void rt_set_solo (boost::shared_ptr<RouteList>, bool yn, bool group_override);
-       void rt_clear_all_solo_state (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;
@@ -1838,6 +1879,8 @@ class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::Scop
 
        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;
 };
 
 
Unnamed repository; edit this file 'description' to name the repository.