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