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