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