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