2 Copyright (C) 2000 Paul Davis
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2 of the License, or
7 (at your option) any later version.
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software
16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20 #ifndef __ardour_session_h__
21 #define __ardour_session_h__
31 #include <boost/dynamic_bitset.hpp>
32 #include <boost/scoped_ptr.hpp>
33 #include <boost/weak_ptr.hpp>
34 #include <boost/utility.hpp>
36 #include <glibmm/thread.h>
38 #include "pbd/error.h"
40 #include "pbd/statefuldestructible.h"
41 #include "pbd/signals.h"
44 #include "midi++/types.h"
46 #include "ardour/ardour.h"
47 #include "ardour/click.h"
48 #include "ardour/chan_count.h"
49 #include "ardour/rc_configuration.h"
50 #include "ardour/session_configuration.h"
51 #include "ardour/session_event.h"
52 #include "ardour/location.h"
53 #include "ardour/timecode.h"
54 #include "ardour/interpolation.h"
56 #ifdef HAVE_JACK_SESSION
57 #include <jack/session.h>
72 class ControllableDescriptor
;
82 class AudioFileSource
;
92 class ControlProtocolInfo
;
103 class NamedSelection
;
116 class SessionDirectory
;
117 class SessionMetadata
;
118 class SessionPlaylists
;
126 extern void setup_enum_writer ();
128 class Session
: public PBD::StatefulDestructible
, public PBD::ScopedConnectionList
, public SessionEventManager
137 /* a new session might have non-empty mix_template, an existing session should always have an empty one.
138 the bus profile can be null if no master out bus is required.
141 Session (AudioEngine
&,
142 const std::string
& fullpath
,
143 const std::string
& snapshot_name
,
144 BusProfile
* bus_profile
= 0,
145 std::string mix_template
= "");
149 std::string
path() const { return _path
; }
150 std::string
name() const { return _name
; }
151 std::string
snap_name() const { return _current_snapshot_name
; }
152 std::string
raid_path () const;
153 bool path_is_within_session (const std::string
&);
155 void set_snap_name ();
157 bool writable() const { return _writable
; }
160 bool dirty() const { return _state_of_the_state
& Dirty
; }
161 void set_deletion_in_progress ();
162 void clear_deletion_in_progress ();
163 bool deletion_in_progress() const { return _state_of_the_state
& Deletion
; }
164 PBD::Signal0
<void> DirtyChanged
;
166 const SessionDirectory
& session_directory () const { return *(_session_dir
.get()); }
168 static PBD::Signal0
<void> AutoBindingOn
;
169 static PBD::Signal0
<void> AutoBindingOff
;
171 static PBD::Signal1
<void,std::string
> Dialog
;
173 std::string
sound_dir (bool with_path
= true) const;
174 std::string
peak_dir () const;
175 std::string
dead_sound_dir () const;
176 std::string
automation_dir () const;
177 std::string
analysis_dir() const;
179 int ensure_subdirs ();
181 Glib::ustring
peak_path (Glib::ustring
) const;
183 std::string
change_source_path_by_name (std::string oldpath
, std::string oldname
, std::string newname
, bool destructive
);
185 std::string
peak_path_from_audio_path (std::string
) const;
186 std::string
new_audio_source_name (const std::string
&, uint32_t nchans
, uint32_t chan
, bool destructive
);
187 std::string
new_midi_source_name (const std::string
&);
188 std::string
new_source_path_from_name (DataType type
, const std::string
&, bool as_stub
= false);
189 RouteList
new_route_from_template (uint32_t how_many
, const std::string
& template_path
);
191 void process (nframes_t nframes
);
193 BufferSet
& get_silent_buffers (ChanCount count
= ChanCount::ZERO
);
194 BufferSet
& get_scratch_buffers (ChanCount count
= ChanCount::ZERO
);
195 BufferSet
& get_mix_buffers (ChanCount count
= ChanCount::ZERO
);
197 bool have_rec_enabled_track () const;
199 bool have_captured() const { return _have_captured
; }
201 void refill_all_track_buffers ();
202 Butler
* butler() { return _butler
; }
203 void butler_transport_work ();
205 void refresh_disk_space ();
207 int load_diskstreams_2X (XMLNode
const &, int);
209 int load_routes (const XMLNode
&, int);
210 boost::shared_ptr
<RouteList
> get_routes() const {
211 return routes
.reader ();
214 boost::shared_ptr
<RouteList
> get_routes_with_internal_returns() const;
216 boost::shared_ptr
<RouteList
> get_routes_with_regions_at (nframes64_t
const) const;
218 uint32_t nroutes() const { return routes
.reader()->size(); }
219 uint32_t ntracks () const;
220 uint32_t nbusses () const;
222 boost::shared_ptr
<BundleList
> bundles () {
223 return _bundles
.reader ();
226 struct RoutePublicOrderSorter
{
227 bool operator() (boost::shared_ptr
<Route
>, boost::shared_ptr
<Route
> b
);
230 void sync_order_keys (std::string
const &);
232 template<class T
> void foreach_route (T
*obj
, void (T::*func
)(Route
&));
233 template<class T
> void foreach_route (T
*obj
, void (T::*func
)(boost::shared_ptr
<Route
>));
234 template<class T
, class A
> void foreach_route (T
*obj
, void (T::*func
)(Route
&, A
), A arg
);
236 bool io_name_is_legal (const std::string
&);
237 boost::shared_ptr
<Route
> route_by_name (std::string
);
238 boost::shared_ptr
<Route
> route_by_id (PBD::ID
);
239 boost::shared_ptr
<Route
> route_by_remote_id (uint32_t id
);
241 bool route_name_unique (std::string
) const;
242 bool route_name_internal (std::string
) const;
244 bool get_record_enabled() const {
245 return (record_status () >= Enabled
);
248 RecordState
record_status() const {
249 return (RecordState
) g_atomic_int_get (&_record_status
);
252 bool actively_recording () {
253 return record_status() == Recording
;
256 bool record_enabling_legal () const;
257 void maybe_enable_record ();
258 void disable_record (bool rt_context
, bool force
= false);
259 void step_back_from_record ();
261 void maybe_write_autosave ();
263 /* Emitted when all i/o connections are complete */
265 PBD::Signal0
<void> IOConnectionsComplete
;
267 /* Record status signals */
269 PBD::Signal0
<void> RecordStateChanged
;
271 /* Transport mechanism signals */
273 PBD::Signal0
<void> TransportStateChange
; /* generic */
274 PBD::Signal1
<void,nframes64_t
> PositionChanged
; /* sent after any non-sequential motion */
275 PBD::Signal1
<void,nframes64_t
> Xrun
;
276 PBD::Signal0
<void> TransportLooped
;
278 /** emitted when a locate has occurred */
279 PBD::Signal0
<void> Located
;
281 PBD::Signal1
<void,RouteList
&> RouteAdded
;
282 /** Emitted when anything about any of our route groups changes */
283 PBD::Signal0
<void> RouteGroupChanged
;
285 void queue_event (SessionEvent
*);
287 void request_roll_at_and_return (nframes_t start
, nframes_t return_to
);
288 void request_bounded_roll (nframes_t start
, nframes_t end
);
289 void request_stop (bool abort
= false, bool clear_state
= false);
290 void request_locate (nframes_t frame
, bool with_roll
= false);
292 void request_play_loop (bool yn
, bool leave_rolling
= false);
293 bool get_play_loop () const { return play_loop
; }
295 nframes_t
last_transport_start() const { return _last_roll_location
; }
298 void set_session_start (nframes_t
);
299 void set_session_end (nframes_t
);
300 void use_rf_shuttle_speed ();
301 void allow_auto_play (bool yn
);
302 void request_transport_speed (double speed
);
303 void request_overwrite_buffer (Track
*);
304 void adjust_playback_buffering();
305 void adjust_capture_buffering();
306 void request_track_speed (Track
*, double speed
);
307 void request_input_change_handling ();
309 bool locate_pending() const { return static_cast<bool>(post_transport_work()&PostTransportLocate
); }
310 bool transport_locked () const;
314 std::pair
<nframes_t
, nframes_t
> get_extent () const;
315 nframes_t
current_end_frame () const;
316 nframes_t
current_start_frame () const;
317 /// "actual" sample rate of session, set by current audioengine rate, pullup/down etc.
318 nframes_t
frame_rate() const { return _current_frame_rate
; }
319 /// "native" sample rate of session, regardless of current audioengine rate, pullup/down etc
320 nframes_t
nominal_frame_rate() const { return _nominal_frame_rate
; }
321 nframes_t
frames_per_hour() const { return _frames_per_hour
; }
323 double frames_per_timecode_frame() const { return _frames_per_timecode_frame
; }
324 nframes_t
timecode_frames_per_hour() const { return _timecode_frames_per_hour
; }
326 MIDI::byte
get_mtc_timecode_bits() const {
327 return mtc_timecode_bits
; /* encoding of SMTPE type for MTC */
330 float timecode_frames_per_second() const;
331 bool timecode_drop_frames() const;
335 Locations
*locations() { return &_locations
; }
337 PBD::Signal1
<void,Location
*> auto_loop_location_changed
;
338 PBD::Signal1
<void,Location
*> auto_punch_location_changed
;
339 PBD::Signal0
<void> locations_modified
;
341 void set_auto_punch_location (Location
*);
342 void set_auto_loop_location (Location
*);
343 int location_name(std::string
& result
, std::string base
= std::string(""));
345 void reset_input_monitor_state ();
347 nframes_t
get_block_size() const { return current_block_size
; }
348 nframes_t
worst_output_latency () const { return _worst_output_latency
; }
349 nframes_t
worst_input_latency () const { return _worst_input_latency
; }
350 nframes_t
worst_track_latency () const { return _worst_track_latency
; }
352 #ifdef HAVE_JACK_SESSION
353 void jack_session_event (jack_session_event_t
* event
);
355 int save_state (std::string snapshot_name
, bool pending
= false, bool switch_to_snapshot
= false);
356 int restore_state (std::string snapshot_name
);
357 int save_template (std::string template_name
);
358 int save_history (std::string snapshot_name
= "");
359 int restore_history (std::string snapshot_name
);
360 void remove_state (std::string snapshot_name
);
361 void rename_state (std::string old_name
, std::string new_name
);
362 void remove_pending_capture_state ();
364 static int rename_template (std::string old_name
, std::string new_name
);
365 static int delete_template (std::string name
);
367 PBD::Signal1
<void,std::string
> StateSaved
;
368 PBD::Signal0
<void> StateReady
;
370 std::vector
<std::string
*>* possible_states() const;
371 static std::vector
<std::string
*>* possible_states (std::string path
);
373 XMLNode
& get_state();
374 int set_state(const XMLNode
& node
, int version
); // not idempotent
375 XMLNode
& get_template();
377 /// The instant xml file is written to the session directory
378 void add_instant_xml (XMLNode
&, bool write_to_config
= true);
379 XMLNode
* instant_xml (const std::string
& str
);
381 enum StateOfTheState
{
386 InitialConnecting
= 0x8,
391 StateOfTheState
state_of_the_state() const { return _state_of_the_state
; }
393 void add_route_group (RouteGroup
*);
394 void remove_route_group (RouteGroup
&);
396 RouteGroup
*route_group_by_name (std::string
);
398 PBD::Signal1
<void,RouteGroup
*> route_group_added
;
399 PBD::Signal0
<void> route_group_removed
;
401 void foreach_route_group (boost::function
<void(RouteGroup
*)> f
) {
402 for (std::list
<RouteGroup
*>::iterator i
= _route_groups
.begin(); i
!= _route_groups
.end(); ++i
) {
407 /* fundamental operations. duh. */
409 std::list
<boost::shared_ptr
<AudioTrack
> > new_audio_track (
410 int input_channels
, int output_channels
, TrackMode mode
= Normal
, RouteGroup
* route_group
= 0, uint32_t how_many
= 1
413 RouteList
new_audio_route (bool aux
, int input_channels
, int output_channels
, RouteGroup
* route_group
, uint32_t how_many
);
415 std::list
<boost::shared_ptr
<MidiTrack
> > new_midi_track (
416 TrackMode mode
= Normal
, RouteGroup
* route_group
= 0, uint32_t how_many
= 1
419 void remove_route (boost::shared_ptr
<Route
>);
420 void resort_routes ();
421 void resort_routes_using (boost::shared_ptr
<RouteList
>);
423 void set_remote_control_ids();
425 AudioEngine
& engine() { return _engine
; }
426 AudioEngine
const & engine () const { return _engine
; }
430 nframes64_t
transport_frame () const {return _transport_frame
; }
431 nframes64_t
audible_frame () const;
432 nframes64_t
requested_return_frame() const { return _requested_return_frame
; }
446 void sync_time_vars();
448 void bbt_time (nframes_t when
, BBT_Time
&);
449 void timecode_to_sample(Timecode::Time
& timecode
, nframes_t
& sample
, bool use_offset
, bool use_subframes
) const;
450 void sample_to_timecode(nframes_t sample
, Timecode::Time
& timecode
, bool use_offset
, bool use_subframes
) const;
451 void timecode_time (Timecode::Time
&);
452 void timecode_time (nframes_t when
, Timecode::Time
&);
453 void timecode_time_subframes (nframes_t when
, Timecode::Time
&);
455 void timecode_duration (nframes_t
, Timecode::Time
&) const;
456 void timecode_duration_string (char *, nframes_t
) const;
458 void set_timecode_offset (nframes_t
);
459 nframes_t
timecode_offset () const { return _timecode_offset
; }
460 void set_timecode_offset_negative (bool);
461 bool timecode_offset_negative () const { return _timecode_offset_negative
; }
463 nframes_t
convert_to_frames_at (nframes_t position
, AnyTime
const &);
465 static PBD::Signal0
<void> StartTimeChanged
;
466 static PBD::Signal0
<void> EndTimeChanged
;
467 static PBD::Signal0
<void> TimecodeOffsetChanged
;
469 std::vector
<SyncSource
> get_available_sync_options() const;
470 void request_sync_source (Slave
*);
471 bool synced_to_jack() const { return config
.get_external_sync() && config
.get_sync_source() == JACK
; }
473 double transport_speed() const { return _transport_speed
; }
474 bool transport_stopped() const { return _transport_speed
== 0.0f
; }
475 bool transport_rolling() const { return _transport_speed
!= 0.0f
; }
477 void set_silent (bool yn
);
478 bool silent () { return _silent
; }
480 int jack_slave_sync (nframes_t
);
482 TempoMap
& tempo_map() { return *_tempo_map
; }
484 /// signals the current transport position in frames, bbt and timecode time (in that order)
485 PBD::Signal3
<void,const nframes_t
&, const BBT_Time
&, const Timecode::Time
&> tick
;
489 boost::shared_ptr
<Region
> find_whole_file_parent (boost::shared_ptr
<Region
const>) const;
491 std::string
path_from_region_name (DataType type
, std::string name
, std::string identifier
);
493 boost::shared_ptr
<Region
> XMLRegionFactory (const XMLNode
&, bool full
);
494 boost::shared_ptr
<AudioRegion
> XMLAudioRegionFactory (const XMLNode
&, bool full
);
495 boost::shared_ptr
<MidiRegion
> XMLMidiRegionFactory (const XMLNode
&, bool full
);
497 /* source management */
499 void import_audiofiles (ImportStatus
&);
500 bool sample_rate_convert (ImportStatus
&, std::string infile
, std::string
& outfile
);
501 std::string
build_tmp_convert_name (std::string file
);
503 boost::shared_ptr
<ExportHandler
> get_export_handler ();
504 boost::shared_ptr
<ExportStatus
> get_export_status ();
506 int start_audio_export (nframes_t position
, bool realtime
);
508 PBD::Signal1
<int,nframes_t
> ProcessExport
;
509 static PBD::Signal2
<void,std::string
, std::string
> Exported
;
511 void add_source (boost::shared_ptr
<Source
>);
512 void remove_source (boost::weak_ptr
<Source
>);
514 int cleanup_sources (CleanupReport
&);
515 int cleanup_trash_sources (CleanupReport
&);
517 int destroy_sources (std::list
<boost::shared_ptr
<Source
> >);
519 int remove_last_capture ();
521 /** handlers should return -1 for "stop cleanup",
522 0 for "yes, delete this playlist",
523 1 for "no, don't delete this playlist".
525 static PBD::Signal1
<int,boost::shared_ptr
<Playlist
> > AskAboutPlaylistDeletion
;
527 /** handlers should return 0 for "ignore the rate mismatch",
528 !0 for "do not use this session"
530 static PBD::Signal2
<int,nframes_t
, nframes_t
> AskAboutSampleRateMismatch
;
532 /** handlers should return !0 for use pending state, 0 for ignore it.
534 static PBD::Signal0
<int> AskAboutPendingState
;
536 boost::shared_ptr
<AudioFileSource
> create_audio_source_for_session (size_t, std::string
const &, uint32_t,
537 bool destructive
, bool as_stub
= false);
539 boost::shared_ptr
<MidiSource
> create_midi_source_for_session (Track
*, std::string
const &, bool as_stub
= false);
541 boost::shared_ptr
<Source
> source_by_id (const PBD::ID
&);
542 boost::shared_ptr
<Source
> source_by_path_and_channel (const Glib::ustring
&, uint16_t);
544 void add_playlist (boost::shared_ptr
<Playlist
>, bool unused
= false);
546 /* named selections */
548 boost::shared_ptr
<NamedSelection
> named_selection_by_name (std::string name
);
549 void add_named_selection (boost::shared_ptr
<NamedSelection
>);
550 void remove_named_selection (boost::shared_ptr
<NamedSelection
>);
552 template<class T
> void foreach_named_selection (T
& obj
, void (T::*func
)(boost::shared_ptr
<NamedSelection
>));
553 PBD::Signal0
<void> NamedSelectionAdded
;
554 PBD::Signal0
<void> NamedSelectionRemoved
;
556 /* Curves and AutomationLists (TODO when they go away) */
557 void add_automation_list(AutomationList
*);
561 float get_default_fade_length () const { return default_fade_msecs
; }
562 float get_default_fade_steepness () const { return default_fade_steepness
; }
563 void set_default_fade (float steepness
, float msecs
);
567 boost::shared_ptr
<Auditioner
> the_auditioner() { return auditioner
; }
568 void audition_playlist ();
569 void audition_region (boost::shared_ptr
<Region
>);
570 void cancel_audition ();
571 bool is_auditioning () const;
573 PBD::Signal1
<void,bool> AuditionActive
;
575 /* flattening stuff */
577 boost::shared_ptr
<Region
> write_one_track (AudioTrack
&, nframes_t start
, nframes_t end
,
578 bool overwrite
, std::vector
<boost::shared_ptr
<Source
> >&, InterThreadInfo
& wot
,
579 bool enable_processing
= true);
580 int freeze_all (InterThreadInfo
&);
582 /* session-wide solo/mute/rec-enable */
584 bool soloing() const { return _non_soloed_outs_muted
; }
585 bool listening() const { return _listen_cnt
> 0; }
586 bool solo_isolated() const { return _solo_isolated_cnt
> 0; }
588 static const SessionEvent::RTeventCallback rt_cleanup
;
590 void set_solo (boost::shared_ptr
<RouteList
>, bool, SessionEvent::RTeventCallback after
= rt_cleanup
, bool group_override
= false);
591 void set_just_one_solo (boost::shared_ptr
<Route
>, bool, SessionEvent::RTeventCallback after
= rt_cleanup
);
592 void set_mute (boost::shared_ptr
<RouteList
>, bool, SessionEvent::RTeventCallback after
= rt_cleanup
, bool group_override
= false);
593 void set_listen (boost::shared_ptr
<RouteList
>, bool, SessionEvent::RTeventCallback after
= rt_cleanup
, bool group_override
= false);
594 void set_record_enable (boost::shared_ptr
<RouteList
>, bool, SessionEvent::RTeventCallback after
= rt_cleanup
, bool group_override
= false);
595 void set_solo_isolated (boost::shared_ptr
<RouteList
>, bool, SessionEvent::RTeventCallback after
= rt_cleanup
, bool group_override
= false);
597 PBD::Signal1
<void,bool> SoloActive
;
598 PBD::Signal0
<void> SoloChanged
;
599 PBD::Signal0
<void> IsolatedChanged
;
601 /* control/master out */
603 boost::shared_ptr
<Route
> monitor_out() const { return _monitor_out
; }
604 boost::shared_ptr
<Route
> master_out() const { return _master_out
; }
606 void globally_add_internal_sends (boost::shared_ptr
<Route
> dest
, Placement p
);
607 void globally_set_send_gains_from_track (boost::shared_ptr
<Route
> dest
);
608 void globally_set_send_gains_to_zero (boost::shared_ptr
<Route
> dest
);
609 void globally_set_send_gains_to_unity (boost::shared_ptr
<Route
> dest
);
610 void add_internal_sends (boost::shared_ptr
<Route
> dest
, Placement p
, boost::shared_ptr
<RouteList
> senders
);
612 static void set_disable_all_loaded_plugins (bool yn
) {
613 _disable_all_loaded_plugins
= yn
;
615 static bool get_disable_all_loaded_plugins() {
616 return _disable_all_loaded_plugins
;
619 uint32_t next_send_id();
620 uint32_t next_return_id();
621 uint32_t next_insert_id();
622 void mark_send_id (uint32_t);
623 void mark_return_id (uint32_t);
624 void mark_insert_id (uint32_t);
625 void unmark_send_id (uint32_t);
626 void unmark_return_id (uint32_t);
627 void unmark_insert_id (uint32_t);
629 /* s/w "RAID" management */
631 nframes_t
available_capture_duration();
635 void add_bundle (boost::shared_ptr
<Bundle
>);
636 void remove_bundle (boost::shared_ptr
<Bundle
>);
637 boost::shared_ptr
<Bundle
> bundle_by_name (std::string
) const;
639 PBD::Signal1
<void,boost::shared_ptr
<Bundle
> > BundleAdded
;
640 PBD::Signal1
<void,boost::shared_ptr
<Bundle
> > BundleRemoved
;
646 void start_scrub (nframes_t where
);
648 void set_scrub_speed (float);
649 nframes_t
scrub_buffer_size() const;
650 PBD::Signal0
<void> ScrubReady
;
652 /* History (for editors, mixers, UIs etc.) */
654 /** Undo some transactions.
655 * @param n Number of transactions to undo.
657 void undo (uint32_t n
) {
661 void redo (uint32_t n
) {
665 UndoHistory
& history() { return _history
; }
667 uint32_t undo_depth() const { return _history
.undo_depth(); }
668 uint32_t redo_depth() const { return _history
.redo_depth(); }
669 std::string
next_undo() const { return _history
.next_undo(); }
670 std::string
next_redo() const { return _history
.next_redo(); }
672 void begin_reversible_command (const std::string
& cmd_name
);
673 void commit_reversible_command (Command
* cmd
= 0);
675 UndoTransaction
* start_reversible_command (const std::string
& cmd_name
);
676 void finish_reversible_command (UndoTransaction
&);
678 void add_command (Command
*const cmd
) {
679 assert(!_current_trans
.empty ());
680 _current_trans
.top()->add_command (cmd
);
683 std::map
<PBD::ID
,PBD::StatefulDestructible
*> registry
;
685 // these commands are implemented in libs/ardour/session_command.cc
686 Command
* memento_command_factory(XMLNode
* n
);
687 Command
* stateful_diff_command_factory (XMLNode
*);
688 void register_with_memento_command_factory(PBD::ID
, PBD::StatefulDestructible
*);
692 boost::shared_ptr
<IO
> click_io() { return _click_io
; }
694 /* disk, buffer loads */
696 uint32_t playback_load ();
697 uint32_t capture_load ();
701 void request_play_range (std::list
<AudioRange
>*, bool leave_rolling
= false);
702 bool get_play_range () const { return _play_range
; }
704 /* buffers for gain and pan */
706 gain_t
* gain_automation_buffer () const;
707 pan_t
** pan_automation_buffer () const;
709 void ensure_buffer_set (BufferSet
& buffers
, const ChanCount
& howmany
);
713 static long vst_callback (AEffect
* effect
,
720 static PBD::Signal0
<void> SendFeedback
;
724 boost::shared_ptr
<PBD::Controllable
> controllable_by_id (const PBD::ID
&);
725 boost::shared_ptr
<PBD::Controllable
> controllable_by_descriptor (const PBD::ControllableDescriptor
&);
727 void add_controllable (boost::shared_ptr
<PBD::Controllable
>);
728 void remove_controllable (PBD::Controllable
*);
730 SessionMetadata
& metadata () { return *_metadata
; }
732 SessionConfiguration config
;
734 bool exporting () const {
738 /* this is a private enum, but setup_enum_writer() needs it,
739 and i can't find a way to give that function
743 enum PostTransportWork
{
744 PostTransportStop
= 0x1,
745 PostTransportDisableRecord
= 0x2,
746 PostTransportPosition
= 0x8,
747 PostTransportDidRecord
= 0x20,
748 PostTransportDuration
= 0x40,
749 PostTransportLocate
= 0x80,
750 PostTransportRoll
= 0x200,
751 PostTransportAbort
= 0x800,
752 PostTransportOverWrite
= 0x1000,
753 PostTransportSpeed
= 0x2000,
754 PostTransportAudition
= 0x4000,
755 PostTransportScrub
= 0x8000,
756 PostTransportReverse
= 0x10000,
757 PostTransportInputChange
= 0x20000,
758 PostTransportCurveRealloc
= 0x40000,
759 PostTransportClearSubstate
= 0x80000,
760 PostTransportAdjustPlaybackBuffering
= 0x100000,
761 PostTransportAdjustCaptureBuffering
= 0x200000
770 SlaveState
slave_state() const { return _slave_state
; }
772 boost::shared_ptr
<SessionPlaylists
> playlists
;
774 void send_mmc_locate (nframes64_t
);
775 int send_full_time_code (nframes64_t
);
777 PBD::Signal0
<void> RouteOrderKeyChanged
;
780 friend class AudioEngine
;
781 void set_block_size (nframes_t nframes
);
782 void set_frame_rate (nframes_t nframes
);
786 void schedule_curve_reallocation ();
787 void update_latency_compensation (bool, bool);
790 int create (const std::string
& mix_template
, BusProfile
*);
794 PendingDeclickIn
= 0x1,
795 PendingDeclickOut
= 0x2,
796 StopPendingCapture
= 0x4,
797 PendingLocate
= 0x20,
800 /* stuff used in process() should be close together to
804 typedef void (Session::*process_function_type
)(nframes_t
);
806 AudioEngine
& _engine
;
807 mutable gint processing_prohibited
;
808 process_function_type process_function
;
809 process_function_type last_process_function
;
810 bool waiting_for_sync_offset
;
811 nframes_t _base_frame_rate
;
812 nframes_t _current_frame_rate
; //this includes video pullup offset
813 nframes_t _nominal_frame_rate
; //ignores audioengine setting, "native" SR
814 int transport_sub_state
;
815 mutable gint _record_status
;
816 volatile nframes64_t _transport_frame
;
817 Location
* _session_range_location
; ///< session range, or 0 if there is nothing in the session yet
821 // varispeed playback
822 volatile double _transport_speed
;
823 double _last_transport_speed
;
824 double _target_transport_speed
;
825 CubicInterpolation interpolation
;
827 bool auto_play_legal
;
828 nframes64_t _last_slave_transport_frame
;
829 nframes_t maximum_output_latency
;
830 volatile nframes64_t _requested_return_frame
;
831 nframes_t current_block_size
;
832 nframes_t _worst_output_latency
;
833 nframes_t _worst_input_latency
;
834 nframes_t _worst_track_latency
;
837 float _meter_falloff
;
838 bool _non_soloed_outs_muted
;
839 uint32_t _listen_cnt
;
840 uint32_t _solo_isolated_cnt
;
844 void set_worst_io_latencies ();
845 void set_worst_io_latencies_x (IOChange
, void *) {
846 set_worst_io_latencies ();
849 void update_latency_compensation_proxy (void* ignored
);
851 void ensure_buffers (ChanCount howmany
= ChanCount::ZERO
);
853 void process_scrub (nframes_t
);
854 void process_without_events (nframes_t
);
855 void process_with_events (nframes_t
);
856 void process_audition (nframes_t
);
857 void process_export (nframes_t
);
858 int process_export_fw (nframes_t
);
860 void block_processing() { g_atomic_int_set (&processing_prohibited
, 1); }
861 void unblock_processing() { g_atomic_int_set (&processing_prohibited
, 0); }
862 bool processing_blocked() const { return g_atomic_int_get (&processing_prohibited
); }
864 Glib::Mutex process_thread_lock
;
865 std::list
<ProcessThread
*> process_threads
;
869 static const int delta_accumulator_size
= 25;
870 int delta_accumulator_cnt
;
871 int32_t delta_accumulator
[delta_accumulator_size
];
872 int32_t average_slave_delta
;
874 bool have_first_delta_accumulator
;
876 SlaveState _slave_state
;
877 nframes_t slave_wait_end
;
879 void reset_slave_state ();
880 bool follow_slave (nframes_t
);
881 void calculate_moving_average_of_slave_delta(int dir
, nframes_t this_delta
);
882 void track_slave_state(float slave_speed
, nframes_t slave_transport_frame
, nframes_t this_delta
);
883 void follow_slave_silently(nframes_t nframes
, float slave_speed
);
885 void switch_to_sync_source (SyncSource
); /* !RT context */
886 void drop_sync_source (); /* !RT context */
887 void use_sync_source (Slave
*); /* RT context */
889 bool post_export_sync
;
890 nframes_t post_export_position
;
893 bool _export_rolling
;
895 boost::shared_ptr
<ExportHandler
> export_handler
;
896 boost::shared_ptr
<ExportStatus
> export_status
;
899 int stop_audio_export ();
900 void finalize_audio_export ();
902 PBD::ScopedConnection export_freewheel_connection
;
904 void get_track_statistics ();
905 int process_routes (nframes_t
, bool& need_butler
);
906 int silent_process_routes (nframes_t
, bool& need_butler
);
908 bool get_rec_monitors_input () {
909 if (actively_recording()) {
912 if (config
.get_auto_input()) {
920 int get_transport_declick_required () {
921 if (transport_sub_state
& PendingDeclickIn
) {
922 transport_sub_state
&= ~PendingDeclickIn
;
924 } else if (transport_sub_state
& PendingDeclickOut
) {
931 bool maybe_stop (nframes_t limit
);
932 bool maybe_sync_start (nframes_t
&);
934 void check_declick_out ();
939 bool session_send_mtc
;
940 bool session_midi_feedback
;
943 nframes_t last_loopend
;
945 boost::scoped_ptr
<SessionDirectory
> _session_dir
;
948 void when_engine_running ();
949 void graph_reordered ();
951 std::string _current_snapshot_name
;
954 bool state_was_pending
;
955 StateOfTheState _state_of_the_state
;
958 int load_options (const XMLNode
&);
959 int load_state (std::string snapshot_name
);
961 nframes_t _last_roll_location
;
962 nframes_t _last_roll_or_reversal_location
;
963 nframes_t _last_record_location
;
965 bool pending_locate_roll
;
966 nframes_t pending_locate_frame
;
967 bool pending_locate_flush
;
969 bool pending_auto_loop
;
973 #if 0 // these should be here, see comments in their other location above
974 enum PostTransportWork
{
975 PostTransportStop
= 0x1,
976 PostTransportDisableRecord
= 0x2,
977 PostTransportPosition
= 0x8,
978 PostTransportDidRecord
= 0x20,
979 PostTransportDuration
= 0x40,
980 PostTransportLocate
= 0x80,
981 PostTransportRoll
= 0x200,
982 PostTransportAbort
= 0x800,
983 PostTransportOverWrite
= 0x1000,
984 PostTransportSpeed
= 0x2000,
985 PostTransportAudition
= 0x4000,
986 PostTransportScrub
= 0x8000,
987 PostTransportReverse
= 0x10000,
988 PostTransportInputChange
= 0x20000,
989 PostTransportCurveRealloc
= 0x40000,
990 PostTransportClearSubstate
= 0x80000
993 static const PostTransportWork ProcessCannotProceedMask
=
995 PostTransportInputChange
|
997 PostTransportReverse
|
998 PostTransportCurveRealloc
|
1000 PostTransportAudition
|
1001 PostTransportLocate
|
1003 PostTransportClearSubstate
);
1005 gint _post_transport_work
; /* accessed only atomic ops */
1006 PostTransportWork
post_transport_work() const { return (PostTransportWork
) g_atomic_int_get (&_post_transport_work
); }
1007 void set_post_transport_work (PostTransportWork ptw
) { g_atomic_int_set (&_post_transport_work
, (gint
) ptw
); }
1008 void add_post_transport_work (PostTransportWork ptw
);
1010 void schedule_playback_buffering_adjustment ();
1011 void schedule_capture_buffering_adjustment ();
1013 uint32_t cumulative_rf_motion
;
1016 void set_rf_speed (float speed
);
1017 void reset_rf_scale (nframes_t frames_moved
);
1019 Locations _locations
;
1020 void locations_changed ();
1021 void locations_added (Location
*);
1022 void handle_locations_changed (Locations::LocationList
&);
1024 PBD::ScopedConnectionList punch_connections
;
1025 void auto_punch_start_changed (Location
*);
1026 void auto_punch_end_changed (Location
*);
1027 void auto_punch_changed (Location
*);
1029 PBD::ScopedConnectionList loop_connections
;
1030 void auto_loop_changed (Location
*);
1032 void first_stage_init (std::string path
, std::string snapshot_name
);
1033 int second_stage_init ();
1034 void update_session_range_location_marker ();
1035 void remove_empty_sounds ();
1037 void setup_midi_control ();
1038 int midi_read (MIDI::Port
*);
1040 void enable_record ();
1042 void increment_transport_position (uint32_t val
) {
1043 if (max_frames
- val
< _transport_frame
) {
1044 _transport_frame
= max_frames
;
1046 _transport_frame
+= val
;
1050 void decrement_transport_position (uint32_t val
) {
1051 if (val
< _transport_frame
) {
1052 _transport_frame
-= val
;
1054 _transport_frame
= 0;
1058 void post_transport_motion ();
1059 static void *session_loader_thread (void *arg
);
1063 /* SessionEventManager interface */
1065 void process_event (SessionEvent
*);
1066 void set_next_event ();
1067 void cleanup_event (SessionEvent
*,int);
1069 /* MIDI Machine Control */
1071 void spp_start (MIDI::Parser
&, nframes_t timestamp
);
1072 void spp_continue (MIDI::Parser
&, nframes_t timestamp
);
1073 void spp_stop (MIDI::Parser
&, nframes_t timestamp
);
1075 void mmc_deferred_play (MIDI::MachineControl
&);
1076 void mmc_stop (MIDI::MachineControl
&);
1077 void mmc_step (MIDI::MachineControl
&, int);
1078 void mmc_pause (MIDI::MachineControl
&);
1079 void mmc_record_pause (MIDI::MachineControl
&);
1080 void mmc_record_strobe (MIDI::MachineControl
&);
1081 void mmc_record_exit (MIDI::MachineControl
&);
1082 void mmc_track_record_status (MIDI::MachineControl
&, uint32_t track
, bool enabled
);
1083 void mmc_fast_forward (MIDI::MachineControl
&);
1084 void mmc_rewind (MIDI::MachineControl
&);
1085 void mmc_locate (MIDI::MachineControl
&, const MIDI::byte
*);
1086 void mmc_shuttle (MIDI::MachineControl
&mmc
, float speed
, bool forw
);
1087 void mmc_record_enable (MIDI::MachineControl
&mmc
, size_t track
, bool enabled
);
1089 struct timeval last_mmc_step
;
1092 typedef boost::function
<bool()> MidiTimeoutCallback
;
1093 typedef std::list
<MidiTimeoutCallback
> MidiTimeoutList
;
1095 MidiTimeoutList midi_timeouts
;
1096 bool mmc_step_timeout ();
1098 MIDI::byte mtc_msg
[16];
1099 MIDI::byte mtc_timecode_bits
; /* encoding of SMTPE type for MTC */
1100 MIDI::byte midi_msg
[16];
1101 nframes_t outbound_mtc_timecode_frame
;
1102 Timecode::Time transmitting_timecode_time
;
1103 int next_quarter_frame_to_send
;
1105 double _frames_per_timecode_frame
; /* has to be floating point because of drop frame */
1106 nframes_t _frames_per_hour
;
1107 nframes_t _timecode_frames_per_hour
;
1108 nframes_t _timecode_offset
;
1109 bool _timecode_offset_negative
;
1111 /* cache the most-recently requested time conversions. This helps when we
1112 * have multiple clocks showing the same time (e.g. the transport frame) */
1113 bool last_timecode_valid
;
1114 nframes_t last_timecode_when
;
1115 Timecode::Time last_timecode
;
1117 bool _send_timecode_update
; ///< Flag to send a full frame (Timecode) MTC message this cycle
1119 int send_midi_time_code_for_cycle(nframes_t nframes
);
1121 nframes_t
adjust_apparent_position (nframes_t frames
);
1123 void reset_record_status ();
1125 int no_roll (nframes_t nframes
);
1126 int fail_roll (nframes_t nframes
);
1128 bool non_realtime_work_pending() const { return static_cast<bool>(post_transport_work()); }
1129 bool process_can_proceed() const { return !(post_transport_work() & ProcessCannotProceedMask
); }
1131 MidiControlUI
* midi_control_ui
;
1133 int start_midi_thread ();
1134 void terminate_midi_thread ();
1136 void set_play_loop (bool yn
);
1137 void unset_play_loop ();
1138 void overwrite_some_buffers (Track
*);
1139 void flush_all_inserts ();
1140 int micro_locate (nframes_t distance
);
1141 void locate (nframes64_t
, bool with_roll
, bool with_flush
, bool with_loop
=false, bool force
=false, bool with_mmc
=true);
1142 void start_locate (nframes64_t
, bool with_roll
, bool with_flush
, bool with_loop
=false, bool force
=false);
1143 void force_locate (nframes64_t frame
, bool with_roll
= false);
1144 void set_track_speed (Track
*, double speed
);
1145 void set_transport_speed (double speed
, bool abort
= false, bool clear_state
= false);
1146 void stop_transport (bool abort
= false, bool clear_state
= false);
1147 void start_transport ();
1148 void realtime_stop (bool abort
, bool clear_state
);
1149 void non_realtime_start_scrub ();
1150 void non_realtime_set_speed ();
1151 void non_realtime_locate ();
1152 void non_realtime_stop (bool abort
, int entry_request_count
, bool& finished
);
1153 void non_realtime_overwrite (int entry_request_count
, bool& finished
);
1154 void post_transport ();
1155 void engine_halted ();
1156 void xrun_recovery ();
1158 TempoMap
*_tempo_map
;
1159 void tempo_map_changed (const PBD::PropertyChange
&);
1161 /* edit/mix groups */
1163 int load_route_groups (const XMLNode
&, int);
1165 std::list
<RouteGroup
*> _route_groups
;
1169 boost::shared_ptr
<Graph
> route_graph
;
1171 SerializedRCUManager
<RouteList
> routes
;
1173 void add_routes (RouteList
&, bool save
);
1174 uint32_t destructive_index
;
1176 boost::shared_ptr
<Route
> XMLRouteFactory (const XMLNode
&, int);
1177 boost::shared_ptr
<Route
> XMLRouteFactory_2X (const XMLNode
&, int);
1179 void route_processors_changed (RouteProcessorChange
);
1181 bool find_route_name (const char* base
, uint32_t& id
, char* name
, size_t name_len
);
1182 void count_existing_route_channels (ChanCount
& in
, ChanCount
& out
);
1183 void auto_connect_route (boost::shared_ptr
<Route
> route
, ChanCount
& existing_inputs
, ChanCount
& existing_outputs
, bool connect_inputs
= true);
1187 bool solo_update_disabled
;
1189 void route_listen_changed (void *src
, boost::weak_ptr
<Route
>);
1190 void route_mute_changed (void *src
);
1191 void route_solo_changed (bool self_solo_change
, void *src
, boost::weak_ptr
<Route
>);
1192 void route_solo_isolated_changed (void *src
, boost::weak_ptr
<Route
>);
1193 void update_route_solo_state (boost::shared_ptr
<RouteList
> r
= boost::shared_ptr
<RouteList
>());
1195 void listen_position_changed ();
1196 void solo_control_mode_changed ();
1198 /* REGION MANAGEMENT */
1200 mutable Glib::Mutex region_lock
;
1202 int load_regions (const XMLNode
& node
);
1204 void route_group_changed ();
1208 mutable Glib::Mutex source_lock
;
1211 typedef std::map
<PBD::ID
,boost::shared_ptr
<Source
> > SourceMap
;
1217 SourceMap
get_sources() { return sources
; }
1220 int load_sources (const XMLNode
& node
);
1221 XMLNode
& get_sources_as_xml ();
1223 boost::shared_ptr
<Source
> XMLSourceFactory (const XMLNode
&);
1227 void remove_playlist (boost::weak_ptr
<Playlist
>);
1228 void playlist_length_changed ();
1229 void track_playlist_changed (boost::weak_ptr
<Track
>);
1231 /* NAMED SELECTIONS */
1233 mutable Glib::Mutex named_selection_lock
;
1234 typedef std::set
<boost::shared_ptr
<NamedSelection
> > NamedSelectionList
;
1235 NamedSelectionList named_selections
;
1237 int load_named_selections (const XMLNode
&);
1239 NamedSelection
*named_selection_factory (std::string name
);
1240 NamedSelection
*XMLNamedSelectionFactory (const XMLNode
&);
1242 /* CURVES and AUTOMATION LISTS */
1243 std::map
<PBD::ID
, AutomationList
*> automation_lists
;
1245 /* DEFAULT FADE CURVES */
1247 float default_fade_steepness
;
1248 float default_fade_msecs
;
1252 boost::shared_ptr
<Auditioner
> auditioner
;
1253 void set_audition (boost::shared_ptr
<Region
>);
1254 void non_realtime_set_audition ();
1255 boost::shared_ptr
<Region
> pending_audition_region
;
1261 int flatten_one_track (AudioTrack
&, nframes_t start
, nframes_t cnt
);
1263 /* INSERT AND SEND MANAGEMENT */
1265 boost::dynamic_bitset
<uint32_t> send_bitset
;
1266 boost::dynamic_bitset
<uint32_t> return_bitset
;
1267 boost::dynamic_bitset
<uint32_t> insert_bitset
;
1271 struct space_and_path
{
1272 uint32_t blocks
; /* 4kB blocks */
1280 struct space_and_path_ascending_cmp
{
1281 bool operator() (space_and_path a
, space_and_path b
) {
1282 return a
.blocks
> b
.blocks
;
1286 void setup_raid_path (std::string path
);
1288 std::vector
<space_and_path
> session_dirs
;
1289 std::vector
<space_and_path
>::iterator last_rr_session_dir
;
1290 uint32_t _total_free_4k_blocks
;
1291 Glib::Mutex space_lock
;
1293 std::string
get_best_session_directory_for_new_source ();
1295 mutable gint _playback_load
;
1296 mutable gint _capture_load
;
1300 SerializedRCUManager
<BundleList
> _bundles
;
1301 XMLNode
* _bundle_xml_node
;
1302 int load_bundles (XMLNode
const &);
1304 void reverse_track_buffers ();
1306 UndoHistory _history
;
1307 std::stack
<UndoTransaction
*> _current_trans
;
1309 void jack_timebase_callback (jack_transport_state_t
, nframes_t
, jack_position_t
*, int);
1310 int jack_sync_callback (jack_transport_state_t
, jack_position_t
*);
1311 void reset_jack_connection (jack_client_t
* jack
);
1312 void process_rtop (SessionEvent
*);
1314 XMLNode
& state(bool);
1320 boost::shared_ptr
<IO
> _click_io
;
1322 Sample
* click_emphasis_data
;
1323 nframes_t click_length
;
1324 nframes_t click_emphasis_length
;
1325 mutable Glib::RWLock click_lock
;
1327 static const Sample default_click
[];
1328 static const nframes_t default_click_length
;
1329 static const Sample default_click_emphasis
[];
1330 static const nframes_t default_click_emphasis_length
;
1333 void setup_click_sounds (int which
);
1334 void clear_clicks ();
1335 void click (nframes_t start
, nframes_t nframes
);
1337 std::vector
<Route
*> master_outs
;
1339 /* range playback */
1341 std::list
<AudioRange
> current_audio_range
;
1343 void set_play_range (std::list
<AudioRange
>&, bool leave_rolling
);
1344 void unset_play_range ();
1349 boost::shared_ptr
<Route
> _master_out
;
1350 boost::shared_ptr
<Route
> _monitor_out
;
1354 long _vst_callback (VSTPlugin
*,
1361 /* number of hardware ports we're using,
1362 based on max (requested,available)
1365 uint32_t n_physical_outputs
;
1366 uint32_t n_physical_inputs
;
1368 uint32_t n_physical_audio_outputs
;
1369 uint32_t n_physical_audio_inputs
;
1371 uint32_t n_physical_midi_outputs
;
1372 uint32_t n_physical_midi_inputs
;
1374 int find_all_sources (std::string path
, std::set
<std::string
>& result
);
1375 int find_all_sources_across_snapshots (std::set
<std::string
>& result
, bool exclude_this_snapshot
);
1377 typedef std::set
<boost::shared_ptr
<PBD::Controllable
> > Controllables
;
1378 Glib::Mutex controllables_lock
;
1379 Controllables controllables
;
1381 void reset_native_file_format();
1382 bool first_file_data_format_reset
;
1383 bool first_file_header_format_reset
;
1385 void config_changed (std::string
, bool);
1387 XMLNode
& get_control_protocol_state ();
1389 void set_history_depth (uint32_t depth
);
1390 void sync_order_keys ();
1392 static bool _disable_all_loaded_plugins
;
1394 SessionMetadata
* _metadata
;
1396 mutable bool have_looped
; ///< Used in ::audible_frame(*)
1398 void update_have_rec_enabled_track ();
1399 gint _have_rec_enabled_track
;
1401 static int ask_about_playlist_deletion (boost::shared_ptr
<Playlist
>);
1403 /* realtime "apply to set of routes" operations */
1404 SessionEvent
* get_rt_event (boost::shared_ptr
<RouteList
> rl
, bool yn
, SessionEvent::RTeventCallback after
, bool group_override
,
1405 void (Session::*method
) (boost::shared_ptr
<RouteList
>, bool, bool));
1407 void rt_set_solo (boost::shared_ptr
<RouteList
>, bool yn
, bool group_override
);
1408 void rt_set_just_one_solo (boost::shared_ptr
<RouteList
>, bool yn
, bool /* ignored*/ );
1409 void rt_set_mute (boost::shared_ptr
<RouteList
>, bool yn
, bool group_override
);
1410 void rt_set_listen (boost::shared_ptr
<RouteList
>, bool yn
, bool group_override
);
1411 void rt_set_solo_isolated (boost::shared_ptr
<RouteList
>, bool yn
, bool group_override
);
1412 void rt_set_record_enable (boost::shared_ptr
<RouteList
>, bool yn
, bool group_override
);
1414 /** temporary list of Diskstreams used only during load of 2.X sessions */
1415 std::list
<boost::shared_ptr
<Diskstream
> > _diskstreams_2X
;
1417 void add_session_range_location (nframes_t
, nframes_t
);
1419 void setup_midi_machine_control ();
1420 void cleanup_stubfiles ();
1422 void route_order_key_changed ();
1425 } // namespace ARDOUR
1427 #endif /* __ardour_session_h__ */