libs/ardour/ardour/session.h

   1 /*
   2     Copyright (C) 2000 Paul Davis
   3
   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.
   8
   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.
  13
  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.
  17
  18 */
  19
  20 #ifndef __ardour_session_h__
  21 #define __ardour_session_h__
  22
  23 #include <list>
  24 #include <map>
  25 #include <set>
  26 #include <stack>
  27 #include <string>
  28 #include <vector>
  29 #include <stdint.h>
  30
  31 #include <boost/dynamic_bitset.hpp>
  32 #include <boost/scoped_ptr.hpp>
  33 #include <boost/weak_ptr.hpp>
  34 #include <boost/utility.hpp>
  35
  36 #include <sndfile.h>
  37
  38 #include <glibmm/thread.h>
  39
  40 #include "pbd/error.h"
  41 #include "pbd/pool.h"
  42 #include "pbd/rcu.h"
  43 #include "pbd/statefuldestructible.h"
  44 #include "pbd/undo.h"
  45
  46 #include "midi++/mmc.h"
  47 #include "midi++/types.h"
  48
  49 #include "pbd/destructible.h"
  50 #include "pbd/stateful.h"
  51
  52 #include "ardour/ardour.h"
  53 #include "ardour/chan_count.h"
  54 #include "ardour/rc_configuration.h"
  55 #include "ardour/session_configuration.h"
  56 #include "ardour/location.h"
  57 #include "ardour/smpte.h"
  58 #include "ardour/interpolation.h"
  59
  60 class XMLTree;
  61 class XMLNode;
  62 class AEffect;
  63
  64 namespace MIDI {
  65         class Port;
  66 }
  67
  68 namespace PBD {
  69         class Controllable;
  70 }
  71
  72 namespace Evoral {
  73         class Curve;
  74 }
  75
  76 namespace ARDOUR {
  77
  78 class AudioDiskstream;
  79 class AudioEngine;
  80 class AudioFileSource;
  81 class AudioRegion;
  82 class AudioSource;
  83 class AudioTrack;
  84 class Auditioner;
  85 class AutomationList;
  86 class AuxInput;
  87 class BufferSet;
  88 class Bundle;
  89 class ControlProtocolInfo;
  90 class Diskstream;
  91 class ExportHandler;
  92 class ExportStatus;
  93 class IO;
  94 class IOProcessor;
  95 class MidiDiskstream;
  96 class MidiRegion;
  97 class MidiSource;
  98 class MidiTrack;
  99 class NamedSelection;
 100 class Playlist;
 101 class PluginInsert;
 102 class Port;
 103 class PortInsert;
 104 class Processor;
 105 class Region;
 106 class Return;
 107 class Route;
 108 class RouteGroup;
 109 class SMFSource;
 110 class Send;
 111 class SessionDirectory;
 112 class SessionMetadata;
 113 class Slave;
 114 class Source;
 115 class TempoMap;
 116 class VSTPlugin;
 117 class Butler;
 118
 119 class Session : public PBD::StatefulDestructible, public boost::noncopyable
 120 {
 121   private:
 122         typedef std::pair<boost::weak_ptr<Route>,bool> RouteBooleanState;
 123         typedef std::vector<RouteBooleanState> GlobalRouteBooleanState;
 124         typedef std::pair<boost::weak_ptr<Route>,MeterPoint> RouteMeterState;
 125         typedef std::vector<RouteMeterState> GlobalRouteMeterState;
 126
 127   public:
 128         enum RecordState {
 129                 Disabled = 0,
 130                 Enabled = 1,
 131                 Recording = 2
 132         };
 133
 134         struct Event {
 135                 enum Type {
 136                         SetTransportSpeed,
 137                         SetDiskstreamSpeed,
 138                         Locate,
 139                         LocateRoll,
 140                         LocateRollLocate,
 141                         SetLoop,
 142                         PunchIn,
 143                         PunchOut,
 144                         RangeStop,
 145                         RangeLocate,
 146                         Overwrite,
 147                         SetSlaveSource,
 148                         Audition,
 149                         InputConfigurationChange,
 150                         SetAudioRange,
 151                         SetPlayRange,
 152
 153                         /* only one of each of these events can be queued at any one time */
 154
 155                         StopOnce,
 156                         AutoLoop
 157                 };
 158
 159                 enum Action {
 160                         Add,
 161                         Remove,
 162                         Replace,
 163                         Clear
 164                 };
 165
 166                 Type             type;
 167                 Action           action;
 168                 nframes_t        action_frame;
 169                 nframes_t        target_frame;
 170                 double           speed;
 171
 172                 union {
 173                         void*        ptr;
 174                         bool         yes_or_no;
 175                         nframes_t    target2_frame;
 176                         SlaveSource  slave;
 177                         Route*       route;
 178                 };
 179
 180                 std::list<AudioRange> audio_range;
 181                 std::list<MusicRange> music_range;
 182
 183                 boost::shared_ptr<Region> region;
 184
 185                 Event(Type t, Action a, nframes_t when, nframes_t where, double spd, bool yn = false)
 186                         : type (t)
 187                         , action (a)
 188                         , action_frame (when)
 189                         , target_frame (where)
 190                         , speed (spd)
 191                         , yes_or_no (yn)
 192                 {}
 193
 194                 void set_ptr (void* p) {
 195                         ptr = p;
 196                 }
 197
 198                 bool before (const Event& other) const {
 199                         return action_frame < other.action_frame;
 200                 }
 201
 202                 bool after (const Event& other) const {
 203                         return action_frame > other.action_frame;
 204                 }
 205
 206                 static bool compare (const Event *e1, const Event *e2) {
 207                         return e1->before (*e2);
 208                 }
 209
 210                 void *operator new (size_t) {
 211                         return pool.alloc ();
 212                 }
 213
 214                 void operator delete (void *ptr, size_t /*size*/) {
 215                         pool.release (ptr);
 216                 }
 217
 218                 static const nframes_t Immediate = 0;
 219
 220                 private:
 221                 static MultiAllocSingleReleasePool pool;
 222         };
 223
 224         /* creating from an XML file */
 225
 226         Session (AudioEngine&,
 227                         const std::string& fullpath,
 228                         const std::string& snapshot_name,
 229                         std::string mix_template = "");
 230
 231         /* creating a new Session */
 232
 233         Session (AudioEngine&,
 234                         std::string fullpath,
 235                         std::string snapshot_name,
 236                         AutoConnectOption input_auto_connect,
 237                         AutoConnectOption output_auto_connect,
 238                         uint32_t control_out_channels,
 239                         uint32_t master_out_channels,
 240                         uint32_t n_physical_in,
 241                         uint32_t n_physical_out,
 242                         nframes_t initial_length);
 243
 244         virtual ~Session ();
 245
 246         std::string path() const { return _path; }
 247         std::string name() const { return _name; }
 248         std::string snap_name() const { return _current_snapshot_name; }
 249         std::string raid_path () const;
 250
 251         void set_snap_name ();
 252
 253         bool writable() const { return _writable; }
 254         void set_dirty ();
 255         void set_clean ();
 256         bool dirty() const { return _state_of_the_state & Dirty; }
 257         void set_deletion_in_progress ();
 258         void clear_deletion_in_progress ();
 259         bool deletion_in_progress() const { return _state_of_the_state & Deletion; }
 260         sigc::signal<void> DirtyChanged;
 261
 262         const SessionDirectory& session_directory () const { return *(_session_dir.get()); }
 263
 264         static sigc::signal<void> AutoBindingOn;
 265         static sigc::signal<void> AutoBindingOff;
 266
 267         static sigc::signal<void,std::string> Dialog;
 268
 269         std::string sound_dir (bool with_path = true) const;
 270         std::string peak_dir () const;
 271         std::string dead_sound_dir () const;
 272         std::string automation_dir () const;
 273         std::string analysis_dir() const;
 274
 275         int ensure_subdirs ();
 276
 277         Glib::ustring peak_path (Glib::ustring) const;
 278
 279         static std::string change_source_path_by_name (std::string oldpath, std::string oldname, std::string newname, bool destructive);
 280
 281         std::string peak_path_from_audio_path (std::string) const;
 282         std::string new_audio_source_name (const std::string&, uint32_t nchans, uint32_t chan, bool destructive);
 283         std::string new_midi_source_name (const std::string&);
 284         std::string new_source_path_from_name (DataType type, const std::string&);
 285         RouteList new_route_from_template (uint32_t how_many, const std::string& template_path);
 286
 287         void process (nframes_t nframes);
 288
 289         BufferSet& get_silent_buffers (ChanCount count = ChanCount::ZERO);
 290         BufferSet& get_scratch_buffers (ChanCount count = ChanCount::ZERO);
 291         BufferSet& get_mix_buffers (ChanCount count = ChanCount::ZERO);
 292
 293         void add_diskstream (boost::shared_ptr<Diskstream>);
 294         boost::shared_ptr<Diskstream> diskstream_by_id (const PBD::ID& id);
 295         boost::shared_ptr<Diskstream> diskstream_by_name (std::string name);
 296         bool have_rec_enabled_diskstream () const;
 297
 298         bool have_captured() const { return _have_captured; }
 299
 300         void refill_all_diskstream_buffers ();
 301         Butler* butler() { return _butler; }
 302         void butler_transport_work ();
 303
 304         uint32_t get_next_diskstream_id() const { return n_diskstreams(); }
 305         uint32_t n_diskstreams() const;
 306
 307         void refresh_disk_space ();
 308
 309         typedef std::list<boost::shared_ptr<Diskstream> > DiskstreamList;
 310
 311         SerializedRCUManager<DiskstreamList>& diskstream_list() { return diskstreams; }
 312
 313         int load_routes (const XMLNode&, int);
 314         boost::shared_ptr<RouteList> get_routes() const {
 315                 return routes.reader ();
 316         }
 317
 318         uint32_t nroutes() const { return routes.reader()->size(); }
 319         uint32_t ntracks () const;
 320         uint32_t nbusses () const;
 321
 322         boost::shared_ptr<BundleList> bundles () {
 323                 return _bundles.reader ();
 324         }
 325
 326         struct RoutePublicOrderSorter {
 327                 bool operator() (boost::shared_ptr<Route>, boost::shared_ptr<Route> b);
 328         };
 329
 330         void sync_order_keys (std::string const &);
 331
 332         template<class T> void foreach_route (T *obj, void (T::*func)(Route&));
 333         template<class T> void foreach_route (T *obj, void (T::*func)(boost::shared_ptr<Route>));
 334         template<class T, class A> void foreach_route (T *obj, void (T::*func)(Route&, A), A arg);
 335
 336         boost::shared_ptr<Route> route_by_name (std::string);
 337         boost::shared_ptr<Route> route_by_id (PBD::ID);
 338         boost::shared_ptr<Route> route_by_remote_id (uint32_t id);
 339
 340         bool route_name_unique (std::string) const;
 341         bool route_name_internal (std::string) const;
 342
 343         bool get_record_enabled() const {
 344                 return (record_status () >= Enabled);
 345         }
 346
 347         RecordState record_status() const {
 348                 return (RecordState) g_atomic_int_get (&_record_status);
 349         }
 350
 351         bool actively_recording () {
 352                 return record_status() == Recording;
 353         }
 354
 355         bool record_enabling_legal () const;
 356         void maybe_enable_record ();
 357         void disable_record (bool rt_context, bool force = false);
 358         void step_back_from_record ();
 359
 360         void maybe_write_autosave ();
 361
 362         /* Proxy signal for region hidden changes */
 363
 364         sigc::signal<void,boost::shared_ptr<Region> > RegionHiddenChange;
 365
 366         /* Emitted when all i/o connections are complete */
 367
 368         sigc::signal<void> IOConnectionsComplete;
 369
 370         /* Record status signals */
 371
 372         sigc::signal<void> RecordStateChanged;
 373
 374         /* Transport mechanism signals */
 375
 376         sigc::signal<void> TransportStateChange; /* generic */
 377         sigc::signal<void,nframes_t> PositionChanged; /* sent after any non-sequential motion */
 378         sigc::signal<void> DurationChanged;
 379         sigc::signal<void,nframes_t> Xrun;
 380         sigc::signal<void> TransportLooped;
 381
 382         /** emitted when a locate has occurred */
 383         sigc::signal<void> Located;
 384
 385         sigc::signal<void,RouteList&> RouteAdded;
 386         sigc::signal<void> RouteGroupChanged;
 387
 388         void request_roll_at_and_return (nframes_t start, nframes_t return_to);
 389         void request_bounded_roll (nframes_t start, nframes_t end);
 390         void request_stop (bool abort = false);
 391         void request_locate (nframes_t frame, bool with_roll = false);
 392
 393         void request_play_loop (bool yn);
 394         bool get_play_loop () const { return play_loop; }
 395
 396         nframes_t  last_transport_start() const { return _last_roll_location; }
 397         void goto_end ()   { request_locate (end_location->start(), false);}
 398         void goto_start () { request_locate (start_location->start(), false); }
 399         void set_session_start (nframes_t start) { start_location->set_start(start); }
 400         void set_session_end (nframes_t end) { end_location->set_start(end); config.set_end_marker_is_free (false); }
 401         void use_rf_shuttle_speed ();
 402         void allow_auto_play (bool yn);
 403         void request_transport_speed (double speed);
 404         void request_overwrite_buffer (Diskstream*);
 405         void request_diskstream_speed (Diskstream&, double speed);
 406         void request_input_change_handling ();
 407
 408         bool locate_pending() const { return static_cast<bool>(post_transport_work&PostTransportLocate); }
 409         bool transport_locked () const;
 410
 411         int wipe ();
 412
 413         int remove_region_from_region_list (boost::shared_ptr<Region>);
 414
 415         nframes_t get_maximum_extent () const;
 416         nframes_t current_end_frame() const { return end_location->start(); }
 417         nframes_t current_start_frame() const { return start_location->start(); }
 418         /// "actual" sample rate of session, set by current audioengine rate, pullup/down etc.
 419         nframes_t frame_rate() const   { return _current_frame_rate; }
 420         /// "native" sample rate of session, regardless of current audioengine rate, pullup/down etc
 421         nframes_t nominal_frame_rate() const   { return _nominal_frame_rate; }
 422         nframes_t frames_per_hour() const { return _frames_per_hour; }
 423
 424         double frames_per_smpte_frame() const { return _frames_per_smpte_frame; }
 425         nframes_t smpte_frames_per_hour() const { return _smpte_frames_per_hour; }
 426
 427         MIDI::byte get_mtc_smpte_bits() const {
 428                 return mtc_smpte_bits;   /* encoding of SMTPE type for MTC */
 429         }
 430
 431         float smpte_frames_per_second() const;
 432         bool smpte_drop_frames() const;
 433
 434         /* Locations */
 435
 436         Locations *locations() { return &_locations; }
 437
 438         sigc::signal<void,Location*>    auto_loop_location_changed;
 439         sigc::signal<void,Location*>    auto_punch_location_changed;
 440         sigc::signal<void>              locations_modified;
 441
 442         void set_auto_punch_location (Location *);
 443         void set_auto_loop_location (Location *);
 444         int location_name(std::string& result, std::string base = std::string(""));
 445
 446         void reset_input_monitor_state ();
 447
 448         void add_event (nframes_t action_frame, Event::Type type, nframes_t target_frame = 0);
 449         void remove_event (nframes_t frame, Event::Type type);
 450         void clear_events (Event::Type type);
 451
 452         nframes_t get_block_size()        const { return current_block_size; }
 453         nframes_t worst_output_latency () const { return _worst_output_latency; }
 454         nframes_t worst_input_latency ()  const { return _worst_input_latency; }
 455         nframes_t worst_track_latency ()  const { return _worst_track_latency; }
 456
 457         int save_state (std::string snapshot_name, bool pending = false);
 458         int restore_state (std::string snapshot_name);
 459         int save_template (std::string template_name);
 460         int save_history (std::string snapshot_name = "");
 461         int restore_history (std::string snapshot_name);
 462         void remove_state (std::string snapshot_name);
 463         void rename_state (std::string old_name, std::string new_name);
 464         void remove_pending_capture_state ();
 465
 466         static int rename_template (std::string old_name, std::string new_name);
 467         static int delete_template (std::string name);
 468
 469         sigc::signal<void,std::string> StateSaved;
 470         sigc::signal<void> StateReady;
 471
 472         std::vector<std::string*>* possible_states() const;
 473         static std::vector<std::string*>* possible_states (std::string path);
 474
 475         XMLNode& get_state();
 476         int      set_state(const XMLNode& node, int version); // not idempotent
 477         XMLNode& get_template();
 478
 479         /// The instant xml file is written to the session directory
 480         void add_instant_xml (XMLNode&, bool write_to_config = true);
 481         XMLNode* instant_xml (const std::string& str);
 482
 483         enum StateOfTheState {
 484                 Clean = 0x0,
 485                 Dirty = 0x1,
 486                 CannotSave = 0x2,
 487                 Deletion = 0x4,
 488                 InitialConnecting = 0x8,
 489                 Loading = 0x10,
 490                 InCleanup = 0x20
 491         };
 492
 493         StateOfTheState state_of_the_state() const { return _state_of_the_state; }
 494
 495         void add_route_group (RouteGroup *);
 496         void remove_route_group (RouteGroup&);
 497
 498         RouteGroup *route_group_by_name (std::string);
 499
 500         sigc::signal<void,RouteGroup*> route_group_added;
 501         sigc::signal<void>             route_group_removed;
 502
 503         void foreach_route_group (sigc::slot<void,RouteGroup*> sl) {
 504                 for (std::list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); i++) {
 505                         sl (*i);
 506                 }
 507         }
 508
 509         /* fundamental operations. duh. */
 510
 511         std::list<boost::shared_ptr<AudioTrack> > new_audio_track (
 512                 int input_channels, int output_channels, TrackMode mode = Normal, RouteGroup* route_group = 0, uint32_t how_many = 1
 513                 );
 514
 515         RouteList new_audio_route (int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many);
 516
 517         std::list<boost::shared_ptr<MidiTrack> > new_midi_track (
 518                 TrackMode mode = Normal, RouteGroup* route_group = 0, uint32_t how_many = 1
 519                 );
 520
 521         void   remove_route (boost::shared_ptr<Route>);
 522         void   resort_routes ();
 523         void   resort_routes_using (boost::shared_ptr<RouteList>);
 524
 525         void   set_remote_control_ids();
 526
 527         AudioEngine & engine() { return _engine; }
 528         AudioEngine const & engine () const { return _engine; }
 529
 530         int32_t  max_level;
 531         int32_t  min_level;
 532
 533         /* Time */
 534
 535         nframes_t transport_frame () const {return _transport_frame; }
 536         nframes_t audible_frame () const;
 537         nframes64_t requested_return_frame() const { return _requested_return_frame; }
 538
 539         enum PullupFormat {
 540                 pullup_Plus4Plus1,
 541                 pullup_Plus4,
 542                 pullup_Plus4Minus1,
 543                 pullup_Plus1,
 544                 pullup_None,
 545                 pullup_Minus1,
 546                 pullup_Minus4Plus1,
 547                 pullup_Minus4,
 548                 pullup_Minus4Minus1
 549         };
 550
 551         void sync_time_vars();
 552
 553         void bbt_time (nframes_t when, BBT_Time&);
 554         void smpte_to_sample(SMPTE::Time& smpte, nframes_t& sample, bool use_offset, bool use_subframes) const;
 555         void sample_to_smpte(nframes_t sample, SMPTE::Time& smpte, bool use_offset, bool use_subframes) const;
 556         void smpte_time (SMPTE::Time &);
 557         void smpte_time (nframes_t when, SMPTE::Time&);
 558         void smpte_time_subframes (nframes_t when, SMPTE::Time&);
 559
 560         void smpte_duration (nframes_t, SMPTE::Time&) const;
 561         void smpte_duration_string (char *, nframes_t) const;
 562
 563         void           set_smpte_offset (nframes_t);
 564         nframes_t      smpte_offset () const { return _smpte_offset; }
 565         void           set_smpte_offset_negative (bool);
 566         bool           smpte_offset_negative () const { return _smpte_offset_negative; }
 567
 568         nframes_t convert_to_frames_at (nframes_t position, AnyTime const &);
 569
 570         static sigc::signal<void> StartTimeChanged;
 571         static sigc::signal<void> EndTimeChanged;
 572         static sigc::signal<void> SMPTEOffsetChanged;
 573
 574         void   request_slave_source (SlaveSource);
 575         bool   synced_to_jack() const { return Config->get_slave_source() == JACK; }
 576
 577         double transport_speed() const { return _transport_speed; }
 578         bool   transport_stopped() const { return _transport_speed == 0.0f; }
 579         bool   transport_rolling() const { return _transport_speed != 0.0f; }
 580
 581         void set_silent (bool yn);
 582         bool silent () { return _silent; }
 583
 584         int jack_slave_sync (nframes_t);
 585
 586         TempoMap& tempo_map() { return *_tempo_map; }
 587
 588         /// signals the current transport position in frames, bbt and smpte time (in that order)
 589         sigc::signal<void, const nframes_t&, const BBT_Time&, const SMPTE::Time&> tick;
 590
 591         /* region info  */
 592
 593         void add_regions (std::vector<boost::shared_ptr<Region> >&);
 594
 595         sigc::signal<void,boost::weak_ptr<Region> > RegionAdded;
 596         sigc::signal<void,std::vector<boost::weak_ptr<Region> >& > RegionsAdded;
 597         sigc::signal<void,boost::weak_ptr<Region> > RegionRemoved;
 598
 599         int region_name (std::string& result, std::string base = std::string(""), bool newlevel = false);
 600         std::string new_region_name (std::string);
 601         std::string path_from_region_name (DataType type, std::string name, std::string identifier);
 602
 603         boost::shared_ptr<Region> find_whole_file_parent (boost::shared_ptr<Region const>);
 604
 605         void find_equivalent_playlist_regions (boost::shared_ptr<Region>, std::vector<boost::shared_ptr<Region> >& result);
 606
 607         boost::shared_ptr<Region>      XMLRegionFactory (const XMLNode&, bool full);
 608         boost::shared_ptr<AudioRegion> XMLAudioRegionFactory (const XMLNode&, bool full);
 609         boost::shared_ptr<MidiRegion>  XMLMidiRegionFactory (const XMLNode&, bool full);
 610
 611         template<class T> void foreach_region (T *obj, void (T::*func)(boost::shared_ptr<Region>));
 612
 613         /* source management */
 614
 615         struct ImportStatus : public InterThreadInfo {
 616                 std::string doing_what;
 617
 618                 /* control info */
 619                 uint32_t total;
 620                 SrcQuality quality;
 621                 volatile bool freeze;
 622                 std::vector<Glib::ustring> paths;
 623                 bool replace_existing_source;
 624
 625                 /* result */
 626                 SourceList sources;
 627         };
 628
 629         void import_audiofiles (ImportStatus&);
 630         bool sample_rate_convert (ImportStatus&, std::string infile, std::string& outfile);
 631         std::string build_tmp_convert_name (std::string file);
 632
 633         boost::shared_ptr<ExportHandler> get_export_handler ();
 634         boost::shared_ptr<ExportStatus> get_export_status ();
 635
 636         int  start_audio_export (nframes_t position, bool realtime);
 637
 638         sigc::signal<int, nframes_t> ProcessExport;
 639         sigc::signal<void> ExportReadFinished;
 640         static sigc::signal<void, std::string, std::string> Exported;
 641
 642         void add_source (boost::shared_ptr<Source>);
 643         void remove_source (boost::weak_ptr<Source>);
 644
 645         struct cleanup_report {
 646                 std::vector<std::string> paths;
 647                 int64_t        space;
 648         };
 649
 650         int  cleanup_sources (cleanup_report&);
 651         int  cleanup_trash_sources (cleanup_report&);
 652
 653         int destroy_region (boost::shared_ptr<Region>);
 654         int destroy_regions (std::list<boost::shared_ptr<Region> >);
 655
 656         int remove_last_capture ();
 657
 658         /** handlers should return -1 for "stop cleanup",
 659             0 for "yes, delete this playlist",
 660             1 for "no, don't delete this playlist".
 661         */
 662         sigc::signal<int,boost::shared_ptr<ARDOUR::Playlist> > AskAboutPlaylistDeletion;
 663
 664         /** handlers should return 0 for "ignore the rate mismatch",
 665             !0 for "do not use this session"
 666         */
 667         static sigc::signal<int,nframes_t, nframes_t> AskAboutSampleRateMismatch;
 668
 669         /** handlers should return !0 for use pending state, 0 for ignore it.
 670         */
 671         static sigc::signal<int> AskAboutPendingState;
 672
 673         boost::shared_ptr<AudioFileSource> create_audio_source_for_session (ARDOUR::AudioDiskstream&, uint32_t which_channel, bool destructive);
 674
 675         boost::shared_ptr<MidiSource> create_midi_source_for_session (ARDOUR::MidiDiskstream&);
 676
 677         boost::shared_ptr<Source> source_by_id (const PBD::ID&);
 678         boost::shared_ptr<Source> source_by_path_and_channel (const Glib::ustring&, uint16_t);
 679
 680         /* playlist management */
 681
 682         boost::shared_ptr<Playlist> playlist_by_name (std::string name);
 683         void unassigned_playlists (std::list<boost::shared_ptr<Playlist> > & list);
 684         void add_playlist (boost::shared_ptr<Playlist>, bool unused = false);
 685         sigc::signal<void,boost::shared_ptr<Playlist> > PlaylistAdded;
 686         sigc::signal<void,boost::shared_ptr<Playlist> > PlaylistRemoved;
 687
 688         uint32_t n_playlists() const;
 689
 690         template<class T> void foreach_playlist (T *obj, void (T::*func)(boost::shared_ptr<Playlist>));
 691         void get_playlists (std::vector<boost::shared_ptr<Playlist> >&);
 692
 693         /* named selections */
 694
 695         NamedSelection* named_selection_by_name (std::string name);
 696         void add_named_selection (NamedSelection *);
 697         void remove_named_selection (NamedSelection *);
 698
 699         template<class T> void foreach_named_selection (T& obj, void (T::*func)(NamedSelection&));
 700         sigc::signal<void> NamedSelectionAdded;
 701         sigc::signal<void> NamedSelectionRemoved;
 702
 703         /* Curves and AutomationLists (TODO when they go away) */
 704         void add_automation_list(AutomationList*);
 705
 706         /* fade curves */
 707
 708         float get_default_fade_length () const { return default_fade_msecs; }
 709         float get_default_fade_steepness () const { return default_fade_steepness; }
 710         void set_default_fade (float steepness, float msecs);
 711
 712         /* auditioning */
 713
 714         boost::shared_ptr<Auditioner> the_auditioner() { return auditioner; }
 715         void audition_playlist ();
 716         void audition_region (boost::shared_ptr<Region>);
 717         void cancel_audition ();
 718         bool is_auditioning () const;
 719
 720         sigc::signal<void,bool> AuditionActive;
 721
 722         /* flattening stuff */
 723
 724         boost::shared_ptr<Region> write_one_track (AudioTrack&, nframes_t start, nframes_t end,
 725                         bool overwrite, std::vector<boost::shared_ptr<Source> >&, InterThreadInfo& wot,
 726                         bool enable_processing = true);
 727         int freeze (InterThreadInfo&);
 728
 729         /* session-wide solo/mute/rec-enable */
 730
 731         bool soloing() const { return _non_soloed_outs_muted; }
 732         bool listening() const { return _listen_cnt > 0; }
 733
 734         void set_all_solo (bool);
 735         void set_all_mute (bool);
 736         void set_all_listen (bool);
 737
 738         sigc::signal<void,bool> SoloActive;
 739         sigc::signal<void> SoloChanged;
 740
 741         void record_disenable_all ();
 742         void record_enable_all ();
 743
 744         /* control/master out */
 745
 746         boost::shared_ptr<Route> control_out() const { return _control_out; }
 747         boost::shared_ptr<Route> master_out() const { return _master_out; }
 748
 749         void globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p);
 750         void globally_set_send_gains_from_track (boost::shared_ptr<Route> dest);
 751         void globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest);
 752         void globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest);
 753         void add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders);
 754
 755         static void set_disable_all_loaded_plugins (bool yn) {
 756                 _disable_all_loaded_plugins = yn;
 757         }
 758         static bool get_disable_all_loaded_plugins() {
 759                 return _disable_all_loaded_plugins;
 760         }
 761
 762         uint32_t next_send_id();
 763         uint32_t next_return_id();
 764         uint32_t next_insert_id();
 765         void mark_send_id (uint32_t);
 766         void mark_return_id (uint32_t);
 767         void mark_insert_id (uint32_t);
 768
 769         /* s/w "RAID" management */
 770
 771         nframes_t available_capture_duration();
 772
 773         /* I/O bundles */
 774
 775         void add_bundle (boost::shared_ptr<Bundle>);
 776         void remove_bundle (boost::shared_ptr<Bundle>);
 777         boost::shared_ptr<Bundle> bundle_by_name (std::string) const;
 778
 779         sigc::signal<void,boost::shared_ptr<Bundle> > BundleAdded;
 780         sigc::signal<void,boost::shared_ptr<Bundle> > BundleRemoved;
 781
 782         /* MIDI control */
 783
 784         void midi_panic(void);
 785         int set_mtc_port (std::string port_tag);
 786         int set_mmc_port (std::string port_tag);
 787         int set_midi_port (std::string port_tag);
 788         int set_midi_clock_port (std::string port_tag);
 789         MIDI::Port *mtc_port() const { return _mtc_port; }
 790         MIDI::Port *mmc_port() const { return _mmc_port; }
 791         MIDI::Port *midi_port() const { return _midi_port; }
 792         MIDI::Port *midi_clock_port() const { return _midi_clock_port; }
 793
 794         sigc::signal<void> MTC_PortChanged;
 795         sigc::signal<void> MMC_PortChanged;
 796         sigc::signal<void> MIDI_PortChanged;
 797         sigc::signal<void> MIDIClock_PortChanged;
 798
 799         void set_trace_midi_input (bool, MIDI::Port* port = 0);
 800         void set_trace_midi_output (bool, MIDI::Port* port = 0);
 801
 802         bool get_trace_midi_input(MIDI::Port *port = 0);
 803         bool get_trace_midi_output(MIDI::Port *port = 0);
 804
 805         void set_mmc_receive_device_id (uint32_t id);
 806         void set_mmc_send_device_id (uint32_t id);
 807
 808         /* Scrubbing */
 809
 810         void start_scrub (nframes_t where);
 811         void stop_scrub ();
 812         void set_scrub_speed (float);
 813         nframes_t scrub_buffer_size() const;
 814         sigc::signal<void> ScrubReady;
 815
 816         /* History (for editors, mixers, UIs etc.) */
 817
 818         /** Undo some transactions.
 819          * @param n Number of transactions to undo.
 820          */
 821         void undo (uint32_t n) {
 822                 _history.undo (n);
 823         }
 824
 825         void redo (uint32_t n) {
 826                 _history.redo (n);
 827         }
 828
 829         UndoHistory& history() { return _history; }
 830
 831         uint32_t undo_depth() const { return _history.undo_depth(); }
 832         uint32_t redo_depth() const { return _history.redo_depth(); }
 833         std::string next_undo() const { return _history.next_undo(); }
 834         std::string next_redo() const { return _history.next_redo(); }
 835
 836         void begin_reversible_command (const std::string& cmd_name);
 837         void commit_reversible_command (Command* cmd = 0);
 838
 839         void add_command (Command *const cmd) {
 840                 assert(!_current_trans.empty ());
 841                 _current_trans.top()->add_command (cmd);
 842         }
 843
 844         std::map<PBD::ID, PBD::StatefulThingWithGoingAway*> registry;
 845
 846         // these commands are implemented in libs/ardour/session_command.cc
 847         Command* memento_command_factory(XMLNode* n);
 848         void register_with_memento_command_factory(PBD::ID, PBD::StatefulThingWithGoingAway*);
 849
 850         Command* global_state_command_factory (const XMLNode& n);
 851
 852         class GlobalRouteStateCommand : public Command
 853         {
 854         public:
 855                 GlobalRouteStateCommand (Session&, void*);
 856                 GlobalRouteStateCommand (Session&, const XMLNode& node);
 857                 int set_state (const XMLNode&, int version);
 858                 XMLNode& get_state ();
 859
 860         protected:
 861                 GlobalRouteBooleanState before, after;
 862                 Session& sess;
 863                 void* src;
 864         };
 865
 866         class GlobalSoloStateCommand : public GlobalRouteStateCommand
 867         {
 868         public:
 869                 GlobalSoloStateCommand (Session &, void *src);
 870                 GlobalSoloStateCommand (Session&, const XMLNode&);
 871                 void operator()(); //redo
 872                 void undo();
 873                 XMLNode &get_state();
 874                 void mark();
 875         };
 876
 877         class GlobalMuteStateCommand : public GlobalRouteStateCommand
 878         {
 879         public:
 880                 GlobalMuteStateCommand(Session &, void *src);
 881                 GlobalMuteStateCommand (Session&, const XMLNode&);
 882                 void operator()(); // redo
 883                 void undo();
 884                 XMLNode &get_state();
 885                 void mark();
 886         };
 887
 888         class GlobalRecordEnableStateCommand : public GlobalRouteStateCommand
 889         {
 890         public:
 891                 GlobalRecordEnableStateCommand(Session &, void *src);
 892                 GlobalRecordEnableStateCommand (Session&, const XMLNode&);
 893                 void operator()(); // redo
 894                 void undo();
 895                 XMLNode &get_state();
 896                 void mark();
 897         };
 898
 899         class GlobalMeteringStateCommand : public Command
 900         {
 901         public:
 902                 GlobalMeteringStateCommand(Session &, void *src);
 903                 GlobalMeteringStateCommand (Session&, const XMLNode&);
 904                 void operator()();
 905                 void undo();
 906                 XMLNode &get_state();
 907                 int set_state (const XMLNode&, int version);
 908                 void mark();
 909
 910         protected:
 911                 Session& sess;
 912                 void* src;
 913                 GlobalRouteMeterState before;
 914                 GlobalRouteMeterState after;
 915         };
 916
 917         /* clicking */
 918
 919         boost::shared_ptr<IO> click_io() { return _click_io; }
 920
 921         /* disk, buffer loads */
 922
 923         uint32_t playback_load ();
 924         uint32_t capture_load ();
 925         uint32_t playback_load_min ();
 926         uint32_t capture_load_min ();
 927
 928         void reset_playback_load_min ();
 929         void reset_capture_load_min ();
 930
 931         /* ranges */
 932
 933         void set_audio_range (std::list<AudioRange>&);
 934         void set_music_range (std::list<MusicRange>&);
 935
 936         void request_play_range (bool yn);
 937         bool get_play_range () const { return _play_range; }
 938
 939         /* buffers for gain and pan */
 940
 941         gain_t* gain_automation_buffer () const { return _gain_automation_buffer; }
 942         pan_t** pan_automation_buffer () const  { return _pan_automation_buffer; }
 943
 944         void ensure_buffer_set (BufferSet& buffers, const ChanCount& howmany);
 945
 946         /* VST support */
 947
 948         static long vst_callback (AEffect* effect,
 949                         long opcode,
 950                         long index,
 951                         long value,
 952                         void* ptr,
 953                         float opt);
 954
 955         static sigc::signal<void> SendFeedback;
 956
 957         /* Controllables */
 958
 959         boost::shared_ptr<PBD::Controllable> controllable_by_id (const PBD::ID&);
 960
 961         void add_controllable (boost::shared_ptr<PBD::Controllable>);
 962         void remove_controllable (PBD::Controllable*);
 963
 964         SessionMetadata & metadata () { return *_metadata; }
 965
 966         SessionConfiguration config;
 967
 968         bool exporting () const {
 969                 return _exporting;
 970         }
 971
 972   protected:
 973         friend class AudioEngine;
 974         void set_block_size (nframes_t nframes);
 975         void set_frame_rate (nframes_t nframes);
 976
 977   protected:
 978         friend class Diskstream;
 979
 980   protected:
 981         friend class Route;
 982         void schedule_curve_reallocation ();
 983         void update_latency_compensation (bool, bool);
 984
 985   private:
 986         int  create (bool& new_session, const std::string& mix_template, nframes_t initial_length);
 987         void destroy ();
 988
 989         nframes_t compute_initial_length ();
 990
 991         enum SubState {
 992                 PendingDeclickIn   = 0x1,
 993                 PendingDeclickOut  = 0x2,
 994                 StopPendingCapture = 0x4,
 995                 AutoReturning      = 0x10,
 996                 PendingLocate      = 0x20,
 997                 PendingSetLoop     = 0x40
 998         };
 999
1000         /* stuff used in process() should be close together to
1001            maximise cache hits
1002         */
1003
1004         typedef void (Session::*process_function_type)(nframes_t);
1005
1006         AudioEngine&            _engine;
1007         mutable gint             processing_prohibited;
1008         process_function_type    process_function;
1009         process_function_type    last_process_function;
1010         bool                     waiting_for_sync_offset;
1011         nframes_t               _base_frame_rate;
1012         nframes_t               _current_frame_rate;  //this includes video pullup offset
1013         nframes_t               _nominal_frame_rate;  //ignores audioengine setting, "native" SR
1014         int                      transport_sub_state;
1015         mutable gint            _record_status;
1016         volatile nframes_t      _transport_frame;
1017         Location*                end_location;
1018         Location*                start_location;
1019         Slave*                  _slave;
1020         bool                    _silent;
1021
1022     // varispeed playback
1023         volatile double             _transport_speed;
1024         double                      _last_transport_speed;
1025         double                      _target_transport_speed;
1026         CubicInterpolation          interpolation;
1027
1028         bool                     auto_play_legal;
1029         nframes_t               _last_slave_transport_frame;
1030         nframes_t                maximum_output_latency;
1031         volatile nframes64_t    _requested_return_frame;
1032         BufferSet*              _scratch_buffers;
1033         BufferSet*              _silent_buffers;
1034         BufferSet*              _mix_buffers;
1035         nframes_t                current_block_size;
1036         nframes_t               _worst_output_latency;
1037         nframes_t               _worst_input_latency;
1038         nframes_t               _worst_track_latency;
1039         bool                    _have_captured;
1040         float                   _meter_hold;
1041         float                   _meter_falloff;
1042         bool                    _non_soloed_outs_muted;
1043         uint32_t                _listen_cnt;
1044         bool                    _writable;
1045
1046         void set_worst_io_latencies ();
1047         void set_worst_io_latencies_x (IOChange, void *) {
1048                 set_worst_io_latencies ();
1049         }
1050
1051         void update_latency_compensation_proxy (void* ignored);
1052
1053         void ensure_buffers (ChanCount howmany);
1054
1055         void process_scrub          (nframes_t);
1056         void process_without_events (nframes_t);
1057         void process_with_events    (nframes_t);
1058         void process_audition       (nframes_t);
1059         void process_export         (nframes_t);
1060         int  process_export_fw      (nframes_t);
1061
1062         void block_processing() { g_atomic_int_set (&processing_prohibited, 1); }
1063         void unblock_processing() { g_atomic_int_set (&processing_prohibited, 0); }
1064         bool processing_blocked() const { return g_atomic_int_get (&processing_prohibited); }
1065
1066         /* slave tracking */
1067
1068         static const int delta_accumulator_size = 25;
1069         int delta_accumulator_cnt;
1070         long delta_accumulator[delta_accumulator_size];
1071         long average_slave_delta;
1072         int  average_dir;
1073         bool have_first_delta_accumulator;
1074
1075         enum SlaveState {
1076                 Stopped,
1077                 Waiting,
1078                 Running
1079         };
1080
1081         SlaveState slave_state;
1082         nframes_t slave_wait_end;
1083
1084         void reset_slave_state ();
1085         bool follow_slave (nframes_t);
1086         void calculate_moving_average_of_slave_delta(int dir, nframes_t this_delta);
1087         void track_slave_state(float slave_speed, nframes_t slave_transport_frame,
1088                                nframes_t this_delta, bool starting);
1089         void follow_slave_silently(nframes_t nframes, float slave_speed);
1090
1091         void set_slave_source (SlaveSource);
1092
1093         SlaveSource post_export_slave;
1094         nframes_t post_export_position;
1095
1096         bool _exporting;
1097         bool _exporting_realtime;
1098
1099         boost::shared_ptr<ExportHandler> export_handler;
1100         boost::shared_ptr<ExportStatus>  export_status;
1101
1102         int  pre_export ();
1103         int  stop_audio_export ();
1104         void finalize_audio_export ();
1105
1106         sigc::connection export_freewheel_connection;
1107
1108         void prepare_diskstreams ();
1109         void commit_diskstreams (nframes_t, bool& session_requires_butler);
1110         int  process_routes (nframes_t);
1111         int  silent_process_routes (nframes_t);
1112
1113         bool get_rec_monitors_input () {
1114                 if (actively_recording()) {
1115                         return true;
1116                 } else {
1117                         if (config.get_auto_input()) {
1118                                 return false;
1119                         } else {
1120                                 return true;
1121                         }
1122                 }
1123         }
1124
1125         int get_transport_declick_required () {
1126                 if (transport_sub_state & PendingDeclickIn) {
1127                         transport_sub_state &= ~PendingDeclickIn;
1128                         return 1;
1129                 } else if (transport_sub_state & PendingDeclickOut) {
1130                         return -1;
1131                 } else {
1132                         return 0;
1133                 }
1134         }
1135
1136         bool maybe_stop (nframes_t limit) {
1137                 if ( (_transport_speed > 0.0f && _transport_frame >= limit)
1138                                 || (_transport_speed < 0.0f && _transport_frame == 0) ) {
1139                         stop_transport ();
1140                         return true;
1141                 }
1142                 return false;
1143         }
1144
1145         bool maybe_sync_start (nframes_t&);
1146
1147         void check_declick_out ();
1148
1149         MIDI::MachineControl*    mmc;
1150         MIDI::Port*             _mmc_port;
1151         MIDI::Port*             _mtc_port;
1152         MIDI::Port*             _midi_port;
1153         MIDI::Port*             _midi_clock_port;
1154         std::string             _path;
1155         std::string             _name;
1156         bool                     session_send_mmc;
1157         bool                     session_send_mtc;
1158         bool                     session_midi_feedback;
1159         bool                     play_loop;
1160         bool                     loop_changing;
1161         nframes_t                last_loopend;
1162
1163         boost::scoped_ptr<SessionDirectory> _session_dir;
1164
1165         RingBuffer<Event*> pending_events;
1166
1167         void hookup_io ();
1168         void when_engine_running ();
1169         void graph_reordered ();
1170
1171         std::string _current_snapshot_name;
1172
1173         XMLTree*         state_tree;
1174         bool             state_was_pending;
1175         StateOfTheState _state_of_the_state;
1176
1177         void     auto_save();
1178         int      load_options (const XMLNode&);
1179         int      load_state (std::string snapshot_name);
1180
1181         nframes_t _last_roll_location;
1182         nframes_t _last_record_location;
1183
1184         bool              pending_locate_roll;
1185         nframes_t         pending_locate_frame;
1186         bool              pending_locate_flush;
1187         bool              pending_abort;
1188         bool              pending_auto_loop;
1189
1190         Butler* _butler;
1191
1192         enum PostTransportWork {
1193                 PostTransportStop               = 0x1,
1194                 PostTransportDisableRecord      = 0x2,
1195                 PostTransportPosition           = 0x8,
1196                 PostTransportDidRecord          = 0x20,
1197                 PostTransportDuration           = 0x40,
1198                 PostTransportLocate             = 0x80,
1199                 PostTransportRoll               = 0x200,
1200                 PostTransportAbort              = 0x800,
1201                 PostTransportOverWrite          = 0x1000,
1202                 PostTransportSpeed              = 0x2000,
1203                 PostTransportAudition           = 0x4000,
1204                 PostTransportScrub              = 0x8000,
1205                 PostTransportReverse            = 0x10000,
1206                 PostTransportInputChange        = 0x20000,
1207                 PostTransportCurveRealloc       = 0x40000
1208         };
1209
1210         static const PostTransportWork ProcessCannotProceedMask =
1211                 PostTransportWork (
1212                                 PostTransportInputChange|
1213                                 PostTransportSpeed|
1214                                 PostTransportReverse|
1215                                 PostTransportCurveRealloc|
1216                                 PostTransportScrub|
1217                                 PostTransportAudition|
1218                                 PostTransportLocate|
1219                                 PostTransportStop);
1220
1221         PostTransportWork post_transport_work;
1222
1223         uint32_t    cumulative_rf_motion;
1224         uint32_t    rf_scale;
1225
1226         void set_rf_speed (float speed);
1227         void reset_rf_scale (nframes_t frames_moved);
1228
1229         Locations        _locations;
1230         void              locations_changed ();
1231         void              locations_added (Location*);
1232         void              handle_locations_changed (Locations::LocationList&);
1233
1234         sigc::connection auto_punch_start_changed_connection;
1235         sigc::connection auto_punch_end_changed_connection;
1236         sigc::connection auto_punch_changed_connection;
1237         void             auto_punch_start_changed (Location *);
1238         void             auto_punch_end_changed (Location *);
1239         void             auto_punch_changed (Location *);
1240
1241         sigc::connection auto_loop_start_changed_connection;
1242         sigc::connection auto_loop_end_changed_connection;
1243         sigc::connection auto_loop_changed_connection;
1244         void             auto_loop_changed (Location *);
1245
1246         typedef std::list<Event *> Events;
1247         Events           events;
1248         Events           immediate_events;
1249         Events::iterator next_event;
1250
1251         /* there can only ever be one of each of these */
1252
1253         Event *auto_loop_event;
1254         Event *punch_out_event;
1255         Event *punch_in_event;
1256
1257         /* events */
1258
1259         void dump_events () const;
1260         void queue_event (Event *ev);
1261         void merge_event (Event*);
1262         void replace_event (Event::Type, nframes_t action_frame, nframes_t target = 0);
1263         bool _replace_event (Event*);
1264         bool _remove_event (Event *);
1265         void _clear_event_type (Event::Type);
1266
1267         void first_stage_init (std::string path, std::string snapshot_name);
1268         int  second_stage_init (bool new_tracks);
1269         void find_current_end ();
1270         void remove_empty_sounds ();
1271
1272         void setup_midi_control ();
1273         int  midi_read (MIDI::Port *);
1274
1275         void enable_record ();
1276
1277         void increment_transport_position (uint32_t val) {
1278                 if (max_frames - val < _transport_frame) {
1279                         _transport_frame = max_frames;
1280                 } else {
1281                         _transport_frame += val;
1282                 }
1283         }
1284
1285         void decrement_transport_position (uint32_t val) {
1286                 if (val < _transport_frame) {
1287                         _transport_frame -= val;
1288                 } else {
1289                         _transport_frame = 0;
1290                 }
1291         }
1292
1293         void post_transport_motion ();
1294         static void *session_loader_thread (void *arg);
1295
1296         void *do_work();
1297
1298         void set_next_event ();
1299         void process_event (Event *ev);
1300
1301         /* MIDI Machine Control */
1302
1303         void deliver_mmc (MIDI::MachineControl::Command, nframes_t);
1304
1305         void spp_start (MIDI::Parser&, nframes_t timestamp);
1306         void spp_continue (MIDI::Parser&, nframes_t timestamp);
1307         void spp_stop (MIDI::Parser&, nframes_t timestamp);
1308
1309         void mmc_deferred_play (MIDI::MachineControl &);
1310         void mmc_stop (MIDI::MachineControl &);
1311         void mmc_step (MIDI::MachineControl &, int);
1312         void mmc_pause (MIDI::MachineControl &);
1313         void mmc_record_pause (MIDI::MachineControl &);
1314         void mmc_record_strobe (MIDI::MachineControl &);
1315         void mmc_record_exit (MIDI::MachineControl &);
1316         void mmc_track_record_status (MIDI::MachineControl &, uint32_t track, bool enabled);
1317         void mmc_fast_forward (MIDI::MachineControl &);
1318         void mmc_rewind (MIDI::MachineControl &);
1319         void mmc_locate (MIDI::MachineControl &, const MIDI::byte *);
1320         void mmc_shuttle (MIDI::MachineControl &mmc, float speed, bool forw);
1321         void mmc_record_enable (MIDI::MachineControl &mmc, size_t track, bool enabled);
1322
1323         struct timeval last_mmc_step;
1324         double step_speed;
1325
1326         typedef sigc::slot<bool> MidiTimeoutCallback;
1327         typedef std::list<MidiTimeoutCallback> MidiTimeoutList;
1328
1329         MidiTimeoutList midi_timeouts;
1330         bool mmc_step_timeout ();
1331
1332         MIDI::byte mmc_buffer[32];
1333         MIDI::byte mtc_msg[16];
1334         MIDI::byte mtc_smpte_bits;   /* encoding of SMTPE type for MTC */
1335         MIDI::byte midi_msg[16];
1336         nframes_t  outbound_mtc_smpte_frame;
1337         SMPTE::Time transmitting_smpte_time;
1338         int next_quarter_frame_to_send;
1339
1340         double _frames_per_smpte_frame; /* has to be floating point because of drop frame */
1341         nframes_t _frames_per_hour;
1342         nframes_t _smpte_frames_per_hour;
1343         nframes_t _smpte_offset;
1344         bool _smpte_offset_negative;
1345
1346         /* cache the most-recently requested time conversions. This helps when we
1347          * have multiple clocks showing the same time (e.g. the transport frame) */
1348         bool           last_smpte_valid;
1349         nframes_t last_smpte_when;
1350         SMPTE::Time    last_smpte;
1351
1352         bool _send_smpte_update; ///< Flag to send a full frame (SMPTE) MTC message this cycle
1353
1354         int send_full_time_code(nframes_t nframes);
1355         int send_midi_time_code_for_cycle(nframes_t nframes);
1356
1357         nframes_t adjust_apparent_position (nframes_t frames);
1358
1359         void reset_record_status ();
1360
1361         int no_roll (nframes_t nframes);
1362         int fail_roll (nframes_t nframes);
1363
1364         bool non_realtime_work_pending() const { return static_cast<bool>(post_transport_work); }
1365         bool process_can_proceed() const { return !(post_transport_work & ProcessCannotProceedMask); }
1366
1367         struct MIDIRequest {
1368                 enum Type {
1369                         PortChange,
1370                         Quit
1371                 };
1372                 Type type;
1373         };
1374
1375         Glib::Mutex  midi_lock;
1376         pthread_t    midi_thread;
1377         int          midi_request_pipe[2];
1378         RingBuffer<MIDIRequest*> midi_requests;
1379
1380         int           start_midi_thread ();
1381         void          terminate_midi_thread ();
1382         void          poke_midi_thread ();
1383         static void *_midi_thread_work (void *arg);
1384         void          midi_thread_work ();
1385         void          change_midi_ports ();
1386         int           use_config_midi_ports ();
1387
1388         void set_play_loop (bool yn);
1389         void overwrite_some_buffers (Diskstream*);
1390         void flush_all_inserts ();
1391         int  micro_locate (nframes_t distance);
1392         void locate (nframes_t, bool with_roll, bool with_flush, bool with_loop=false);
1393         void start_locate (nframes_t, bool with_roll, bool with_flush, bool with_loop=false);
1394         void force_locate (nframes_t frame, bool with_roll = false);
1395         void set_diskstream_speed (Diskstream*, double speed);
1396         void set_transport_speed (double speed, bool abort = false);
1397         void stop_transport (bool abort = false);
1398         void start_transport ();
1399         void realtime_stop (bool abort);
1400         void non_realtime_start_scrub ();
1401         void non_realtime_set_speed ();
1402         void non_realtime_locate ();
1403         void non_realtime_stop (bool abort, int entry_request_count, bool& finished);
1404         void non_realtime_overwrite (int entry_request_count, bool& finished);
1405         void post_transport ();
1406         void engine_halted ();
1407         void xrun_recovery ();
1408
1409         TempoMap    *_tempo_map;
1410         void          tempo_map_changed (Change);
1411
1412         /* edit/mix groups */
1413
1414         int load_route_groups (const XMLNode&, int);
1415
1416         std::list<RouteGroup *> _route_groups;
1417
1418         /* disk-streams */
1419
1420         SerializedRCUManager<DiskstreamList>  diskstreams;
1421
1422         int load_diskstreams (const XMLNode&);
1423
1424         /* routes stuff */
1425
1426         SerializedRCUManager<RouteList>  routes;
1427
1428         void add_routes (RouteList&, bool save);
1429         uint32_t destructive_index;
1430
1431         boost::shared_ptr<Route> XMLRouteFactory (const XMLNode&, int);
1432
1433         /* mixer stuff */
1434
1435         bool solo_update_disabled;
1436
1437         void route_listen_changed (void *src, boost::weak_ptr<Route>);
1438         void route_mute_changed (void *src);
1439         void route_solo_changed (void *src, boost::weak_ptr<Route>);
1440         void update_route_solo_state (boost::shared_ptr<RouteList> r = boost::shared_ptr<RouteList>());
1441
1442         void listen_position_changed ();
1443         void solo_control_mode_changed ();
1444
1445         /* REGION MANAGEMENT */
1446
1447         std::map<std::string,uint32_t> region_name_map;
1448         void update_region_name_map (boost::shared_ptr<Region>);
1449
1450         mutable Glib::Mutex region_lock;
1451         typedef std::map<PBD::ID,boost::shared_ptr<Region> > RegionList;
1452         RegionList regions;
1453
1454         void add_region (boost::shared_ptr<Region>);
1455         void region_changed (Change, boost::weak_ptr<Region>);
1456         void remove_region (boost::weak_ptr<Region>);
1457
1458         int load_regions (const XMLNode& node);
1459
1460         void route_group_changed ();
1461
1462         /* SOURCES */
1463
1464         mutable Glib::Mutex source_lock;
1465         typedef std::map<PBD::ID,boost::shared_ptr<Source> > SourceMap;
1466
1467         SourceMap sources;
1468
1469   public:
1470         SourceMap get_sources() { return sources; }
1471
1472   private:
1473         int load_sources (const XMLNode& node);
1474         XMLNode& get_sources_as_xml ();
1475
1476         boost::shared_ptr<Source> XMLSourceFactory (const XMLNode&);
1477
1478         /* PLAYLISTS */
1479
1480         mutable Glib::Mutex playlist_lock;
1481         typedef std::set<boost::shared_ptr<Playlist> > PlaylistList;
1482         PlaylistList playlists;
1483         PlaylistList unused_playlists;
1484
1485         int load_playlists (const XMLNode&);
1486         int load_unused_playlists (const XMLNode&);
1487         void remove_playlist (boost::weak_ptr<Playlist>);
1488         void track_playlist (bool, boost::weak_ptr<Playlist>);
1489
1490         boost::shared_ptr<Playlist> playlist_factory (std::string name);
1491         boost::shared_ptr<Playlist> XMLPlaylistFactory (const XMLNode&);
1492
1493         void playlist_length_changed ();
1494         void diskstream_playlist_changed (boost::shared_ptr<Diskstream>);
1495
1496         /* NAMED SELECTIONS */
1497
1498         mutable Glib::Mutex named_selection_lock;
1499         typedef std::set<NamedSelection *> NamedSelectionList;
1500         NamedSelectionList named_selections;
1501
1502         int load_named_selections (const XMLNode&);
1503
1504         NamedSelection *named_selection_factory (std::string name);
1505         NamedSelection *XMLNamedSelectionFactory (const XMLNode&);
1506
1507         /* CURVES and AUTOMATION LISTS */
1508         std::map<PBD::ID, AutomationList*> automation_lists;
1509
1510         /* DEFAULT FADE CURVES */
1511
1512         float default_fade_steepness;
1513         float default_fade_msecs;
1514
1515         /* AUDITIONING */
1516
1517         boost::shared_ptr<Auditioner> auditioner;
1518         void set_audition (boost::shared_ptr<Region>);
1519         void non_realtime_set_audition ();
1520         boost::shared_ptr<Region> pending_audition_region;
1521
1522         /* EXPORT */
1523
1524         /* FLATTEN */
1525
1526         int flatten_one_track (AudioTrack&, nframes_t start, nframes_t cnt);
1527
1528         /* INSERT AND SEND MANAGEMENT */
1529
1530         boost::dynamic_bitset<uint32_t> send_bitset;
1531         boost::dynamic_bitset<uint32_t> return_bitset;
1532         boost::dynamic_bitset<uint32_t> insert_bitset;
1533
1534         void add_processor (Processor *);
1535         void remove_processor (Processor *);
1536
1537         /* S/W RAID */
1538
1539         struct space_and_path {
1540                 uint32_t blocks; /* 4kB blocks */
1541                 std::string path;
1542
1543                 space_and_path() {
1544                         blocks = 0;
1545                 }
1546         };
1547
1548         struct space_and_path_ascending_cmp {
1549                 bool operator() (space_and_path a, space_and_path b) {
1550                         return a.blocks > b.blocks;
1551                 }
1552         };
1553
1554         void setup_raid_path (std::string path);
1555
1556         std::vector<space_and_path> session_dirs;
1557         std::vector<space_and_path>::iterator last_rr_session_dir;
1558         uint32_t _total_free_4k_blocks;
1559         Glib::Mutex space_lock;
1560
1561         std::string get_best_session_directory_for_new_source ();
1562
1563         mutable gint _playback_load;
1564         mutable gint _capture_load;
1565         mutable gint _playback_load_min;
1566         mutable gint _capture_load_min;
1567
1568         /* I/O bundles */
1569
1570         SerializedRCUManager<BundleList> _bundles;
1571         XMLNode* _bundle_xml_node;
1572         int load_bundles (XMLNode const &);
1573
1574         void reverse_diskstream_buffers ();
1575
1576         UndoHistory                  _history;
1577         std::stack<UndoTransaction*> _current_trans;
1578
1579         GlobalRouteBooleanState get_global_route_boolean (bool (Route::*method)(void) const);
1580         GlobalRouteMeterState get_global_route_metering ();
1581
1582         void set_global_route_boolean (GlobalRouteBooleanState s, void (Route::*method)(bool, void*), void *arg);
1583         void set_global_route_metering (GlobalRouteMeterState s, void *arg);
1584
1585         void set_global_mute (GlobalRouteBooleanState s, void *src);
1586         void set_global_solo (GlobalRouteBooleanState s, void *src);
1587         void set_global_record_enable (GlobalRouteBooleanState s, void *src);
1588
1589         void jack_timebase_callback (jack_transport_state_t, nframes_t, jack_position_t*, int);
1590         int  jack_sync_callback (jack_transport_state_t, jack_position_t*);
1591         void reset_jack_connection (jack_client_t* jack);
1592         void record_enable_change_all (bool yn);
1593
1594         XMLNode& state(bool);
1595
1596         /* click track */
1597
1598         struct Click {
1599                 nframes_t start;
1600                 nframes_t duration;
1601                 nframes_t offset;
1602                 const Sample *data;
1603
1604                 Click (nframes_t s, nframes_t d, const Sample *b)
1605                         : start (s), duration (d), data (b) { offset = 0; }
1606
1607                 void *operator new (size_t) {
1608                         return pool.alloc ();
1609                 };
1610
1611                 void operator delete(void *ptr, size_t /*size*/) {
1612                         pool.release (ptr);
1613                 }
1614
1615         private:
1616                 static Pool pool;
1617         };
1618
1619         typedef std::list<Click*> Clicks;
1620
1621         Clicks                 clicks;
1622         bool                  _clicking;
1623         boost::shared_ptr<IO> _click_io;
1624         Sample*                click_data;
1625         Sample*                click_emphasis_data;
1626         nframes_t              click_length;
1627         nframes_t              click_emphasis_length;
1628         mutable Glib::RWLock   click_lock;
1629
1630         static const Sample    default_click[];
1631         static const nframes_t default_click_length;
1632         static const Sample    default_click_emphasis[];
1633         static const nframes_t default_click_emphasis_length;
1634
1635         Click *get_click();
1636         void   setup_click_sounds (int which);
1637         void   clear_clicks ();
1638         void   click (nframes_t start, nframes_t nframes);
1639
1640         std::vector<Route*> master_outs;
1641
1642         /* range playback */
1643
1644         std::list<AudioRange> current_audio_range;
1645         bool _play_range;
1646         void set_play_range (bool yn);
1647         void setup_auto_play ();
1648
1649         /* main outs */
1650         uint32_t main_outs;
1651
1652         boost::shared_ptr<Route> _master_out;
1653         boost::shared_ptr<Route> _control_out;
1654
1655         gain_t* _gain_automation_buffer;
1656         pan_t** _pan_automation_buffer;
1657         void allocate_pan_automation_buffers (nframes_t nframes, uint32_t howmany, bool force);
1658         uint32_t _npan_buffers;
1659
1660         /* VST support */
1661
1662         long _vst_callback (VSTPlugin*,
1663                         long opcode,
1664                         long index,
1665                         long value,
1666                         void* ptr,
1667                         float opt);
1668
1669         /* number of hardware ports we're using,
1670            based on max (requested,available)
1671         */
1672
1673         uint32_t n_physical_outputs;
1674         uint32_t n_physical_inputs;
1675
1676         uint32_t n_physical_audio_outputs;
1677         uint32_t n_physical_audio_inputs;
1678
1679         uint32_t n_physical_midi_outputs;
1680         uint32_t n_physical_midi_inputs;
1681
1682         int find_all_sources (std::string path, std::set<std::string>& result);
1683         int find_all_sources_across_snapshots (std::set<std::string>& result, bool exclude_this_snapshot);
1684
1685         typedef std::set<boost::shared_ptr<PBD::Controllable> > Controllables;
1686         Glib::Mutex controllables_lock;
1687         Controllables controllables;
1688
1689         void reset_native_file_format();
1690         bool first_file_data_format_reset;
1691         bool first_file_header_format_reset;
1692
1693         void config_changed (std::string, bool);
1694
1695         XMLNode& get_control_protocol_state ();
1696
1697         void set_history_depth (uint32_t depth);
1698         void sync_order_keys ();
1699
1700         static bool _disable_all_loaded_plugins;
1701
1702         SessionMetadata * _metadata;
1703
1704         mutable bool have_looped; ///< Used in ::audible_frame(*)
1705
1706         void update_have_rec_enabled_diskstream ();
1707         gint _have_rec_enabled_diskstream;
1708 };
1709
1710 } // namespace ARDOUR
1711
1712 #endif /* __ardour_session_h__ */