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