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