35 #include "libardour-config.h"
49 #include <boost/dynamic_bitset.hpp>
50 #include <glibmm/threads.h>
106 class MachineControl;
133 class AudioFileSource;
138 class AutomationList;
154 class MidiClockTicker;
156 class MidiPortManager;
178 class SessionDirectory;
179 class SessionMetadata;
180 class SessionPlaylists;
181 class SoloMuteRelease;
184 class TransportMaster;
187 class UI_TransportMaster;
189 class WindowsVSTPlugin;
198 virtual const char*
what()
const throw() {
return _message.c_str(); }
218 const std::string& fullpath,
219 const std::string& snapshot_name,
221 std::string mix_template =
"",
222 bool unnamed =
false,
236 std::string
path()
const {
return _path; }
237 std::string
name()
const {
return _name; }
238 std::string
snap_name()
const {
return _current_snapshot_name; }
254 bool loading ()
const {
return _state_of_the_state & Loading; }
255 bool cannot_save ()
const {
return _state_of_the_state & CannotSave; }
256 bool in_cleanup ()
const {
return _state_of_the_state & InCleanup; }
279 std::string
construct_peak_filepath (
const std::string& audio_path,
const bool in_session =
false,
const bool old_peak_name =
false)
const;
282 std::string
format_audio_source_name (
const std::string& legalized_base, uint32_t nchan, uint32_t chan,
bool take_required, uint32_t cnt,
bool related_exists);
298 uint32_t channels, std::vector<std::string>
const & smf_track_names,
bool use_smf_file_names);
332 return routes.reader ();
335 std::shared_ptr<RTTaskList>
rt_tasklist () {
return _rt_tasklist; }
336 std::shared_ptr<IOTaskList>
io_tasklist () {
return _io_tasklist; }
356 uint32_t
nroutes()
const {
return routes.reader()->size(); }
363 std::shared_ptr<BundleList const>
bundles () {
364 return _bundles.reader ();
369 template<
class T>
void foreach_route (T *obj,
void (T::*func)(
Route&),
bool sort =
true);
370 template<
class T>
void foreach_route (T *obj,
void (T::*func)(std::shared_ptr<Route>),
bool sort =
true);
371 template<
class T,
class A>
void foreach_route (T *obj,
void (T::*func)(
Route&, A), A arg,
bool sort =
true);
373 template<
class A>
void foreach_track (
void (
Track::*method)(A), A arg);
374 template<
class A1,
class A2>
void foreach_track (
void (
Track::*method)(A1, A2), A1 arg1, A2 arg2);
377 template<
class A>
void foreach_route (
void (
Route::*method)(A), A arg);
378 template<
class A1,
class A2>
void foreach_route (
void (
Route::*method)(A1, A2), A1 arg1, A2 arg2);
395 return _track_number_decimals;
399 return (record_status () >=
Enabled);
403 return _record_status.load();
534 return mtc_timecode_bits;
604 bool pending =
false,
605 bool switch_to_snapshot =
false,
606 bool template_only =
false,
607 bool for_archive =
false,
608 bool only_used_assets =
false);
619 bool only_used_sources =
false,
623 int save_template (
const std::string& template_name,
const std::string& description =
"",
bool replace_existing =
false);
666 InitialConnecting = 0x8,
679 while (_session->_save_queued) {
680 _session->_save_queued =
false;
681 _session->save_state (
"");
683 while (_session->_save_queued_pending) {
684 _session->_save_queued_pending =
false;
685 _session->save_state (
"",
true);
717 for (std::list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); ++i) {
723 return _route_groups;
733 std::string name_template,
736 bool input_auto_connect =
true,
737 bool trigger_visibility =
false
742 std::shared_ptr<PluginInfo> instrument,
744 RouteGroup* route_group, uint32_t how_many, std::string name_template,
747 bool input_auto_connect,
748 bool trigger_visibility =
false
902 size_t, std::string
const &, uint32_t);
943 std::shared_ptr<IOPlugList const> iop (_io_plugins.reader ());
944 if (n < iop->size ()) {
947 return std::shared_ptr<IOPlug> ();
950 std::shared_ptr<IOPlugList const>
io_plugs ()
const {
951 return _io_plugins.reader ();
957 bool overwrite, std::vector<std::shared_ptr<Source> >&,
InterThreadInfo& wot,
958 std::shared_ptr<Processor> endpoint,
959 bool include_endpoint,
bool for_export,
bool for_freeze,
960 std::string
const& source_name =
"", std::string
const& region_name =
"");
968 bool soloing ()
const {
return _non_soloed_outs_muted; }
1002 bool monitor_active()
const {
return (_monitor_out && _monitor_out->monitor_control () && _monitor_out->monitor_control ()->monitor_active()); }
1005 std::shared_ptr<Route>
master_out()
const {
return _master_out; }
1018 void add_internal_send (std::shared_ptr<Route>, std::shared_ptr<Processor>, std::shared_ptr<Route>);
1021 _disable_all_loaded_plugins = yn;
1024 return _disable_all_loaded_plugins;
1027 _bypass_all_loaded_plugins = yn;
1030 return _bypass_all_loaded_plugins;
1058 void add_bundle (std::shared_ptr<Bundle>,
bool emit_signal =
true);
1081 std::string
next_undo()
const {
return _history.next_undo(); }
1082 std::string
next_redo()
const {
return _history.next_redo(); }
1139 static const char* vst_can_do_strings[];
1189 return _realtime_export;
1193 return _bounce_processing_active;
1202 PostTransportStop = 0x1,
1203 PostTransportLocate = 0x2,
1204 PostTransportAbort = 0x8,
1205 PostTransportOverWrite = 0x10,
1206 PostTransportAudition = 0x20,
1207 PostTransportReverse = 0x40,
1208 PostTransportClearSubstate = 0x80,
1209 PostTransportAdjustPlaybackBuffering = 0x100,
1210 PostTransportAdjustCaptureBuffering = 0x200,
1211 PostTransportLoopChanged = 0x400
1214 std::shared_ptr<SessionPlaylists>
playlists ()
const {
return _playlists; }
1257 _missing_file_replacement = mfr;
1313 return (this->index1 == other.
index1);
1321 ProcessFunction = 1,
1501 : action (TransportMasterRelax)
1504 , catch_speed (0.) {}
1583 int load_state (std::string snapshot_name,
bool from_template =
false);
1672 _transport_sample += val;
1677 if (val < _transport_sample) {
1678 _transport_sample -= val;
1680 _transport_sample = 0;
1722 : route (std::weak_ptr<
Route> (r))
1723 , connect_inputs (ci)
1724 , connect_outputs (co)
1728 , output_offset (oo)
1918 std::shared_ptr<PluginInfo> instrument,
1972 typedef std::map<PBD::ID,std::shared_ptr<Source> >
SourceMap;
1976 for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
2042 , blocks_unknown (true)
2092 bool for_archive =
false,
2093 bool only_used_assets =
false)
const;
2121 static const Sample default_click_emphasis[];
2207 ev->
rt_slot = std::bind (method,
this, rl, targ, group_override);
2219 ev->
rt_slot = std::bind (method,
this, rl, t1arg, t2arg, group_override);
2264 std::shared_ptr<GraphChain> _io_graph_chain[2];
static const ChanCount ZERO
std::list< Location * > LocationList
static const Flag MixerStripables
static const Flag MixerRoutes
std::function< void(SessionEvent *)> RTeventCallback
RTeventCallback rt_return
std::function< void(void)> rt_slot
static const samplepos_t Immediate
PBD::EventLoop * event_loop
virtual ~SessionException()
SessionException(const std::string msg)
virtual const char * what() const
~ProcessorChangeBlocker()
bool _reconfigure_on_delete
ProcessorChangeBlocker(Session *s, bool rc=true)
StateProtector(Session *s)
void process_without_events(pframes_t)
void add_internal_sends(std::shared_ptr< Route > dest, Placement p, std::shared_ptr< RouteList > senders)
int send_midi_time_code_for_cycle(samplepos_t, samplepos_t, pframes_t nframes)
PBD::Signal< void(RouteList &)> RouteAdded
void clear_all_solo_state(std::shared_ptr< RouteList const >)
void mark_surround_send_id(uint32_t)
luabridge::LuaRef * _lua_load
std::shared_ptr< Route > route_by_name(std::string) const
int load_regions(const XMLNode &node)
std::shared_ptr< Auditioner > the_auditioner()
std::shared_ptr< Stripable > get_remote_nth_stripable(PresentationInfo::order_t n, PresentationInfo::Flag) const
int next_quarter_frame_to_send
std::map< PBD::ID, std::shared_ptr< Source > > SourceMap
SceneChanger * scene_changer() const
std::atomic< int > _ignore_route_processor_changes
const std::unique_ptr< SessionDirectory > _session_dir
void route_added_to_route_group(RouteGroup *, std::weak_ptr< Route >)
std::shared_ptr< IOTaskList > io_tasklist()
bool follow_transport_master(pframes_t nframes)
Glib::Threads::Mutex space_lock
void step_back_from_record()
PBD::ScopedConnectionList loop_connections
boost::dynamic_bitset< uint32_t > aux_send_bitset
std::shared_ptr< Route > master_out() const
bool loop_is_possible() const
void add_surround_master()
std::queue< AutoConnectRequest > AutoConnectQueue
std::shared_ptr< Bundle > bundle_by_name(std::string) const
static std::vector< std::string > possible_states(std::string path)
void setup_route_surround_sends(bool enable, bool need_process_lock)
void realtime_locate(bool)
PBD::UndoHistory & history()
samplecnt_t preroll_samples(samplepos_t) const
PBD::Signal< void(bool)> SoloActive
void remove_surround_master()
samplecnt_t _worst_route_latency
void click(samplepos_t start, samplecnt_t nframes)
void auto_punch_changed(Location *)
void send_ltc_for_cycle(samplepos_t, samplepos_t, pframes_t)
void sync_source_changed(SyncSource, samplepos_t pos, pframes_t cycle_nframes)
void stop_transport(bool abort=false, bool clear_state=false)
void end_unnamed_status() const
void timecode_duration_string(char *, size_t len, samplecnt_t) const
bool solo_isolated() const
pan_t ** pan_automation_buffer() const
void process(pframes_t nframes)
TriggerPtr trigger_at(int32_t route_index, int32_t row_index) const
void unset_play_loop(bool change_transport_state=false)
CoreSelection * _selection
std::map< PBD::ID, std::string > _diskstreams_2X
std::shared_ptr< Graph > _process_graph
void set_session_extents(timepos_t const &start, timepos_t const &end)
bool import_sndfile_as_region(std::string path, SrcQuality quality, timepos_t &pos, SourceList &sources, ImportStatus &status, uint32_t current, uint32_t total)
samplecnt_t _remaining_latency_preroll
XMLNode * instant_xml(const std::string &str)
samplecnt_t remaining_latency_preroll() const
void maybe_find_pending_cue()
void load_io_plugin(std::shared_ptr< IOPlug >)
int restore_state(std::string snapshot_name)
std::shared_ptr< TransportMaster > transport_master() const
void try_run_lua(pframes_t)
XMLNode & get_sources_as_xml()
bool _ignore_skips_updates
void mark_aux_send_id(uint32_t)
uint64_t _total_free_4k_blocks
double timecode_frames_per_second() const
void set_owned_port_public_latency(bool playback)
int fail_roll(pframes_t nframes)
void request_default_play_speed(double speed, TransportRequestSource origin=TRS_UI)
void run_click(samplepos_t start, samplecnt_t nframes)
bool no_questions_about_missing_files
int32_t first_cue_within(samplepos_t s, samplepos_t e, bool &was_recorded)
std::atomic< int > _update_pretty_names
PBD::Signal< void()> DirtyChanged
PBD::Signal< void(samplepos_t)> Xrun
void request_transport_speed_nonzero(double, TransportRequestSource origin=TRS_UI)
std::string raid_path() const
Location * _session_range_location
session range, or 0 if there is nothing in the session yet
void follow_playhead_priority()
void request_stop(bool abort=false, bool clear_state=false, TransportRequestSource origin=TRS_UI)
double samples_per_timecode_frame() const
bool step_editing() const
void auto_loop_changed(Location *)
static unsigned int name_id_counter()
void reset_write_sources(bool mark_write_complete)
static PBD::Signal< void(samplepos_t)> StartTimeChanged
static PBD::Signal< void(std::string, std::string)> VersionMismatch
Glib::Threads::Mutex save_state_lock
BufferSet & get_mix_buffers(ChanCount count=ChanCount::ZERO)
CueEvents const & cue_events() const
int load_state(std::string snapshot_name, bool from_template=false)
void finalize_export_internal(bool stop_freewheel)
void use_rf_shuttle_speed()
bool plot_process_graph(std::string const &file_name) const
std::shared_ptr< MidiSource > midi_source_by_path(const std::string &, bool need_source_lock) const
std::list< Click * > Clicks
std::string new_audio_source_path(const std::string &, uint32_t nchans, uint32_t chan, bool take_required)
void mtc_tx_resync_latency(bool)
bool transport_stopped() const
void non_realtime_set_speed()
pframes_t get_block_size() const
void auto_connect(const AutoConnectRequest &)
bool select_playhead_priority_target(samplepos_t &)
BufferSet & get_silent_buffers(ChanCount count=ChanCount::ZERO)
std::shared_ptr< Route > _monitor_out
void remove_dir_from_search_path(const std::string &path, DataType type)
std::shared_ptr< Source > source_by_id(const PBD::ID &)
std::shared_ptr< Route > XMLRouteFactory(const XMLNode &, int)
bool ltc_timecode_negative_offset
samplecnt_t worst_output_latency() const
SceneChanger * _scene_changer
void add_internal_send(std::shared_ptr< Route >, int, std::shared_ptr< Route >)
void cleanup_event(SessionEvent *, int)
uint32_t next_insert_id()
void request_roll_at_and_return(samplepos_t start, samplepos_t return_to)
void step_edit_status_change(bool)
PBD::ScopedConnectionList ltc_tx_connections
void set_snapshot_name(const std::string &)
std::atomic< int > _current_usecs_per_track
static const samplecnt_t default_click_emphasis_length
void mmc_record_strobe(MIDI::MachineControl &)
void set_transport_speed(double speed)
void trigger_cue_row(int32_t)
bool _route_deletion_in_progress
samplecnt_t sample_rate() const
bool maybe_sync_start(pframes_t &)
void maybe_write_autosave()
void disable_record(bool rt_context, bool force=false)
PBD::Signal< void()> SoloChanged
static intptr_t vst_callback(AEffect *effect, int32_t opcode, int32_t index, intptr_t value, void *ptr, float opt)
bool record_enabling_legal() const
int freeze_all(InterThreadInfo &)
uint32_t next_aux_send_id()
bool audio_source_name_is_unique(const std::string &name)
void setup_click_sounds(Sample **, Sample const *, samplecnt_t *, samplecnt_t, std::string const &)
void set_worst_input_latency()
void pre_engine_init(std::string path)
bool _had_destructive_tracks
process_function_type process_function
static const samplecnt_t bounce_chunk_size
void update_route_record_state()
void process_audition(pframes_t)
PBD::Signal< void()> LuaScriptsChanged
int load_bundles(XMLNode const &)
const SessionDirectory & session_directory() const
void setup_route_monitor_sends(bool enable, bool need_process_lock)
std::map< PBD::ID, AutomationList * > automation_lists
void import_pt_sources(PTFFormat &ptf, ImportStatus &status)
void process_export_fw(pframes_t)
void unregister_lua_function(const std::string &name)
void controllable_touched(std::weak_ptr< PBD::Controllable >)
std::shared_ptr< AudioFileSource > create_audio_source_for_session(size_t, std::string const &, uint32_t)
TransportFSM * _transport_fsm
bool nth_mixer_scene_valid(size_t) const
ltcsnd_sample_t * ltc_enc_buf
PBD::Signal< void()> BundleAddedOrRemoved
void reconnect_mmc_ports(bool)
std::string next_undo() const
double default_play_speed()
int load_options(const XMLNode &)
std::set< std::shared_ptr< PBD::Controllable > > Controllables
void remove_bundle(std::shared_ptr< Bundle >)
bool non_realtime_work_pending() const
Temporal::Range _range_selection
void request_suspend_timecode_transmission()
int process_routes(pframes_t, bool &need_butler)
void add_routes(RouteList &, bool input_auto_connect, bool output_auto_connect, PresentationInfo::order_t)
std::string _missing_file_replacement
samplepos_t master_wait_end
void send_mclk_for_cycle(samplepos_t, samplepos_t, pframes_t, samplecnt_t)
bool _total_free_4k_blocks_uncertain
double _samples_per_timecode_frame
MIDI::MachineControl & mmc()
void mmc_deferred_play(MIDI::MachineControl &)
void auto_punch_end_changed(Location *)
Timecode::Time last_timecode
MidiClockTicker * midi_clock
std::list< std::shared_ptr< AudioTrack > > new_audio_track(int input_channels, int output_channels, RouteGroup *route_group, uint32_t how_many, std::string name_template, PresentationInfo::order_t order, TrackMode mode=Normal, bool input_auto_connect=true, bool trigger_visibility=false)
TransportMasterStrategy transport_master_strategy
void non_realtime_stop(bool abort, int entry_request_count, bool &finished, bool will_locate)
std::shared_ptr< Auditioner > auditioner
std::shared_ptr< MidiPort > midi_clock_output_port() const
void set_range_selection(Temporal::timepos_t const &start, Temporal::timepos_t const &end)
std::shared_ptr< RTTaskList > _rt_tasklist
bool inital_connect_or_deletion_in_progress() const
std::string get_best_session_directory_for_new_audio()
void locate(samplepos_t, bool for_loop_end=false, bool force=false, bool with_mmc=true)
bool transport_rolling() const
bool timecode_transmission_suspended() const
timepos_t current_start() const
std::shared_ptr< Route > route_by_selected_count(uint32_t cnt) const
PBD::Signal< void()> SurroundMasterAddedOrRemoved
void butler_completed_transport_work()
RouteGroup * _all_route_group
void load_and_connect_instruments(RouteList &, bool strict_io, std::shared_ptr< PluginInfo > instrument, Plugin::PresetRecord *pset, ChanCount &existing_outputs)
bool compute_audible_delta(samplepos_t &pos_and_delta) const
bool declick_in_progress() const
void request_roll(TransportRequestSource origin=TRS_UI)
static void set_disable_all_loaded_plugins(bool yn)
bool maybe_stop(samplepos_t limit)
MidiControlUI * midi_control_ui
samplepos_t _last_record_location
std::shared_ptr< Region > XMLRegionFactory(const XMLNode &, bool full)
std::optional< samplepos_t > const & nominal_jack_transport_sample()
PBD::Signal< void()> PunchLoopConstraintChange
PBD::Signal< void()> MtcOrLtcInputPortChanged
std::shared_ptr< RouteList > get_routes_with_regions_at(timepos_t const &) const
std::list< std::shared_ptr< MidiTrack > > new_midi_track(const ChanCount &input, const ChanCount &output, bool strict_io, std::shared_ptr< PluginInfo > instrument, Plugin::PresetRecord *pset, RouteGroup *route_group, uint32_t how_many, std::string name_template, PresentationInfo::order_t, TrackMode mode, bool input_auto_connect, bool trigger_visibility=false)
void rt_clear_all_solo_state(std::shared_ptr< RouteList const >, bool yn, PBD::Controllable::GroupControlDisposition group_override)
std::shared_ptr< RouteList > get_routes_with_internal_returns() const
std::string format_audio_source_name(const std::string &legalized_base, uint32_t nchan, uint32_t chan, bool take_required, uint32_t cnt, bool related_exists)
static std::string default_track_name_pattern(DataType)
bool routes_deletion_in_progress() const
void update_send_delaylines()
int bring_all_sources_into_session(std::function< void(uint32_t, uint32_t, std::string)> callback)
bool io_name_is_legal(const std::string &) const
samplepos_t _transport_sample
std::shared_ptr< MidiSource > create_midi_source_for_session(std::string const &)
void non_realtime_overwrite(int entry_request_count, bool &finished, bool reset_loop_declicks)
std::shared_ptr< RTTaskList > rt_tasklist()
std::string plugins_dir() const
Plugin state.
bool apply_nth_mixer_scene(size_t)
std::shared_ptr< ARDOUR::Trigger > trigger_by_id(PBD::ID) const
float default_fade_steepness
std::list< TimelineRange > current_audio_range
void remove_pending_capture_state()
AnyTime global_quantization() const
void process_export(pframes_t)
int save_history(std::string snapshot_name="")
void ensure_buffers(ChanCount howmany=ChanCount::ZERO)
void mmc_locate(MIDI::MachineControl &, const MIDI::byte *)
void mmc_pause(MIDI::MachineControl &)
std::shared_ptr< SessionPlaylists > _playlists
std::shared_ptr< AsyncMIDIPort > vkbd_output_port() const
std::shared_ptr< IOPlug > nth_io_plug(uint32_t n)
void route_solo_changed(bool self_solo_change, PBD::Controllable::GroupControlDisposition group_override, std::weak_ptr< Route >)
samplecnt_t _count_in_samples
samplecnt_t calc_preroll_subcycle(samplecnt_t) const
bool first_file_data_format_reset
void sample_to_timecode(samplepos_t sample, Timecode::Time &timecode, bool use_offset, bool use_subframes) const
void resort_routes_using(std::shared_ptr< RouteList >)
void set_worst_output_latency()
void clear_cue(int row_index)
PBD::Signal< void()> SessionLoaded
double compute_speed_from_master(pframes_t nframes)
std::optional< samplecnt_t > available_capture_duration()
std::string build_tmp_convert_name(std::string file)
MIDI::byte get_mtc_timecode_bits() const
double plan_master_strategy_engine(pframes_t nframes, double master_speed, samplepos_t master_transport_sample, double catch_speed)
std::atomic< unsigned int > _latency_recompute_pending
std::shared_ptr< Route > XMLRouteFactory_2X(const XMLNode &, int)
void unset_preroll_record_trim()
void get_track_statistics()
bool should_roll_after_locate() const
RecordState record_status() const
static const samplecnt_t default_click_length
std::shared_ptr< ExportStatus > get_export_status()
std::list< RouteGroup * > _route_groups
PBD::Signal< void(bool)> StepEditStatusChange
void rewire_selected_midi(std::shared_ptr< MidiTrack >)
void collect_sources_of_this_snapshot(std::set< std::shared_ptr< Source >> &, bool incl_unused=true) const
void set_exclusive_input_active(std::shared_ptr< RouteList > rt, bool onoff, bool flip_others=false)
samplepos_t _requested_return_sample
std::weak_ptr< MidiTrack > current_midi_target
SessionEvent * get_rt_event(std::shared_ptr< RouteList const > rl, T1 t1arg, T2 t2arg, SessionEvent::RTeventCallback after, PBD::Controllable::GroupControlDisposition group_override, void(Session::*method)(std::shared_ptr< RouteList const >, T1, T2, PBD::Controllable::GroupControlDisposition))
void globally_set_send_gains_to_unity(std::shared_ptr< Route > dest)
PBD::ScopedConnectionList punch_connections
void add_automation_list(AutomationList *)
void set_deletion_in_progress()
void playlist_ranges_moved(std::list< Temporal::RangeMove > const &)
void globally_set_send_gains_to_zero(std::shared_ptr< Route > dest)
void end_time_changed(samplepos_t)
bool have_looped
Used in audible_sample.
static void init_name_id_counter(unsigned int n)
void reset_native_file_format()
bool _update_send_delaylines
void ltc_tx_resync_latency(bool)
Timecode::Time transmitting_timecode_time
void maybe_enable_record(bool rt_context=false)
samplepos_t audible_sample(bool *latent_locate=NULL) const
double actual_speed() const
void queue_event(SessionEvent *)
boost::dynamic_bitset< uint32_t > insert_bitset
PBD::Signal< void()> RecordStateChanged
void remove_playlist(std::weak_ptr< Playlist >)
bool _reconnecting_routes_in_progress
std::shared_ptr< PBD::Controllable > recently_touched_controllable() const
static PBD::Signal< void(samplepos_t)> EndTimeChanged
std::shared_ptr< Amp > _click_gain
samplecnt_t worst_input_latency() const
bool locate_initiated() const
void request_bounded_roll(samplepos_t start, samplepos_t end)
void send_song_position_pointer(samplepos_t)
samplecnt_t nominal_sample_rate() const
std::string externals_dir() const
Links to external files.
int archive_session(const std::string &, const std::string &, ArchiveEncode compress_audio=FLAC_16BIT, PBD::FileArchive::CompressionLevel compression_level=PBD::FileArchive::CompressGood, bool only_used_sources=false, PBD::Progress *p=0)
void set_history_depth(uint32_t depth)
bool transport_state_rolling() const
void cut_copy_section(Temporal::timepos_t const &start, Temporal::timepos_t const &end, Temporal::timepos_t const &to, SectionOperation const op)
double _signalled_varispeed
std::atomic< int > _playback_load
void load_nested_sources(const XMLNode &node)
uint32_t undo_depth() const
void request_transport_speed(double speed, TransportRequestSource origin=TRS_UI)
luabridge::LuaRef * _lua_cleanup
std::shared_ptr< Port > ltc_output_port() const
void mmc_rewind(MIDI::MachineControl &)
bool processing_blocked() const
RouteList new_midi_route(RouteGroup *route_group, uint32_t how_many, std::string name_template, bool strict_io, std::shared_ptr< PluginInfo > instrument, Plugin::PresetRecord *, PresentationInfo::Flag, PresentationInfo::order_t)
pthread_cond_t _rt_emit_cond
void playlist_region_added(std::weak_ptr< Region >)
static PBD::Signal< void()> AfterConnect
samplecnt_t _capture_duration
std::atomic< int > _have_rec_enabled_track
void save_snapshot_name(const std::string &)
void register_lua_function(const std::string &, const std::string &, const LuaScriptParamList &)
void send_mmc_locate(samplepos_t)
boost::dynamic_bitset< uint32_t > surround_send_bitset
samplepos_t current_end_sample() const
void add_bundle(std::shared_ptr< Bundle >, bool emit_signal=true)
void set_audition(std::shared_ptr< Region >)
bool _non_soloed_outs_muted
SessionConfiguration config
std::shared_ptr< TriggerBox > triggerbox_at(int32_t route_index) const
bool need_declick_before_locate() const
void force_locate(samplepos_t sample, LocateTransportDisposition)
static PBD::Signal< int()> AskAboutPendingState
bool is_auditioning() const
int rename(const std::string &)
PBD::Signal< void()> QuantizationChanged
void setup_engine_resampling()
void clear_deletion_in_progress()
void setup_thread_local_variables()
std::shared_ptr< IOPlugList const > io_plugs() const
PBD::Signal< void()> IOConnectionsComplete
bool transport_master_no_external_or_using_engine() const
unsigned int _capture_xruns
luabridge::LuaRef * _lua_add
void store_nth_mixer_scene(size_t)
void trigger_stop_all(bool now=true)
void request_cancel_play_range()
void update_latency(bool playback)
void send_latency_compensation_change()
void ensure_route_presentation_info_gap(PresentationInfo::order_t, uint32_t gap_size)
std::shared_ptr< Route > route_by_id(PBD::ID) const
std::string new_midi_source_path(const std::string &, bool need_source_lock=true)
void auto_connect_monitor_bus()
std::atomic< int32_t > _pending_cue
void initialize_latencies()
samplecnt_t capture_duration() const
int create(const std::string &mix_template, BusProfile const *, bool unnamed)
void mark_insert_id(uint32_t)
void emit_thread_terminate()
PBD::Signal< void()> MuteChanged
pframes_t _pframes_since_last_mtc
std::shared_ptr< PBD::Controllable > solo_cut_control() const
std::list< std::string > missing_filesources(DataType) const
void consolidate_skips(Location *)
bool rechain_ioplug_graph(bool)
PBD::Signal< void(std::string)> StateSaved
void add_internal_send(std::shared_ptr< Route >, std::shared_ptr< Processor >, std::shared_ptr< Route >)
bool ensure_stripable_sort_order()
void solo_selection(StripableList &, bool)
static unsigned int next_name_id()
void probe_ctrl_surfaces()
void prepare_momentary_solo(SoloMuteRelease *smr=NULL, bool exclusive=false, std::shared_ptr< Route > route=std::shared_ptr< Route >())
void _locations_changed(const Locations::LocationList &)
void auto_connect_thread_run()
boost::dynamic_bitset< uint32_t > return_bitset
void setup_midi_control()
bool should_stop_before_locate() const
int silent_process_routes(pframes_t, bool &need_butler)
std::string snap_name() const
gain_t * gain_automation_buffer() const
void import_files(ImportStatus &)
void handle_slots_empty_status(std::weak_ptr< Route > const &)
std::shared_ptr< Amp > click_gain()
void reset_record_status()
std::shared_ptr< Port > mmc_input_port() const
void unmark_surround_send_id(uint32_t)
bool get_play_range() const
BufferSet & get_noinplace_buffers(ChanCount count=ChanCount::ZERO)
Controllables controllables
XMLNode & get_control_protocol_state() const
bool timecode_drop_frames() const
void overwrite_some_buffers(std::shared_ptr< Route >, OverwriteReason)
void set_play_loop(bool yn, bool change_transport_state)
bool get_play_loop() const
std::atomic< int32_t > _active_cue
void ltc_tx_parse_offset()
bool transport_will_roll_forwards() const
samplecnt_t _worst_input_latency
void refresh_disk_space()
int midi_read(MIDI::Port *)
std::list< MidiTimeoutCallback > MidiTimeoutList
PBD::Signal< void(bool)> AuditionActive
std::shared_ptr< MidiRegion > XMLMidiRegionFactory(const XMLNode &, bool full)
static bool get_disable_all_loaded_plugins()
void timecode_time_subframes(samplepos_t when, Timecode::Time &)
void time_domain_changed()
void location_added(Location *)
static int ask_about_playlist_deletion(std::shared_ptr< Playlist >)
void clear_range_selection()
void maybe_update_tempo_from_midiclock_tempo(float bpm)
PostTransportWork post_transport_work() const
void ensure_buffers_unlocked(ChanCount howmany)
std::string analysis_dir() const
Analysis data.
void set_sample_rate(samplecnt_t nframes)
void ltc_tx_recalculate_position()
bool maybe_copy_midifile(snapshot_t, std::shared_ptr< Source > src, XMLNode *)
uint32_t naudiotracks() const
void queue_latency_recompute()
void foreach_route(void(Route::*method)())
bool should_ignore_transport_request(TransportRequestSource, TransportRequestType)
std::shared_ptr< PBD::Controllable > _solo_cut_control
void ensure_search_path_includes(const std::string &path, DataType type)
std::shared_ptr< Port > trigger_input_port() const
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, bool use_smf_file_names)
luabridge::LuaRef * _lua_del
int num_triggerboxes() const
void remove_source(std::weak_ptr< Source >, bool drop_references=true)
void remove_monitor_section()
samplepos_t compute_stop_limit() const
int find_all_sources_across_snapshots(std::set< std::string > &result, bool exclude_this_snapshot)
void set_default_play_speed(double spd)
uint32_t count_sources_by_origin(const std::string &)
std::shared_ptr< Region > pending_audition_region
bool _adding_routes_in_progress
void non_realtime_locate()
samplecnt_t _timecode_frames_per_hour
static int get_info_from_path(const std::string &xmlpath, float &sample_rate, SampleFormat &data_format, std::string &program_version, XMLNode *engine_hints=0)
VCAManager & vca_manager()
volatile bool _save_queued_pending
void start_time_changed(samplepos_t)
PBD::Signal< void()> Located
void reconnect_ltc_output()
void add_instant_xml(XMLNode &, bool write_to_config=true)
The instant xml file is written to the session directory.
std::shared_ptr< Processor > processor_by_id(PBD::ID) const
void set_play_range(std::list< TimelineRange > &, bool leave_rolling)
void schedule_butler_for_transport_work()
Glib::Threads::RWLock _mixer_scenes_lock
void start_domain_bounce(Temporal::DomainBounceInfo &)
bool vapor_export_barrier()
double engine_speed() const
luabridge::LuaRef * _lua_list
void remove_route_group(RouteGroup &)
bool have_rec_disabled_track() const
void reset_punch_loop_constraint()
void reconnect_midi_scene_ports(bool)
samplepos_t _clicks_cleared
std::string unnamed_file_name() const
uint32_t registered_lua_function_count() const
LatencyRange ltc_out_latency
XMLNode & get_state() const
void set_had_destructive_tracks(bool yn)
std::shared_ptr< ExportStatus > export_status
samplepos_t _last_roll_location
bool had_destructive_tracks() const
void notify_presentation_info_change(PBD::PropertyChange const &)
std::shared_ptr< Route > _master_out
void rt_set_controls(std::shared_ptr< WeakAutomationControlList >, double val, PBD::Controllable::GroupControlDisposition group_override)
std::shared_ptr< MidiPort > mtc_output_port() const
void route_solo_isolated_changed(std::weak_ptr< Route >)
void adjust_capture_buffering()
void unmark_aux_send_id(uint32_t)
void request_play_range(std::list< TimelineRange > *, bool leave_rolling=false)
void request_sync_source(std::shared_ptr< TransportMaster >)
PBD::Signal< void(int)> SurroundObjectCountChanged
bool _send_timecode_update
Flag to send a full sample (Timecode) MTC message this cycle.
VCAManager * _vca_manager
void sync_locations_to_skips()
samplepos_t requested_return_sample() const
void add_routes_inner(RouteList &, bool input_auto_connect, bool output_auto_connect, PresentationInfo::order_t)
std::atomic< int > _ac_thread_active
bool actively_recording() const
void set_requested_return_sample(samplepos_t return_to)
std::list< std::string > unknown_processors() const
timepos_t current_end() const
bool transport_locating() const
samplecnt_t worst_route_latency() const
samplecnt_t _current_sample_rate
RouteGroup * new_route_group(const std::string &)
std::shared_ptr< PBD::Controllable > controllable_by_id(const PBD::ID &)
std::atomic< int > _ignored_a_processor_change
void route_removed_from_route_group(RouteGroup *, std::weak_ptr< Route >)
std::shared_ptr< AudioFileSource > audio_source_by_path_and_channel(const std::string &, uint16_t) const
samplepos_t transport_sample() const
std::shared_ptr< Port > scene_input_port() const
unsigned int get_xrun_count() const
PBD::Signal< void()> route_group_removed
samplepos_t current_start_sample() const
void location_removed(Location *)
std::shared_ptr< Speakers > get_speakers()
int immediately_post_engine()
std::map< PBD::ID, PBD::StatefulDestructible * > registry
luabridge::LuaRef * _lua_run
bool _session_range_is_free
size_t last_touched_mixer_scene_idx()
bool bang_trigger_at(int32_t route_index, int32_t row_index, float velocity=1.0)
void graph_reordered(bool called_from_backend)
bool _pre_export_mmc_enabled
void remove_state(std::string snapshot_name)
unsigned int export_xruns() const
void set_global_quantization(AnyTime const &)
std::list< RouteGroup * > const & route_groups() const
bool bounce_processing() const
int flatten_one_track(AudioTrack &, samplepos_t start, samplecnt_t cnt)
SerializedRCUManager< BundleList > _bundles
samplecnt_t any_duration_to_samples(samplepos_t position, AnyTime const &duration)
double plan_master_strategy(pframes_t nframes, double master_speed, samplepos_t master_transport_sample, double catch_speed)
PBD::Signal< void()> BatchUpdateEnd
uint32_t track_number_decimals() const
static bool _disable_all_loaded_plugins
ARDOUR::CueMarkers pending_source_markers
void route_listen_changed(PBD::Controllable::GroupControlDisposition, std::weak_ptr< Route >)
std::string automation_dir() const
Automation data.
boost::dynamic_bitset< uint32_t > send_bitset
bool peaks_cleanup_in_progres() const
PBD::Signal< void(RouteGroup *, std::weak_ptr< Route >)> RouteAddedToRouteGroup
PBD::Signal< void()> session_routes_reconnected
std::string new_audio_source_path_for_embedded(const std::string &existing_path)
Temporal::Range _object_selection
void remove_routes(std::shared_ptr< RouteList >)
std::optional< bool > _vapor_available
void add_post_transport_work(PostTransportWork ptw)
samplecnt_t preroll_record_trim_len() const
void mark_return_id(uint32_t)
bool unload_io_plugin(std::shared_ptr< IOPlug >)
std::shared_ptr< Region > write_one_track(Track &, samplepos_t start, samplepos_t end, bool overwrite, std::vector< std::shared_ptr< Source > > &, InterThreadInfo &wot, std::shared_ptr< Processor > endpoint, bool include_endpoint, bool for_export, bool for_freeze, std::string const &source_name="", std::string const ®ion_name="")
static void set_bypass_all_loaded_plugins(bool yn)
void realtime_stop(bool abort, bool clear_state)
SessionEvent * get_rt_event(std::shared_ptr< WeakAutomationControlList > cl, double arg, PBD::Controllable::GroupControlDisposition group_override)
void reset_transport_speed(TransportRequestSource origin=TRS_UI)
samplecnt_t _preroll_record_trim_len
void route_mute_changed()
bool route_name_unique(std::string) const
ChanCount _required_thread_buffers
void setup_click_sounds(int which)
void count_existing_track_channels(ChanCount &in, ChanCount &out)
bool update_route_latency(bool reverse, bool apply_to_delayline, bool *delayline_update_needed)
Glib::Threads::Mutex _auto_connect_queue_lock
gain_t * trim_automation_buffer() const
PBD::Signal< void()> MonitorChanged
bool first_file_header_format_reset
static const SessionEvent::RTeventCallback rt_cleanup
void post_transport_motion()
static PBD::Signal< void()> Quit
MIDI::byte mtc_timecode_bits
PBD::Signal< void(bool)> LatencyUpdated
Glib::Threads::Mutex save_source_lock
uint32_t nstripables(bool with_monitor=false) const
void port_registry_changed()
double transport_speed(bool incl_preroll=false) const
std::shared_ptr< Stripable > stripable_by_id(PBD::ID) const
void set_all_tracks_record_enabled(bool)
samplepos_t _export_preroll
samplecnt_t _worst_output_latency
void set_missing_file_replacement(const std::string &mfr)
PBD::Signal< void(RouteGroup *)> RouteGroupPropertyChanged
RouteList new_audio_route(int input_channels, int output_channels, RouteGroup *route_group, uint32_t how_many, std::string name_template, PresentationInfo::Flag, PresentationInfo::order_t)
std::shared_ptr< Port > _ltc_output_port
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)
void finalize_audio_export(TransportRequestSource trs)
void set_track_loop(bool)
void timecode_time(Timecode::Time &)
Sample * click_emphasis_data
Glib::Threads::Mutex _update_latency_lock
std::vector< std::shared_ptr< MixerScene > > _mixer_scenes
void unset_dirty(bool emit_dirty_changed=false)
pframes_t current_block_size
uint32_t _track_number_decimals
unsigned int capture_xruns() const
PBD::Signal< void()> IOPluginsChanged
bool reconnection_in_progress() const
static const uint32_t session_end_shift
bool solo_selection_active()
void update_skips(Location *, bool consolidate)
PBD::Signal< void()> RecordArmStateChanged
PBD::Signal< void(Location *)> auto_punch_location_changed
void auto_connect_io(std::shared_ptr< IO >)
void decrement_transport_position(samplecnt_t val)
AudioEngine const & engine() const
bool _global_locate_pending
void config_changed(std::string, bool)
RouteGroup & all_route_group() const
PBD::Signal< void()> FBSendsChanged
void mmc_step(MIDI::MachineControl &, int)
void clear_object_selection()
void process_rtop(SessionEvent *)
std::atomic< int > _capture_load
void set_control(std::shared_ptr< AutomationControl >, double val, PBD::Controllable::GroupControlDisposition)
void auto_punch_start_changed(Location *)
SessionEvent * get_rt_event(std::shared_ptr< RouteList const > rl, T targ, SessionEvent::RTeventCallback after, PBD::Controllable::GroupControlDisposition group_override, void(Session::*method)(std::shared_ptr< RouteList const >, T, PBD::Controllable::GroupControlDisposition))
void set_post_transport_work(PostTransportWork ptw)
PBD::Signal< void()> SessionSaveUnderway
std::shared_ptr< Port > scene_output_port() const
int cleanup_sources(CleanupReport &)
PBD::Signal< void()> IsolatedChanged
void foreach_source(std::function< void(std::shared_ptr< Source >)> f)
std::atomic< PunchLoopLock > _punch_or_loop
static int parse_stateful_loading_version(const std::string &)
PBD::Signal< void()> locations_modified
PBD::Signal< void(samplepos_t)> PositionChanged
process_function_type last_process_function
PBD::Signal< void(Location *)> auto_loop_location_changed
std::shared_ptr< IOTaskList > _io_tasklist
SessionConfiguration * cfg()
PBD::ScopedConnectionList skip_update_connections
int add_master_bus(ChanCount const &)
std::atomic< PostTransportWork > _post_transport_work
samplepos_t position() const
int load_routes(const XMLNode &, int)
bool _bounce_processing_active
Glib::Threads::Mutex controllables_lock
GraphEdges _current_route_graph
std::shared_ptr< Route > surround_master() const
bool synced_to_engine() const
std::atomic< RecordState > _record_status
void setup_raid_path(std::string path)
std::atomic< int > _processing_prohibited
void reassign_track_numbers()
std::shared_ptr< ExportHandler > export_handler
std::optional< bool > _vapor_exportable
BufferSet & get_route_buffers(ChanCount count=ChanCount::ZERO, bool silence=true)
std::shared_ptr< IO > _click_io
static const int vst_can_do_string_count
bool unbang_trigger_at(int32_t route_index, int32_t row_index)
void refill_all_track_buffers()
void disconnect_port_for_rewire(std::string const &port) const
void add_playlist(std::shared_ptr< Playlist >)
Glib::Threads::Mutex source_lock
std::shared_ptr< Route > get_remote_nth_route(PresentationInfo::order_t n) const
SourceList pt_imported_sources
void globally_add_internal_sends(std::shared_ptr< Route > dest, Placement p, bool)
void timecode_duration(samplecnt_t, Timecode::Time &) const
PBD::Signal< void(std::string)> SaveSessionRequested
MIDI::MachineControl * _mmc
void get_physical_ports(std::vector< std::string > &inputs, std::vector< std::string > &outputs, DataType type, MidiPortFlags include=MidiPortFlags(0), MidiPortFlags exclude=MidiPortFlags(0))
static PBD::Signal< void()> SendFeedback
samplecnt_t io_latency() const
void audition_region(std::shared_ptr< Region >)
void flush_cue_recording()
std::atomic< int > _have_rec_disabled_track
void request_resume_timecode_transmission()
void reorder_route_groups(std::list< RouteGroup * >)
void unblock_processing()
SerializedRCUManager< RouteList > routes
static PBD::Signal< int(Session *, std::string, DataType)> MissingFile
std::shared_ptr< GainControl > master_volume() const
void add_route_group(RouteGroup *)
bool implement_master_strategy()
bool save_default_options()
pthread_t _rt_emit_thread
PBD::ReallocPool _mempool
AutoConnectQueue _auto_connect_queue
std::string modified_with
Glib::Threads::Mutex peak_cleanup_lock
pthread_mutex_t _auto_connect_mutex
BufferSet & get_scratch_buffers(ChanCount count=ChanCount::ZERO, bool silence=true)
bool global_locate_pending() const
PBD::ScopedConnection _click_io_connection
std::atomic< int > _suspend_save
void setup_click_state(const XMLNode *)
bool get_record_enabled() const
static void * auto_connect_thread(void *)
void luabindings_session_rt(lua_State *)
unsigned int _export_xruns
double outbound_mtc_timecode_frame
Glib::Threads::RWLock click_lock
static const std::string session_name_is_legal(const std::string &)
std::shared_ptr< RouteList const > get_routes() const
PresentationInfo::order_t master_order_key() const
uint32_t next_return_id()
samplecnt_t convert_to_samples(AnyTime const &position)
samplepos_t record_location() const
static PBD::Signal< int(std::shared_ptr< Playlist >)> AskAboutPlaylistDeletion
bool export_track_state(std::shared_ptr< RouteList > rl, const std::string &path)
size_t _last_touched_mixer_scene_idx
CoreSelection & selection() const
void update_route_solo_state(std::shared_ptr< RouteList const > r=std::shared_ptr< RouteList const >())
VCAManager * vca_manager_ptr()
RouteList get_routelist(bool mixer_order=false, PresentationInfo::Flag fl=PresentationInfo::MixerRoutes) const
std::shared_ptr< AutomationControl > automation_control_by_id(const PBD::ID &)
void timecode_to_sample(Timecode::Time &timecode, samplepos_t &sample, bool use_offset, bool use_subframes) const
void get_last_capture_sources(std::list< std::shared_ptr< Source > > &)
volatile bool _save_queued
std::function< bool()> MidiTimeoutCallback
void mark_send_id(uint32_t)
bool have_rec_enabled_track() const
std::shared_ptr< MixerScene > nth_mixer_scene(size_t, bool create_if_missing=false)
void remove_route_group(RouteGroup *rg)
void playlist_regions_extended(std::list< Temporal::Range > const &)
static int vst_current_loading_id
void mmc_record_exit(MIDI::MachineControl &)
pthread_cond_t _auto_connect_cond
void queue_full_time_code()
SerializedRCUManager< IOPlugList > _io_plugins
std::shared_ptr< Speakers > _speakers
int find_all_sources(std::string path, std::set< std::string > &result)
void add_controllable(std::shared_ptr< PBD::Controllable >)
std::atomic< int > _butler_seek_counter
PBD::Signal< void()> TransportStateChange
gain_t * send_gain_automation_buffer() const
std::shared_ptr< Port > mmc_output_port() const
std::vector< std::weak_ptr< AutomationControl > > cancel_all_mute()
void request_locate(samplepos_t sample, bool force=false, LocateTransportDisposition ltd=RollIfAppropriate, TransportRequestSource origin=TRS_UI)
bool rechain_process_graph(GraphNodeList &)
void mmc_stop(MIDI::MachineControl &)
bool sample_rate_convert(ImportStatus &, std::string infile, std::string &outfile)
static PBD::Signal< int(samplecnt_t, samplecnt_t)> AskAboutSampleRateMismatch
int save_template(const std::string &template_name, const std::string &description="", bool replace_existing=false)
uint32_t redo_depth() const
void set_track_monitor_input_status(bool)
bool playlist_is_active(std::shared_ptr< Playlist >)
std::shared_ptr< Route > monitor_out() const
bool waiting_for_sync_offset
Timecode::TimecodeFormat ltc_enc_tcformat
void process_with_events(pframes_t)
StateOfTheState _state_of_the_state
PBD::Signal< void()> MonitorBusAddedOrRemoved
std::shared_ptr< Source > XMLSourceFactory(const XMLNode &)
XMLNode * _bundle_xml_node
void process_event(SessionEvent *)
void request_count_in_record()
void set_auto_loop_location(Location *)
void route_processors_changed(RouteProcessorChange)
std::atomic< int > _seek_counter
MidiPortManager * _midi_ports
void schedule_playback_buffering_adjustment()
void reset_monitor_section()
AnyTime _global_quantization
std::shared_ptr< Route > _surround_master
std::shared_ptr< SessionPlaylists > playlists() const
samplecnt_t click_emphasis_length
bool apply_nth_mixer_scene(size_t, RouteList const &)
std::atomic< int > _suspend_timecode_transmission
void auto_connect_thread_start()
bool punch_active() const
std::vector< space_and_path >::iterator last_rr_session_dir
Session(AudioEngine &, const std::string &fullpath, const std::string &snapshot_name, BusProfile const *bus_profile=0, std::string mix_template="", bool unnamed=false, samplecnt_t samplerate=0)
void schedule_capture_buffering_adjustment()
XMLNode & state(bool save_template, snapshot_t snapshot_type=NormalSave, bool for_archive=false, bool only_used_assets=false) const
bool session_range_is_free() const
int no_roll(pframes_t nframes)
std::shared_ptr< BundleList const > bundles()
void non_realtime_set_audition()
samplepos_t ltc_timecode_offset
PBD::Signal< void(std::weak_ptr< Source >)> SourceAdded
PBD::Signal< void(RouteGroup *, std::weak_ptr< Route >)> RouteRemovedFromRouteGroup
void request_preroll_record_trim(samplepos_t start, samplecnt_t preroll)
pthread_mutex_t _rt_emit_mutex
bool user_roll_after_locate() const
PBD::Signal< void()> route_groups_reordered
static PBD::Signal< void(samplecnt_t, samplecnt_t)> NotifyAboutSampleRateMismatch
static bool get_bypass_all_loaded_plugins()
void queue_song_position_pointer()
bool locate_pending() const
samplepos_t ltc_prev_cycle
void routes_using_input_from(const std::string &str, RouteList &rl)
PBD::Signal< void(std::weak_ptr< Source >)> SourceRemoved
void butler_transport_work(bool have_process_lock=false)
void mmc_record_enable(MIDI::MachineControl &mmc, size_t track, bool enabled)
std::shared_ptr< MidiSource > create_midi_source_by_stealing_name(std::shared_ptr< Track >)
int cleanup_trash_sources(CleanupReport &)
bool path_is_within_session(const std::string &)
Glib::Threads::Mutex region_lock
void send_immediate_mmc(MIDI::MachineControlCommand)
std::shared_ptr< AudioRegion > XMLAudioRegionFactory(const XMLNode &, bool full)
void midi_output_change_handler(IOChange change, void *, std::weak_ptr< Route > midi_track)
void add_monitor_section()
uint32_t _send_latency_changes
MidiTimeoutList midi_timeouts
std::vector< std::string > registered_lua_functions()
void add_source(std::shared_ptr< Source >)
samplecnt_t worst_latency_preroll() const
std::shared_ptr< Route > XMLRouteFactory_3X(const XMLNode &, int)
samplecnt_t frames_per_hour() const
void auto_connect_surround_master()
std::optional< samplepos_t > _nominal_jack_transport_sample
bool get_nsm_state() const
void timecode_time(samplepos_t when, Timecode::Time &)
uint32_t _solo_isolated_cnt
int start_audio_export(samplepos_t position, bool realtime=false, bool region_export=false)
bool monitor_active() const
static void * session_loader_thread(void *arg)
void remove_route(std::shared_ptr< Route >)
int send_full_time_code(samplepos_t, pframes_t nframes)
void set_auto_punch_location(Location *)
void cue_marker_change(Location *)
static PBD::Signal< void()> FeedbackDetected
void set_controls(std::shared_ptr< AutomationControlList >, double val, PBD::Controllable::GroupControlDisposition)
void set_block_size(pframes_t nframes)
bool _route_reorder_in_progress
void click_io_resync_latency(bool)
samplepos_t last_transport_start() const
void mmc_fast_forward(MIDI::MachineControl &)
void mmc_shuttle(MIDI::MachineControl &mmc, float speed, bool forw)
int load_sources(const XMLNode &node)
std::string next_redo() const
bool find_route_name(std::string const &, uint32_t &id, std::string &name, bool)
int set_state(const XMLNode &node, int version)
bool transport_master_is_external() const
bool transport_locked() const
int load_route_groups(const XMLNode &, int)
void auto_connect_master_bus()
void mmc_record_pause(MIDI::MachineControl &)
std::shared_ptr< GraphChain > _graph_chain
void rewire_midi_selection_ports()
PBD::Signal< void()> BatchUpdateStart
void setup_midi_machine_control()
samplecnt_t worst_latency_preroll_buffer_size_ceil() const
samplecnt_t timecode_frames_per_hour() const
std::string _current_snapshot_name
bool transport_stopped_or_stopping() const
void import_pt_rest(PTFFormat &ptf)
void deinterlace_midi_region(std::shared_ptr< MidiRegion > mr)
void unmark_insert_id(uint32_t)
void register_with_memento_command_factory(PBD::ID, PBD::StatefulDestructible *)
samplecnt_t _click_io_latency
RouteGroup * route_group_by_name(std::string)
Glib::Threads::Mutex lua_lock
PBD::Signal< void()> UpdateRouteRecordState
void add_click(samplepos_t pos, bool emphasis)
std::weak_ptr< PBD::Controllable > _recently_touched_controllable
void save_as_bring_callback(uint32_t, uint32_t, std::string)
luabridge::LuaRef * _lua_save
void adjust_playback_buffering()
pthread_t _auto_connect_thread
void solo_control_mode_changed()
void request_overwrite_buffer(std::shared_ptr< Track >, OverwriteReason)
void emit_route_signals()
PBD::ScopedConnection export_freewheel_connection
std::string _template_state_dir
void listen_position_changed()
void auto_connect_thread_terminate()
PBD::Signal< void()> StateReady
RouteList new_route_from_template(uint32_t how_many, PresentationInfo::order_t insert_at, XMLNode &, const std::string &name, PlaylistDisposition pd=NewPlaylist)
std::shared_ptr< RouteList > get_tracks() const
void track_playlist_changed(std::weak_ptr< Track >)
std::shared_ptr< Route > get_midi_nth_route_by_id(PresentationInfo::order_t n) const
samplepos_t _last_roll_or_reversal_location
int destroy_sources(std::list< std::shared_ptr< Source > > const &)
void foreach_route_group(std::function< void(RouteGroup *)> f)
std::vector< space_and_path > session_dirs
PBD::Command * stateful_diff_command_factory(XMLNode *)
std::shared_ptr< Region > find_whole_file_parent(std::shared_ptr< Region const >) const
void rename_state(std::string old_name, std::string new_name)
samplecnt_t _frames_per_hour
size_t _required_thread_buffersize
int save_state(std::string snapshot_name="", bool pending=false, bool switch_to_snapshot=false, bool template_only=false, bool for_archive=false, bool only_used_assets=false)
void unmark_return_id(uint32_t)
uint32_t next_surround_send_id()
int remove_last_capture()
bool maybe_allow_only_punch()
void finish_domain_bounce(Temporal::DomainBounceInfo &)
void goto_start(bool and_roll=false)
LatencyRange mtc_out_latency
std::vector< std::string > source_search_path(DataType) const
void update_marks(Location *loc)
gain_t * scratch_automation_buffer() const
int load_compounds(const XMLNode &node)
std::shared_ptr< ExportHandler > get_export_handler()
bool punch_is_possible() const
void remove_empty_sounds()
void auto_connect_thread_wakeup()
void unmark_send_id(uint32_t)
static PBD::Signal< void()> SuccessfulGraphSort
std::string construct_peak_filepath(const std::string &audio_path, const bool in_session=false, const bool old_peak_name=false) const
static void * emit_thread(void *)
bool route_name_internal(std::string) const
samplepos_t post_export_position
std::shared_ptr< IO > click_io()
std::vector< std::shared_ptr< MixerScene > > mixer_scenes() const
bool can_cleanup_peakfiles() const
samplecnt_t _base_sample_rate
void update_latency_compensation(bool force, bool called_from_backend)
bool maybe_allow_only_loop(bool play_loop=false)
bool process_can_proceed() const
bool deletion_in_progress() const
void mmc_track_record_status(MIDI::MachineControl &, uint32_t track, bool enabled)
void _sync_locations_to_skips()
bool realtime_export() const
static std::string get_snapshot_from_instant(const std::string &session_dir)
void sync_cues_from_list(Locations::LocationList const &)
bool have_external_connections_for_current_backend(bool tracks_only=true) const
void increment_transport_position(samplecnt_t val)
void auto_connect_route(std::shared_ptr< Route >, bool, bool, const ChanCount &, const ChanCount &, const ChanCount &io=ChanCount(), const ChanCount &oo=ChanCount())
int backend_sync_callback(TransportState, samplepos_t)
void set_object_selection(Temporal::timepos_t const &start, Temporal::timepos_t const &end)
bool have_captured() const
PBD::Signal< void(RouteGroup *)> route_group_added
StripableList get_stripables() const
static std::atomic< unsigned int > _name_id_counter
StripableList _soloSelection
void globally_set_send_gains_from_track(std::shared_ptr< Route > dest)
std::vector< struct ptflookup > ptfwavpair
void get_stripables(StripableList &, PresentationInfo::Flag fl=PresentationInfo::MixerStripables) const
void start_transport(bool after_loop)
int restore_history(std::string snapshot_name)
void set_nsm_state(bool state)
void set_session_range_is_free(bool)
Temporal::GridIterator _click_iterator
void maybe_update_session_range(timepos_t const &, timepos_t const &)
int micro_locate(samplecnt_t distance)
static bool _bypass_all_loaded_plugins
void request_play_loop(bool yn, bool leave_rolling=false)
PBD::Command * memento_command_factory(XMLNode *n)
void allow_auto_play(bool yn)
static PBD::Signal< void(std::string, std::string, bool, samplepos_t)> Exported
std::vector< std::string > possible_states() const
void route_group_property_changed(RouteGroup *)
PBD::Signal< void()> TransportLooped
samplepos_t last_timecode_when
void midi_track_presentation_info_changed(PBD::PropertyChange const &, std::weak_ptr< MidiTrack >)
PBD::Signal< int(samplecnt_t)> ProcessExport
static PBD::Signal< void(std::string)> Dialog
static EventLoop * get_event_loop_for_thread()
GtkImageIconNameData name
libltc - en+decode linear timecode
unsigned char ltcsnd_sample_t
PBD::PropertyDescriptor< uint32_t > order
PBD::PropertyDescriptor< timepos_t > start
LocateTransportDisposition
std::shared_ptr< Trigger > TriggerPtr
std::set< CueMarker > CueMarkers
std::vector< std::shared_ptr< Source > > SourceList
std::vector< CueEvent > CueEvents
std::list< std::shared_ptr< Stripable > > StripableList
Temporal::samplecnt_t samplecnt_t
std::list< std::shared_ptr< GraphNode > > GraphNodeList
std::list< std::shared_ptr< Route > > RouteList
std::vector< LuaScriptParamPtr > LuaScriptParamList
Temporal::samplepos_t samplepos_t
std::shared_ptr< PBD::Controllable > Controllable
void atomic_inc(std::atomic< T > &aval)
bool atomic_dec_and_test(std::atomic< T > &aval)
static const samplepos_t max_samplepos
bool operator==(const ProcessorSelection &a, const ProcessorSelection &b)
AutoConnectRequest(std::shared_ptr< Route > r, bool ci, bool co, const ChanCount &is, const ChanCount &os, const ChanCount &io, const ChanCount &oo)
std::weak_ptr< Route > route
std::string final_session_folder_name
std::string failure_message
std::string new_parent_folder
PBD::Signal< bool(float, int64_t, int64_t)> Progress
TransportMasterAction action
TransportMasterStrategy()
LocateTransportDisposition roll_disposition
uint32_t blocks
4kB blocks
bool blocks_unknown
true if blocks is unknown