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