libs/ardour/ardour/session.h

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