libs/ardour/ardour/session.h

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