Ardour  9.0-pre0-1029-g1f27dc81f9
session.h
Go to the documentation of this file.
1 /*
2  * Copyright (C) 2000-2019 Paul Davis <paul@linuxaudiosystems.com>
3  * Copyright (C) 2005-2009 Taybin Rutkin <taybin@taybin.com>
4  * Copyright (C) 2006-2007 Jesse Chappell <jesse@essej.net>
5  * Copyright (C) 2006-2009 Sampo Savolainen <v2@iki.fi>
6  * Copyright (C) 2006-2015 David Robillard <d@drobilla.net>
7  * Copyright (C) 2007-2012 Carl Hetherington <carl@carlh.net>
8  * Copyright (C) 2007-2015 Tim Mayberry <mojofunk@gmail.com>
9  * Copyright (C) 2008-2009 Hans Baier <hansfbaier@googlemail.com>
10  * Copyright (C) 2008-2009 Sakari Bergen <sakari.bergen@beatwaves.net>
11  * Copyright (C) 2012-2019 Robin Gareus <robin@gareus.org>
12  * Copyright (C) 2013-2017 Nick Mainsbridge <mainsbridge@gmail.com>
13  * Copyright (C) 2013-2018 John Emmas <john@creativepost.co.uk>
14  * Copyright (C) 2014-2018 Ben Loftis <ben@harrisonconsoles.com>
15  * Copyright (C) 2015-2018 Len Ovens <len@ovenwerks.net>
16  *
17  * This program is free software; you can redistribute it and/or modify
18  * it under the terms of the GNU General Public License as published by
19  * the Free Software Foundation; either version 2 of the License, or
20  * (at your option) any later version.
21  *
22  * This program is distributed in the hope that it will be useful,
23  * but WITHOUT ANY WARRANTY; without even the implied warranty of
24  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
25  * GNU General Public License for more details.
26  *
27  * You should have received a copy of the GNU General Public License along
28  * with this program; if not, write to the Free Software Foundation, Inc.,
29  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
30  */
31 
32 #pragma once
33 
34 #ifdef WAF_BUILD
35 #include "libardour-config.h"
36 #endif
37 
38 #include <atomic>
39 #include <exception>
40 #include <list>
41 #include <map>
42 #include <memory>
43 #include <set>
44 #include <string>
45 #include <vector>
46 #include <queue>
47 #include <stdint.h>
48 
49 #include <boost/dynamic_bitset.hpp>
50 #include <glibmm/threads.h>
51 
52 #include <ltc.h>
53 
54 #include "pbd/atomic.h"
55 #include "pbd/error.h"
56 #include "pbd/event_loop.h"
57 #include "pbd/file_archive.h"
58 #include "pbd/history_owner.h"
59 #include "pbd/rcu.h"
61 #include "pbd/signals.h"
62 #include "pbd/undo.h"
63 
64 #ifdef USE_TLSF
65 # include "pbd/tlsf.h"
66 #else
67 # include "pbd/reallocpool.h"
68 #endif
69 #include "lua/luastate.h"
70 
71 #include "temporal/range.h"
73 
74 #include "midi++/types.h"
75 #include "midi++/mmc.h"
76 
77 #include "temporal/time.h"
78 
79 #include "ardour/ardour.h"
80 #include "ardour/chan_count.h"
81 #include "ardour/delivery.h"
83 #include "ardour/luascripting.h"
84 #include "ardour/location.h"
89 #include "ardour/session_event.h"
90 #include "ardour/plugin.h"
92 #include "ardour/route.h"
93 #include "ardour/graph_edges.h"
94 #include "ardour/transport_api.h"
95 #include "ardour/triggerbox.h"
96 
97 class XMLTree;
98 class XMLNode;
99 struct _AEffect;
100 typedef struct _AEffect AEffect;
101 
102 class PTFFormat;
103 
104 namespace MIDI {
105 class Port;
106 class MachineControl;
107 class Parser;
108 }
109 
110 namespace PBD {
111 class Controllable;
112 class Progress;
113 class Command;
114 }
115 
116 namespace luabridge {
117  class LuaRef;
118 }
119 
120 namespace Evoral {
121 class Curve;
122 }
123 
124 namespace Temporal {
125 class TempoMap;
126 }
127 
128 namespace ARDOUR {
129 
130 class Amp;
131 class AsyncMIDIPort;
132 class AudioEngine;
133 class AudioFileSource;
134 class AudioRegion;
135 class AudioSource;
136 class AudioTrack;
137 class Auditioner;
138 class AutomationList;
139 class AuxInput;
140 class BufferSet;
141 class Bundle;
142 class Butler;
143 class Click;
144 class CoreSelection;
145 class ExportHandler;
146 class ExportStatus;
147 class Graph;
148 struct GraphChain;
149 class IO;
150 class IOPlug;
151 class IOProcessor;
152 class IOTaskList;
153 class ImportStatus;
154 class MidiClockTicker;
155 class MidiControlUI;
156 class MidiPortManager;
157 class MidiPort;
158 class MidiRegion;
159 class MidiSource;
160 class MidiTrack;
161 class MixerScene;
162 class Playlist;
163 class PluginInsert;
164 class PluginInfo;
165 class Port;
166 class PortInsert;
167 class PortManager;
168 class ProcessThread;
169 class Processor;
170 class Region;
171 class Return;
172 class Route;
173 class RouteGroup;
174 class RTTaskList;
175 class SMFSource;
176 class Send;
177 class SceneChanger;
178 class SessionDirectory;
179 class SessionMetadata;
180 class SessionPlaylists;
181 class SoloMuteRelease;
182 class Source;
183 class Speakers;
184 class TransportMaster;
185 struct TransportFSM;
186 class Track;
187 class UI_TransportMaster;
188 class VCAManager;
189 class WindowsVSTPlugin;
190 
191 extern void setup_enum_writer ();
192 
193 class LIBARDOUR_API SessionException: public std::exception {
194 public:
195  explicit SessionException(const std::string msg) : _message(msg) {}
196  virtual ~SessionException() throw() {}
197 
198  virtual const char* what() const throw() { return _message.c_str(); }
199 
200 private:
201  std::string _message;
202 };
203 
208  public SessionEventManager,
209  public TransportAPI,
211 {
212 public:
213  /* a new session might have non-empty mix_template, an existing session should always have an empty one.
214  the bus profile can be null if no master out bus is required.
215  */
216 
218  const std::string& fullpath,
219  const std::string& snapshot_name,
220  BusProfile const * bus_profile = 0,
221  std::string mix_template = "",
222  bool unnamed = false,
223  samplecnt_t samplerate = 0);
224 
225  virtual ~Session ();
226 
227  static int get_info_from_path (const std::string& xmlpath, float& sample_rate, SampleFormat& data_format, std::string& program_version, XMLNode* engine_hints = 0);
228  static std::string get_snapshot_from_instant (const std::string& session_dir);
229 
234  static unsigned int next_name_id ();
235 
236  std::string path() const { return _path; }
237  std::string name() const { return _name; }
238  std::string snap_name() const { return _current_snapshot_name; }
239  std::string raid_path () const;
240  bool path_is_within_session (const std::string&);
241 
242  bool writable() const { return _writable; }
243  void set_clean (); // == Clean and emit DirtyChanged IFF session was Dirty
244  void set_dirty (); // |= Dirty and emit DirtyChanged (unless already dirty or Loading, Deletion)
245  void unset_dirty (bool emit_dirty_changed = false); // &= ~Dirty
246  void set_deletion_in_progress (); // |= Deletion
247  void clear_deletion_in_progress (); // &= ~Deletion
248 
249  bool reconnection_in_progress () const { return _reconnecting_routes_in_progress; }
250  bool routes_deletion_in_progress () const { return _route_deletion_in_progress; }
251  bool dirty () const { return _state_of_the_state & Dirty; }
252  bool deletion_in_progress () const { return _state_of_the_state & Deletion; }
253  bool peaks_cleanup_in_progres () const { return _state_of_the_state & PeakCleanup; }
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; }
257  bool inital_connect_or_deletion_in_progress () const { return _state_of_the_state & (InitialConnecting | Deletion); }
258  bool have_external_connections_for_current_backend (bool tracks_only = true) const;
259  bool unnamed() const;
260 
261  void end_unnamed_status () const;
262 
264 
265  const SessionDirectory& session_directory () const { return *(_session_dir.get()); }
266 
267  static PBD::Signal<void(std::string)> Dialog;
268 
271 
273 
274  std::string automation_dir () const;
275  std::string analysis_dir () const;
276  std::string plugins_dir () const;
277  std::string externals_dir () const;
278 
279  std::string construct_peak_filepath (const std::string& audio_path, const bool in_session = false, const bool old_peak_name = false) const;
280 
281  bool audio_source_name_is_unique (const std::string& name);
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);
283  std::string new_audio_source_path_for_embedded (const std::string& existing_path);
284  std::string new_audio_source_path (const std::string&, uint32_t nchans, uint32_t chan, bool take_required);
285  std::string new_midi_source_path (const std::string&, bool need_source_lock = true);
286 
295  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);
296  RouteList new_route_from_template (uint32_t how_many, PresentationInfo::order_t insert_at, XMLNode&, const std::string& name, PlaylistDisposition pd = NewPlaylist);
297  std::vector<std::string> get_paths_for_new_sources (bool allow_replacing, const std::string& import_file_path,
298  uint32_t channels, std::vector<std::string> const & smf_track_names, bool use_smf_file_names);
299 
300  int bring_all_sources_into_session (std::function<void(uint32_t,uint32_t,std::string)> callback);
301 
302  void process (pframes_t nframes);
303 
306 
309  BufferSet& get_scratch_buffers (ChanCount count = ChanCount::ZERO, bool silence = true);
310  BufferSet& get_route_buffers (ChanCount count = ChanCount::ZERO, bool silence = true);
312 
314 
315  bool have_rec_enabled_track () const;
316  bool have_rec_disabled_track () const;
317 
318  bool have_captured() const { return _have_captured; }
319 
320  samplecnt_t capture_duration () const { return _capture_duration; }
321  unsigned int capture_xruns () const { return _capture_xruns; }
322  unsigned int export_xruns () const { return _export_xruns; }
323 
325  Butler* butler() { return _butler; }
326  void butler_transport_work (bool have_process_lock = false);
327 
329 
330  int load_routes (const XMLNode&, int);
331  std::shared_ptr<RouteList const> get_routes() const {
332  return routes.reader ();
333  }
334 
335  std::shared_ptr<RTTaskList> rt_tasklist () { return _rt_tasklist; }
336  std::shared_ptr<IOTaskList> io_tasklist () { return _io_tasklist; }
337 
339 
340  CoreSelection& selection () const { return *_selection; }
341 
342  /* because the set of Stripables consists of objects managed
343  * independently, in multiple containers within the Session (or objects
344  * owned by the session), we fill out a list in-place rather than
345  * return a pointer to a copy of the (RCU) managed list, as happens
346  * with get_routes()
347  */
348 
351  std::shared_ptr<RouteList> get_tracks() const;
352  std::shared_ptr<RouteList> get_routes_with_internal_returns() const;
353  std::shared_ptr<RouteList> get_routes_with_regions_at (timepos_t const &) const;
354 
355  uint32_t nstripables (bool with_monitor = false) const;
356  uint32_t nroutes() const { return routes.reader()->size(); }
357  uint32_t ntracks () const;
358  uint32_t naudiotracks () const;
359  uint32_t nbusses () const;
360 
361  bool plot_process_graph (std::string const& file_name) const;
362 
363  std::shared_ptr<BundleList const> bundles () {
364  return _bundles.reader ();
365  }
366 
368 
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);
372 
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);
375 
376  void foreach_route (void (Route::*method)());
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);
379 
380  static const std::string session_name_is_legal (const std::string&);
381 
382  bool io_name_is_legal (const std::string&) const;
383  std::shared_ptr<Route> route_by_name (std::string) const;
384  std::shared_ptr<Route> route_by_id (PBD::ID) const;
385  std::shared_ptr<Stripable> stripable_by_id (PBD::ID) const;
387  std::shared_ptr<Route> get_remote_nth_route (PresentationInfo::order_t n) const;
388  std::shared_ptr<Route> route_by_selected_count (uint32_t cnt) const;
389  void routes_using_input_from (const std::string& str, RouteList& rl);
390 
391  bool route_name_unique (std::string) const;
392  bool route_name_internal (std::string) const;
393 
394  uint32_t track_number_decimals () const {
395  return _track_number_decimals;
396  }
397 
398  bool get_record_enabled() const {
399  return (record_status () >= Enabled);
400  }
401 
403  return _record_status.load();
404  }
405 
406  bool actively_recording () const {
407  return record_status() == Recording;
408  }
409 
410  bool record_enabling_legal () const;
411  void maybe_enable_record (bool rt_context = false);
412  void disable_record (bool rt_context, bool force = false);
414 
416 
418 
420 
421  /* Emitted when all i/o connections are complete */
422 
424 
425  /* Record status signals */
426 
427  PBD::Signal<void()> RecordStateChanged; /* signals changes in recording state (i.e. are we recording) */
428  /* XXX may 2015: paul says: it isn't clear to me that this has semantics that cannot be inferrred
429  from the previous signal and session state.
430  */
431  PBD::Signal<void()> RecordArmStateChanged; /* signals changes in recording arming */
432 
433  PBD::Signal<void()> UpdateRouteRecordState; /* signals potential change in route recording arming */
434 
437 
438  /* Emited when session is loaded */
440 
441  /* Transport mechanism signals */
442 
451 
452  PBD::Signal<void(samplepos_t)> PositionChanged; /* sent after any non-sequential motion */
455 
458 
467  PBD::Signal<void(RouteGroup *, std::weak_ptr<Route> )> RouteAddedToRouteGroup;
471  PBD::Signal<void(RouteGroup *, std::weak_ptr<Route> )> RouteRemovedFromRouteGroup;
472 
476 
477  /* Step Editing status changed */
479 
480  /* Timecode state signals */
482 
484 
488  void request_stop (bool abort = false, bool clear_state = false, TransportRequestSource origin = TRS_UI);
490 
491  void request_play_loop (bool yn, bool leave_rolling = false);
492  bool get_play_loop () const { return play_loop; }
493 
494  samplepos_t last_transport_start () const { return _last_roll_location; }
495  void goto_end ();
496  void goto_start (bool and_roll = false);
498  void allow_auto_play (bool yn);
499 
502 
503  void trigger_stop_all (bool now = true);
504 
508  void request_overwrite_buffer (std::shared_ptr<Track>, OverwriteReason);
511 
512  bool global_locate_pending() const { return _global_locate_pending; }
513  bool locate_pending() const;
514  bool locate_initiated() const;
515  bool declick_in_progress () const;
516  bool transport_locked () const;
517 
518  bool had_destructive_tracks () const;
520 
521  int wipe ();
522 
528  samplecnt_t sample_rate () const { return _current_sample_rate; }
530  samplecnt_t nominal_sample_rate () const { return _base_sample_rate; }
531  samplecnt_t frames_per_hour () const { return _frames_per_hour; }
532 
533  double samples_per_timecode_frame() const { return _samples_per_timecode_frame; }
534  samplecnt_t timecode_frames_per_hour() const { return _timecode_frames_per_hour; }
535 
537  return mtc_timecode_bits; /* encoding of SMTPE type for MTC */
538  }
539 
541  bool timecode_drop_frames() const;
542 
543  /* Locations */
544 
545  Locations *locations() { return _locations; }
546 
550 
553  void set_session_extents (timepos_t const & start, timepos_t const & end);
554  bool session_range_is_free () const { return _session_range_is_free; }
556 
557  pframes_t get_block_size () const { return current_block_size; }
558  samplecnt_t worst_output_latency () const { return _worst_output_latency; }
559  samplecnt_t worst_input_latency () const { return _worst_input_latency; }
560  samplecnt_t worst_route_latency () const { return _worst_route_latency; }
561  samplecnt_t io_latency () const { return _io_latency; }
564 
566 
567  struct SaveAs {
568  std::string new_parent_folder; /* parent folder where new session folder will be created */
569  std::string new_name; /* name of newly saved session */
570  bool switch_to; /* true if we should be working on newly saved session after save-as; false otherwise */
571  bool include_media; /* true if the newly saved session should contain references to media */
572  bool copy_media; /* true if media files (audio, media, etc) should be copied into newly saved session; false otherwise */
573  bool copy_external; /* true if external media should be consolidated into the newly saved session; false otherwise */
574 
575  std::string final_session_folder_name; /* filled in by * Session::save_as(), provides full path to newly saved session */
576 
577  /* emitted as we make progress. 3 arguments passed to signal
578  * handler:
579  *
580  * 1: percentage complete measured as a fraction (0-1.0) of
581  * total data copying done.
582  * 2: number of files copied so far
583  * 3: total number of files to copy
584  *
585  * Handler should return true for save-as to continue, or false
586  * to stop (and remove all evidence of partial save-as).
587  */
588  PBD::Signal<bool(float,int64_t,int64_t)> Progress;
589 
590  /* if save_as() returns non-zero, this string will indicate the reason why.
591  */
592  std::string failure_message;
593  };
594 
595  int save_as (SaveAs&);
596 
606  int save_state (std::string snapshot_name = "",
607  bool pending = false,
608  bool switch_to_snapshot = false,
609  bool template_only = false,
610  bool for_archive = false,
611  bool only_used_assets = false);
612 
616  FLAC_24BIT
617  };
618 
619  int archive_session (const std::string&, const std::string&,
620  ArchiveEncode compress_audio = FLAC_16BIT,
622  bool only_used_sources = false,
623  PBD::Progress* p = 0);
624 
625  int restore_state (std::string snapshot_name);
626  int save_template (const std::string& template_name, const std::string& description = "", bool replace_existing = false);
627  int save_history (std::string snapshot_name = "");
628  int restore_history (std::string snapshot_name);
629  void remove_state (std::string snapshot_name);
630  void rename_state (std::string old_name, std::string new_name);
632  int rename (const std::string&);
633  bool get_nsm_state () const { return _under_nsm_control; }
634  void set_nsm_state (bool state) { _under_nsm_control = state; }
636 
637  PBD::Signal<void(std::string)> StateSaved;
639 
640  /* emitted when session needs to be saved due to some internal
641  * event or condition (i.e. not in response to a user request).
642  *
643  * Only one object should
644  * connect to this signal and take responsibility.
645  *
646  * Argument is the snapshot name to use when saving.
647  */
648  PBD::Signal<void(std::string)> SaveSessionRequested;
649 
650  /* emitted during a session save to allow other entities to add state, via
651  * extra XML, to the session state
652  */
654 
655  std::vector<std::string> possible_states() const;
656  static std::vector<std::string> possible_states (std::string path);
657 
658  bool export_track_state (std::shared_ptr<RouteList> rl, const std::string& path);
659 
661  void add_instant_xml (XMLNode&, bool write_to_config = true);
662  XMLNode* instant_xml (const std::string& str);
663 
665  Clean = 0x0,
666  Dirty = 0x1,
667  CannotSave = 0x2,
668  Deletion = 0x4,
669  InitialConnecting = 0x8,
670  Loading = 0x10,
671  InCleanup = 0x20,
672  PeakCleanup = 0x40
673  };
674 
676  public:
677  StateProtector (Session* s) : _session (s) {
679  }
681  if (PBD::atomic_dec_and_test (_session->_suspend_save)) {
682  while (_session->_save_queued) {
683  _session->_save_queued = false;
684  _session->save_state ("");
685  }
686  while (_session->_save_queued_pending) {
687  _session->_save_queued_pending = false;
688  _session->save_state ("", true);
689  }
690  }
691  }
692  private:
694  };
695 
697  public:
698  ProcessorChangeBlocker (Session* s, bool rc = true);
700 
701  private:
704  };
705 
706  RouteGroup* new_route_group (const std::string&);
708  void remove_route_group (RouteGroup* rg) { if (rg) remove_route_group (*rg); }
710  void reorder_route_groups (std::list<RouteGroup*>);
711 
714 
718 
719  void foreach_route_group (std::function<void(RouteGroup*)> f) {
720  for (std::list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); ++i) {
721  f (*i);
722  }
723  }
724 
725  std::list<RouteGroup*> const & route_groups () const {
726  return _route_groups;
727  }
728 
729  /* fundamental operations. duh. */
730 
731  std::list<std::shared_ptr<AudioTrack> > new_audio_track (
732  int input_channels,
733  int output_channels,
734  RouteGroup* route_group,
735  uint32_t how_many,
736  std::string name_template,
738  TrackMode mode = Normal,
739  bool input_auto_connect = true,
740  bool trigger_visibility = false
741  );
742 
743  std::list<std::shared_ptr<MidiTrack> > new_midi_track (
744  const ChanCount& input, const ChanCount& output, bool strict_io,
745  std::shared_ptr<PluginInfo> instrument,
746  Plugin::PresetRecord* pset,
747  RouteGroup* route_group, uint32_t how_many, std::string name_template,
749  TrackMode mode,
750  bool input_auto_connect,
751  bool trigger_visibility = false
752  );
753 
754  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);
755  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);
756 
757  void remove_routes (std::shared_ptr<RouteList>);
758  void remove_route (std::shared_ptr<Route>);
759 
760  void resort_routes ();
761 
762  AudioEngine & engine() { return _engine; }
763  AudioEngine const & engine () const { return _engine; }
764 
765  static std::string default_track_name_pattern (DataType);
766 
767  /* Time */
768 
769  samplepos_t transport_sample () const { return _transport_sample; }
770  samplepos_t record_location () const { return _last_record_location; }
771  samplepos_t audible_sample (bool* latent_locate = NULL) const;
772  samplepos_t requested_return_sample() const { return _requested_return_sample; }
774  std::optional<samplepos_t> const & nominal_jack_transport_sample() { return _nominal_jack_transport_sample; }
775 
776  bool compute_audible_delta (samplepos_t& pos_and_delta) const;
777  samplecnt_t remaining_latency_preroll () const { return _remaining_latency_preroll; }
778 
788  pullup_Minus4Minus1
789  };
790 
792 
793  void timecode_to_sample(Timecode::Time& timecode, samplepos_t& sample, bool use_offset, bool use_subframes) const;
794  void sample_to_timecode(samplepos_t sample, Timecode::Time& timecode, bool use_offset, bool use_subframes) const;
798 
800  void timecode_duration_string (char *, size_t len, samplecnt_t) const;
801 
804 
807 
808  void request_sync_source (std::shared_ptr<TransportMaster>);
809  bool synced_to_engine() const;
810 
811  double engine_speed() const { return _engine_speed; }
812  double actual_speed() const;
813  double transport_speed (bool incl_preroll = false) const;
815  bool transport_stopped() const;
826  bool transport_rolling() const;
828  bool transport_locating() const;
829 
830  bool silent () { return _silent; }
831 
832  bool punch_is_possible () const;
833  bool loop_is_possible () const;
835 
837 
838  unsigned int get_xrun_count () const {return _xrun_count; }
840 
841  /* region info */
842 
843  std::shared_ptr<Region> find_whole_file_parent (std::shared_ptr<Region const>) const;
844 
845  std::shared_ptr<Region> XMLRegionFactory (const XMLNode&, bool full);
846  std::shared_ptr<AudioRegion> XMLAudioRegionFactory (const XMLNode&, bool full);
847  std::shared_ptr<MidiRegion> XMLMidiRegionFactory (const XMLNode&, bool full);
848 
849  void deinterlace_midi_region ( std::shared_ptr<MidiRegion> mr );
850 
851  /* source management */
852 
854  bool sample_rate_convert (ImportStatus&, std::string infile, std::string& outfile);
855  std::string build_tmp_convert_name (std::string file);
856 
857  std::shared_ptr<ExportHandler> get_export_handler ();
858  std::shared_ptr<ExportStatus> get_export_status ();
859 
860  int start_audio_export (samplepos_t position, bool realtime = false, bool region_export = false);
861 
863  static PBD::Signal<void(std::string, std::string, bool, samplepos_t)> Exported;
864 
865  void add_source (std::shared_ptr<Source>);
866  void remove_source (std::weak_ptr<Source>, bool drop_references = true);
867 
869  bool can_cleanup_peakfiles () const;
873 
874  int destroy_sources (std::list<std::shared_ptr<Source> > const&);
875 
878  void last_capture_sources (std::list<std::shared_ptr<Source> >&) const;
880 
885  static PBD::Signal<int(std::shared_ptr<Playlist> )> AskAboutPlaylistDeletion;
886 
891 
894 
898 
904  static PBD::Signal<void()> AfterConnect;
905 
906  std::shared_ptr<AudioFileSource> create_audio_source_for_session (
907  size_t, std::string const &, uint32_t);
908 
909  std::shared_ptr<MidiSource> create_midi_source_for_session (std::string const &);
910  std::shared_ptr<MidiSource> create_midi_source_by_stealing_name (std::shared_ptr<Track>);
911 
912  std::shared_ptr<Source> source_by_id (const PBD::ID&);
913  std::shared_ptr<AudioFileSource> audio_source_by_path_and_channel (const std::string&, uint16_t) const;
914  std::shared_ptr<MidiSource> midi_source_by_path (const std::string&, bool need_source_lock) const;
915  uint32_t count_sources_by_origin (const std::string&);
916 
917  void add_playlist (std::shared_ptr<Playlist>);
918 
919  /* Curves and AutomationLists (TODO when they go away) */
921 
922  /* auditioning */
923 
924  std::shared_ptr<Auditioner> the_auditioner() { return auditioner; }
926  void audition_region (std::shared_ptr<Region>);
928  bool is_auditioning () const;
929 
931 
932  /* session script */
933  void register_lua_function (const std::string&, const std::string&, const LuaScriptParamList&);
934  void unregister_lua_function (const std::string& name);
935  std::vector<std::string> registered_lua_functions ();
936  uint32_t registered_lua_function_count () const { return _n_lua_scripts; }
937  void scripts_changed (); // called from lua, updates _n_lua_scripts
938 
940 
941  /* I/O Plugin */
943 
944  void load_io_plugin (std::shared_ptr<IOPlug>);
945  bool unload_io_plugin (std::shared_ptr<IOPlug>);
946 
947  std::shared_ptr<IOPlug> nth_io_plug (uint32_t n) {
948  std::shared_ptr<IOPlugList const> iop (_io_plugins.reader ());
949  if (n < iop->size ()) {
950  return (*iop)[n];
951  }
952  return std::shared_ptr<IOPlug> ();
953  }
954 
955  std::shared_ptr<IOPlugList const> io_plugs () const {
956  return _io_plugins.reader ();
957  }
958 
959  /* flattening stuff */
960 
961  std::shared_ptr<Region> write_one_track (Track&, samplepos_t start, samplepos_t end,
962  bool overwrite, std::vector<std::shared_ptr<Source> >&, InterThreadInfo& wot,
963  std::shared_ptr<Processor> endpoint,
964  bool include_endpoint, bool for_export, bool for_freeze,
965  std::string const& source_name = "", std::string const& region_name = "");
967 
968  /* session-wide solo/mute/rec-enable */
969 
970  bool muted () const;
971  std::vector<std::weak_ptr<AutomationControl> > cancel_all_mute ();
972 
973  bool soloing () const { return _non_soloed_outs_muted; }
974  bool listening () const;
975  bool solo_isolated () const { return _solo_isolated_cnt > 0; }
977 
980 
981  void clear_all_solo_state (std::shared_ptr<RouteList const>);
982  void prepare_momentary_solo (SoloMuteRelease* smr = NULL, bool exclusive = false, std::shared_ptr<Route> route = std::shared_ptr<Route> ());
983 
985 
986  /* Control-based methods */
987 
988  void set_controls (std::shared_ptr<AutomationControlList>, double val, PBD::Controllable::GroupControlDisposition);
989  void set_control (std::shared_ptr<AutomationControl>, double val, PBD::Controllable::GroupControlDisposition);
990 
991  void set_exclusive_input_active (std::shared_ptr<RouteList> rt, bool onoff, bool flip_others = false);
992 
993  PBD::Signal<void(bool)> SoloActive;
1000 
1002 
1003  /* monitor/master out */
1005 
1007  bool monitor_active() const { return (_monitor_out && _monitor_out->monitor_control () && _monitor_out->monitor_control ()->monitor_active()); }
1008 
1009  std::shared_ptr<Route> monitor_out() const { return _monitor_out; }
1010  std::shared_ptr<Route> master_out() const { return _master_out; }
1011  std::shared_ptr<GainControl> master_volume () const;
1012  std::shared_ptr<Route> surround_master() const { return _surround_master; }
1013 
1014  PresentationInfo::order_t master_order_key () const { return _master_out ? _master_out->presentation_info ().order () : -1; }
1016 
1017  void globally_add_internal_sends (std::shared_ptr<Route> dest, Placement p, bool);
1018  void globally_set_send_gains_from_track (std::shared_ptr<Route> dest);
1019  void globally_set_send_gains_to_zero (std::shared_ptr<Route> dest);
1020  void globally_set_send_gains_to_unity (std::shared_ptr<Route> dest);
1021  void add_internal_sends (std::shared_ptr<Route> dest, Placement p, std::shared_ptr<RouteList> senders);
1022  void add_internal_send (std::shared_ptr<Route>, int, std::shared_ptr<Route>);
1023  void add_internal_send (std::shared_ptr<Route>, std::shared_ptr<Processor>, std::shared_ptr<Route>);
1024 
1025  static void set_disable_all_loaded_plugins (bool yn) {
1026  _disable_all_loaded_plugins = yn;
1027  }
1029  return _disable_all_loaded_plugins;
1030  }
1031  static void set_bypass_all_loaded_plugins (bool yn) {
1032  _bypass_all_loaded_plugins = yn;
1033  }
1035  return _bypass_all_loaded_plugins;
1036  }
1037 
1038  uint32_t next_send_id();
1040  uint32_t next_aux_send_id();
1041  uint32_t next_return_id();
1042  uint32_t next_insert_id();
1043  void mark_send_id (uint32_t);
1044  void mark_surround_send_id (uint32_t);
1045  void mark_aux_send_id (uint32_t);
1046  void mark_return_id (uint32_t);
1047  void mark_insert_id (uint32_t);
1048  void unmark_send_id (uint32_t);
1049  void unmark_surround_send_id (uint32_t);
1050  void unmark_aux_send_id (uint32_t);
1051  void unmark_return_id (uint32_t);
1052  void unmark_insert_id (uint32_t);
1053 
1054  bool vapor_barrier ();
1056 
1057  /* s/w "RAID" management */
1058 
1059  std::optional<samplecnt_t> available_capture_duration();
1060 
1061  /* I/O bundles */
1062 
1063  void add_bundle (std::shared_ptr<Bundle>, bool emit_signal = true);
1064  void remove_bundle (std::shared_ptr<Bundle>);
1065  std::shared_ptr<Bundle> bundle_by_name (std::string) const;
1066 
1068 
1069  void midi_panic ();
1070 
1071  /* History (for editors, mixers, UIs etc.) */
1072 
1076  void undo (uint32_t n);
1080  void redo (uint32_t n);
1081 
1082  PBD::UndoHistory& history() { return _history; }
1083 
1084  uint32_t undo_depth() const { return _history.undo_depth(); }
1085  uint32_t redo_depth() const { return _history.redo_depth(); }
1086  std::string next_undo() const { return _history.next_undo(); }
1087  std::string next_redo() const { return _history.next_redo(); }
1088 
1089 
1090  std::map<PBD::ID,PBD::StatefulDestructible*> registry;
1091 
1092  // these commands are implemented in libs/ardour/session_command.cc
1096 
1097  /* clicking */
1098 
1099  std::shared_ptr<IO> click_io() { return _click_io; }
1100  std::shared_ptr<Amp> click_gain() { return _click_gain; }
1101 
1102  /* disk, buffer loads */
1103 
1104  uint32_t playback_load ();
1105  uint32_t capture_load ();
1106 
1107  /* ranges */
1108 
1109  void request_play_range (std::list<TimelineRange>*, bool leave_rolling = false);
1111  bool get_play_range () const { return _play_range; }
1112 
1114 
1115  /* preroll */
1117 
1120 
1121  samplecnt_t preroll_record_trim_len () const { return _preroll_record_trim_len; }
1122 
1123  /* temporary hacks to allow selection to be pushed from GUI into backend.
1124  Whenever we move the selection object into libardour, these will go away.
1125  */
1130 
1132 
1133  /* buffers for gain and pan */
1134 
1140 
1141  /* VST support */
1142 
1144  static const char* vst_can_do_strings[];
1145  static const int vst_can_do_string_count;
1146 
1147  static intptr_t vst_callback (
1148  AEffect* effect,
1149  int32_t opcode,
1150  int32_t index,
1151  intptr_t value,
1152  void* ptr,
1153  float opt
1154  );
1155 
1156  static PBD::Signal<void()> SendFeedback;
1157 
1158  /* Speakers */
1159 
1160  std::shared_ptr<Speakers> get_speakers ();
1161 
1162  /* Controllables */
1163 
1164  std::shared_ptr<ARDOUR::Trigger> trigger_by_id (PBD::ID) const;
1165 
1166  std::shared_ptr<Processor> processor_by_id (PBD::ID) const;
1167 
1168  std::shared_ptr<PBD::Controllable> controllable_by_id (const PBD::ID&);
1169  std::shared_ptr<AutomationControl> automation_control_by_id (const PBD::ID&);
1170 
1171  void add_controllable (std::shared_ptr<PBD::Controllable>);
1172 
1173  std::shared_ptr<PBD::Controllable> solo_cut_control() const;
1174  std::shared_ptr<PBD::Controllable> recently_touched_controllable () const;
1175 
1176  bool apply_nth_mixer_scene (size_t);
1177  bool apply_nth_mixer_scene (size_t, RouteList const&);
1178  void store_nth_mixer_scene (size_t);
1179  bool nth_mixer_scene_valid (size_t) const;
1180  size_t last_touched_mixer_scene_idx () {return _last_touched_mixer_scene_idx;}
1181 
1182  std::shared_ptr<MixerScene> nth_mixer_scene (size_t, bool create_if_missing = false);
1183  std::vector<std::shared_ptr<MixerScene>> mixer_scenes () const;
1184 
1186 
1187  SessionConfiguration* cfg () { return &config; }
1188 
1189  bool exporting () const {
1190  return _exporting;
1191  }
1192 
1193  bool realtime_export() const {
1194  return _realtime_export;
1195  }
1196 
1197  bool bounce_processing() const {
1198  return _bounce_processing_active;
1199  }
1200 
1201  /* this is a private enum, but setup_enum_writer() needs it,
1202  and i can't find a way to give that function
1203  friend access. sigh.
1204  */
1205 
1207  PostTransportStop = 0x1,
1208  PostTransportLocate = 0x2,
1209  PostTransportAbort = 0x8,
1210  PostTransportOverWrite = 0x10,
1211  PostTransportAudition = 0x20,
1212  PostTransportReverse = 0x40,
1213  PostTransportClearSubstate = 0x80,
1214  PostTransportAdjustPlaybackBuffering = 0x100,
1215  PostTransportAdjustCaptureBuffering = 0x200,
1216  PostTransportLoopChanged = 0x400
1217  };
1218 
1219  std::shared_ptr<SessionPlaylists> playlists () const { return _playlists; }
1220 
1222  void queue_full_time_code () { _send_timecode_update = true; }
1223  void queue_song_position_pointer () { /* currently does nothing */ }
1224 
1225  bool step_editing() const { return (_step_editors > 0); }
1226 
1230 
1231  std::vector<std::string> source_search_path(DataType) const;
1232  void ensure_search_path_includes (const std::string& path, DataType type);
1233  void remove_dir_from_search_path (const std::string& path, DataType type);
1234 
1235  std::list<std::string> unknown_processors () const;
1236 
1237  std::list<std::string> missing_filesources (DataType) const;
1238 
1244 
1249 
1250  /* handlers can return an integer value:
1251  0: config.set_audio_search_path() or config.set_midi_search_path() was used
1252  to modify the search path and we should try to find it again.
1253  1: quit entire session load
1254  2: as 0, but don't ask about other missing files
1255  3: don't ask about other missing files, and just mark this one missing
1256  -1: just mark this one missing
1257  any other value: as -1
1258  */
1259  static PBD::Signal<int(Session*,std::string,DataType)> MissingFile;
1260 
1261  void set_missing_file_replacement (const std::string& mfr) {
1262  _missing_file_replacement = mfr;
1263  }
1264 
1266  static PBD::Signal<void()> Quit;
1267 
1271  static PBD::Signal<void(std::string,std::string)> VersionMismatch;
1272 
1273  SceneChanger* scene_changer() const { return _scene_changer; }
1274 
1275  /* asynchronous MIDI control ports */
1276 
1277  std::shared_ptr<Port> mmc_output_port () const;
1278  std::shared_ptr<Port> mmc_input_port () const;
1279  std::shared_ptr<Port> trigger_input_port () const;
1280  std::shared_ptr<Port> scene_input_port () const;
1281  std::shared_ptr<Port> scene_output_port () const;
1282 
1283  std::shared_ptr<AsyncMIDIPort> vkbd_output_port () const;
1284 
1285  /* synchronous MIDI ports used for synchronization */
1286 
1287  std::shared_ptr<MidiPort> midi_clock_output_port () const;
1288  std::shared_ptr<MidiPort> mtc_output_port () const;
1289  std::shared_ptr<Port> ltc_output_port() const { return _ltc_output_port; }
1290 
1291  MIDI::MachineControl& mmc() { return *_mmc; }
1292 
1294  void reconnect_mmc_ports (bool);
1295 
1297 
1298  VCAManager& vca_manager() { return *_vca_manager; }
1299  VCAManager* vca_manager_ptr() { return _vca_manager; }
1300 
1302 
1306  std::shared_ptr<TransportMaster> transport_master() const;
1307 
1310  bool import_sndfile_as_region (std::string path, SrcQuality quality, timepos_t& pos, SourceList& sources, ImportStatus& status, uint32_t current, uint32_t total);
1311 
1312  struct ptflookup {
1313  uint16_t index1;
1314  uint16_t index2;
1316 
1317  bool operator ==(const struct ptflookup& other) {
1318  return (this->index1 == other.index1);
1319  }
1320  };
1321  std::vector<struct ptflookup> ptfwavpair;
1323 
1325  OverallProcess = 0,
1326  ProcessFunction = 1,
1327  NoRoll = 2,
1328  Roll = 3,
1329  /* end */
1330  NTT = 4
1331  };
1332 
1333  PBD::TimingStats dsp_stats[NTT];
1334 
1335  int32_t first_cue_within (samplepos_t s, samplepos_t e, bool& was_recorded);
1336  void trigger_cue_row (int32_t);
1337  CueEvents const & cue_events() const { return _cue_events; }
1338 
1339  int num_triggerboxes () const;
1340  std::shared_ptr<TriggerBox> triggerbox_at (int32_t route_index) const;
1341  TriggerPtr trigger_at (int32_t route_index, int32_t row_index) const;
1342  bool bang_trigger_at(int32_t route_index, int32_t row_index, float velocity = 1.0);
1343  bool unbang_trigger_at(int32_t route_index, int32_t row_index);
1344  void clear_cue (int row_index);
1345 
1348 
1349  AnyTime global_quantization() const { return _global_quantization; }
1352 
1353 protected:
1354  friend class AudioEngine;
1355  void set_block_size (pframes_t nframes);
1357 
1358  friend class Route;
1359  void update_latency_compensation (bool force, bool called_from_backend);
1360 
1361  /* transport API */
1362 
1363  void locate (samplepos_t, bool for_loop_end=false, bool force=false, bool with_mmc=true);
1364  void stop_transport (bool abort = false, bool clear_state = false);
1365  void start_transport (bool after_loop);
1367  void post_locate ();
1370  bool user_roll_after_locate () const;
1372  samplepos_t position() const { return _transport_sample; }
1373  void set_transport_speed (double speed);
1374  void set_default_play_speed (double spd);
1377 
1378 private:
1379  int create (const std::string& mix_template, BusProfile const *, bool unnamed);
1380  void destroy ();
1381 
1382  static std::atomic<unsigned int> _name_id_counter;
1383  static void init_name_id_counter (unsigned int n);
1384  static unsigned int name_id_counter ();
1385 
1386  std::shared_ptr<SessionPlaylists> _playlists;
1387 
1388  /* stuff used in process() should be close together to
1389  maximise cache hits
1390  */
1391 
1392  typedef void (Session::*process_function_type)(pframes_t);
1393 
1395  process_function_type process_function;
1396  process_function_type last_process_function;
1399  samplecnt_t _base_sample_rate; // sample-rate of the session at creation time, "native" SR
1400  samplecnt_t _current_sample_rate; // this includes video pullup offset
1402  std::atomic<int> _seek_counter;
1403  std::atomic<int> _butler_seek_counter;
1406  bool _silent;
1409 
1410  // varispeed playback -- TODO: move out of session to backend.
1413 
1425  unsigned int _capture_xruns;
1426  unsigned int _export_xruns;
1429  uint32_t _listen_cnt;
1434  unsigned int _xrun_count;
1435 
1437 
1438  mutable std::atomic<int> _processing_prohibited;
1439  mutable std::atomic<RecordState> _record_status;
1440 
1443 
1446 
1447  std::optional<bool> _vapor_available;
1448  std::optional<bool> _vapor_exportable;
1449 
1450  void update_latency (bool playback);
1451  void set_owned_port_public_latency (bool playback);
1452  bool update_route_latency (bool reverse, bool apply_to_delayline, bool* delayline_update_needed);
1456 
1459 
1461 
1465 
1471 
1473 
1475  void unblock_processing() { _processing_prohibited.store (0); }
1476  bool processing_blocked() const { return _processing_prohibited.load (); }
1477 
1479 
1480  /* Transport master DLL */
1481 
1483  Stopped, /* no incoming or invalid signal/data for master to run with */
1484  Waiting, /* waiting to get full lock on incoming signal/data */
1485  Running /* lock achieved, master is generating meaningful speed & position */
1486  };
1487 
1489 
1497  };
1498 
1503  double catch_speed;
1504 
1506  : action (TransportMasterRelax)
1507  , target (0)
1508  , roll_disposition (MustStop)
1509  , catch_speed (0.) {}
1510  };
1511 
1513  double plan_master_strategy (pframes_t nframes, double master_speed, samplepos_t master_transport_sample, double catch_speed);
1514  double plan_master_strategy_engine (pframes_t nframes, double master_speed, samplepos_t master_transport_sample, double catch_speed);
1516 
1518 
1520 
1523 
1529 
1530  std::shared_ptr<ExportHandler> export_handler;
1531  std::shared_ptr<ExportStatus> export_status;
1532 
1533  int pre_export ();
1536  void finalize_export_internal (bool stop_freewheel);
1538 
1540 
1542  int process_routes (pframes_t, bool& need_butler);
1543  int silent_process_routes (pframes_t, bool& need_butler);
1544 
1549  bool maybe_stop (samplepos_t limit);
1551 
1552  std::string _path;
1553  std::string _name;
1554  bool _is_new;
1563 
1564  const std::unique_ptr<SessionDirectory> _session_dir;
1565 
1566  void hookup_io ();
1567  void graph_reordered (bool called_from_backend);
1568 
1570  void set_snapshot_name (const std::string &);
1571  void save_snapshot_name (const std::string &);
1573 
1576 
1577  friend class StateProtector;
1578  std::atomic<int> _suspend_save;
1579  volatile bool _save_queued;
1580  volatile bool _save_queued_pending;
1582 
1583  Glib::Threads::Mutex save_state_lock;
1584  Glib::Threads::Mutex save_source_lock;
1585  Glib::Threads::Mutex peak_cleanup_lock;
1586 
1587  int load_options (const XMLNode&);
1588  int load_state (std::string snapshot_name, bool from_template = false);
1589  static int parse_stateful_loading_version (const std::string&);
1590 
1595 
1598 
1599 #ifdef USE_TLSF
1600  PBD::TLSF _mempool;
1601 #else
1603 #endif
1605  mutable Glib::Threads::Mutex lua_lock;
1606  luabridge::LuaRef * _lua_run;
1607  luabridge::LuaRef * _lua_add;
1608  luabridge::LuaRef * _lua_del;
1609  luabridge::LuaRef * _lua_list;
1610  luabridge::LuaRef * _lua_load;
1611  luabridge::LuaRef * _lua_save;
1612  luabridge::LuaRef * _lua_cleanup;
1613  uint32_t _n_lua_scripts;
1614 
1615  void setup_lua ();
1618 
1620 
1621  std::vector<std::shared_ptr<MixerScene>> _mixer_scenes;
1622  mutable Glib::Threads::RWLock _mixer_scenes_lock;
1623 
1625 
1627 
1628  static const PostTransportWork ProcessCannotProceedMask = PostTransportWork (PostTransportAudition);
1629 
1630  std::atomic<PostTransportWork> _post_transport_work; /* accessed only atomic ops */
1631  PostTransportWork post_transport_work() const { return _post_transport_work.load(); }
1632  void set_post_transport_work (PostTransportWork ptw) { _post_transport_work.store (ptw); }
1634 
1637 
1643 
1644  void update_skips (Location*, bool consolidate);
1645  void update_marks (Location* loc);
1649 
1652 
1657 
1660 
1661  void pre_engine_init (std::string path);
1665 
1667 
1670 
1671  void enable_record ();
1672 
1674  if (max_samplepos - val < _transport_sample) {
1675  _transport_sample = max_samplepos;
1676  } else {
1677  _transport_sample += val;
1678  }
1679  }
1680 
1682  if (val < _transport_sample) {
1683  _transport_sample -= val;
1684  } else {
1685  _transport_sample = 0;
1686  }
1687  }
1688 
1690  static void *session_loader_thread (void *arg);
1691 
1692  void *do_work();
1693 
1694  /* Signal Forwarding */
1697  static void *emit_thread (void *);
1700 
1701  pthread_t _rt_emit_thread;
1703 
1704  pthread_mutex_t _rt_emit_mutex;
1705  pthread_cond_t _rt_emit_cond;
1707 
1708  /* Auto Connect Thread */
1709  static void *auto_connect_thread (void *);
1713 
1715  std::atomic<int> _ac_thread_active;
1716  pthread_mutex_t _auto_connect_mutex;
1717  pthread_cond_t _auto_connect_cond;
1718 
1720  public:
1721  AutoConnectRequest (std::shared_ptr <Route> r,
1722  bool ci, bool co,
1723  const ChanCount& is,
1724  const ChanCount& os,
1725  const ChanCount& io,
1726  const ChanCount& oo)
1727  : route (std::weak_ptr<Route> (r))
1728  , connect_inputs (ci)
1729  , connect_outputs (co)
1730  , input_start (is)
1731  , output_start (os)
1732  , input_offset (io)
1733  , output_offset (oo)
1734  {}
1735 
1736  std::weak_ptr <Route> route;
1743  };
1744 
1745  Glib::Threads::Mutex _update_latency_lock;
1746 
1747  typedef std::queue<AutoConnectRequest> AutoConnectQueue;
1748  Glib::Threads::Mutex _auto_connect_queue_lock;
1750  std::atomic<unsigned int> _latency_recompute_pending;
1751 
1752  void get_physical_ports (std::vector<std::string>& inputs, std::vector<std::string>& outputs, DataType type,
1753  MidiPortFlags include = MidiPortFlags (0),
1754  MidiPortFlags exclude = MidiPortFlags (0));
1755 
1758 
1759  /* SessionEventManager interface */
1760 
1764 
1765  /* MIDI Machine Control */
1766 
1767  void spp_start ();
1768  void spp_continue ();
1769  void spp_stop ();
1770 
1778  void mmc_track_record_status (MIDI::MachineControl &, uint32_t track, bool enabled);
1782  void mmc_shuttle (MIDI::MachineControl &mmc, float speed, bool forw);
1783  void mmc_record_enable (MIDI::MachineControl &mmc, size_t track, bool enabled);
1784 
1786  double step_speed;
1787 
1788  typedef std::function<bool()> MidiTimeoutCallback;
1789  typedef std::list<MidiTimeoutCallback> MidiTimeoutList;
1790 
1794 
1795  MIDI::byte mtc_msg[16];
1796  MIDI::byte mtc_timecode_bits; /* encoding of SMTPE type for MTC */
1797  MIDI::byte midi_msg[16];
1801 
1802  double _samples_per_timecode_frame; /* has to be floating point because of drop sample */
1805 
1806  /* cache the most-recently requested time conversions. This helps when we
1807  * have multiple clocks showing the same time (e.g. the transport sample) */
1811 
1813 
1815 
1818 
1820  int32_t ltc_buf_off;
1821  int32_t ltc_buf_len;
1822 
1823  double ltc_speed;
1824  int32_t ltc_enc_byte;
1826  double ltc_enc_cnt;
1830 
1833 
1836 
1844 
1846 
1847  int no_roll (pframes_t nframes);
1848  int fail_roll (pframes_t nframes);
1849 
1850  bool non_realtime_work_pending() const { return static_cast<bool>(post_transport_work()); }
1851  bool process_can_proceed() const { return !(post_transport_work() & ProcessCannotProceedMask); }
1852 
1854 
1856 
1858 
1859  void set_play_loop (bool yn, bool change_transport_state);
1860  void unset_play_loop (bool change_transport_state = false);
1861  void overwrite_some_buffers (std::shared_ptr<Route>, OverwriteReason);
1863  int micro_locate (samplecnt_t distance);
1864 
1869  };
1870 
1871  std::atomic<PunchLoopLock> _punch_or_loop;
1872  std::atomic<int> _current_usecs_per_track;
1873 
1874  bool punch_active () const;
1875  void unset_punch ();
1877  bool maybe_allow_only_loop (bool play_loop = false);
1879 
1881  void realtime_stop (bool abort, bool clear_state);
1882  void realtime_locate (bool);
1885  void non_realtime_stop (bool abort, int entry_request_count, bool& finished, bool will_locate);
1886  void non_realtime_overwrite (int entry_request_count, bool& finished, bool reset_loop_declicks);
1887  void engine_halted ();
1889  void xrun_recovery ();
1890  void set_track_loop (bool);
1894 
1895  /* These are synchronous and so can only be called from within the process
1896  * cycle
1897  */
1898 
1902 
1903  /* edit/mix groups */
1904 
1905  int load_route_groups (const XMLNode&, int);
1906 
1907  std::list<RouteGroup *> _route_groups;
1909 
1910  /* routes stuff */
1911 
1913 
1914  void add_routes (RouteList&, bool input_auto_connect, bool output_auto_connect, PresentationInfo::order_t);
1915  void add_routes_inner (RouteList&, bool input_auto_connect, bool output_auto_connect, PresentationInfo::order_t);
1920 
1922  bool strict_io,
1923  std::shared_ptr<PluginInfo> instrument,
1924  Plugin::PresetRecord* pset,
1925  ChanCount& existing_outputs
1926  );
1927 
1928  std::shared_ptr<Route> XMLRouteFactory (const XMLNode&, int);
1929  std::shared_ptr<Route> XMLRouteFactory_2X (const XMLNode&, int);
1930  std::shared_ptr<Route> XMLRouteFactory_3X (const XMLNode&, int);
1931 
1933 
1934  bool find_route_name (std::string const &, uint32_t& id, std::string& name, bool);
1936  void auto_connect_route (std::shared_ptr<Route>, bool, bool, const ChanCount&, const ChanCount&, const ChanCount& io = ChanCount(), const ChanCount& oo = ChanCount());
1937  void midi_output_change_handler (IOChange change, void* /*src*/, std::weak_ptr<Route> midi_track);
1938 
1939  /* track numbering */
1940 
1943 
1944  /* solo/mute/notifications */
1945 
1948  void route_solo_changed (bool self_solo_change, PBD::Controllable::GroupControlDisposition group_override, std::weak_ptr<Route>);
1949  void route_solo_isolated_changed (std::weak_ptr<Route>);
1950 
1951  void update_route_solo_state (std::shared_ptr<RouteList const> r = std::shared_ptr<RouteList const>());
1952 
1955 
1956  /* REGION MANAGEMENT */
1957 
1958  mutable Glib::Threads::Mutex region_lock;
1959 
1960  int load_regions (const XMLNode& node);
1961  int load_compounds (const XMLNode& node);
1962 
1963  void route_added_to_route_group (RouteGroup *, std::weak_ptr<Route>);
1964  void route_removed_from_route_group (RouteGroup *, std::weak_ptr<Route>);
1966 
1967  /* SOURCES */
1968 
1969  mutable Glib::Threads::Mutex source_lock;
1970 
1971 public:
1972 
1973  /* Emited when a new source is added to the session */
1974  PBD::Signal< void(std::weak_ptr<Source> )> SourceAdded;
1975  PBD::Signal< void(std::weak_ptr<Source> )> SourceRemoved;
1976 
1977  typedef std::map<PBD::ID,std::shared_ptr<Source> > SourceMap;
1978 
1979  void foreach_source (std::function<void( std::shared_ptr<Source> )> f) {
1980  Glib::Threads::Mutex::Lock ls (source_lock);
1981  for (SourceMap::iterator i = sources.begin(); i != sources.end(); ++i) {
1982  f ( (*i).second );
1983  }
1984  }
1985 
1986  bool playlist_is_active( std::shared_ptr<Playlist>);
1987  ARDOUR::CueMarkers pending_source_markers; // source markers created while recording
1988 
1989 private:
1990  void reset_write_sources (bool mark_write_complete);
1992 
1993  int load_sources (const XMLNode& node);
1995 
1996  std::shared_ptr<Source> XMLSourceFactory (const XMLNode&);
1997 
1998  /* PLAYLISTS */
1999 
2000  void remove_playlist (std::weak_ptr<Playlist>);
2001  void track_playlist_changed (std::weak_ptr<Track>);
2002  void playlist_region_added (std::weak_ptr<Region>);
2003  void playlist_ranges_moved (std::list<Temporal::RangeMove> const &);
2004  void playlist_regions_extended (std::list<Temporal::Range> const &);
2005 
2006  /* CURVES and AUTOMATION LISTS */
2007  std::map<PBD::ID, AutomationList*> automation_lists;
2008 
2010  std::map<PBD::ID, std::string> _diskstreams_2X;
2011 
2012  /* DEFAULT FADE CURVES */
2013 
2016 
2017  /* AUDITIONING */
2018 
2019  std::shared_ptr<Auditioner> auditioner;
2020  void set_audition (std::shared_ptr<Region>);
2022  std::shared_ptr<Region> pending_audition_region;
2023 
2024  /* EXPORT */
2025 
2026  /* FLATTEN */
2027 
2029 
2030  /* INSERT AND SEND MANAGEMENT */
2031 
2032  boost::dynamic_bitset<uint32_t> send_bitset;
2033  boost::dynamic_bitset<uint32_t> surround_send_bitset;
2034  boost::dynamic_bitset<uint32_t> aux_send_bitset;
2035  boost::dynamic_bitset<uint32_t> return_bitset;
2036  boost::dynamic_bitset<uint32_t> insert_bitset;
2037 
2038  /* S/W RAID */
2039 
2041  uint32_t blocks;
2043  std::string path;
2044 
2046  : blocks (0)
2047  , blocks_unknown (true)
2048  {}
2049  };
2050 
2052  bool operator() (space_and_path a, space_and_path b) {
2053  if (a.blocks_unknown != b.blocks_unknown) {
2054  return !a.blocks_unknown;
2055  }
2056  return a.blocks > b.blocks;
2057  }
2058  };
2059 
2060  void setup_raid_path (std::string path);
2061 
2062  std::vector<space_and_path> session_dirs;
2063  std::vector<space_and_path>::iterator last_rr_session_dir;
2070  Glib::Threads::Mutex space_lock;
2071 
2073 
2075 
2076  mutable std::atomic<int> _playback_load;
2077  mutable std::atomic<int> _capture_load;
2078 
2079  /* I/O bundles */
2080 
2083  int load_bundles (XMLNode const &);
2084 
2086 
2088 
2089  enum snapshot_t {
2092  SwitchToSnapshot
2093  };
2094 
2095  XMLNode& state (bool save_template,
2096  snapshot_t snapshot_type = NormalSave,
2097  bool for_archive = false,
2098  bool only_used_assets = false) const;
2099 
2100  XMLNode& get_state () const;
2101  int set_state (const XMLNode& node, int version); // not idempotent
2103 
2104  bool maybe_copy_midifile (snapshot_t, std::shared_ptr<Source> src, XMLNode*);
2105 
2106  void collect_sources_of_this_snapshot (std::set<std::shared_ptr<Source>>&, bool incl_unused = true) const;
2107 
2108  /* click track */
2109  typedef std::list<Click*> Clicks;
2113  std::shared_ptr<IO> _click_io;
2114  std::shared_ptr<Amp> _click_gain;
2119  mutable Glib::Threads::RWLock click_lock;
2123 
2124  static const Sample default_click[];
2126  static const Sample default_click_emphasis[];
2128 
2132  void setup_click_sounds (int which);
2133  void setup_click_sounds (Sample**, Sample const *, samplecnt_t*, samplecnt_t, std::string const &);
2134  void clear_clicks ();
2137  void add_click (samplepos_t pos, bool emphasis);
2139 
2140  /* range playback */
2141 
2142  std::list<TimelineRange> current_audio_range;
2144  void set_play_range (std::list<TimelineRange>&, bool leave_rolling);
2146 
2147  /* temporary hacks to allow selection to be pushed from GUI into backend
2148  Whenever we move the selection object into libardour, these will go away.
2149  */
2152 
2154 
2157 
2158  /* main outs */
2159  uint32_t main_outs;
2160 
2161  std::shared_ptr<Route> _master_out;
2162  std::shared_ptr<Route> _monitor_out;
2163  std::shared_ptr<Route> _surround_master;
2164 
2165  friend class PortManager;
2169  void auto_connect_io (std::shared_ptr<IO>);
2170 
2171  void setup_route_monitor_sends (bool enable, bool need_process_lock);
2172  void setup_route_surround_sends (bool enable, bool need_process_lock);
2173 
2174  int find_all_sources (std::string path, std::set<std::string>& result);
2175  int find_all_sources_across_snapshots (std::set<std::string>& result, bool exclude_this_snapshot);
2176 
2177  typedef std::set<std::shared_ptr<PBD::Controllable> > Controllables;
2178  Glib::Threads::Mutex controllables_lock;
2180 
2181  std::shared_ptr<PBD::Controllable> _solo_cut_control;
2182 
2183  void controllable_touched (std::weak_ptr<PBD::Controllable>);
2184  std::weak_ptr<PBD::Controllable> _recently_touched_controllable;
2185 
2189 
2190  void config_changed (std::string, bool);
2191 
2193 
2194  void set_history_depth (uint32_t depth);
2195 
2198 
2199  mutable bool have_looped;
2200 
2202  std::atomic<int> _have_rec_enabled_track;
2203  std::atomic<int> _have_rec_disabled_track;
2204 
2205  static int ask_about_playlist_deletion (std::shared_ptr<Playlist>);
2206 
2207  /* realtime "apply to set of routes" operations */
2208  template<typename T> SessionEvent*
2209  get_rt_event (std::shared_ptr<RouteList const> rl, T targ, SessionEvent::RTeventCallback after, PBD::Controllable::GroupControlDisposition group_override,
2210  void (Session::*method) (std::shared_ptr<RouteList const>, T, PBD::Controllable::GroupControlDisposition)) {
2212  ev->rt_slot = std::bind (method, this, rl, targ, group_override);
2213  ev->rt_return = after;
2215 
2216  return ev;
2217  }
2218 
2219  /* specialized version realtime "apply to set of routes" operations */
2220  template<typename T1, typename T2> SessionEvent*
2221  get_rt_event (std::shared_ptr<RouteList const> rl, T1 t1arg, T2 t2arg, SessionEvent::RTeventCallback after, PBD::Controllable::GroupControlDisposition group_override,
2222  void (Session::*method) (std::shared_ptr<RouteList const>, T1, T2, PBD::Controllable::GroupControlDisposition)) {
2224  ev->rt_slot = std::bind (method, this, rl, t1arg, t2arg, group_override);
2225  ev->rt_return = after;
2227 
2228  return ev;
2229  }
2230 
2231  /* specialized version realtime "apply to set of controls" operations */
2232  SessionEvent* get_rt_event (std::shared_ptr<WeakAutomationControlList> cl, double arg, PBD::Controllable::GroupControlDisposition group_override) {
2234  ev->rt_slot = std::bind (&Session::rt_set_controls, this, cl, arg, group_override);
2237 
2238  return ev;
2239  }
2240 
2241  void rt_set_controls (std::shared_ptr<WeakAutomationControlList>, double val, PBD::Controllable::GroupControlDisposition group_override);
2242  void rt_clear_all_solo_state (std::shared_ptr<RouteList const>, bool yn, PBD::Controllable::GroupControlDisposition group_override);
2243 
2245 
2247  uint32_t _step_editors;
2248 
2250  mutable std::atomic<int> _suspend_timecode_transmission;
2251 
2254 
2257 
2258  std::shared_ptr<Speakers> _speakers;
2259  void load_nested_sources (const XMLNode& node);
2260 
2265 
2266  friend class IOPlug;
2267  std::shared_ptr<Graph> _process_graph;
2268  std::shared_ptr<GraphChain> _graph_chain;
2269  std::shared_ptr<GraphChain> _io_graph_chain[2];
2270 
2271  void resort_routes_using (std::shared_ptr<RouteList>);
2273 
2276 
2278 
2282 
2284 
2285  std::shared_ptr<Port> _ltc_output_port;
2286 
2287  std::shared_ptr<RTTaskList> _rt_tasklist;
2288  std::shared_ptr<IOTaskList> _io_tasklist;
2289 
2290  /* Scene Changing */
2292 
2293  /* persistent, non-track related MIDI ports */
2296 
2297  void setup_ltc ();
2298  void setup_click ();
2300  void setup_bundles ();
2301 
2304 
2305  void save_as_bring_callback (uint32_t, uint32_t, std::string);
2306 
2307  static const uint32_t session_end_shift;
2308 
2309  std::string _template_state_dir;
2310 
2312 
2313  std::shared_ptr<Route> get_midi_nth_route_by_id (PresentationInfo::order_t n) const;
2314 
2315  std::string created_with;
2316  mutable std::string modified_with;
2317 
2318  void midi_track_presentation_info_changed (PBD::PropertyChange const &, std::weak_ptr<MidiTrack>);
2319  void rewire_selected_midi (std::shared_ptr<MidiTrack>);
2321  void disconnect_port_for_rewire (std::string const& port) const;
2322  std::weak_ptr<MidiTrack> current_midi_target;
2323 
2324  StripableList _soloSelection; //the items that are soloe'd during a solo-selection operation; need to unsolo after the roll
2325 
2327 
2329  std::optional<samplepos_t> _nominal_jack_transport_sample;
2330 
2332 
2333  std::string unnamed_file_name () const;
2334 
2335  std::atomic<int> _update_pretty_names;
2336 
2339 
2341  bool operator() (CueEvent const & c, samplepos_t s) {
2342  return c.time < s;
2343  }
2344  };
2345 
2347  void sync_cues ();
2349 
2350  std::atomic<int32_t> _pending_cue;
2351  std::atomic<int32_t> _active_cue;
2354 
2356  void handle_slots_empty_status (std::weak_ptr<Route> const &);
2357 
2359 
2361 };
2362 
2363 
2364 } // namespace ARDOUR
2365 
static const ChanCount ZERO
Definition: chan_count.h:208
std::list< Location * > LocationList
Definition: location.h:251
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()
Definition: session.h:196
std::string _message
Definition: session.h:201
SessionException(const std::string msg)
Definition: session.h:195
virtual const char * what() const
Definition: session.h:198
ProcessorChangeBlocker(Session *s, bool rc=true)
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)
std::string created_with
Definition: session.h:2315
PBD::Signal< void(RouteList &)> RouteAdded
Definition: session.h:459
void clear_all_solo_state(std::shared_ptr< RouteList const >)
void mark_surround_send_id(uint32_t)
luabridge::LuaRef * _lua_load
Definition: session.h:1610
std::shared_ptr< Route > route_by_name(std::string) const
int load_regions(const XMLNode &node)
std::shared_ptr< Auditioner > the_auditioner()
Definition: session.h:924
void emit_thread_start()
std::shared_ptr< Stripable > get_remote_nth_stripable(PresentationInfo::order_t n, PresentationInfo::Flag) const
int next_quarter_frame_to_send
Definition: session.h:1800
std::map< PBD::ID, std::shared_ptr< Source > > SourceMap
Definition: session.h:1977
SceneChanger * scene_changer() const
Definition: session.h:1273
std::atomic< int > _ignore_route_processor_changes
Definition: session.h:2280
const std::unique_ptr< SessionDirectory > _session_dir
Definition: session.h:1564
void route_added_to_route_group(RouteGroup *, std::weak_ptr< Route >)
std::shared_ptr< IOTaskList > io_tasklist()
Definition: session.h:336
bool follow_transport_master(pframes_t nframes)
Glib::Threads::Mutex space_lock
Definition: session.h:2070
void step_back_from_record()
PBD::ScopedConnectionList loop_connections
Definition: session.h:1658
boost::dynamic_bitset< uint32_t > aux_send_bitset
Definition: session.h:2034
std::shared_ptr< Route > master_out() const
Definition: session.h:1010
bool loop_is_possible() const
void add_surround_master()
std::queue< AutoConnectRequest > AutoConnectQueue
Definition: session.h:1747
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()
Definition: session.h:1082
void last_capture_sources(std::list< std::shared_ptr< Source > > &) const
samplecnt_t preroll_samples(samplepos_t) const
PBD::Signal< void(bool)> SoloActive
Definition: session.h:993
bool _rt_emit_pending
Definition: session.h:1706
void remove_surround_master()
float default_fade_msecs
Definition: session.h:2015
samplecnt_t _worst_route_latency
Definition: session.h:1419
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
Definition: session.h:975
void audition_playlist()
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
Definition: session.h:2326
std::map< PBD::ID, std::string > _diskstreams_2X
Definition: session.h:2010
std::shared_ptr< Graph > _process_graph
Definition: session.h:2267
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
Definition: session.h:1407
XMLNode * instant_xml(const std::string &str)
samplecnt_t remaining_latency_preroll() const
Definition: session.h:777
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)
void resort_io_plugs()
XMLNode & get_sources_as_xml()
bool _ignore_skips_updates
Definition: session.h:1651
void mark_aux_send_id(uint32_t)
uint64_t _total_free_4k_blocks
Definition: session.h:2064
double timecode_frames_per_second() const
void set_owned_port_public_latency(bool playback)
int fail_roll(pframes_t nframes)
bool in_cleanup() const
Definition: session.h:256
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
Definition: session.h:2072
int32_t first_cue_within(samplepos_t s, samplepos_t e, bool &was_recorded)
std::atomic< int > _update_pretty_names
Definition: session.h:2335
PBD::Signal< void()> DirtyChanged
Definition: session.h:263
PBD::Signal< void(samplepos_t)> Xrun
Definition: session.h:453
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
Definition: session.h:1404
void follow_playhead_priority()
void request_stop(bool abort=false, bool clear_state=false, TransportRequestSource origin=TRS_UI)
double samples_per_timecode_frame() const
Definition: session.h:533
bool step_editing() const
Definition: session.h:1225
void auto_loop_changed(Location *)
static unsigned int name_id_counter()
Locations * locations()
Definition: session.h:545
void reset_write_sources(bool mark_write_complete)
static PBD::Signal< void(samplepos_t)> StartTimeChanged
Definition: session.h:805
static PBD::Signal< void(std::string, std::string)> VersionMismatch
Definition: session.h:1271
Glib::Threads::Mutex save_state_lock
Definition: session.h:1583
BufferSet & get_mix_buffers(ChanCount count=ChanCount::ZERO)
CueEvents const & cue_events() const
Definition: session.h:1337
int load_state(std::string snapshot_name, bool from_template=false)
void finalize_export_internal(bool stop_freewheel)
void use_rf_shuttle_speed()
bool auto_play_legal
Definition: session.h:1414
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
Definition: session.h:2109
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
Definition: session.h:557
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
Definition: session.h:2162
void remove_dir_from_search_path(const std::string &path, DataType type)
bool _region_export
Definition: session.h:1527
std::shared_ptr< Source > source_by_id(const PBD::ID &)
std::shared_ptr< Route > XMLRouteFactory(const XMLNode &, int)
bool ltc_timecode_negative_offset
Definition: session.h:1832
void undo(uint32_t n)
samplecnt_t worst_output_latency() const
Definition: session.h:558
SceneChanger * _scene_changer
Definition: session.h:2291
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
Definition: session.h:1843
void set_snapshot_name(const std::string &)
std::atomic< int > _current_usecs_per_track
Definition: session.h:1872
static const samplecnt_t default_click_emphasis_length
Definition: session.h:2127
void mmc_record_strobe(MIDI::MachineControl &)
bool have_last_capture_sources() const
void set_transport_speed(double speed)
void trigger_cue_row(int32_t)
bool _route_deletion_in_progress
Definition: session.h:1918
samplecnt_t sample_rate() const
Definition: session.h:528
bool maybe_sync_start(pframes_t &)
void maybe_write_autosave()
void disable_record(bool rt_context, bool force=false)
int stop_audio_export()
PBD::Signal< void()> SoloChanged
Definition: session.h:994
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 &)
bool exporting() const
Definition: session.h:1189
void set_worst_input_latency()
void pre_engine_init(std::string path)
int64_t _last_mmc_step
Definition: session.h:1785
bool _had_destructive_tracks
Definition: session.h:2331
process_function_type process_function
Definition: session.h:1395
static const samplecnt_t bounce_chunk_size
Definition: session.h:1478
void update_route_record_state()
void process_audition(pframes_t)
PBD::Signal< void()> LuaScriptsChanged
Definition: session.h:939
int load_bundles(XMLNode const &)
const SessionDirectory & session_directory() const
Definition: session.h:265
void setup_route_monitor_sends(bool enable, bool need_process_lock)
std::map< PBD::ID, AutomationList * > automation_lists
Definition: session.h:2007
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
Definition: session.h:1626
bool nth_mixer_scene_valid(size_t) const
ltcsnd_sample_t * ltc_enc_buf
Definition: session.h:1817
PBD::Signal< void()> BundleAddedOrRemoved
Definition: session.h:1067
void reconnect_mmc_ports(bool)
uint32_t ntracks() const
std::string next_undo() const
Definition: session.h:1086
double default_play_speed()
int load_options(const XMLNode &)
std::set< std::shared_ptr< PBD::Controllable > > Controllables
Definition: session.h:2177
void remove_bundle(std::shared_ptr< Bundle >)
bool non_realtime_work_pending() const
Definition: session.h:1850
Temporal::Range _range_selection
Definition: session.h:2150
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
Definition: session.h:1436
samplepos_t master_wait_end
Definition: session.h:1488
void send_mclk_for_cycle(samplepos_t, samplepos_t, pframes_t, samplecnt_t)
bool _total_free_4k_blocks_uncertain
Definition: session.h:2069
double _samples_per_timecode_frame
Definition: session.h:1802
uint32_t _n_lua_scripts
Definition: session.h:1613
MIDI::MachineControl & mmc()
Definition: session.h:1291
void mmc_deferred_play(MIDI::MachineControl &)
samplepos_t last_loopend
Definition: session.h:1562
void auto_punch_end_changed(Location *)
Timecode::Time last_timecode
Definition: session.h:1810
MidiClockTicker * midi_clock
Definition: session.h:2283
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
Definition: session.h:1512
void non_realtime_stop(bool abort, int entry_request_count, bool &finished, bool will_locate)
std::shared_ptr< Auditioner > auditioner
Definition: session.h:2019
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
Definition: session.h:2287
bool inital_connect_or_deletion_in_progress() const
Definition: session.h:257
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)
std::string _name
Definition: session.h:1553
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
double _engine_speed
Definition: session.h:1411
PBD::Signal< void()> SurroundMasterAddedOrRemoved
Definition: session.h:999
void butler_completed_transport_work()
RouteGroup * _all_route_group
Definition: session.h:1908
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)
Definition: session.h:1025
bool writable() const
Definition: session.h:242
bool maybe_stop(samplepos_t limit)
MidiControlUI * midi_control_ui
Definition: session.h:1853
samplepos_t _last_record_location
Definition: session.h:1594
std::shared_ptr< Region > XMLRegionFactory(const XMLNode &, bool full)
std::optional< samplepos_t > const & nominal_jack_transport_sample()
Definition: session.h:774
PBD::Signal< void()> PunchLoopConstraintChange
Definition: session.h:834
PBD::Signal< void()> MtcOrLtcInputPortChanged
Definition: session.h:481
std::shared_ptr< RouteList > get_routes_with_regions_at(timepos_t const &) const
@ TransportMasterLocate
Definition: session.h:1493
@ TransportMasterRelax
Definition: session.h:1491
@ TransportMasterNoRoll
Definition: session.h:1492
@ TransportMasterStart
Definition: session.h:1494
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
Definition: session.h:250
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
Definition: session.h:1401
PBD::Signal< void()> RecordPassCompleted
Definition: session.h:435
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()
Definition: session.h:335
XMLTree * state_tree
Definition: session.h:1574
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
Definition: session.h:2014
void session_loaded()
std::list< TimelineRange > current_audio_range
Definition: session.h:2142
void remove_pending_capture_state()
AnyTime global_quantization() const
Definition: session.h:1349
void process_export(pframes_t)
bool listening() const
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 &)
bool pending_auto_loop
Definition: session.h:1597
std::shared_ptr< SessionPlaylists > _playlists
Definition: session.h:1386
std::shared_ptr< AsyncMIDIPort > vkbd_output_port() const
std::shared_ptr< IOPlug > nth_io_plug(uint32_t n)
Definition: session.h:947
void route_solo_changed(bool self_solo_change, PBD::Controllable::GroupControlDisposition group_override, std::weak_ptr< Route >)
samplecnt_t _count_in_samples
Definition: session.h:2131
samplecnt_t calc_preroll_subcycle(samplecnt_t) const
bool first_file_data_format_reset
Definition: session.h:2187
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
Definition: session.h:439
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
Definition: session.h:536
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
Definition: session.h:1750
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
Definition: session.h:402
static const samplecnt_t default_click_length
Definition: session.h:2125
std::shared_ptr< ExportStatus > get_export_status()
std::list< RouteGroup * > _route_groups
Definition: session.h:1907
PBD::Signal< void(bool)> StepEditStatusChange
Definition: session.h:478
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
Definition: session.h:1415
int tb_with_filled_slots
Definition: session.h:2355
std::weak_ptr< MidiTrack > current_midi_target
Definition: session.h:2322
int32_t ltc_buf_len
Definition: session.h:1821
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))
Definition: session.h:2221
void globally_set_send_gains_to_unity(std::shared_ptr< Route > dest)
PBD::ScopedConnectionList punch_connections
Definition: session.h:1653
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.
Definition: session.h:2199
bool _rt_thread_active
Definition: session.h:1702
static void init_name_id_counter(unsigned int n)
void reset_native_file_format()
bool _update_send_delaylines
Definition: session.h:1422
void ltc_tx_resync_latency(bool)
Timecode::Time transmitting_timecode_time
Definition: session.h:1799
void maybe_enable_record(bool rt_context=false)
samplepos_t audible_sample(bool *latent_locate=NULL) const
void scripts_changed()
double actual_speed() const
int32_t ltc_buf_off
Definition: session.h:1820
void queue_event(SessionEvent *)
boost::dynamic_bitset< uint32_t > insert_bitset
Definition: session.h:2036
PBD::Signal< void()> RecordStateChanged
Definition: session.h:427
void remove_playlist(std::weak_ptr< Playlist >)
bool _reconnecting_routes_in_progress
Definition: session.h:1917
std::shared_ptr< PBD::Controllable > recently_touched_controllable() const
static PBD::Signal< void(samplepos_t)> EndTimeChanged
Definition: session.h:806
std::shared_ptr< Amp > _click_gain
Definition: session.h:2114
samplecnt_t worst_input_latency() const
Definition: session.h:559
bool locate_initiated() const
void request_bounded_roll(samplepos_t start, samplepos_t end)
void redo(uint32_t n)
bool _have_captured
Definition: session.h:1423
void send_song_position_pointer(samplepos_t)
samplecnt_t nominal_sample_rate() const
Definition: session.h:530
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
Definition: session.h:1412
std::atomic< int > _playback_load
Definition: session.h:2076
void load_nested_sources(const XMLNode &node)
uint32_t undo_depth() const
Definition: session.h:1084
std::string path() const
Definition: session.h:236
void request_transport_speed(double speed, TransportRequestSource origin=TRS_UI)
luabridge::LuaRef * _lua_cleanup
Definition: session.h:1612
std::shared_ptr< Port > ltc_output_port() const
Definition: session.h:1289
void mmc_rewind(MIDI::MachineControl &)
bool processing_blocked() const
Definition: session.h:1476
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
Definition: session.h:1705
void playlist_region_added(std::weak_ptr< Region >)
static PBD::Signal< void()> AfterConnect
Definition: session.h:904
samplecnt_t _capture_duration
Definition: session.h:1424
int post_engine_init()
std::atomic< int > _have_rec_enabled_track
Definition: session.h:2202
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
Definition: session.h:2033
bool cannot_save() const
Definition: session.h:255
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
Definition: session.h:1427
SessionConfiguration config
Definition: session.h:1185
std::shared_ptr< TriggerBox > triggerbox_at(int32_t route_index) const
bool need_declick_before_locate() const
void force_locate(samplepos_t sample, LocateTransportDisposition)
void enable_record()
static PBD::Signal< int()> AskAboutPendingState
Definition: session.h:897
bool is_auditioning() const
int rename(const std::string &)
PBD::Signal< void()> QuantizationChanged
Definition: session.h:1351
void setup_engine_resampling()
void clear_deletion_in_progress()
void setup_thread_local_variables()
std::shared_ptr< IOPlugList const > io_plugs() const
Definition: session.h:955
PBD::Signal< void()> IOConnectionsComplete
Definition: session.h:423
bool transport_master_no_external_or_using_engine() const
unsigned int _capture_xruns
Definition: session.h:1425
luabridge::LuaRef * _lua_add
Definition: session.h:1607
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()
bool last_timecode_valid
Definition: session.h:1808
void ensure_route_presentation_info_gap(PresentationInfo::order_t, uint32_t gap_size)
std::shared_ptr< Route > route_by_id(PBD::ID) const
Sample * click_data
Definition: session.h:2115
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
Definition: session.h:2350
void initialize_latencies()
bool _click_rec_only
Definition: session.h:2112
samplecnt_t capture_duration() const
Definition: session.h:320
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
Definition: session.h:995
bool loop_changing
Definition: session.h:1561
pframes_t _pframes_since_last_mtc
Definition: session.h:1559
std::shared_ptr< PBD::Controllable > solo_cut_control() const
std::list< std::string > missing_filesources(DataType) const
void consolidate_skips(Location *)
int cleanup_peakfiles()
bool rechain_ioplug_graph(bool)
PBD::Signal< void(std::string)> StateSaved
Definition: session.h:637
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 >())
double ltc_speed
Definition: session.h:1823
void _locations_changed(const Locations::LocationList &)
void auto_connect_thread_run()
boost::dynamic_bitset< uint32_t > return_bitset
Definition: session.h:2035
void setup_midi_control()
bool should_stop_before_locate() const
int silent_process_routes(pframes_t, bool &need_butler)
std::string snap_name() const
Definition: session.h:238
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()
Definition: session.h:1100
void reset_record_status()
std::shared_ptr< Port > mmc_input_port() const
void unmark_surround_send_id(uint32_t)
bool get_play_range() const
Definition: session.h:1111
double ltc_enc_cnt
Definition: session.h:1826
BufferSet & get_noinplace_buffers(ChanCount count=ChanCount::ZERO)
bool loading() const
Definition: session.h:254
uint32_t _listen_cnt
Definition: session.h:1429
Controllables controllables
Definition: session.h:2179
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
Definition: session.h:492
std::atomic< int32_t > _active_cue
Definition: session.h:2351
void ltc_tx_parse_offset()
bool transport_will_roll_forwards() const
samplecnt_t _worst_input_latency
Definition: session.h:1418
void refresh_disk_space()
int midi_read(MIDI::Port *)
std::list< MidiTimeoutCallback > MidiTimeoutList
Definition: session.h:1789
PBD::Signal< void(bool)> AuditionActive
Definition: session.h:930
std::shared_ptr< MidiRegion > XMLMidiRegionFactory(const XMLNode &, bool full)
bool pending_abort
Definition: session.h:1596
static bool get_disable_all_loaded_plugins()
Definition: session.h:1028
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
Definition: session.h:1631
void ensure_buffers_unlocked(ChanCount howmany)
std::string analysis_dir() const
Analysis data.
void set_sample_rate(samplecnt_t nframes)
void reset_xrun_count()
uint32_t next_send_id()
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
Definition: session.h:2181
void ensure_search_path_includes(const std::string &path, DataType type)
std::shared_ptr< Port > trigger_input_port() const
void setup_bundles()
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)
bool mmc_step_timeout()
luabridge::LuaRef * _lua_del
Definition: session.h:1608
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
Definition: session.h:2022
bool _adding_routes_in_progress
Definition: session.h:1916
void non_realtime_locate()
samplecnt_t _timecode_frames_per_hour
Definition: session.h:1804
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()
Definition: session.h:1298
volatile bool _save_queued_pending
Definition: session.h:1580
void start_time_changed(samplepos_t)
PBD::Signal< void()> Located
Definition: session.h:457
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
Definition: session.h:1622
SourceMap sources
Definition: session.h:1991
void start_domain_bounce(Temporal::DomainBounceInfo &)
bool vapor_export_barrier()
double engine_speed() const
Definition: session.h:811
luabridge::LuaRef * _lua_list
Definition: session.h:1609
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
Definition: session.h:2130
std::string unnamed_file_name() const
uint32_t registered_lua_function_count() const
Definition: session.h:936
LatencyRange ltc_out_latency
Definition: session.h:1834
XMLNode & get_state() const
void set_had_destructive_tracks(bool yn)
std::shared_ptr< ExportStatus > export_status
Definition: session.h:1531
samplepos_t _last_roll_location
Definition: session.h:1591
void resort_routes()
bool had_destructive_tracks() const
void notify_presentation_info_change(PBD::PropertyChange const &)
std::shared_ptr< Route > _master_out
Definition: session.h:2161
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 reset_last_capture_sources()
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
Definition: session.h:419
bool _send_timecode_update
Flag to send a full sample (Timecode) MTC message this cycle.
Definition: session.h:1812
void engine_running()
VCAManager * _vca_manager
Definition: session.h:2311
void sync_locations_to_skips()
samplepos_t requested_return_sample() const
Definition: session.h:772
void add_routes_inner(RouteList &, bool input_auto_connect, bool output_auto_connect, PresentationInfo::order_t)
std::atomic< int > _ac_thread_active
Definition: session.h:1715
bool actively_recording() const
Definition: session.h:406
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
Definition: session.h:560
samplecnt_t _current_sample_rate
Definition: session.h:1400
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
Definition: session.h:2281
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
Definition: session.h:769
std::shared_ptr< Port > scene_input_port() const
unsigned int get_xrun_count() const
Definition: session.h:838
PBD::Signal< void()> route_group_removed
Definition: session.h:716
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
Definition: session.h:1090
void locations_changed()
luabridge::LuaRef * _lua_run
Definition: session.h:1606
bool _session_range_is_free
Definition: session.h:1405
samplecnt_t click_length
Definition: session.h:2117
size_t last_touched_mixer_scene_idx()
Definition: session.h:1180
void flush_all_inserts()
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
Definition: session.h:1537
void remove_state(std::string snapshot_name)
unsigned int export_xruns() const
Definition: session.h:322
void set_global_quantization(AnyTime const &)
std::list< RouteGroup * > const & route_groups() const
Definition: session.h:725
bool bounce_processing() const
Definition: session.h:1197
int flatten_one_track(AudioTrack &, samplepos_t start, samplecnt_t cnt)
void cleanup_regions()
SerializedRCUManager< BundleList > _bundles
Definition: session.h:2081
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
Definition: session.h:270
uint32_t track_number_decimals() const
Definition: session.h:394
static bool _disable_all_loaded_plugins
Definition: session.h:2196
ARDOUR::CueMarkers pending_source_markers
Definition: session.h:1987
void route_listen_changed(PBD::Controllable::GroupControlDisposition, std::weak_ptr< Route >)
LuaState lua
Definition: session.h:1604
std::string automation_dir() const
Automation data.
boost::dynamic_bitset< uint32_t > send_bitset
Definition: session.h:2032
bool peaks_cleanup_in_progres() const
Definition: session.h:253
PBD::Signal< void(RouteGroup *, std::weak_ptr< Route >)> RouteAddedToRouteGroup
Definition: session.h:467
PBD::Signal< void()> session_routes_reconnected
Definition: session.h:1001
std::string new_audio_source_path_for_embedded(const std::string &existing_path)
Temporal::Range _object_selection
Definition: session.h:2151
void remove_routes(std::shared_ptr< RouteList >)
std::optional< bool > _vapor_available
Definition: session.h:1447
void add_post_transport_work(PostTransportWork ptw)
samplecnt_t preroll_record_trim_len() const
Definition: session.h:1121
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 &region_name="")
static void set_bypass_all_loaded_plugins(bool yn)
Definition: session.h:1031
void realtime_stop(bool abort, bool clear_state)
SessionEvent * get_rt_event(std::shared_ptr< WeakAutomationControlList > cl, double arg, PBD::Controllable::GroupControlDisposition group_override)
Definition: session.h:2232
void reset_transport_speed(TransportRequestSource origin=TRS_UI)
samplecnt_t _preroll_record_trim_len
Definition: session.h:2155
void route_mute_changed()
bool route_name_unique(std::string) const
ChanCount _required_thread_buffers
Definition: session.h:1463
void setup_click_sounds(int which)
void count_existing_track_channels(ChanCount &in, ChanCount &out)
double step_speed
Definition: session.h:1786
bool update_route_latency(bool reverse, bool apply_to_delayline, bool *delayline_update_needed)
Glib::Threads::Mutex _auto_connect_queue_lock
Definition: session.h:1748
gain_t * trim_automation_buffer() const
LTCEncoder * ltc_encoder
Definition: session.h:1816
PBD::Signal< void()> MonitorChanged
Definition: session.h:997
bool first_file_header_format_reset
Definition: session.h:2188
static const SessionEvent::RTeventCallback rt_cleanup
Definition: session.h:984
void post_transport_motion()
static PBD::Signal< void()> Quit
Definition: session.h:1266
MIDI::byte mtc_timecode_bits
Definition: session.h:1796
PBD::Signal< void(bool)> LatencyUpdated
Definition: session.h:565
Glib::Threads::Mutex save_source_lock
Definition: session.h:1584
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
Definition: session.h:1528
samplecnt_t _worst_output_latency
Definition: session.h:1417
void set_missing_file_replacement(const std::string &mfr)
Definition: session.h:1261
PBD::Signal< void(RouteGroup *)> RouteGroupPropertyChanged
Definition: session.h:463
PBD::Signal< void()> ClearedLastCaptureSources
Definition: session.h:436
void engine_halted()
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
Definition: session.h:2285
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 cancel_all_solo()
void timecode_time(Timecode::Time &)
Sample * click_emphasis_data
Definition: session.h:2116
Glib::Threads::Mutex _update_latency_lock
Definition: session.h:1745
std::vector< std::shared_ptr< MixerScene > > _mixer_scenes
Definition: session.h:1621
void unset_dirty(bool emit_dirty_changed=false)
pframes_t current_block_size
Definition: session.h:1416
uint32_t _track_number_decimals
Definition: session.h:1942
unsigned int capture_xruns() const
Definition: session.h:321
PBD::Signal< void()> IOPluginsChanged
Definition: session.h:942
bool _send_qf_mtc
Definition: session.h:1555
bool reconnection_in_progress() const
Definition: session.h:249
static const uint32_t session_end_shift
Definition: session.h:2307
bool _count_in_once
Definition: session.h:2156
bool solo_selection_active()
void update_skips(Location *, bool consolidate)
PBD::Signal< void()> RecordArmStateChanged
Definition: session.h:431
bool _realtime_export
Definition: session.h:1526
PBD::Signal< void(Location *)> auto_punch_location_changed
Definition: session.h:548
int save_as(SaveAs &)
void auto_connect_io(std::shared_ptr< IO >)
void decrement_transport_position(samplecnt_t val)
Definition: session.h:1681
AudioEngine const & engine() const
Definition: session.h:763
bool _global_locate_pending
Definition: session.h:2328
void config_changed(std::string, bool)
CueEvents _cue_events
Definition: session.h:2346
RouteGroup & all_route_group() const
PBD::Signal< void()> FBSendsChanged
Definition: session.h:475
void mmc_step(MIDI::MachineControl &, int)
void clear_object_selection()
void process_rtop(SessionEvent *)
std::atomic< int > _capture_load
Definition: session.h:2077
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))
Definition: session.h:2209
void set_post_transport_work(PostTransportWork ptw)
Definition: session.h:1632
PBD::Signal< void()> SessionSaveUnderway
Definition: session.h:653
std::shared_ptr< Port > scene_output_port() const
int cleanup_sources(CleanupReport &)
PBD::Signal< void()> IsolatedChanged
Definition: session.h:996
XMLNode & get_template()
void foreach_source(std::function< void(std::shared_ptr< Source >)> f)
Definition: session.h:1979
std::atomic< PunchLoopLock > _punch_or_loop
Definition: session.h:1871
static int parse_stateful_loading_version(const std::string &)
AudioEngine & _engine
Definition: session.h:1394
PBD::Signal< void()> locations_modified
Definition: session.h:549
PBD::Signal< void(samplepos_t)> PositionChanged
Definition: session.h:452
bool _was_seamless
Definition: session.h:1432
process_function_type last_process_function
Definition: session.h:1396
Clicks clicks
Definition: session.h:2110
Butler * _butler
Definition: session.h:1624
PBD::Signal< void(Location *)> auto_loop_location_changed
Definition: session.h:547
std::shared_ptr< IOTaskList > _io_tasklist
Definition: session.h:2288
SessionConfiguration * cfg()
Definition: session.h:1187
PBD::ScopedConnectionList skip_update_connections
Definition: session.h:1650
int add_master_bus(ChanCount const &)
std::atomic< PostTransportWork > _post_transport_work
Definition: session.h:1630
samplepos_t position() const
Definition: session.h:1372
int load_routes(const XMLNode &, int)
bool _bounce_processing_active
Definition: session.h:1397
Glib::Threads::Mutex controllables_lock
Definition: session.h:2178
GraphEdges _current_route_graph
Definition: session.h:2264
std::shared_ptr< Route > surround_master() const
Definition: session.h:1012
bool synced_to_engine() const
std::atomic< RecordState > _record_status
Definition: session.h:1439
void setup_raid_path(std::string path)
std::atomic< int > _processing_prohibited
Definition: session.h:1438
void reassign_track_numbers()
std::shared_ptr< ExportHandler > export_handler
Definition: session.h:1530
std::optional< bool > _vapor_exportable
Definition: session.h:1448
BufferSet & get_route_buffers(ChanCount count=ChanCount::ZERO, bool silence=true)
std::shared_ptr< IO > _click_io
Definition: session.h:2113
static const int vst_can_do_string_count
Definition: session.h:1145
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
Definition: session.h:1969
std::shared_ptr< Route > get_remote_nth_route(PresentationInfo::order_t n) const
SourceList pt_imported_sources
Definition: session.h:1322
void globally_add_internal_sends(std::shared_ptr< Route > dest, Placement p, bool)
void timecode_duration(samplecnt_t, Timecode::Time &) const
uint32_t capture_load()
PBD::Signal< void(std::string)> SaveSessionRequested
Definition: session.h:648
MIDI::MachineControl * _mmc
Definition: session.h:2295
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
Definition: session.h:1156
samplecnt_t io_latency() const
Definition: session.h:561
void audition_region(std::shared_ptr< Region >)
void flush_cue_recording()
void * do_work()
std::atomic< int > _have_rec_disabled_track
Definition: session.h:2203
void request_resume_timecode_transmission()
void reorder_route_groups(std::list< RouteGroup * >)
void unblock_processing()
Definition: session.h:1475
SerializedRCUManager< RouteList > routes
Definition: session.h:1912
static PBD::Signal< int(Session *, std::string, DataType)> MissingFile
Definition: session.h:1259
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
Definition: session.h:1701
PBD::ReallocPool _mempool
Definition: session.h:1602
AutoConnectQueue _auto_connect_queue
Definition: session.h:1749
std::string modified_with
Definition: session.h:2316
Glib::Threads::Mutex peak_cleanup_lock
Definition: session.h:1585
pthread_mutex_t _auto_connect_mutex
Definition: session.h:1716
BufferSet & get_scratch_buffers(ChanCount count=ChanCount::ZERO, bool silence=true)
bool global_locate_pending() const
Definition: session.h:512
void cancel_audition()
PBD::ScopedConnection _click_io_connection
Definition: session.h:2121
std::atomic< int > _suspend_save
Definition: session.h:1578
void setup_click_state(const XMLNode *)
bool get_record_enabled() const
Definition: session.h:398
static void * auto_connect_thread(void *)
Locations * _locations
Definition: session.h:1638
void luabindings_session_rt(lua_State *)
unsigned int _export_xruns
Definition: session.h:1426
double outbound_mtc_timecode_frame
Definition: session.h:1798
Glib::Threads::RWLock click_lock
Definition: session.h:2119
static const std::string session_name_is_legal(const std::string &)
std::shared_ptr< RouteList const > get_routes() const
Definition: session.h:331
PresentationInfo::order_t master_order_key() const
Definition: session.h:1014
uint32_t next_return_id()
samplecnt_t convert_to_samples(AnyTime const &position)
samplepos_t record_location() const
Definition: session.h:770
static PBD::Signal< int(std::shared_ptr< Playlist >)> AskAboutPlaylistDeletion
Definition: session.h:885
bool export_track_state(std::shared_ptr< RouteList > rl, const std::string &path)
size_t _last_touched_mixer_scene_idx
Definition: session.h:1408
CoreSelection & selection() const
Definition: session.h:340
void update_route_solo_state(std::shared_ptr< RouteList const > r=std::shared_ptr< RouteList const >())
VCAManager * vca_manager_ptr()
Definition: session.h:1299
RouteList get_routelist(bool mixer_order=false, PresentationInfo::Flag fl=PresentationInfo::MixerRoutes) const
std::shared_ptr< AutomationControl > automation_control_by_id(const PBD::ID &)
AudioEngine & engine()
Definition: session.h:762
void timecode_to_sample(Timecode::Time &timecode, samplepos_t &sample, bool use_offset, bool use_subframes) const
volatile bool _save_queued
Definition: session.h:1579
std::function< bool()> MidiTimeoutCallback
Definition: session.h:1788
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)
Definition: session.h:708
void playlist_regions_extended(std::list< Temporal::Range > const &)
uint32_t main_outs
Definition: session.h:2159
static int vst_current_loading_id
Definition: session.h:1143
void mmc_record_exit(MIDI::MachineControl &)
pthread_cond_t _auto_connect_cond
Definition: session.h:1717
void queue_full_time_code()
Definition: session.h:1222
SerializedRCUManager< IOPlugList > _io_plugins
Definition: session.h:1619
std::shared_ptr< Speakers > _speakers
Definition: session.h:2258
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
Definition: session.h:1403
PBD::Signal< void()> TransportStateChange
Definition: session.h:450
gain_t * send_gain_automation_buffer() const
void emit_thread_run()
std::shared_ptr< Port > mmc_output_port() const
std::vector< std::weak_ptr< AutomationControl > > cancel_all_mute()
void xrun_recovery()
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
Definition: session.h:890
int save_template(const std::string &template_name, const std::string &description="", bool replace_existing=false)
uint32_t redo_depth() const
Definition: session.h:1085
void set_track_monitor_input_status(bool)
bool playlist_is_active(std::shared_ptr< Playlist >)
std::shared_ptr< Route > monitor_out() const
Definition: session.h:1009
bool waiting_for_sync_offset
Definition: session.h:1398
Timecode::TimecodeFormat ltc_enc_tcformat
Definition: session.h:1819
void process_with_events(pframes_t)
StateOfTheState _state_of_the_state
Definition: session.h:1575
PBD::Signal< void()> MonitorBusAddedOrRemoved
Definition: session.h:998
std::shared_ptr< Source > XMLSourceFactory(const XMLNode &)
XMLNode * _bundle_xml_node
Definition: session.h:2082
void process_event(SessionEvent *)
bool soloing() const
Definition: session.h:973
samplecnt_t _io_latency
Definition: session.h:1420
void request_count_in_record()
void set_auto_loop_location(Location *)
void route_processors_changed(RouteProcessorChange)
std::atomic< int > _seek_counter
Definition: session.h:1402
MidiPortManager * _midi_ports
Definition: session.h:2294
void schedule_playback_buffering_adjustment()
void reset_monitor_section()
bool muted() const
AnyTime _global_quantization
Definition: session.h:2360
std::shared_ptr< Route > _surround_master
Definition: session.h:2163
std::shared_ptr< SessionPlaylists > playlists() const
Definition: session.h:1219
samplecnt_t click_emphasis_length
Definition: session.h:2118
bool apply_nth_mixer_scene(size_t, RouteList const &)
void clear_active_cue()
std::atomic< int > _suspend_timecode_transmission
Definition: session.h:2250
void auto_connect_thread_start()
bool punch_active() const
std::vector< space_and_path >::iterator last_rr_session_dir
Definition: session.h:2063
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
Definition: session.h:554
int no_roll(pframes_t nframes)
std::shared_ptr< BundleList const > bundles()
Definition: session.h:363
void non_realtime_set_audition()
samplepos_t ltc_timecode_offset
Definition: session.h:1831
PBD::Signal< void(std::weak_ptr< Source >)> SourceAdded
Definition: session.h:1974
PBD::Signal< void(RouteGroup *, std::weak_ptr< Route >)> RouteRemovedFromRouteGroup
Definition: session.h:471
void request_preroll_record_trim(samplepos_t start, samplecnt_t preroll)
pthread_mutex_t _rt_emit_mutex
Definition: session.h:1704
bool user_roll_after_locate() const
PBD::Signal< void()> route_groups_reordered
Definition: session.h:717
static PBD::Signal< void(samplecnt_t, samplecnt_t)> NotifyAboutSampleRateMismatch
Definition: session.h:893
static bool get_bypass_all_loaded_plugins()
Definition: session.h:1034
void queue_song_position_pointer()
Definition: session.h:1223
bool locate_pending() const
samplepos_t ltc_prev_cycle
Definition: session.h:1829
bool vapor_barrier()
void routes_using_input_from(const std::string &str, RouteList &rl)
PBD::Signal< void(std::weak_ptr< Source >)> SourceRemoved
Definition: session.h:1975
void butler_transport_work(bool have_process_lock=false)
samplepos_t ltc_enc_pos
Definition: session.h:1825
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
Definition: session.h:1958
std::string name() const
Definition: session.h:237
Butler * butler()
Definition: session.h:325
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
Definition: session.h:1421
MidiTimeoutList midi_timeouts
Definition: session.h:1791
std::vector< std::string > registered_lua_functions()
void add_source(std::shared_ptr< Source >)
samplecnt_t worst_latency_preroll() const
int32_t ltc_enc_byte
Definition: session.h:1824
std::shared_ptr< Route > XMLRouteFactory_3X(const XMLNode &, int)
samplecnt_t frames_per_hour() const
Definition: session.h:531
void auto_connect_surround_master()
std::optional< samplepos_t > _nominal_jack_transport_sample
Definition: session.h:2329
bool get_nsm_state() const
Definition: session.h:633
void timecode_time(samplepos_t when, Timecode::Time &)
std::string _path
Definition: session.h:1552
uint32_t _solo_isolated_cnt
Definition: session.h:1430
int start_audio_export(samplepos_t position, bool realtime=false, bool region_export=false)
bool monitor_active() const
Definition: session.h:1007
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
Definition: session.h:1243
void set_controls(std::shared_ptr< AutomationControlList >, double val, PBD::Controllable::GroupControlDisposition)
void set_block_size(pframes_t nframes)
bool _route_reorder_in_progress
Definition: session.h:1919
void click_io_resync_latency(bool)
samplepos_t last_transport_start() const
Definition: session.h:494
void unset_play_range()
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
Definition: session.h:1087
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()
Click * get_click()
void mmc_record_pause(MIDI::MachineControl &)
std::shared_ptr< GraphChain > _graph_chain
Definition: session.h:2268
void rewire_midi_selection_ports()
PBD::Signal< void()> BatchUpdateStart
Definition: session.h:269
void setup_midi_machine_control()
samplecnt_t worst_latency_preroll_buffer_size_ceil() const
samplecnt_t timecode_frames_per_hour() const
Definition: session.h:534
std::string _current_snapshot_name
Definition: session.h:1572
bool transport_stopped_or_stopping() const
uint32_t playback_load()
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
Definition: session.h:2120
RouteGroup * route_group_by_name(std::string)
unsigned int _xrun_count
Definition: session.h:1434
Glib::Threads::Mutex lua_lock
Definition: session.h:1605
virtual ~Session()
PBD::Signal< void()> UpdateRouteRecordState
Definition: session.h:433
void add_click(samplepos_t pos, bool emphasis)
std::weak_ptr< PBD::Controllable > _recently_touched_controllable
Definition: session.h:2184
void save_as_bring_callback(uint32_t, uint32_t, std::string)
luabridge::LuaRef * _lua_save
Definition: session.h:1611
void adjust_playback_buffering()
pthread_t _auto_connect_thread
Definition: session.h:1714
void solo_control_mode_changed()
void request_overwrite_buffer(std::shared_ptr< Track >, OverwriteReason)
void emit_route_signals()
PBD::ScopedConnection export_freewheel_connection
Definition: session.h:1539
std::string _template_state_dir
Definition: session.h:2309
void listen_position_changed()
void auto_connect_thread_terminate()
PBD::Signal< void()> StateReady
Definition: session.h:638
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
Definition: session.h:1593
int destroy_sources(std::list< std::shared_ptr< Source > > const &)
void foreach_route_group(std::function< void(RouteGroup *)> f)
Definition: session.h:719
std::vector< space_and_path > session_dirs
Definition: session.h:2062
samplepos_t ltc_enc_off
Definition: session.h:1827
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
Definition: session.h:1803
size_t _required_thread_buffersize
Definition: session.h:1464
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 &)
bool dirty() const
Definition: session.h:251
void goto_start(bool and_roll=false)
@ pullup_Minus4Plus1
Definition: session.h:786
@ pullup_Plus4Minus1
Definition: session.h:782
LatencyRange mtc_out_latency
Definition: session.h:1835
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
Definition: session.h:1248
void set_next_event()
bool _no_save_signal
Definition: session.h:1581
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
Definition: session.h:1522
std::shared_ptr< IO > click_io()
Definition: session.h:1099
std::vector< std::shared_ptr< MixerScene > > mixer_scenes() const
bool can_cleanup_peakfiles() const
samplecnt_t _base_sample_rate
Definition: session.h:1399
bool _export_rolling
Definition: session.h:1525
void update_latency_compensation(bool force, bool called_from_backend)
bool maybe_allow_only_loop(bool play_loop=false)
bool process_can_proceed() const
Definition: session.h:1851
bool deletion_in_progress() const
Definition: session.h:252
void ltc_tx_initialize()
void mmc_track_record_status(MIDI::MachineControl &, uint32_t track, bool enabled)
void _sync_locations_to_skips()
bool post_export_sync
Definition: session.h:1521
bool realtime_export() const
Definition: session.h:1193
static std::string get_snapshot_from_instant(const std::string &session_dir)
bool silent()
Definition: session.h:830
void sync_cues_from_list(Locations::LocationList const &)
bool have_external_connections_for_current_backend(bool tracks_only=true) const
uint32_t nbusses() const
void increment_transport_position(samplecnt_t val)
Definition: session.h:1673
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)
uint32_t _step_editors
Definition: session.h:2247
void set_object_selection(Temporal::timepos_t const &start, Temporal::timepos_t const &end)
bool have_captured() const
Definition: session.h:318
void sync_time_vars()
PBD::Signal< void(RouteGroup *)> route_group_added
Definition: session.h:715
void ltc_tx_cleanup()
StripableList get_stripables() const
static std::atomic< unsigned int > _name_id_counter
Definition: session.h:1382
StripableList _soloSelection
Definition: session.h:2324
void globally_set_send_gains_from_track(std::shared_ptr< Route > dest)
bool _play_range
Definition: session.h:2143
std::vector< struct ptflookup > ptfwavpair
Definition: session.h:1321
void block_processing()
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)
Definition: session.h:634
void set_session_range_is_free(bool)
Temporal::GridIterator _click_iterator
Definition: session.h:2122
bool unnamed() const
void maybe_update_session_range(timepos_t const &, timepos_t const &)
int micro_locate(samplecnt_t distance)
void tempo_map_changed()
static bool _bypass_all_loaded_plugins
Definition: session.h:2197
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
Definition: session.h:863
std::vector< std::string > possible_states() const
int start_midi_thread()
void route_group_property_changed(RouteGroup *)
PBD::Signal< void()> TransportLooped
Definition: session.h:454
samplepos_t last_timecode_when
Definition: session.h:1809
bool _under_nsm_control
Definition: session.h:1433
void midi_track_presentation_info_changed(PBD::PropertyChange const &, std::weak_ptr< MidiTrack >)
PBD::Signal< int(samplecnt_t)> ProcessExport
Definition: session.h:862
static PBD::Signal< void(std::string)> Dialog
Definition: session.h:267
uint32_t nroutes() const
Definition: session.h:356
Definition: LuaRef.h:52
static EventLoop * get_event_loop_for_thread()
Definition: id.h:34
Definition: tlsf.h:30
Definition: xml++.h:114
Definition: xml++.h:74
GtkImageIconNameData name
Definition: gtkimage.h:6
#define LIBARDOUR_API
libltc - en+decode linear timecode
unsigned char ltcsnd_sample_t
Definition: ltc.h:82
PBD::PropertyDescriptor< uint32_t > order
PBD::PropertyDescriptor< timepos_t > start
std::shared_ptr< Trigger > TriggerPtr
Definition: triggerbox.h:83
std::set< CueMarker > CueMarkers
uint32_t pframes_t
std::vector< std::shared_ptr< Source > > SourceList
std::vector< CueEvent > CueEvents
std::list< std::shared_ptr< Stripable > > StripableList
Temporal::samplecnt_t samplecnt_t
void setup_enum_writer()
std::list< std::shared_ptr< GraphNode > > GraphNodeList
std::list< std::shared_ptr< Route > > RouteList
std::vector< LuaScriptParamPtr > LuaScriptParamList
Definition: luascripting.h:107
Temporal::samplepos_t samplepos_t
std::shared_ptr< PBD::Controllable > Controllable
Definition: console1.h:80
Definition: editor.h:87
DebugBits IOTaskList
DebugBits Graph
DebugBits AudioEngine
Definition: session.h:1354
DebugBits Butler
Definition: axis_view.h:42
void atomic_inc(std::atomic< T > &aval)
Definition: atomic.h:29
bool atomic_dec_and_test(std::atomic< T > &aval)
Definition: atomic.h:26
static const samplepos_t max_samplepos
TimecodeFormat
Definition: time.h:38
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)
Definition: session.h:1721
std::weak_ptr< Route > route
Definition: session.h:1736
std::string final_session_folder_name
Definition: session.h:575
std::string failure_message
Definition: session.h:592
std::string new_parent_folder
Definition: session.h:568
std::string new_name
Definition: session.h:569
PBD::Signal< bool(float, int64_t, int64_t)> Progress
Definition: session.h:588
LocateTransportDisposition roll_disposition
Definition: session.h:1502
uint32_t blocks
4kB blocks
Definition: session.h:2041
bool blocks_unknown
true if blocks is unknown
Definition: session.h:2042