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