libs/ardour/ardour/session.h

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