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