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