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&);
1310         void spp_continue (MIDI::Parser&);
1311         void spp_stop (MIDI::Parser&);
1312
1313         void midi_clock_start (MIDI::Parser&);
1314         void midi_clock_continue (MIDI::Parser&);
1315         void midi_clock_stop (MIDI::Parser&);
1316
1317         void mmc_deferred_play (MIDI::MachineControl &);
1318         void mmc_stop (MIDI::MachineControl &);
1319         void mmc_step (MIDI::MachineControl &, int);
1320         void mmc_pause (MIDI::MachineControl &);
1321         void mmc_record_pause (MIDI::MachineControl &);
1322         void mmc_record_strobe (MIDI::MachineControl &);
1323         void mmc_record_exit (MIDI::MachineControl &);
1324         void mmc_track_record_status (MIDI::MachineControl &, uint32_t track, bool enabled);
1325         void mmc_fast_forward (MIDI::MachineControl &);
1326         void mmc_rewind (MIDI::MachineControl &);
1327         void mmc_locate (MIDI::MachineControl &, const MIDI::byte *);
1328         void mmc_shuttle (MIDI::MachineControl &mmc, float speed, bool forw);
1329         void mmc_record_enable (MIDI::MachineControl &mmc, size_t track, bool enabled);
1330
1331         struct timeval last_mmc_step;
1332         double step_speed;
1333
1334         typedef sigc::slot<bool> MidiTimeoutCallback;
1335         typedef list<MidiTimeoutCallback> MidiTimeoutList;
1336
1337         MidiTimeoutList midi_timeouts;
1338         bool mmc_step_timeout ();
1339
1340         MIDI::byte mmc_buffer[32];
1341         MIDI::byte mtc_msg[16];
1342         MIDI::byte mtc_smpte_bits;   /* encoding of SMTPE type for MTC */
1343         MIDI::byte midi_msg[16];
1344         nframes_t  outbound_mtc_smpte_frame;
1345         SMPTE::Time transmitting_smpte_time;
1346         int next_quarter_frame_to_send;
1347
1348         double _frames_per_smpte_frame; /* has to be floating point because of drop frame */
1349         nframes_t _frames_per_hour;
1350         nframes_t _smpte_frames_per_hour;
1351         nframes_t _smpte_offset;
1352         bool _smpte_offset_negative;
1353
1354         /* cache the most-recently requested time conversions. This helps when we
1355          * have multiple clocks showing the same time (e.g. the transport frame) */
1356         bool           last_smpte_valid;
1357         nframes_t last_smpte_when;
1358         SMPTE::Time    last_smpte;
1359
1360         bool _send_smpte_update; ///< Flag to send a full frame (SMPTE) MTC message this cycle
1361
1362         int send_full_time_code(nframes_t nframes);
1363         int send_midi_time_code_for_cycle(nframes_t nframes);
1364
1365         nframes_t adjust_apparent_position (nframes_t frames);
1366
1367         void reset_record_status ();
1368
1369         int no_roll (nframes_t nframes, nframes_t offset);
1370
1371         bool non_realtime_work_pending() const { return static_cast<bool>(post_transport_work); }
1372         bool process_can_proceed() const { return !(post_transport_work & ProcessCannotProceedMask); }
1373
1374         struct MIDIRequest {
1375
1376             enum Type {
1377                     PortChange,
1378                     Quit
1379             };
1380
1381             Type type;
1382
1383             MIDIRequest () {}
1384         };
1385
1386         Glib::Mutex  midi_lock;
1387         pthread_t    midi_thread;
1388         int          midi_request_pipe[2];
1389         RingBuffer<MIDIRequest*> midi_requests;
1390
1391         int           start_midi_thread ();
1392         void          terminate_midi_thread ();
1393         void          poke_midi_thread ();
1394         static void *_midi_thread_work (void *arg);
1395         void          midi_thread_work ();
1396         void          change_midi_ports ();
1397         int           use_config_midi_ports ();
1398
1399         mutable  gint   butler_active;
1400
1401         void set_play_loop (bool yn);
1402         void overwrite_some_buffers (Diskstream*);
1403         void flush_all_inserts ();
1404         int  micro_locate (nframes_t distance);
1405         void locate (nframes_t, bool with_roll, bool with_flush, bool with_loop=false);
1406         void start_locate (nframes_t, bool with_roll, bool with_flush, bool with_loop=false);
1407         void force_locate (nframes_t frame, bool with_roll = false);
1408         void set_diskstream_speed (Diskstream*, float speed);
1409         void set_transport_speed (float speed, bool abort = false);
1410         void stop_transport (bool abort = false);
1411         void start_transport ();
1412         void realtime_stop (bool abort);
1413         void non_realtime_start_scrub ();
1414         void non_realtime_set_speed ();
1415         void non_realtime_locate ();
1416         void non_realtime_stop (bool abort, int entry_request_count, bool& finished);
1417         void non_realtime_overwrite (int entry_request_count, bool& finished);
1418         void butler_transport_work ();
1419         void post_transport ();
1420         void engine_halted ();
1421         void xrun_recovery ();
1422
1423         TempoMap    *_tempo_map;
1424         void          tempo_map_changed (Change);
1425
1426         /* edit/mix groups */
1427
1428         int load_route_groups (const XMLNode&, bool is_edit);
1429         int load_edit_groups (const XMLNode&);
1430         int load_mix_groups (const XMLNode&);
1431
1432
1433         list<RouteGroup *> edit_groups;
1434         list<RouteGroup *> mix_groups;
1435
1436         /* disk-streams */
1437
1438         SerializedRCUManager<DiskstreamList>  diskstreams;
1439
1440         uint32_t audio_dstream_buffer_size;
1441         uint32_t midi_dstream_buffer_size;
1442         int  load_diskstreams (const XMLNode&);
1443
1444         /* routes stuff */
1445
1446         SerializedRCUManager<RouteList>  routes;
1447
1448         void   add_routes (RouteList&, bool save);
1449         uint32_t destructive_index;
1450
1451         int load_routes (const XMLNode&);
1452         boost::shared_ptr<Route> XMLRouteFactory (const XMLNode&);
1453
1454         /* mixer stuff */
1455
1456         bool       solo_update_disabled;
1457         bool       currently_soloing;
1458
1459         void route_mute_changed (void *src);
1460         void route_solo_changed (void *src, boost::weak_ptr<Route>);
1461         void catch_up_on_solo ();
1462         void update_route_solo_state ();
1463         void modify_solo_mute (bool, bool);
1464         void strip_portname_for_solo (string& portname);
1465
1466         /* REGION MANAGEMENT */
1467
1468         std::map<std::string,uint32_t> region_name_map;
1469         void update_region_name_map (boost::shared_ptr<Region>);
1470
1471         mutable Glib::Mutex region_lock;
1472         typedef map<PBD::ID,boost::shared_ptr<Region> > RegionList;
1473         RegionList regions;
1474
1475         void add_region (boost::shared_ptr<Region>);
1476         void region_changed (Change, boost::weak_ptr<Region>);
1477         void remove_region (boost::weak_ptr<Region>);
1478
1479         int load_regions (const XMLNode& node);
1480
1481         /* SOURCES */
1482
1483         mutable Glib::Mutex source_lock;
1484         typedef std::map<PBD::ID,boost::shared_ptr<Source> > SourceMap;
1485
1486         SourceMap sources;
1487
1488   public:
1489         SourceMap get_sources() { return sources; }
1490
1491   private:
1492
1493
1494         int load_sources (const XMLNode& node);
1495         XMLNode& get_sources_as_xml ();
1496
1497         boost::shared_ptr<Source> XMLSourceFactory (const XMLNode&);
1498
1499         /* PLAYLISTS */
1500
1501         mutable Glib::Mutex playlist_lock;
1502         typedef set<boost::shared_ptr<Playlist> > PlaylistList;
1503         PlaylistList playlists;
1504         PlaylistList unused_playlists;
1505
1506         int load_playlists (const XMLNode&);
1507         int load_unused_playlists (const XMLNode&);
1508         void remove_playlist (boost::weak_ptr<Playlist>);
1509         void track_playlist (bool, boost::weak_ptr<Playlist>);
1510
1511         boost::shared_ptr<Playlist> playlist_factory (string name);
1512         boost::shared_ptr<Playlist> XMLPlaylistFactory (const XMLNode&);
1513
1514         void playlist_length_changed ();
1515         void diskstream_playlist_changed (boost::shared_ptr<Diskstream>);
1516
1517         /* NAMED SELECTIONS */
1518
1519         mutable Glib::Mutex named_selection_lock;
1520         typedef set<NamedSelection *> NamedSelectionList;
1521         NamedSelectionList named_selections;
1522
1523         int load_named_selections (const XMLNode&);
1524
1525         NamedSelection *named_selection_factory (string name);
1526         NamedSelection *XMLNamedSelectionFactory (const XMLNode&);
1527
1528         /* CURVES and AUTOMATION LISTS */
1529         std::map<PBD::ID, Evoral::Curve*> curves;
1530         std::map<PBD::ID, AutomationList*> automation_lists;
1531
1532         /* DEFAULT FADE CURVES */
1533
1534         float default_fade_steepness;
1535         float default_fade_msecs;
1536
1537         /* AUDITIONING */
1538
1539         boost::shared_ptr<Auditioner> auditioner;
1540         void set_audition (boost::shared_ptr<Region>);
1541         void non_realtime_set_audition ();
1542         boost::shared_ptr<Region> pending_audition_region;
1543
1544         /* EXPORT */
1545
1546         /* FLATTEN */
1547
1548         int flatten_one_track (AudioTrack&, nframes_t start, nframes_t cnt);
1549
1550         /* INSERT AND SEND MANAGEMENT */
1551
1552         list<PortInsert *>              _port_inserts;
1553         list<PluginInsert *>            _plugin_inserts;
1554         list<Send *>                    _sends;
1555         boost::dynamic_bitset<uint32_t> send_bitset;
1556         boost::dynamic_bitset<uint32_t> insert_bitset;
1557         uint32_t                        send_cnt;
1558         uint32_t                        insert_cnt;
1559
1560
1561         void add_processor (Processor *);
1562         void remove_processor (Processor *);
1563
1564         /* S/W RAID */
1565
1566         struct space_and_path {
1567             uint32_t blocks; /* 4kB blocks */
1568             string path;
1569
1570             space_and_path() {
1571                     blocks = 0;
1572             }
1573         };
1574
1575         struct space_and_path_ascending_cmp {
1576             bool operator() (space_and_path a, space_and_path b) {
1577                     return a.blocks > b.blocks;
1578             }
1579         };
1580
1581         void setup_raid_path (string path);
1582
1583         vector<space_and_path> session_dirs;
1584         vector<space_and_path>::iterator last_rr_session_dir;
1585         uint32_t _total_free_4k_blocks;
1586         Glib::Mutex space_lock;
1587
1588         string get_best_session_directory_for_new_source ();
1589         void refresh_disk_space ();
1590
1591         mutable gint _playback_load;
1592         mutable gint _capture_load;
1593         mutable gint _playback_load_min;
1594         mutable gint _capture_load_min;
1595
1596         /* I/O bundles */
1597
1598         typedef list<boost::shared_ptr<Bundle> > BundleList;
1599         mutable Glib::Mutex bundle_lock;
1600         BundleList _bundles;
1601         XMLNode* _bundle_xml_node;
1602         int load_bundles (XMLNode const &);
1603
1604         void reverse_diskstream_buffers ();
1605
1606         UndoHistory _history;
1607         UndoTransaction* current_trans;
1608
1609         GlobalRouteBooleanState get_global_route_boolean (bool (Route::*method)(void) const);
1610         GlobalRouteMeterState get_global_route_metering ();
1611
1612         void set_global_route_boolean (GlobalRouteBooleanState s, void (Route::*method)(bool, void*), void *arg);
1613         void set_global_route_metering (GlobalRouteMeterState s, void *arg);
1614
1615         void set_global_mute (GlobalRouteBooleanState s, void *src);
1616         void set_global_solo (GlobalRouteBooleanState s, void *src);
1617         void set_global_record_enable (GlobalRouteBooleanState s, void *src);
1618
1619         void jack_timebase_callback (jack_transport_state_t, nframes_t, jack_position_t*, int);
1620         int  jack_sync_callback (jack_transport_state_t, jack_position_t*);
1621         void reset_jack_connection (jack_client_t* jack);
1622         void record_enable_change_all (bool yn);
1623
1624         XMLNode& state(bool);
1625
1626         /* click track */
1627
1628         struct Click {
1629             nframes_t start;
1630             nframes_t duration;
1631             nframes_t offset;
1632             const Sample *data;
1633
1634             Click (nframes_t s, nframes_t d, const Sample *b)
1635                     : start (s), duration (d), data (b) { offset = 0; }
1636
1637             void *operator new(size_t ignored) {
1638                     return pool.alloc ();
1639             };
1640
1641             void operator delete(void *ptr, size_t size) {
1642                     pool.release (ptr);
1643             }
1644
1645           private:
1646             static Pool pool;
1647         };
1648
1649         typedef list<Click*> Clicks;
1650
1651         Clicks          clicks;
1652         bool           _clicking;
1653         boost::shared_ptr<IO> _click_io;
1654         Sample*         click_data;
1655         Sample*         click_emphasis_data;
1656         nframes_t  click_length;
1657         nframes_t  click_emphasis_length;
1658         mutable Glib::RWLock click_lock;
1659
1660         static const Sample    default_click[];
1661         static const nframes_t default_click_length;
1662         static const Sample    default_click_emphasis[];
1663         static const nframes_t default_click_emphasis_length;
1664
1665         Click *get_click();
1666         void   setup_click_sounds (int which);
1667         void   clear_clicks ();
1668         void   click (nframes_t start, nframes_t nframes, nframes_t offset);
1669
1670         vector<Route*> master_outs;
1671
1672         /* range playback */
1673
1674         list<AudioRange> current_audio_range;
1675         bool _play_range;
1676         void set_play_range (bool yn);
1677         void setup_auto_play ();
1678
1679         /* main outs */
1680         uint32_t main_outs;
1681
1682         boost::shared_ptr<IO> _master_out;
1683         boost::shared_ptr<IO> _control_out;
1684
1685         gain_t* _gain_automation_buffer;
1686         pan_t** _pan_automation_buffer;
1687         void allocate_pan_automation_buffers (nframes_t nframes, uint32_t howmany, bool force);
1688         uint32_t _npan_buffers;
1689
1690         /* VST support */
1691
1692         long _vst_callback (VSTPlugin*,
1693                             long opcode,
1694                             long index,
1695                             long value,
1696                             void* ptr,
1697                             float opt);
1698
1699         /* number of hardware ports we're using,
1700            based on max (requested,available)
1701         */
1702
1703         uint32_t n_physical_outputs;
1704         uint32_t n_physical_inputs;
1705
1706
1707         int find_all_sources (std::string path, std::set<std::string>& result);
1708         int find_all_sources_across_snapshots (std::set<std::string>& result, bool exclude_this_snapshot);
1709
1710         LayerModel layer_model;
1711         CrossfadeModel xfade_model;
1712
1713         typedef std::set<boost::shared_ptr<PBD::Controllable> > Controllables;
1714         Glib::Mutex controllables_lock;
1715         Controllables controllables;
1716
1717         void reset_native_file_format();
1718         bool first_file_data_format_reset;
1719         bool first_file_header_format_reset;
1720
1721         void config_changed (const char*);
1722
1723         XMLNode& get_control_protocol_state ();
1724
1725         void set_history_depth (uint32_t depth);
1726         void sync_order_keys ();
1727
1728         static bool _disable_all_loaded_plugins;
1729
1730         /* Metadata */
1731
1732         SessionMetadata * _metadata;
1733   public:
1734         SessionMetadata & metadata () { return *_metadata; }
1735 };
1736
1737 } // namespace ARDOUR
1738
1739 #endif /* __ardour_session_h__ */