/*
- 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
- the Free Software Foundation; either version 2 of the License, or
- (at your option) any later version.
+ 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
+ the Free Software Foundation; either version 2 of the License, or
+ (at your option) any later version.
- This program is distributed in the hope that it will be useful,
- but WITHOUT ANY WARRANTY; without even the implied warranty of
- MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- GNU General Public License for more details.
+ This program is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ GNU General Public License for more details.
- You should have received a copy of the GNU General Public License
- along with this program; if not, write to the Free Software
- Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+ You should have received a copy of the GNU General Public License
+ along with this program; if not, write to the Free Software
+ Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#include "libardour-config.h"
+#include <exception>
#include <list>
#include <map>
#include <set>
#include <string>
#include <vector>
+#include <queue>
#include <stdint.h>
#include <boost/dynamic_bitset.hpp>
#include "pbd/error.h"
#include "pbd/event_loop.h"
#include "pbd/rcu.h"
+#include "pbd/reallocpool.h"
#include "pbd/statefuldestructible.h"
#include "pbd/signals.h"
#include "pbd/undo.h"
-#include "evoral/types.hpp"
+#include "lua/luastate.h"
+
+#include "evoral/Range.hpp"
#include "midi++/types.h"
#include "midi++/mmc.h"
#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"
typedef struct _AEffect AEffect;
namespace MIDI {
- class Port;
- class MachineControl;
- class Parser;
+class Port;
+class MachineControl;
+class Parser;
}
namespace PBD {
- class Controllable;
- class ControllableDescriptor;
+class Controllable;
+class ControllableDescriptor;
+}
+
+namespace luabridge {
+ class LuaRef;
}
namespace Evoral {
- class Curve;
+class Curve;
}
namespace ARDOUR {
extern void setup_enum_writer ();
+class LIBARDOUR_API SessionException: public std::exception {
+public:
+ explicit SessionException(const std::string msg) : _message(msg) {}
+ virtual ~SessionException() throw() {}
+
+ virtual const char* what() const throw() { return _message.c_str(); }
+
+private:
+ std::string _message;
+};
+
+/** Ardour Session */
class LIBARDOUR_API Session : public PBD::StatefulDestructible, public PBD::ScopedConnectionList, public SessionEventManager
{
public:
virtual ~Session ();
- static int get_info_from_path (const std::string& xmlpath, float& sample_rate, SampleFormat& data_format);
+ static int get_info_from_path (const std::string& xmlpath, float& sample_rate, SampleFormat& data_format);
+ static std::string get_snapshot_from_instant (const std::string& session_dir);
+
+ /** a monotonic counter used for naming user-visible things uniquely
+ * (curently the sidechain port).
+ * Use sparingly to keep the numbers low, prefer PBD::ID for all
+ * internal, not user-visible IDs */
+ static unsigned int next_name_id ();
std::string path() const { return _path; }
std::string name() const { return _name; }
std::string raid_path () const;
bool path_is_within_session (const std::string&);
- void set_snap_name ();
-
bool writable() const { return _writable; }
void set_dirty ();
void set_clean ();
bool dirty() const { return _state_of_the_state & Dirty; }
void set_deletion_in_progress ();
void clear_deletion_in_progress ();
+ bool reconnection_in_progress() const { return _reconnecting_routes_in_progress; }
bool deletion_in_progress() const { return _state_of_the_state & Deletion; }
+ bool routes_deletion_in_progress() const { return _route_deletion_in_progress; }
+ bool peaks_cleanup_in_progres() const { return _state_of_the_state & PeakCleanup; }
+
PBD::Signal0<void> DirtyChanged;
+ PBD::Signal1<void, bool> RouteAddedOrRemoved;
+
const SessionDirectory& session_directory () const { return *(_session_dir.get()); }
static PBD::Signal1<void,std::string> Dialog;
+ PBD::Signal0<void> BatchUpdateStart;
+ PBD::Signal0<void> BatchUpdateEnd;
+
int ensure_subdirs ();
std::string automation_dir () const; ///< Automation data
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, uint32_t chan);
+ bool audio_source_name_is_unique (const std::string& name);
std::string format_audio_source_name (const std::string& legalized_base, uint32_t nchan, uint32_t chan, bool destructive, bool take_required, uint32_t cnt, bool related_exists);
std::string new_audio_source_path_for_embedded (const std::string& existing_path);
std::string new_audio_source_path (const std::string&, uint32_t nchans, uint32_t chan, bool destructive, bool take_required);
std::string new_midi_source_path (const std::string&);
- RouteList new_route_from_template (uint32_t how_many, const std::string& template_path, const std::string& name);
+ /** create a new track or bus from a template (XML path)
+ * @param how_many how many tracks or busses to create
+ * @param template_path path to xml template file
+ * @param name name (prefix) of the route to create
+ * @param pd Playlist disposition
+ * @return list of newly created routes
+ */
+ RouteList new_route_from_template (uint32_t how_many, const std::string& template_path, const std::string& name, PlaylistDisposition pd = NewPlaylist);
+ RouteList new_route_from_template (uint32_t how_many, XMLNode&, const std::string& name, PlaylistDisposition pd = NewPlaylist);
std::vector<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);
void process (pframes_t nframes);
BufferSet& get_silent_buffers (ChanCount count = ChanCount::ZERO);
- BufferSet& get_scratch_buffers (ChanCount count = ChanCount::ZERO, bool silence = true );
+ BufferSet& get_noinplace_buffers (ChanCount count = ChanCount::ZERO);
+ BufferSet& get_scratch_buffers (ChanCount count = ChanCount::ZERO, bool silence = true);
BufferSet& get_route_buffers (ChanCount count = ChanCount::ZERO, bool silence = true);
BufferSet& get_mix_buffers (ChanCount count = ChanCount::ZERO);
bool have_rec_enabled_track () const;
+ bool have_rec_disabled_track () const;
bool have_captured() const { return _have_captured; }
bool operator() (boost::shared_ptr<Route>, boost::shared_ptr<Route> b);
};
- void set_order_hint (uint32_t order_hint) {_order_hint = order_hint;};
- void notify_remote_id_change ();
- void sync_order_keys ();
+ void set_order_hint (int32_t order_hint) {_order_hint = order_hint;};
+ void notify_remote_id_change ();
+ void sync_order_keys ();
- template<class T> void foreach_route (T *obj, void (T::*func)(Route&));
- template<class T> void foreach_route (T *obj, void (T::*func)(boost::shared_ptr<Route>));
- template<class T, class A> void foreach_route (T *obj, void (T::*func)(Route&, A), A arg);
+ template<class T> void foreach_route (T *obj, void (T::*func)(Route&), bool sort = true);
+ template<class T> void foreach_route (T *obj, void (T::*func)(boost::shared_ptr<Route>), bool sort = true);
+ template<class T, class A> void foreach_route (T *obj, void (T::*func)(Route&, A), A arg, bool sort = true);
static char session_name_is_legal (const std::string&);
bool io_name_is_legal (const std::string&);
boost::shared_ptr<Route> 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 routes_using_input_from (const std::string& str, RouteList& rl);
bool route_name_unique (std::string) const;
bool route_name_internal (std::string) const;
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 ();
PBD::Signal0<void> IOConnectionsComplete;
+ /* Timecode status signals */
+ PBD::Signal1<void, bool> MTCSyncStateChanged;
+ PBD::Signal1<void, bool> LTCSyncStateChanged;
+
/* Record status signals */
- PBD::Signal0<void> RecordStateChanged;
+ PBD::Signal0<void> RecordStateChanged; /* signals changes in recording state (i.e. are we recording) */
+ /* XXX may 2015: paul says: it isn't clear to me that this has semantics that cannot be inferrred
+ from the previous signal and session state.
+ */
+ PBD::Signal0<void> RecordArmStateChanged; /* signals changes in recording arming */
+
+ /* Emited when session is loaded */
+ PBD::Signal0<void> SessionLoaded;
/* Transport mechanism signals */
* - change in the play range (from the process thread)
* - start (from the process thread)
* - engine halted
- */
+ */
PBD::Signal0<void> TransportStateChange;
PBD::Signal1<void,framepos_t> PositionChanged; /* sent after any non-sequential motion */
/* Step Editing status changed */
PBD::Signal1<void,bool> StepEditStatusChange;
+ /* 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_track_latency () const { return _worst_track_latency; }
framecnt_t worst_playback_latency () const { return _worst_output_latency + _worst_track_latency; }
- int save_state (std::string snapshot_name, bool pending = false, bool switch_to_snapshot = false);
+ struct SaveAs {
+ std::string new_parent_folder; /* parent folder where new session folder will be created */
+ std::string new_name; /* name of newly saved session */
+ bool switch_to; /* true if we should be working on newly saved session after save-as; false otherwise */
+ bool include_media; /* true if the newly saved session should contain references to media */
+ bool copy_media; /* true if media files (audio, media, etc) should be copied into newly saved session; false otherwise */
+ bool copy_external; /* true if external media should be consolidated into the newly saved session; false otherwise */
+
+ std::string final_session_folder_name; /* filled in by * Session::save_as(), provides full path to newly saved session */
+
+ /* emitted as we make progress. 3 arguments passed to signal
+ * handler:
+ *
+ * 1: percentage complete measured as a fraction (0-1.0) of
+ * total data copying done.
+ * 2: number of files copied so far
+ * 3: total number of files to copy
+ *
+ * Handler should return true for save-as to continue, or false
+ * to stop (and remove all evidence of partial save-as).
+ */
+ PBD::Signal3<bool,float,int64_t,int64_t> Progress;
+
+ /* if save_as() returns non-zero, this string will indicate the reason why.
+ */
+ std::string failure_message;
+ };
+
+ int save_as (SaveAs&);
+ /** save session
+ * @param snapshot_name name of the session (use an empty string for the current name)
+ * @param pending save a 'recovery', not full state (default: false)
+ * @param switch_to_snapshot switch to given snapshot after saving (default: false)
+ * @param template_only save a session template (default: false)
+ * @return zero on success
+ */
+ int save_state (std::string snapshot_name, bool pending = false, bool switch_to_snapshot = false, bool template_only = false);
int restore_state (std::string snapshot_name);
- int save_template (std::string template_name);
+ int save_template (std::string template_name, bool replace_existing = false);
int save_history (std::string snapshot_name = "");
int restore_history (std::string snapshot_name);
void remove_state (std::string snapshot_name);
*
* 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; }
class StateProtector {
- public:
- StateProtector (Session* s) : _session (s) {
- g_atomic_int_inc (&s->_suspend_save);
- }
- ~StateProtector () {
- if (g_atomic_int_dec_and_test (&_session->_suspend_save)) {
- while (_session->_save_queued) {
- _session->_save_queued = false;
- _session->save_state ("");
- }
+ public:
+ StateProtector (Session* s) : _session (s) {
+ g_atomic_int_inc (&s->_suspend_save);
+ }
+ ~StateProtector () {
+ if (g_atomic_int_dec_and_test (&_session->_suspend_save)) {
+ while (_session->_save_queued) {
+ _session->_save_queued = false;
+ _session->save_state ("");
}
}
- private:
- Session * _session;
+ }
+ private:
+ Session * _session;
};
void add_route_group (RouteGroup *);
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 = ""
);
- void remove_route (boost::shared_ptr<Route>);
- void resort_routes ();
- void resort_routes_using (boost::shared_ptr<RouteList>);
+ RouteList new_midi_route (RouteGroup* route_group, uint32_t how_many, std::string name_template = "", boost::shared_ptr<PluginInfo> instrument = boost::shared_ptr<PluginInfo>());
+
+ void remove_routes (boost::shared_ptr<RouteList>);
+ void remove_route (boost::shared_ptr<Route>);
+
+ void resort_routes ();
+ void resort_routes_using (boost::shared_ptr<RouteList>);
AudioEngine & engine() { return _engine; }
AudioEngine const & engine () const { return _engine; }
+ static std::string default_track_name_pattern (DataType);
+
/* Time */
framepos_t transport_frame () const {return _transport_frame; }
void timecode_time_subframes (framepos_t when, Timecode::Time&);
void timecode_duration (framecnt_t, Timecode::Time&) const;
- void timecode_duration_string (char *, size_t len, framecnt_t) const;
+ void timecode_duration_string (char *, size_t len, framecnt_t) const;
framecnt_t convert_to_frames (AnyTime const & position);
framecnt_t any_duration_to_frames (framepos_t position, AnyTime const & duration);
static PBD::Signal1<void, framepos_t> EndTimeChanged;
void request_sync_source (Slave*);
- bool synced_to_engine() const { return config.get_external_sync() && Config->get_sync_source() == Engine; }
+ 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 set_silent (bool yn);
bool silent () { return _silent; }
TempoMap& tempo_map() { return *_tempo_map; }
const TempoMap& tempo_map() const { return *_tempo_map; }
+ unsigned int get_xrun_count () const {return _xrun_count; }
+ void reset_xrun_count () {_xrun_count = 0; }
+
/* region info */
boost::shared_ptr<Region> find_whole_file_parent (boost::shared_ptr<Region const>) const;
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&);
int remove_last_capture ();
- /** handlers should return 0 for "everything OK", and any other value for
+ /** handlers should return 0 for "everything OK", and any other value for
* "cannot setup audioengine".
*/
- static PBD::Signal1<int,uint32_t> AudioEngineSetupRequired;
+ static PBD::Signal1<int,uint32_t> AudioEngineSetupRequired;
/** handlers should return -1 for "stop cleanup",
0 for "yes, delete this playlist",
*/
static PBD::Signal2<int, framecnt_t, framecnt_t> AskAboutSampleRateMismatch;
+ /** non interactive message */
+ static PBD::Signal2<void, framecnt_t, framecnt_t> NotifyAboutSampleRateMismatch;
+
/** handlers should return !0 for use pending state, 0 for ignore it.
- */
+ */
static PBD::Signal0<int> AskAboutPendingState;
boost::shared_ptr<AudioFileSource> create_audio_source_for_session (
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,
- bool overwrite, std::vector<boost::shared_ptr<Source> >&, InterThreadInfo& wot,
- boost::shared_ptr<Processor> endpoint,
- bool include_endpoint, bool for_export, bool for_freeze);
+ bool overwrite, std::vector<boost::shared_ptr<Source> >&, InterThreadInfo& wot,
+ boost::shared_ptr<Processor> endpoint,
+ bool include_endpoint, bool for_export, bool for_freeze);
int freeze_all (InterThreadInfo&);
/* session-wide solo/mute/rec-enable */
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_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;
/* monitor/master out */
void add_monitor_section ();
+ void reset_monitor_section ();
void remove_monitor_section ();
+ bool monitor_active() const { return (_monitor_out && _monitor_out->monitor_control () && _monitor_out->monitor_control ()->monitor_active()); }
boost::shared_ptr<Route> monitor_out() const { return _monitor_out; }
boost::shared_ptr<Route> master_out() const { return _master_out; }
static bool get_disable_all_loaded_plugins() {
return _disable_all_loaded_plugins;
}
+ static void set_bypass_all_loaded_plugins (bool yn) {
+ _bypass_all_loaded_plugins = yn;
+ }
+ static bool get_bypass_all_loaded_plugins() {
+ return _bypass_all_loaded_plugins;
+ }
uint32_t next_send_id();
uint32_t next_aux_send_id();
/* I/O bundles */
- void add_bundle (boost::shared_ptr<Bundle>);
+ void add_bundle (boost::shared_ptr<Bundle>, bool emit_signal = true);
void remove_bundle (boost::shared_ptr<Bundle>);
boost::shared_ptr<Bundle> bundle_by_name (std::string) const;
- PBD::Signal1<void,boost::shared_ptr<Bundle> > BundleAdded;
- PBD::Signal1<void,boost::shared_ptr<Bundle> > BundleRemoved;
+ PBD::Signal0<void> BundleAddedOrRemoved;
void midi_panic ();
std::string next_undo() const { return _history.next_undo(); }
std::string next_redo() const { return _history.next_redo(); }
+ /** begin collecting undo information
+ *
+ * This call must always be followed by either
+ * begin_reversible_command() or commit_reversible_command()
+ *
+ * @param cmd_name human readable name for the undo operation
+ */
void begin_reversible_command (const std::string& cmd_name);
void begin_reversible_command (GQuark);
+ /** abort an open undo command
+ * This must only be called after begin_reversible_command ()
+ */
+ void abort_reversible_command ();
+ /** finalize an undo command and commit pending transactions
+ *
+ * This must only be called after begin_reversible_command ()
+ * @param cmd (additional) command to add
+ */
void commit_reversible_command (Command* cmd = 0);
- void add_command (Command *const cmd) {
- assert (_current_trans);
- _current_trans->add_command (cmd);
- }
+ void add_command (Command *const cmd);
+
+ /** create an StatefulDiffCommand from the given object and add it to the stack.
+ *
+ * This function must only be called after begin_reversible_command.
+ * Failing to do so may lead to a crash.
+ *
+ * @param sfd the object to diff
+ * @returns the allocated StatefulDiffCommand (already added via add_command)
+ */
+ PBD::StatefulDiffCommand* add_stateful_diff_command (boost::shared_ptr<PBD::StatefulDestructible> sfd);
/** @return The list of operations that are currently in progress */
std::list<GQuark> const & current_operations () {
void maybe_update_session_range (framepos_t, framepos_t);
+ /* temporary hacks to allow selection to be pushed from GUI into backend.
+ Whenever we move the selection object into libardour, these will go away.
+ */
+ void set_range_selection (framepos_t start, framepos_t end);
+ void set_object_selection (framepos_t start, framepos_t end);
+ void clear_range_selection ();
+ void clear_object_selection ();
+
/* buffers for gain and pan */
gain_t* gain_automation_buffer () const;
+ gain_t* trim_automation_buffer () const;
gain_t* send_gain_automation_buffer () const;
pan_t** pan_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&);
};
SlaveState slave_state() const { return _slave_state; }
- Slave* slave() const { return _slave; }
+ Slave* slave() const { return _slave; }
boost::shared_ptr<SessionPlaylists> playlists;
void send_mmc_locate (framepos_t);
- void queue_full_time_code () { _send_timecode_update = true; }
- void queue_song_position_pointer () { /* currently does nothing */ }
+ void queue_full_time_code () { _send_timecode_update = true; }
+ void queue_song_position_pointer () { /* currently does nothing */ }
bool step_editing() const { return (_step_editors > 0); }
/** Emitted when the session wants Ardour to quit */
static PBD::Signal0<void> Quit;
- /** Emitted when Ardour is asked to load a session in an older session
+ /** Emitted when Ardour is asked to load a session in an older session
* format, and makes a backup copy.
*/
- static PBD::Signal2<void,std::string,std::string> VersionMismatch;
+ static PBD::Signal2<void,std::string,std::string> VersionMismatch;
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;
+ 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* scene_input_port () const;
- MIDI::Port* scene_output_port () const;
+ /* synchronous MIDI ports used for synchronization */
- 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_mtc_ports ();
+ void reconnect_mmc_ports (bool);
+
+ void reconnect_ltc_input ();
+ void reconnect_ltc_output ();
+
protected:
friend class AudioEngine;
void set_block_size (pframes_t nframes);
void set_frame_rate (framecnt_t nframes);
- void reconnect_existing_routes (bool withLock, bool reconnect_master = true, bool reconnect_inputs = true, bool reconnect_outputs = true);
+#ifdef USE_TRACKS_CODE_FEATURES
+ void reconnect_existing_routes (bool withLock, bool reconnect_master = true, bool reconnect_inputs = true, bool reconnect_outputs = true);
+#endif
protected:
friend class Route;
int create (const std::string& mix_template, BusProfile*);
void destroy ();
+ static guint _name_id_counter;
+ static void init_name_id_counter (guint n);
+ static unsigned int name_id_counter ();
+
enum SubState {
PendingDeclickIn = 0x1, ///< pending de-click fade-in for start
PendingDeclickOut = 0x2, ///< pending de-click fade-out for stop
process_function_type last_process_function;
bool _bounce_processing_active;
bool waiting_for_sync_offset;
- framecnt_t _base_frame_rate;
- framecnt_t _current_frame_rate; //this includes video pullup offset
- framecnt_t _nominal_frame_rate; //ignores audioengine setting, "native" SR
+ framecnt_t _base_frame_rate; // sample-rate of the session at creation time, "native" SR
+ framecnt_t _nominal_frame_rate; // overridden by audioengine setting
+ framecnt_t _current_frame_rate; // this includes video pullup offset
int transport_sub_state;
mutable gint _record_status;
framepos_t _transport_frame;
double _transport_speed;
double _default_transport_speed;
double _last_transport_speed;
+ double _signalled_varispeed;
double _target_transport_speed;
CubicInterpolation interpolation;
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;
bool _was_seamless;
bool _under_nsm_control;
+ unsigned int _xrun_count;
+
+ void mtc_status_changed (bool);
+ PBD::ScopedConnection mtc_status_connection;
+ void ltc_status_changed (bool);
+ PBD::ScopedConnection ltc_status_connection;
void initialize_latencies ();
void set_worst_io_latencies ();
bool have_first_delta_accumulator;
SlaveState _slave_state;
+ gint _mtc_active;
+ gint _ltc_active;
framepos_t slave_wait_end;
void reset_slave_state ();
framepos_t post_export_position;
bool _exporting;
- bool _export_started;
bool _export_rolling;
+ framepos_t _export_preroll;
boost::shared_ptr<ExportHandler> export_handler;
boost::shared_ptr<ExportStatus> export_status;
int silent_process_routes (pframes_t, bool& need_butler);
/** @return 1 if there is a pending declick fade-in,
- -1 if there is a pending declick fade-out,
- 0 if there is no pending declick.
+ -1 if there is a pending declick fade-out,
+ 0 if there is no pending declick.
*/
int get_transport_declick_required () {
if (transport_sub_state & PendingDeclickIn) {
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 =
PostTransportWork (
- PostTransportInputChange|
- PostTransportSpeed|
- PostTransportReverse|
- PostTransportCurveRealloc|
- PostTransportAudition|
- PostTransportLocate|
- PostTransportStop|
- PostTransportClearSubstate);
+ PostTransportInputChange|
+ PostTransportSpeed|
+ PostTransportReverse|
+ PostTransportCurveRealloc|
+ PostTransportAudition|
+ PostTransportLocate|
+ PostTransportStop|
+ PostTransportClearSubstate);
gint _post_transport_work; /* accessed only atomic ops */
- PostTransportWork post_transport_work() const { return (PostTransportWork) g_atomic_int_get (const_cast<gint*>(&_post_transport_work)); }
+ PostTransportWork post_transport_work() const { return (PostTransportWork) g_atomic_int_get (const_cast<gint*>(&_post_transport_work)); }
void set_post_transport_work (PostTransportWork ptw) { g_atomic_int_set (&_post_transport_work, (gint) ptw); }
void add_post_transport_work (PostTransportWork ptw);
void reset_rf_scale (framecnt_t frames_moved);
Locations* _locations;
- void location_added (Location*);
- void location_removed (Location*);
- void locations_changed ();
- void _locations_changed (const Locations::LocationList&);
+ void location_added (Location*);
+ void location_removed (Location*);
+ void locations_changed ();
+ void _locations_changed (const Locations::LocationList&);
+
+ void update_skips (Location*, bool consolidate);
+ void update_marks (Location* loc);
+ void consolidate_skips (Location*);
+ void sync_locations_to_skips ();
+ void _sync_locations_to_skips ();
- void update_skips (Location*, bool consolidate);
- Locations::LocationList consolidate_skips (Location*);
- void sync_locations_to_skips (const Locations::LocationList&);
- PBD::ScopedConnectionList skip_connections;
+ PBD::ScopedConnectionList skip_update_connections;
+ bool _ignore_skips_updates;
PBD::ScopedConnectionList punch_connections;
void auto_punch_start_changed (Location *);
void auto_loop_changed (Location *);
void auto_loop_declick_range (Location *, framepos_t &, framepos_t &);
- int ensure_engine (uint32_t desired_sample_rate);
+ int ensure_engine (uint32_t desired_sample_rate);
void pre_engine_init (std::string path);
int post_engine_init ();
- int immediately_post_engine ();
+ int immediately_post_engine ();
void remove_empty_sounds ();
+ void session_loaded ();
+
void setup_midi_control ();
int midi_read (MIDI::Port *);
void *do_work();
+ /* Signal Forwarding */
+ void emit_route_signals ();
+ void emit_thread_run ();
+ static void *emit_thread (void *);
+ void emit_thread_start ();
+ void emit_thread_terminate ();
+
+ pthread_t _rt_emit_thread;
+ bool _rt_thread_active;
+
+ pthread_mutex_t _rt_emit_mutex;
+ pthread_cond_t _rt_emit_cond;
+ bool _rt_emit_pending;
+
+ /* Auto Connect Thread */
+ static void *auto_connect_thread (void *);
+ void auto_connect_thread_run ();
+ void auto_connect_thread_start ();
+ void auto_connect_thread_terminate ();
+
+ pthread_t _auto_connect_thread;
+ bool _ac_thread_active;
+ pthread_mutex_t _auto_connect_mutex;
+ pthread_cond_t _auto_connect_cond;
+
+ struct AutoConnectRequest {
+ public:
+ AutoConnectRequest (boost::shared_ptr <Route> r, bool ci,
+ const ChanCount& is,
+ const ChanCount& os,
+ const ChanCount& io,
+ const ChanCount& oo)
+ : route (boost::weak_ptr<Route> (r))
+ , connect_inputs (ci)
+ , input_start (is)
+ , output_start (os)
+ , input_offset (io)
+ , output_offset (oo)
+ {}
+
+ boost::weak_ptr <Route> route;
+ bool connect_inputs;
+ ChanCount input_start;
+ ChanCount output_start;
+ ChanCount input_offset;
+ ChanCount output_offset;
+ };
+
+ typedef std::queue<AutoConnectRequest> AutoConnectQueue;
+ Glib::Threads::Mutex _auto_connect_queue_lock;
+ AutoConnectQueue _auto_connect_queue;
+
+ void auto_connect (const AutoConnectRequest&);
+
/* SessionEventManager interface */
void process_event (SessionEvent*);
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_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 ();
void realtime_stop (bool abort, bool clear_state);
void post_transport ();
void engine_halted ();
void xrun_recovery ();
+ void set_track_loop (bool);
+ bool select_playhead_priority_target (framepos_t&);
+ void follow_playhead_priority ();
- /* These are synchronous and so can only be called from within the process
- * cycle
- */
+ /* These are synchronous and so can only be called from within the process
+ * cycle
+ */
- int send_full_time_code (framepos_t, pframes_t nframes);
- void send_song_position_pointer (framepos_t);
+ int send_full_time_code (framepos_t, pframes_t nframes);
+ void send_song_position_pointer (framepos_t);
TempoMap *_tempo_map;
void tempo_map_changed (const PBD::PropertyChange&);
SerializedRCUManager<RouteList> routes;
void add_routes (RouteList&, bool input_auto_connect, bool output_auto_connect, bool save);
- void add_routes_inner (RouteList&, bool input_auto_connect, bool output_auto_connect);
- bool _adding_routes_in_progress;
+ void add_routes_inner (RouteList&, bool input_auto_connect, bool output_auto_connect);
+ bool _adding_routes_in_progress;
+ bool _reconnecting_routes_in_progress;
+ bool _route_deletion_in_progress;
+
uint32_t destructive_index;
boost::shared_ptr<Route> XMLRouteFactory (const XMLNode&, int);
void route_processors_changed (RouteProcessorChange);
- bool find_route_name (std::string const &, uint32_t& id, char* name, size_t name_len, bool);
+ bool find_route_name (std::string const &, uint32_t& id, std::string& name, bool);
void count_existing_track_channels (ChanCount& in, ChanCount& out);
- void auto_connect_route (boost::shared_ptr<Route> route, ChanCount& existing_inputs, ChanCount& existing_outputs,
- bool with_lock, bool connect_inputs = true,
- ChanCount input_start = ChanCount (), ChanCount output_start = ChanCount ());
+ void auto_connect_route (boost::shared_ptr<Route>, bool, const ChanCount&, const ChanCount&, const ChanCount& io = ChanCount(), const ChanCount& oo = ChanCount());
void midi_output_change_handler (IOChange change, void* /*src*/, boost::weak_ptr<Route> midi_track);
/* track numbering */
/* 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 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 ();
typedef std::map<PBD::ID,boost::shared_ptr<Source> > SourceMap;
private:
+ void reset_write_sources (bool mark_write_complete, bool force = false);
SourceMap sources;
+
private:
int load_sources (const XMLNode& node);
XMLNode& get_sources_as_xml ();
*/
std::list<GQuark> _current_trans_quarks;
- int backend_sync_callback (TransportState, framepos_t);
+ int backend_sync_callback (TransportState, framepos_t);
void process_rtop (SessionEvent*);
void set_play_range (std::list<AudioRange>&, bool leave_rolling);
void unset_play_range ();
+ /* temporary hacks to allow selection to be pushed from GUI into backend
+ Whenever we move the selection object into libardour, these will go away.
+ */
+ Evoral::Range<framepos_t> _range_selection;
+ Evoral::Range<framepos_t> _object_selection;
+
/* main outs */
uint32_t main_outs;
void set_history_depth (uint32_t depth);
static bool _disable_all_loaded_plugins;
+ static bool _bypass_all_loaded_plugins;
mutable bool have_looped; ///< Used in ::audible_frame(*)
- void update_have_rec_enabled_track ();
+ void update_route_record_state ();
gint _have_rec_enabled_track;
+ gint _have_rec_disabled_track;
static int ask_about_playlist_deletion (boost::shared_ptr<Playlist>);
/* 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_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;
- void add_session_range_location (framepos_t, framepos_t);
+ void set_session_range_location (framepos_t, framepos_t);
void setup_midi_machine_control ();
GraphEdges _current_route_graph;
uint32_t next_control_id () const;
- uint32_t _order_hint;
+ int32_t _order_hint;
bool ignore_route_processor_changes;
MidiClockTicker* midi_clock;
- boost::shared_ptr<IO> _ltc_input;
- boost::shared_ptr<IO> _ltc_output;
-
- void reconnect_ltc_input ();
- void reconnect_ltc_output ();
+ boost::shared_ptr<IO> _ltc_input;
+ boost::shared_ptr<IO> _ltc_output;
/* Scene Changing */
SceneChanger* _scene_changer;
-
+
/* persistent, non-track related MIDI ports */
MidiPortManager* _midi_ports;
MIDI::MachineControl* _mmc;
-
+
void setup_ltc ();
void setup_click ();
void setup_click_state (const XMLNode*);
void setup_bundles ();
-
+
+ void save_as_bring_callback (uint32_t, uint32_t, std::string);
+
static int get_session_info_from_path (XMLTree& state_tree, const std::string& xmlpath);
+ static const uint32_t session_end_shift;
+
+ std::string _template_state_dir;
};