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