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     $Id$
  19 */
  20
  21 #ifndef __ardour_session_h__
  22 #define __ardour_session_h__
  23
  24 #include <string>
  25 #include <list>
  26 #include <map>
  27 #include <vector>
  28 #include <set>
  29 #include <stack>
  30 #include <stdint.h>
  31
  32 #include <sndfile.h>
  33
  34 #include <pbd/error.h>
  35 #include <pbd/atomic.h>
  36 #include <pbd/lockmonitor.h>
  37 #include <pbd/undo.h>
  38 #include <pbd/pool.h>
  39
  40 #include <midi++/types.h>
  41 #include <midi++/mmc.h>
  42
  43 #include <ardour/ardour.h>
  44 #include <ardour/configuration.h>
  45 #include <ardour/location.h>
  46 #include <ardour/stateful.h>
  47 #include <ardour/gain.h>
  48 #include <ardour/io.h>
  49
  50 class XMLTree;
  51 class XMLNode;
  52 class AEffect;
  53
  54 namespace MIDI {
  55         class Port;
  56 }
  57
  58 namespace ARDOUR {
  59
  60 class Port;
  61 class AudioEngine;
  62 class Slave;
  63 class DiskStream;
  64 class Route;
  65 class AuxInput;
  66 class Source;
  67 class FileSource;
  68 class Auditioner;
  69 class Insert;
  70 class Send;
  71 class Redirect;
  72 class PortInsert;
  73 class PluginInsert;
  74 class Connection;
  75 class TempoMap;
  76 class AudioTrack;
  77 class NamedSelection;
  78 class AudioRegion;
  79 class Region;
  80 class Playlist;
  81 class VSTPlugin;
  82 class ControlProtocolManager;
  83
  84 struct AudioExportSpecification;
  85 struct RouteGroup;
  86
  87 using std::vector;
  88 using std::string;
  89 using std::list;
  90 using std::map;
  91 using std::set;
  92
  93 class Session : public sigc::trackable, public Stateful
  94
  95 {
  96   private:
  97         typedef std::pair<Route*,bool> RouteBooleanState;
  98         typedef vector<RouteBooleanState> GlobalRouteBooleanState;
  99         typedef std::pair<Route*,MeterPoint> RouteMeterState;
 100         typedef vector<RouteMeterState> GlobalRouteMeterState;
 101
 102   public:
 103         enum RecordState {
 104                 Disabled = 0,
 105                 Enabled = 1,
 106                 Recording = 2
 107         };
 108
 109         enum SlaveSource {
 110                 None = 0,
 111                 MTC,
 112                 JACK,
 113         };
 114
 115         enum AutoConnectOption {
 116                 AutoConnectPhysical = 0x1,
 117                 AutoConnectMaster = 0x2
 118         };
 119
 120         struct Event {
 121             enum Type {
 122                     SetTransportSpeed,
 123                     SetDiskstreamSpeed,
 124                     Locate,
 125                     LocateRoll,
 126                     SetLoop,
 127                     PunchIn,
 128                     PunchOut,
 129                     RangeStop,
 130                     RangeLocate,
 131                     Overwrite,
 132                     SetSlaveSource,
 133                     Audition,
 134                     InputConfigurationChange,
 135                     SetAudioRange,
 136                     SetPlayRange,
 137
 138                     /* only one of each of these events
 139                        can be queued at any one time
 140                     */
 141
 142                     StopOnce,
 143                     AutoLoop,
 144             };
 145
 146             enum Action {
 147                     Add,
 148                     Remove,
 149                     Replace,
 150                     Clear
 151             };
 152
 153             Type                type;
 154             Action              action;
 155             jack_nframes_t      action_frame;
 156             jack_nframes_t      target_frame;
 157             float               speed;
 158
 159             union {
 160                 void*                ptr;
 161                 bool                 yes_or_no;
 162                 Session::SlaveSource slave;
 163             };
 164
 165             list<AudioRange>     audio_range;
 166             list<MusicRange>     music_range;
 167
 168             Event(Type t, Action a, jack_nframes_t when, jack_nframes_t where, float spd, bool yn = false)
 169                     : type (t),
 170                       action (a),
 171                       action_frame (when),
 172                       target_frame (where),
 173                       speed (spd),
 174                       yes_or_no (yn) {}
 175
 176             void set_ptr (void* p) {
 177                     ptr = p;
 178             }
 179
 180             bool before (const Event& other) const {
 181                     return action_frame < other.action_frame;
 182             }
 183
 184             bool after (const Event& other) const {
 185                     return action_frame > other.action_frame;
 186             }
 187
 188             static bool compare (const Event *e1, const Event *e2) {
 189                     return e1->before (*e2);
 190             }
 191
 192             void *operator new (size_t ignored) {
 193                     return pool.alloc ();
 194             }
 195
 196             void operator delete(void *ptr, size_t size) {
 197                     pool.release (ptr);
 198             }
 199
 200             static const jack_nframes_t Immediate = 0;
 201
 202          private:
 203             static MultiAllocSingleReleasePool pool;
 204         };
 205
 206         /* creating from an XML file */
 207
 208         Session (AudioEngine&,
 209                  string fullpath,
 210                  string snapshot_name,
 211                  string* mix_template = 0);
 212
 213         /* creating a new Session */
 214
 215         Session (AudioEngine&,
 216                  string fullpath,
 217                  string snapshot_name,
 218                  AutoConnectOption input_auto_connect,
 219                  AutoConnectOption output_auto_connect,
 220                  uint32_t control_out_channels,
 221                  uint32_t master_out_channels,
 222                  uint32_t n_physical_in,
 223                  uint32_t n_physical_out,
 224                  jack_nframes_t initial_length);
 225
 226         virtual ~Session ();
 227
 228
 229         static int find_session (string str, string& path, string& snapshot, bool& isnew);
 230
 231         string path() const { return _path; }
 232         string name() const { return _name; }
 233         string snap_name() const { return _current_snapshot_name; }
 234
 235         void set_snap_name ();
 236
 237         void set_dirty ();
 238         void set_clean ();
 239         bool dirty() const { return _state_of_the_state & Dirty; }
 240         sigc::signal<void> DirtyChanged;
 241
 242         std::string sound_dir () const;
 243         std::string tape_dir () const;
 244         std::string peak_dir () const;
 245         std::string dead_sound_dir () const;
 246         std::string automation_dir () const;
 247
 248         static string suffixed_search_path (std::string suffix, bool data);
 249         static string control_protocol_path ();
 250         static string template_path ();
 251         static string template_dir ();
 252         static void get_template_list (list<string>&);
 253
 254         static string change_audio_path_by_name (string oldpath, string oldname, string newname, bool destructive);
 255         static string peak_path_from_audio_path (string);
 256         string audio_path_from_name (string, uint32_t nchans, uint32_t chan, bool destructive);
 257
 258         void process (jack_nframes_t nframes);
 259
 260         vector<Sample*>& get_passthru_buffers() { return _passthru_buffers; }
 261         vector<Sample*>& get_silent_buffers (uint32_t howmany);
 262         vector<Sample*>& get_send_buffers () { return _send_buffers; }
 263
 264         DiskStream    *diskstream_by_id (id_t id);
 265         DiskStream    *diskstream_by_name (string name);
 266
 267         bool have_captured() const { return _have_captured; }
 268
 269         void refill_all_diskstream_buffers ();
 270         uint32_t diskstream_buffer_size() const { return dstream_buffer_size; }
 271         uint32_t get_next_diskstream_id() const { return n_diskstreams(); }
 272         uint32_t n_diskstreams() const;
 273
 274         typedef list<DiskStream *> DiskStreamList;
 275
 276         Session::DiskStreamList disk_streams() const {
 277                 RWLockMonitor lm (diskstream_lock, false, __LINE__, __FILE__);
 278                 return diskstreams; /* XXX yes, force a copy */
 279         }
 280
 281         void foreach_diskstream (void (DiskStream::*func)(void));
 282         template<class T> void foreach_diskstream (T *obj, void (T::*func)(DiskStream&));
 283
 284         typedef list<Route *> RouteList;
 285
 286         RouteList get_routes() const {
 287                 RWLockMonitor rlock (route_lock, false, __LINE__, __FILE__);
 288                 return routes; /* XXX yes, force a copy */
 289         }
 290
 291         uint32_t nroutes() const { return routes.size(); }
 292         uint32_t ntracks () const;
 293         uint32_t nbusses () const;
 294
 295         struct RoutePublicOrderSorter {
 296             bool operator() (Route *, Route *b);
 297         };
 298
 299         template<class T> void foreach_route (T *obj, void (T::*func)(Route&));
 300         template<class T> void foreach_route (T *obj, void (T::*func)(Route*));
 301         template<class T, class A> void foreach_route (T *obj, void (T::*func)(Route&, A), A arg);
 302
 303         Route *route_by_name (string);
 304         Route *route_by_remote_id (uint32_t id);
 305
 306         bool route_name_unique (string) const;
 307
 308         bool get_record_enabled() const {
 309                 return (record_status () >= Enabled);
 310         }
 311
 312         RecordState record_status() const {
 313                 return (RecordState) atomic_read (&_record_status);
 314         }
 315
 316         bool actively_recording () {
 317                 return record_status() == Recording;
 318         }
 319
 320         bool record_enabling_legal () const;
 321         void maybe_enable_record ();
 322         void disable_record (bool rt_context, bool force = false);
 323         void step_back_from_record ();
 324
 325         sigc::signal<void> going_away;
 326
 327         /* Proxy signal for region hidden changes */
 328
 329         sigc::signal<void,Region*> RegionHiddenChange;
 330
 331         /* Emitted when all i/o connections are complete */
 332
 333         sigc::signal<void> IOConnectionsComplete;
 334
 335         /* Record status signals */
 336
 337         sigc::signal<void> RecordStateChanged;
 338
 339         /* Transport mechanism signals */
 340
 341         sigc::signal<void> TransportStateChange; /* generic */
 342         sigc::signal<void,jack_nframes_t> PositionChanged; /* sent after any non-sequential motion */
 343         sigc::signal<void> DurationChanged;
 344         sigc::signal<void> HaltOnXrun;
 345
 346         sigc::signal<void,Route*> RouteAdded;
 347         sigc::signal<void,DiskStream*> DiskStreamAdded;
 348
 349         void request_roll ();
 350         void request_bounded_roll (jack_nframes_t start, jack_nframes_t end);
 351         void request_stop (bool abort = false);
 352         void request_locate (jack_nframes_t frame, bool with_roll = false);
 353         void request_auto_loop (bool yn);
 354         jack_nframes_t  last_transport_start() const { return _last_roll_location; }
 355         void goto_end ()   { request_locate (end_location->start(), false);}
 356         void goto_start () { request_locate (start_location->start(), false); }
 357         void use_rf_shuttle_speed ();
 358         void request_transport_speed (float speed);
 359         void request_overwrite_buffer (DiskStream*);
 360         void request_diskstream_speed (DiskStream&, float speed);
 361         void request_input_change_handling ();
 362
 363         int wipe ();
 364         int wipe_diskstream (DiskStream *);
 365
 366         int remove_region_from_region_list (Region&);
 367
 368         jack_nframes_t get_maximum_extent () const;
 369         jack_nframes_t current_end_frame() const { return end_location->start(); }
 370         jack_nframes_t current_start_frame() const { return start_location->start(); }
 371         jack_nframes_t frame_rate() const   { return _current_frame_rate; }
 372         double frames_per_smpte_frame() const { return _frames_per_smpte_frame; }
 373         jack_nframes_t frames_per_hour() const { return _frames_per_hour; }
 374         jack_nframes_t smpte_frames_per_hour() const { return _smpte_frames_per_hour; }
 375
 376         /* Locations */
 377
 378         Locations *locations() { return &_locations; }
 379
 380         sigc::signal<void,Location*>    auto_loop_location_changed;
 381         sigc::signal<void,Location*>    auto_punch_location_changed;
 382         sigc::signal<void>              locations_modified;
 383
 384         void set_auto_punch_location (Location *);
 385         void set_auto_loop_location (Location *);
 386
 387
 388         enum ControlType {
 389                 AutoPlay,
 390                 AutoLoop,
 391                 AutoReturn,
 392                 AutoInput,
 393                 PunchIn,
 394                 PunchOut,
 395                 SendMTC,
 396                 MMCControl,
 397                 SoloLatch,
 398                 SoloingModel,
 399                 RecordingPlugins,
 400                 CrossFadesActive,
 401                 SendMMC,
 402                 SlaveType,
 403                 Clicking,
 404                 EditingMode,
 405                 PlayRange,
 406                 LayeringModel,
 407                 CrossfadingModel,
 408                 SeamlessLoop,
 409                 MidiFeedback,
 410                 MidiControl,
 411                 TranzportControl,
 412                 Feedback
 413         };
 414
 415         sigc::signal<void,ControlType> ControlChanged;
 416
 417         void set_auto_play (bool yn);
 418         void set_auto_return (bool yn);
 419         void set_auto_input (bool yn);
 420         void reset_input_monitor_state ();
 421         void set_input_auto_connect (bool yn);
 422         void set_output_auto_connect (AutoConnectOption);
 423         void set_punch_in (bool yn);
 424         void set_punch_out (bool yn);
 425         void set_send_mtc (bool yn);
 426         void set_send_mmc (bool yn);
 427         void set_mmc_control (bool yn);
 428         void set_midi_feedback (bool yn);
 429         void set_midi_control (bool yn);
 430         void set_do_not_record_plugins (bool yn);
 431         void set_crossfades_active (bool yn);
 432         void set_seamless_loop (bool yn);
 433
 434         bool get_auto_play () const { return auto_play; }
 435         bool get_auto_input () const { return auto_input; }
 436         bool get_auto_loop () const { return auto_loop; }
 437         bool get_seamless_loop () const { return seamless_loop; }
 438         bool get_punch_in () const { return punch_in; }
 439         bool get_punch_out () const { return punch_out; }
 440         bool get_all_safe () const { return all_safe; }
 441         bool get_auto_return () const { return auto_return; }
 442         bool get_send_mtc () const;
 443         bool get_send_mmc () const;
 444         bool get_mmc_control () const;
 445         bool get_midi_feedback () const;
 446         bool get_midi_control () const;
 447         bool get_do_not_record_plugins () const { return do_not_record_plugins; }
 448         bool get_crossfades_active () const { return crossfades_active; }
 449
 450         bool get_input_auto_connect () const;
 451         AutoConnectOption get_output_auto_connect () const { return output_auto_connect; }
 452
 453         enum LayerModel {
 454                 LaterHigher,
 455                 MoveAddHigher,
 456                 AddHigher
 457         };
 458
 459         void set_layer_model (LayerModel);
 460         LayerModel get_layer_model () const { return layer_model; }
 461
 462         void set_xfade_model (CrossfadeModel);
 463         CrossfadeModel get_xfade_model () const { return xfade_model; }
 464
 465         void add_event (jack_nframes_t action_frame, Event::Type type, jack_nframes_t target_frame = 0);
 466         void remove_event (jack_nframes_t frame, Event::Type type);
 467         void clear_events (Event::Type type);
 468
 469         jack_nframes_t get_block_size() const { return current_block_size; }
 470         jack_nframes_t worst_output_latency () const { return _worst_output_latency; }
 471         jack_nframes_t worst_input_latency () const { return _worst_input_latency; }
 472         jack_nframes_t worst_track_latency () const { return _worst_track_latency; }
 473
 474         int save_state (string snapshot_name, bool pending = false);
 475         int restore_state (string snapshot_name);
 476         int save_template (string template_name);
 477
 478         static int rename_template (string old_name, string new_name);
 479
 480         static int delete_template (string name);
 481
 482         sigc::signal<void,string> StateSaved;
 483         sigc::signal<void> StateReady;
 484
 485         vector<string*>* possible_states() const;
 486         static vector<string*>* possible_states(string path);
 487
 488         XMLNode& get_state();
 489         int      set_state(const XMLNode& node);
 490         XMLNode& get_template();
 491
 492         void add_instant_xml (XMLNode&, const std::string& dir);
 493
 494         void swap_configuration(Configuration** new_config);
 495         void copy_configuration(Configuration* new_config);
 496
 497         enum StateOfTheState {
 498                 Clean = 0x0,
 499                 Dirty = 0x1,
 500                 CannotSave = 0x2,
 501                 Deletion = 0x4,
 502                 InitialConnecting = 0x8,
 503                 Loading = 0x10,
 504                 InCleanup = 0x20
 505         };
 506
 507         StateOfTheState state_of_the_state() const { return _state_of_the_state; }
 508
 509         RouteGroup* add_edit_group (string);
 510         RouteGroup* add_mix_group (string);
 511
 512         void remove_edit_group (RouteGroup&);
 513         void remove_mix_group (RouteGroup&);
 514
 515         RouteGroup *mix_group_by_name (string);
 516         RouteGroup *edit_group_by_name (string);
 517
 518         sigc::signal<void,RouteGroup*> edit_group_added;
 519         sigc::signal<void,RouteGroup*> mix_group_added;
 520         sigc::signal<void> edit_group_removed;
 521         sigc::signal<void> mix_group_removed;
 522
 523         void foreach_edit_group (sigc::slot<void,RouteGroup*> sl) {
 524                 for (list<RouteGroup *>::iterator i = edit_groups.begin(); i != edit_groups.end(); i++) {
 525                         sl (*i);
 526                 }
 527         }
 528
 529         void foreach_mix_group (sigc::slot<void,RouteGroup*> sl) {
 530                 for (list<RouteGroup *>::iterator i = mix_groups.begin(); i != mix_groups.end(); i++) {
 531                         sl (*i);
 532                 }
 533         }
 534
 535         /* fundamental operations. duh. */
 536
 537
 538         AudioTrack *new_audio_track (int input_channels, int output_channels, TrackMode mode = Normal);
 539
 540         Route *new_audio_route (int input_channels, int output_channels);
 541
 542         void   remove_route (Route&);
 543         void   resort_routes (void *src);
 544
 545         AudioEngine &engine() { return _engine; };
 546
 547         /* configuration. there should really be accessors/mutators
 548            for these
 549         */
 550
 551         float   meter_hold () { return _meter_hold; }
 552         void    set_meter_hold (float);
 553         sigc::signal<void> MeterHoldChanged;
 554
 555         float   meter_falloff () { return _meter_falloff; }
 556         void    set_meter_falloff (float);
 557         sigc::signal<void> MeterFalloffChanged;
 558
 559         int32_t  max_level;
 560         int32_t  min_level;
 561         string  click_emphasis_sound;
 562         string  click_sound;
 563         bool    click_requested;
 564         jack_nframes_t over_length_short;
 565         jack_nframes_t over_length_long;
 566         bool    send_midi_timecode;
 567         bool    send_midi_machine_control;
 568         float   shuttle_speed_factor;
 569         float   shuttle_speed_threshold;
 570         float   rf_speed;
 571         float   smpte_frames_per_second;
 572         bool    smpte_drop_frames;
 573         AnyTime preroll;
 574         AnyTime postroll;
 575
 576         /* Time */
 577
 578         jack_nframes_t transport_frame () const {return _transport_frame; }
 579         jack_nframes_t audible_frame () const;
 580
 581         int  set_smpte_type (float fps, bool drop_frames);
 582
 583         void bbt_time (jack_nframes_t when, BBT_Time&);
 584
 585         ARDOUR::smpte_wrap_t smpte_increment( SMPTE_Time& smpte ) const;
 586         ARDOUR::smpte_wrap_t smpte_decrement( SMPTE_Time& smpte ) const;
 587         ARDOUR::smpte_wrap_t smpte_increment_subframes( SMPTE_Time& smpte ) const;
 588         ARDOUR::smpte_wrap_t smpte_decrement_subframes( SMPTE_Time& smpte ) const;
 589         ARDOUR::smpte_wrap_t smpte_increment_seconds( SMPTE_Time& smpte ) const;
 590         ARDOUR::smpte_wrap_t smpte_increment_minutes( SMPTE_Time& smpte ) const;
 591         ARDOUR::smpte_wrap_t smpte_increment_hours( SMPTE_Time& smpte ) const;
 592         void smpte_frames_floor( SMPTE_Time& smpte ) const;
 593         void smpte_seconds_floor( SMPTE_Time& smpte ) const;
 594         void smpte_minutes_floor( SMPTE_Time& smpte ) const;
 595         void smpte_hours_floor( SMPTE_Time& smpte ) const;
 596         void smpte_to_sample( SMPTE_Time& smpte, jack_nframes_t& sample, bool use_offset, bool use_subframes ) const;
 597         void sample_to_smpte( jack_nframes_t sample, SMPTE_Time& smpte, bool use_offset, bool use_subframes ) const;
 598         void smpte_time (SMPTE_Time &);
 599         void smpte_time (jack_nframes_t when, SMPTE_Time&);
 600         void smpte_time_subframes (jack_nframes_t when, SMPTE_Time&);
 601
 602         void smpte_duration (jack_nframes_t, SMPTE_Time&) const;
 603         void smpte_duration_string (char *, jack_nframes_t) const;
 604
 605         void           set_smpte_offset (jack_nframes_t);
 606         jack_nframes_t smpte_offset () const { return _smpte_offset; }
 607         void           set_smpte_offset_negative (bool);
 608         bool           smpte_offset_negative () const { return _smpte_offset_negative; }
 609
 610         jack_nframes_t convert_to_frames_at (jack_nframes_t position, AnyTime&);
 611
 612         sigc::signal<void> SMPTEOffsetChanged;
 613         sigc::signal<void> SMPTETypeChanged;
 614
 615         void        request_slave_source (SlaveSource, jack_nframes_t pos = 0);
 616         SlaveSource slave_source() const { return _slave_type; }
 617         bool        synced_to_jack() const { return _slave_type == JACK; }
 618         float       transport_speed() const { return _transport_speed; }
 619         bool        transport_stopped() const { return _transport_speed == 0.0f; }
 620         bool        transport_rolling() const { return _transport_speed != 0.0f; }
 621
 622         int jack_slave_sync (jack_nframes_t);
 623
 624         TempoMap& tempo_map() { return *_tempo_map; }
 625
 626         /* region info  */
 627
 628         sigc::signal<void,AudioRegion *> AudioRegionAdded;
 629         sigc::signal<void,AudioRegion *> AudioRegionRemoved;
 630
 631         int region_name (string& result, string base = string(""), bool newlevel = false) const;
 632         string new_region_name (string);
 633         string path_from_region_name (string name, string identifier);
 634
 635         AudioRegion* find_whole_file_parent (AudioRegion&);
 636         void find_equivalent_playlist_regions (AudioRegion&, std::vector<AudioRegion*>& result);
 637
 638         AudioRegion *XMLRegionFactory (const XMLNode&, bool full);
 639
 640         template<class T> void foreach_audio_region (T *obj, void (T::*func)(AudioRegion *));
 641
 642         /* source management */
 643
 644         struct import_status : public InterThreadInfo {
 645             string doing_what;
 646
 647             /* control info */
 648             bool multichan;
 649             bool sample_convert;
 650             volatile bool freeze;
 651             string pathname;
 652
 653             /* result */
 654             std::vector<AudioRegion*> new_regions;
 655
 656         };
 657
 658         int import_audiofile (import_status&);
 659         bool sample_rate_convert (import_status&, string infile, string& outfile);
 660         string build_tmp_convert_name (string file);
 661
 662         Session::SlaveSource post_export_slave;
 663         jack_nframes_t post_export_position;
 664
 665         int start_audio_export (ARDOUR::AudioExportSpecification&);
 666         int stop_audio_export (ARDOUR::AudioExportSpecification&);
 667
 668         void add_source (Source *);
 669         int  remove_file_source (FileSource&);
 670
 671         struct cleanup_report {
 672             vector<string> paths;
 673             int32_t space;
 674         };
 675
 676         int  cleanup_sources (cleanup_report&);
 677         int  cleanup_trash_sources (cleanup_report&);
 678
 679         int destroy_region (Region*);
 680         int destroy_regions (list<Region*>);
 681
 682         int remove_last_capture ();
 683
 684         /* handlers should return -1 for "stop cleanup", 0 for
 685            "yes, delete this playlist" and 1 for "no, don't delete
 686            this playlist.
 687         */
 688
 689         sigc::signal<int,ARDOUR::Playlist*> AskAboutPlaylistDeletion;
 690
 691
 692         /* handlers should return !0 for use pending state, 0 for
 693            ignore it.
 694         */
 695
 696         static sigc::signal<int> AskAboutPendingState;
 697
 698         sigc::signal<void,Source *> SourceAdded;
 699         sigc::signal<void,Source *> SourceRemoved;
 700
 701         FileSource *create_file_source (ARDOUR::DiskStream&, int32_t chan, bool destructive);
 702         Source *get_source (ARDOUR::id_t);
 703
 704         /* playlist management */
 705
 706         Playlist* playlist_by_name (string name);
 707         void add_playlist (Playlist *);
 708         sigc::signal<void,Playlist*> PlaylistAdded;
 709         sigc::signal<void,Playlist*> PlaylistRemoved;
 710
 711         Playlist *get_playlist (string name);
 712
 713         uint32_t n_playlists() const;
 714
 715         template<class T> void foreach_playlist (T *obj, void (T::*func)(Playlist *));
 716
 717         /* named selections */
 718
 719         NamedSelection* named_selection_by_name (string name);
 720         void add_named_selection (NamedSelection *);
 721         void remove_named_selection (NamedSelection *);
 722
 723         template<class T> void foreach_named_selection (T& obj, void (T::*func)(NamedSelection&));
 724         sigc::signal<void> NamedSelectionAdded;
 725         sigc::signal<void> NamedSelectionRemoved;
 726
 727         /* fade curves */
 728
 729         float get_default_fade_length () const { return default_fade_msecs; }
 730         float get_default_fade_steepness () const { return default_fade_steepness; }
 731         void set_default_fade (float steepness, float msecs);
 732
 733         /* auditioning */
 734
 735         Auditioner& the_auditioner() { return *auditioner; }
 736         void audition_playlist ();
 737         void audition_region (AudioRegion&);
 738         void cancel_audition ();
 739         bool is_auditioning () const;
 740
 741         sigc::signal<void,bool> AuditionActive;
 742
 743         /* flattening stuff */
 744
 745         int write_one_track (AudioTrack&, jack_nframes_t start, jack_nframes_t cnt, bool overwrite, vector<Source*>&,
 746                              InterThreadInfo& wot);
 747         int freeze (InterThreadInfo&);
 748
 749         /* session-wide solo/mute/rec-enable */
 750
 751         enum SoloModel {
 752                 InverseMute,
 753                 SoloBus
 754         };
 755
 756         bool soloing() const { return currently_soloing; }
 757
 758         SoloModel solo_model() const { return _solo_model; }
 759         void set_solo_model (SoloModel);
 760
 761         bool solo_latched() const { return _solo_latched; }
 762         void set_solo_latched (bool yn);
 763
 764         void set_all_solo (bool);
 765         void set_all_mute (bool);
 766
 767         sigc::signal<void,bool> SoloActive;
 768
 769         void record_disenable_all ();
 770         void record_enable_all ();
 771
 772         /* control/master out */
 773
 774         IO* control_out() const { return _control_out; }
 775         IO* master_out() const { return _master_out; }
 776
 777         /* insert/send management */
 778
 779         uint32_t n_port_inserts() const { return _port_inserts.size(); }
 780         uint32_t n_plugin_inserts() const { return _plugin_inserts.size(); }
 781         uint32_t n_sends() const { return _sends.size(); }
 782
 783         string next_send_name();
 784         string next_insert_name();
 785
 786         /* s/w "RAID" management */
 787
 788         jack_nframes_t available_capture_duration();
 789
 790         /* I/O Connections */
 791
 792         template<class T> void foreach_connection (T *obj, void (T::*func)(Connection *));
 793         void add_connection (Connection *);
 794         void remove_connection (Connection *);
 795         Connection *connection_by_name (string) const;
 796
 797         sigc::signal<void,Connection *> ConnectionAdded;
 798         sigc::signal<void,Connection *> ConnectionRemoved;
 799
 800         /* MIDI */
 801
 802         int set_mtc_port (string port_tag);
 803         int set_mmc_port (string port_tag);
 804         int set_midi_port (string port_tag);
 805         MIDI::Port *mtc_port() const { return _mtc_port; }
 806         MIDI::Port *mmc_port() const { return _mmc_port; }
 807         MIDI::Port *midi_port() const { return _midi_port; }
 808
 809         sigc::signal<void> MTC_PortChanged;
 810         sigc::signal<void> MMC_PortChanged;
 811         sigc::signal<void> MIDI_PortChanged;
 812
 813         void set_trace_midi_input (bool, MIDI::Port* port = 0);
 814         void set_trace_midi_output (bool, MIDI::Port* port = 0);
 815
 816         bool get_trace_midi_input(MIDI::Port *port = 0);
 817         bool get_trace_midi_output(MIDI::Port *port = 0);
 818
 819         void send_midi_message (MIDI::Port * port, MIDI::eventType ev, MIDI::channel_t, MIDI::EventTwoBytes);
 820
 821         void deliver_midi (MIDI::Port*, MIDI::byte*, int32_t size);
 822
 823         /* Scrubbing */
 824
 825         void start_scrub (jack_nframes_t where);
 826         void stop_scrub ();
 827         void set_scrub_speed (float);
 828         jack_nframes_t scrub_buffer_size() const;
 829         sigc::signal<void> ScrubReady;
 830
 831         /* History (for editors, mixers, UIs etc.) */
 832
 833         void undo (uint32_t n) {
 834                 history.undo (n);
 835         }
 836         void redo (uint32_t n) {
 837                 history.redo (n);
 838         }
 839
 840         uint32_t undo_depth() const { return history.undo_depth(); }
 841         uint32_t redo_depth() const { return history.redo_depth(); }
 842         string next_undo() const { return history.next_undo(); }
 843         string next_redo() const { return history.next_redo(); }
 844
 845         void begin_reversible_command (string cmd_name, UndoAction *private_undo = 0);
 846         void commit_reversible_command (UndoAction* private_redo = 0);
 847
 848         void add_undo (const UndoAction& ua) {
 849                 current_cmd.add_undo (ua);
 850         }
 851         void add_redo (const UndoAction& ua) {
 852                 current_cmd.add_redo (ua);
 853         }
 854         void add_redo_no_execute (const UndoAction& ua) {
 855                 current_cmd.add_redo_no_execute (ua);
 856         }
 857
 858         UndoAction global_solo_memento (void *src);
 859         UndoAction global_mute_memento (void *src);
 860         UndoAction global_record_enable_memento (void *src);
 861         UndoAction global_metering_memento (void *src);
 862
 863         /* edit mode */
 864
 865         void set_edit_mode (EditMode);
 866         EditMode get_edit_mode () const { return _edit_mode; }
 867
 868         /* clicking */
 869
 870         IO&  click_io() { return *_click_io; }
 871         void set_clicking (bool yn);
 872         bool get_clicking() const;
 873
 874         void set_click_sound (string path);
 875         void set_click_emphasis_sound (string path);
 876
 877         /* tempo FX */
 878
 879         struct TimeStretchRequest {
 880             ARDOUR::AudioRegion* region;
 881             float                fraction; /* session: read ; GUI: write */
 882             float                progress; /* session: write ; GUI: read */
 883             bool                 running;  /* read/write */
 884             bool                 quick_seek; /* GUI: write */
 885             bool                 antialias;  /* GUI: write */
 886
 887             TimeStretchRequest () : region (0) {}
 888         };
 889
 890         AudioRegion* tempoize_region (TimeStretchRequest&);
 891
 892         string raid_path() const;
 893         void   set_raid_path(string);
 894
 895         /* need to call this whenever we change native file formats */
 896
 897         void reset_native_file_format();
 898
 899         /* disk, buffer loads */
 900
 901         uint32_t playback_load ();
 902         uint32_t capture_load ();
 903         uint32_t playback_load_min ();
 904         uint32_t capture_load_min ();
 905
 906         void reset_playback_load_min ();
 907         void reset_capture_load_min ();
 908
 909         float read_data_rate () const;
 910         float write_data_rate () const;
 911
 912         /* ranges */
 913
 914         void set_audio_range (list<AudioRange>&);
 915         void set_music_range (list<MusicRange>&);
 916
 917         void request_play_range (bool yn);
 918         bool get_play_range () const { return _play_range; }
 919
 920         /* favorite dirs */
 921         typedef vector<string> FavoriteDirs;
 922
 923         static int read_favorite_dirs (FavoriteDirs&);
 924
 925         static int write_favorite_dirs (FavoriteDirs&);
 926
 927         /* file suffixes */
 928
 929         static const char* template_suffix() { return _template_suffix; }
 930         static const char* statefile_suffix() { return _statefile_suffix; }
 931         static const char* pending_suffix() { return _pending_suffix; }
 932
 933         /* buffers for gain and pan */
 934
 935         gain_t* gain_automation_buffer () const { return _gain_automation_buffer; }
 936         pan_t** pan_automation_buffer() const { return _pan_automation_buffer; }
 937
 938         /* buffers for conversion */
 939         enum RunContext {
 940                 ButlerContext = 0,
 941                 TransportContext,
 942                 ExportContext
 943         };
 944
 945         char *  conversion_buffer(RunContext context) { return _conversion_buffers[context]; }
 946
 947         /* VST support */
 948
 949         static long vst_callback (AEffect* effect,
 950                                   long opcode,
 951                                   long index,
 952                                   long value,
 953                                   void* ptr,
 954                                   float opt);
 955
 956         typedef float (*compute_peak_t)                         (Sample *, jack_nframes_t, float);
 957         typedef void  (*apply_gain_to_buffer_t)         (Sample *, jack_nframes_t, float);
 958         typedef void  (*mix_buffers_with_gain_t)        (Sample *, Sample *, jack_nframes_t, float);
 959         typedef void  (*mix_buffers_no_gain_t)          (Sample *, Sample *, jack_nframes_t);
 960
 961         static compute_peak_t                   compute_peak;
 962         static apply_gain_to_buffer_t   apply_gain_to_buffer;
 963         static mix_buffers_with_gain_t  mix_buffers_with_gain;
 964         static mix_buffers_no_gain_t    mix_buffers_no_gain;
 965
 966   protected:
 967         friend class AudioEngine;
 968         void set_block_size (jack_nframes_t nframes);
 969         void set_frame_rate (jack_nframes_t nframes);
 970
 971   protected:
 972         friend class DiskStream;
 973         void stop_butler ();
 974         void wait_till_butler_finished();
 975
 976   protected:
 977         friend class Route;
 978         void schedule_curve_reallocation ();
 979         void update_latency_compensation (bool, bool);
 980
 981   private:
 982         int  create (bool& new_session, string* mix_template, jack_nframes_t initial_length);
 983
 984         static const char* _template_suffix;
 985         static const char* _statefile_suffix;
 986         static const char* _pending_suffix;
 987
 988         enum SubState {
 989                 PendingDeclickIn   = 0x1,
 990                 PendingDeclickOut  = 0x2,
 991                 StopPendingCapture = 0x4,
 992                 AutoReturning      = 0x10,
 993                 PendingLocate      = 0x20,
 994                 PendingSetLoop     = 0x40
 995         };
 996
 997         /* stuff used in process() should be close together to
 998            maximise cache hits
 999         */
1000
1001         typedef void (Session::*process_function_type)(jack_nframes_t);
1002
1003         AudioEngine            &_engine;
1004         atomic_t                 processing_prohibited;
1005         process_function_type    process_function;
1006         process_function_type    last_process_function;
1007         jack_nframes_t          _current_frame_rate;
1008         int                      transport_sub_state;
1009         atomic_t                _record_status;
1010         jack_nframes_t          _transport_frame;
1011         Location*                end_location;
1012         Location*                start_location;
1013         Slave                  *_slave;
1014         SlaveSource             _slave_type;
1015         volatile float          _transport_speed;
1016         volatile float          _desired_transport_speed;
1017         float                   _last_transport_speed;
1018         jack_nframes_t          _last_slave_transport_frame;
1019         jack_nframes_t           maximum_output_latency;
1020         jack_nframes_t           last_stop_frame;
1021         vector<Sample *>        _passthru_buffers;
1022         vector<Sample *>        _silent_buffers;
1023         vector<Sample *>        _send_buffers;
1024         map<RunContext,char*>   _conversion_buffers;
1025         jack_nframes_t           current_block_size;
1026         jack_nframes_t          _worst_output_latency;
1027         jack_nframes_t          _worst_input_latency;
1028         jack_nframes_t          _worst_track_latency;
1029         bool                    _have_captured;
1030         float                   _meter_hold;
1031         float                   _meter_falloff;
1032         bool                    _end_location_is_free;
1033
1034         void set_worst_io_latencies (bool take_lock);
1035         void set_worst_io_latencies_x (IOChange asifwecare, void *ignored) {
1036                 set_worst_io_latencies (true);
1037         }
1038
1039         void update_latency_compensation_proxy (void* ignored);
1040
1041         void ensure_passthru_buffers (uint32_t howmany);
1042
1043         void process_scrub          (jack_nframes_t);
1044         void process_without_events (jack_nframes_t);
1045         void process_with_events    (jack_nframes_t);
1046         void process_audition       (jack_nframes_t);
1047         int  process_export         (jack_nframes_t, ARDOUR::AudioExportSpecification*);
1048
1049         /* slave tracking */
1050
1051         static const int delta_accumulator_size = 25;
1052         int delta_accumulator_cnt;
1053         long delta_accumulator[delta_accumulator_size];
1054         long average_slave_delta;
1055         int  average_dir;
1056         bool have_first_delta_accumulator;
1057
1058         enum SlaveState {
1059                 Stopped,
1060                 Waiting,
1061                 Running
1062         };
1063
1064         SlaveState slave_state;
1065         jack_nframes_t slave_wait_end;
1066
1067         void reset_slave_state ();
1068         bool follow_slave (jack_nframes_t, jack_nframes_t);
1069
1070         bool _exporting;
1071         int prepare_to_export (ARDOUR::AudioExportSpecification&);
1072
1073         void prepare_diskstreams ();
1074         void commit_diskstreams (jack_nframes_t, bool& session_requires_butler);
1075         int  process_routes (jack_nframes_t, jack_nframes_t);
1076         int  silent_process_routes (jack_nframes_t, jack_nframes_t);
1077
1078         bool get_rec_monitors_input () {
1079                 if (actively_recording()) {
1080                         return true;
1081                 } else {
1082                         if (auto_input) {
1083                                 return false;
1084                         } else {
1085                                 return true;
1086                         }
1087                 }
1088         }
1089
1090         int get_transport_declick_required () {
1091
1092                 if (transport_sub_state & PendingDeclickIn) {
1093                         transport_sub_state &= ~PendingDeclickIn;
1094                         return 1;
1095                 } else if (transport_sub_state & PendingDeclickOut) {
1096                         return -1;
1097                 } else {
1098                         return 0;
1099                 }
1100         }
1101
1102         bool maybe_stop (jack_nframes_t limit) {
1103                 if ((_transport_speed > 0.0f && _transport_frame >= limit) || (_transport_speed < 0.0f && _transport_frame == 0)) {
1104                         stop_transport ();
1105                         return true;
1106                 }
1107                 return false;
1108         }
1109
1110         void check_declick_out ();
1111
1112         MIDI::MachineControl*    mmc;
1113         MIDI::Port*             _mmc_port;
1114         MIDI::Port*             _mtc_port;
1115         MIDI::Port*             _midi_port;
1116         string                  _path;
1117         string                  _name;
1118         bool                     do_not_record_plugins;
1119
1120         /* toggles */
1121
1122         bool auto_play;
1123         bool punch_in;
1124         bool punch_out;
1125         bool auto_loop;
1126         bool seamless_loop;
1127         bool loop_changing;
1128         jack_nframes_t last_loopend;
1129         bool auto_input;
1130         bool crossfades_active;
1131         bool all_safe;
1132         bool auto_return;
1133         bool monitor_in;
1134         bool send_mtc;
1135         bool send_mmc;
1136         bool mmc_control;
1137         bool midi_control;
1138
1139         RingBuffer<Event*> pending_events;
1140
1141         void hookup_io ();
1142         void when_engine_running ();
1143         sigc::connection first_time_running;
1144         void graph_reordered ();
1145
1146         string _current_snapshot_name;
1147
1148         XMLTree* state_tree;
1149         bool     state_was_pending;
1150         StateOfTheState _state_of_the_state;
1151
1152         void     auto_save();
1153         int      load_options (const XMLNode&);
1154         XMLNode& get_options () const;
1155         int      load_state (string snapshot_name);
1156
1157         jack_nframes_t   _last_roll_location;
1158         jack_nframes_t   _last_record_location;
1159         bool              pending_locate_roll;
1160         jack_nframes_t    pending_locate_frame;
1161
1162         bool              pending_locate_flush;
1163         bool              pending_abort;
1164         bool              pending_auto_loop;
1165
1166         Sample*              butler_mixdown_buffer;
1167         float*               butler_gain_buffer;
1168         pthread_t            butler_thread;
1169         PBD::NonBlockingLock butler_request_lock;
1170         pthread_cond_t       butler_paused;
1171         bool                 butler_should_run;
1172         atomic_t             butler_should_do_transport_work;
1173         int                  butler_request_pipe[2];
1174
1175         struct ButlerRequest {
1176             enum Type {
1177                     Wake,
1178                     Run,
1179                     Pause,
1180                     Quit
1181             };
1182         };
1183
1184         enum PostTransportWork {
1185                 PostTransportStop               = 0x1,
1186                 PostTransportDisableRecord      = 0x2,
1187                 PostTransportPosition           = 0x8,
1188                 PostTransportDidRecord          = 0x20,
1189                 PostTransportDuration           = 0x40,
1190                 PostTransportLocate             = 0x80,
1191                 PostTransportRoll               = 0x200,
1192                 PostTransportAbort              = 0x800,
1193                 PostTransportOverWrite          = 0x1000,
1194                 PostTransportSpeed              = 0x2000,
1195                 PostTransportAudition           = 0x4000,
1196                 PostTransportScrub              = 0x8000,
1197                 PostTransportReverse            = 0x10000,
1198                 PostTransportInputChange        = 0x20000,
1199                 PostTransportCurveRealloc       = 0x40000
1200         };
1201
1202         static const PostTransportWork ProcessCannotProceedMask =
1203                 PostTransportWork (PostTransportInputChange|
1204                                    PostTransportSpeed|
1205                                    PostTransportReverse|
1206                                    PostTransportCurveRealloc|
1207                                    PostTransportScrub|
1208                                    PostTransportAudition|
1209                                    PostTransportLocate|
1210                                    PostTransportStop);
1211
1212         PostTransportWork post_transport_work;
1213
1214         void             summon_butler ();
1215         void             schedule_butler_transport_work ();
1216         int              start_butler_thread ();
1217         void             terminate_butler_thread ();
1218         static void    *_butler_thread_work (void *arg);
1219         void*            butler_thread_work ();
1220
1221         uint32_t    cumulative_rf_motion;
1222         uint32_t    rf_scale;
1223
1224         void set_rf_speed (float speed);
1225         void reset_rf_scale (jack_nframes_t frames_moved);
1226
1227         Locations        _locations;
1228         void              locations_changed ();
1229         void              locations_added (Location*);
1230         void              handle_locations_changed (Locations::LocationList&);
1231
1232         sigc::connection auto_punch_start_changed_connection;
1233         sigc::connection auto_punch_end_changed_connection;
1234         sigc::connection auto_punch_changed_connection;
1235         void             auto_punch_start_changed (Location *);
1236         void             auto_punch_end_changed (Location *);
1237         void             auto_punch_changed (Location *);
1238
1239         sigc::connection auto_loop_start_changed_connection;
1240         sigc::connection auto_loop_end_changed_connection;
1241         sigc::connection auto_loop_changed_connection;
1242         void             auto_loop_changed (Location *);
1243
1244         typedef list<Event *> Events;
1245         Events           events;
1246         Events           immediate_events;
1247         Events::iterator next_event;
1248
1249         /* there can only ever be one of each of these */
1250
1251         Event *auto_loop_event;
1252         Event *punch_out_event;
1253         Event *punch_in_event;
1254
1255         /* events */
1256
1257         void dump_events () const;
1258         void queue_event (Event *ev);
1259         void merge_event (Event*);
1260         void replace_event (Event::Type, jack_nframes_t action_frame, jack_nframes_t target = 0);
1261         bool _replace_event (Event*);
1262         bool _remove_event (Event *);
1263         void _clear_event_type (Event::Type);
1264
1265         void first_stage_init (string path, string snapshot_name);
1266         int  second_stage_init (bool new_tracks);
1267         void find_current_end ();
1268         void remove_empty_sounds ();
1269
1270         void setup_midi_control ();
1271         int  midi_read (MIDI::Port *);
1272
1273         void enable_record ();
1274
1275         void increment_transport_position (uint32_t val) {
1276                 if (max_frames - val < _transport_frame) {
1277                         _transport_frame = max_frames;
1278                 } else {
1279                         _transport_frame += val;
1280                 }
1281         }
1282
1283         void decrement_transport_position (uint32_t val) {
1284                 if (val < _transport_frame) {
1285                         _transport_frame -= val;
1286                 } else {
1287                         _transport_frame = 0;
1288                 }
1289         }
1290
1291         void post_transport_motion ();
1292         static void *session_loader_thread (void *arg);
1293
1294         void *do_work();
1295
1296         void set_next_event ();
1297         void process_event (Event *);
1298
1299         /* MIDI Machine Control */
1300
1301         void deliver_mmc (MIDI::MachineControl::Command, jack_nframes_t);
1302         void deliver_midi_message (MIDI::Port * port, MIDI::eventType ev, MIDI::channel_t, MIDI::EventTwoBytes);
1303         void deliver_data (MIDI::Port* port, MIDI::byte*, int32_t size);
1304
1305         void spp_start (MIDI::Parser&);
1306         void spp_continue (MIDI::Parser&);
1307         void spp_stop (MIDI::Parser&);
1308
1309         void mmc_deferred_play (MIDI::MachineControl &);
1310         void mmc_stop (MIDI::MachineControl &);
1311         void mmc_step (MIDI::MachineControl &, int);
1312         void mmc_pause (MIDI::MachineControl &);
1313         void mmc_record_pause (MIDI::MachineControl &);
1314         void mmc_record_strobe (MIDI::MachineControl &);
1315         void mmc_record_exit (MIDI::MachineControl &);
1316         void mmc_track_record_status (MIDI::MachineControl &,
1317                                       uint32_t track, bool enabled);
1318         void mmc_fast_forward (MIDI::MachineControl &);
1319         void mmc_rewind (MIDI::MachineControl &);
1320         void mmc_locate (MIDI::MachineControl &, const MIDI::byte *);
1321         void mmc_shuttle (MIDI::MachineControl &mmc, float speed, bool forw);
1322         void mmc_record_enable (MIDI::MachineControl &mmc, size_t track, bool enabled);
1323
1324         struct timeval last_mmc_step;
1325         double step_speed;
1326
1327         typedef sigc::slot<bool> MidiTimeoutCallback;
1328         typedef list<MidiTimeoutCallback> MidiTimeoutList;
1329
1330         MidiTimeoutList midi_timeouts;
1331         bool mmc_step_timeout ();
1332
1333         MIDI::byte mmc_buffer[32];
1334         MIDI::byte mtc_msg[16];
1335         MIDI::byte mtc_smpte_bits;   /* encoding of SMTPE type for MTC */
1336         MIDI::byte midi_msg[16];
1337         jack_nframes_t  outbound_mtc_smpte_frame;
1338         SMPTE_Time transmitting_smpte_time;
1339         int next_quarter_frame_to_send;
1340
1341         double _frames_per_smpte_frame; /* has to be floating point because of drop frame */
1342         jack_nframes_t _frames_per_hour;
1343         jack_nframes_t _smpte_frames_per_hour;
1344         jack_nframes_t _smpte_offset;
1345         bool _smpte_offset_negative;
1346
1347         /* cache the most-recently requested time conversions.
1348            this helps when we have multiple clocks showing the
1349            same time (e.g. the transport frame)
1350         */
1351
1352         bool       last_smpte_valid;
1353         jack_nframes_t  last_smpte_when;
1354         SMPTE_Time last_smpte;
1355
1356         int send_full_time_code ();
1357         int send_midi_time_code ();
1358
1359         void send_full_time_code_in_another_thread ();
1360         void send_midi_time_code_in_another_thread ();
1361         void send_time_code_in_another_thread (bool full);
1362         void send_mmc_in_another_thread (MIDI::MachineControl::Command, jack_nframes_t frame = 0);
1363
1364         jack_nframes_t adjust_apparent_position (jack_nframes_t frames);
1365
1366         void reset_record_status ();
1367
1368         int no_roll (jack_nframes_t nframes, jack_nframes_t offset);
1369
1370         bool non_realtime_work_pending() const { return static_cast<bool>(post_transport_work); }
1371         bool process_can_proceed() const { return !(post_transport_work & ProcessCannotProceedMask); }
1372
1373         struct MIDIRequest {
1374
1375             enum Type {
1376                     SendFullMTC,
1377                     SendMTC,
1378                     SendMMC,
1379                     PortChange,
1380                     SendMessage,
1381                     Deliver,
1382                     Quit
1383             };
1384
1385             Type type;
1386             MIDI::MachineControl::Command mmc_cmd;
1387             jack_nframes_t locate_frame;
1388
1389             // for SendMessage type
1390
1391             MIDI::Port * port;
1392             MIDI::channel_t chan;
1393             union {
1394                 MIDI::EventTwoBytes data;
1395                 MIDI::byte* buf;
1396             };
1397
1398             union {
1399                 MIDI::eventType ev;
1400                 int32_t size;
1401             };
1402
1403             MIDIRequest () {}
1404
1405             void *operator new(size_t ignored) {
1406                     return pool.alloc ();
1407             };
1408
1409             void operator delete(void *ptr, size_t size) {
1410                     pool.release (ptr);
1411             }
1412
1413           private:
1414             static MultiAllocSingleReleasePool pool;
1415         };
1416
1417         PBD::Lock       midi_lock;
1418         pthread_t       midi_thread;
1419         int             midi_request_pipe[2];
1420         atomic_t        butler_active;
1421         RingBuffer<MIDIRequest*> midi_requests;
1422
1423         int           start_midi_thread ();
1424         void          terminate_midi_thread ();
1425         void          poke_midi_thread ();
1426         static void *_midi_thread_work (void *arg);
1427         void          midi_thread_work ();
1428         void          change_midi_ports ();
1429         int           use_config_midi_ports ();
1430
1431         bool waiting_to_start;
1432
1433         void set_auto_loop (bool yn);
1434         void overwrite_some_buffers (DiskStream*);
1435         void flush_all_redirects ();
1436         void locate (jack_nframes_t, bool with_roll, bool with_flush, bool with_loop=false);
1437         void start_locate (jack_nframes_t, bool with_roll, bool with_flush, bool with_loop=false);
1438         void force_locate (jack_nframes_t frame, bool with_roll = false);
1439         void set_diskstream_speed (DiskStream*, float speed);
1440         void set_transport_speed (float speed, bool abort = false);
1441         void stop_transport (bool abort = false);
1442         void start_transport ();
1443         void actually_start_transport ();
1444         void realtime_stop (bool abort);
1445         void non_realtime_start_scrub ();
1446         void non_realtime_set_speed ();
1447         void non_realtime_stop (bool abort);
1448         void non_realtime_overwrite ();
1449         void non_realtime_buffer_fill ();
1450         void butler_transport_work ();
1451         void post_transport ();
1452         void engine_halted ();
1453         void xrun_recovery ();
1454
1455         TempoMap    *_tempo_map;
1456         void          tempo_map_changed (Change);
1457
1458         /* edit/mix groups */
1459
1460         int load_route_groups (const XMLNode&, bool is_edit);
1461         int load_edit_groups (const XMLNode&);
1462         int load_mix_groups (const XMLNode&);
1463
1464
1465         list<RouteGroup *> edit_groups;
1466         list<RouteGroup *> mix_groups;
1467
1468         /* disk-streams */
1469
1470         DiskStreamList  diskstreams;
1471         mutable PBD::NonBlockingRWLock diskstream_lock;
1472         uint32_t dstream_buffer_size;
1473         void add_diskstream (DiskStream*);
1474         int  load_diskstreams (const XMLNode&);
1475
1476         /* routes stuff */
1477
1478         RouteList       routes;
1479         mutable PBD::NonBlockingRWLock route_lock;
1480         void   add_route (Route*);
1481         uint32_t destructive_index;
1482
1483         int load_routes (const XMLNode&);
1484         Route* XMLRouteFactory (const XMLNode&);
1485
1486         /* mixer stuff */
1487
1488         bool      _solo_latched;
1489         SoloModel _solo_model;
1490         bool       solo_update_disabled;
1491         bool       currently_soloing;
1492
1493         void route_mute_changed (void *src);
1494         void route_solo_changed (void *src, Route *);
1495         void catch_up_on_solo ();
1496         void update_route_solo_state ();
1497         void modify_solo_mute (bool, bool);
1498         void strip_portname_for_solo (string& portname);
1499
1500         /* REGION MANAGEMENT */
1501
1502         mutable PBD::Lock region_lock;
1503         typedef map<ARDOUR::id_t,AudioRegion *> AudioRegionList;
1504         AudioRegionList audio_regions;
1505
1506         void region_renamed (Region *);
1507         void region_changed (Change, Region *);
1508         void add_region (Region *);
1509         void remove_region (Region *);
1510
1511         int load_regions (const XMLNode& node);
1512
1513         /* SOURCES */
1514
1515         mutable PBD::Lock source_lock;
1516         typedef std::map<id_t, Source *>    SourceList;
1517
1518         SourceList sources;
1519
1520         int load_sources (const XMLNode& node);
1521         XMLNode& get_sources_as_xml ();
1522
1523         void remove_source (Source *);
1524
1525         Source *XMLSourceFactory (const XMLNode&);
1526
1527         /* PLAYLISTS */
1528
1529         mutable PBD::Lock playlist_lock;
1530         typedef set<Playlist *> PlaylistList;
1531         PlaylistList playlists;
1532         PlaylistList unused_playlists;
1533
1534         int load_playlists (const XMLNode&);
1535         int load_unused_playlists (const XMLNode&);
1536         void remove_playlist (Playlist *);
1537         void track_playlist (Playlist *, bool);
1538
1539         Playlist *playlist_factory (string name);
1540         Playlist *XMLPlaylistFactory (const XMLNode&);
1541
1542         void playlist_length_changed (Playlist *);
1543         void diskstream_playlist_changed (DiskStream *);
1544
1545         /* NAMED SELECTIONS */
1546
1547         mutable PBD::Lock named_selection_lock;
1548         typedef set<NamedSelection *> NamedSelectionList;
1549         NamedSelectionList named_selections;
1550
1551         int load_named_selections (const XMLNode&);
1552
1553         NamedSelection *named_selection_factory (string name);
1554         NamedSelection *XMLNamedSelectionFactory (const XMLNode&);
1555
1556         /* DEFAULT FADE CURVES */
1557
1558         float default_fade_steepness;
1559         float default_fade_msecs;
1560
1561         /* AUDITIONING */
1562
1563         Auditioner *auditioner;
1564         void set_audition (AudioRegion*);
1565         void non_realtime_set_audition ();
1566         AudioRegion *pending_audition_region;
1567
1568         /* EXPORT */
1569
1570         /* FLATTEN */
1571
1572         int flatten_one_track (AudioTrack&, jack_nframes_t start, jack_nframes_t cnt);
1573
1574         /* INSERT AND SEND MANAGEMENT */
1575
1576         list<PortInsert *>   _port_inserts;
1577         list<PluginInsert *> _plugin_inserts;
1578         list<Send *>         _sends;
1579         uint32_t          send_cnt;
1580         uint32_t          insert_cnt;
1581
1582         void add_redirect (Redirect *);
1583         void remove_redirect (Redirect *);
1584
1585         /* S/W RAID */
1586
1587         struct space_and_path {
1588             uint32_t blocks; /* 4kB blocks */
1589             string path;
1590
1591             space_and_path() {
1592                     blocks = 0;
1593             }
1594         };
1595
1596         struct space_and_path_ascending_cmp {
1597             bool operator() (space_and_path a, space_and_path b) {
1598                     return a.blocks > b.blocks;
1599             }
1600         };
1601
1602         void setup_raid_path (string path);
1603
1604         vector<space_and_path> session_dirs;
1605         vector<space_and_path>::iterator last_rr_session_dir;
1606         uint32_t _total_free_4k_blocks;
1607         PBD::Lock space_lock;
1608
1609         static const char* sound_dir_name;
1610         static const char* tape_dir_name;
1611         static const char* dead_sound_dir_name;
1612         static const char* peak_dir_name;
1613
1614         string discover_best_sound_dir (bool destructive = false);
1615         int ensure_sound_dir (string, string&);
1616         void refresh_disk_space ();
1617
1618         atomic_t _playback_load;
1619         atomic_t _capture_load;
1620         atomic_t _playback_load_min;
1621         atomic_t _capture_load_min;
1622
1623         /* I/O Connections */
1624
1625         typedef list<Connection *> ConnectionList;
1626         mutable PBD::Lock connection_lock;
1627         ConnectionList _connections;
1628         int load_connections (const XMLNode&);
1629
1630         int set_slave_source (SlaveSource, jack_nframes_t);
1631
1632         void reverse_diskstream_buffers ();
1633
1634         UndoHistory history;
1635         UndoCommand current_cmd;
1636
1637         GlobalRouteBooleanState get_global_route_boolean (bool (Route::*method)(void) const);
1638         GlobalRouteMeterState get_global_route_metering ();
1639
1640         void set_global_route_boolean (GlobalRouteBooleanState s, void (Route::*method)(bool, void*), void *arg);
1641         void set_global_route_metering (GlobalRouteMeterState s, void *arg);
1642
1643         void set_global_mute (GlobalRouteBooleanState s, void *src);
1644         void set_global_solo (GlobalRouteBooleanState s, void *src);
1645         void set_global_record_enable (GlobalRouteBooleanState s, void *src);
1646
1647         void jack_timebase_callback (jack_transport_state_t, jack_nframes_t, jack_position_t*, int);
1648         int  jack_sync_callback (jack_transport_state_t, jack_position_t*);
1649         void record_enable_change_all (bool yn);
1650
1651         XMLNode& state(bool);
1652
1653         /* click track */
1654
1655         struct Click {
1656             jack_nframes_t start;
1657             jack_nframes_t duration;
1658             jack_nframes_t offset;
1659             const Sample *data;
1660
1661             Click (jack_nframes_t s, jack_nframes_t d, const Sample *b)
1662                     : start (s), duration (d), data (b) { offset = 0; }
1663
1664             void *operator new(size_t ignored) {
1665                     return pool.alloc ();
1666             };
1667
1668             void operator delete(void *ptr, size_t size) {
1669                     pool.release (ptr);
1670             }
1671
1672           private:
1673             static Pool pool;
1674         };
1675
1676         typedef list<Click*> Clicks;
1677
1678         Clicks          clicks;
1679         bool           _clicking;
1680         IO*            _click_io;
1681         Sample*         click_data;
1682         Sample*         click_emphasis_data;
1683         jack_nframes_t  click_length;
1684         jack_nframes_t  click_emphasis_length;
1685         mutable PBD::NonBlockingRWLock click_lock;
1686
1687         static const Sample         default_click[];
1688         static const jack_nframes_t default_click_length;
1689         static const Sample         default_click_emphasis[];
1690         static const jack_nframes_t default_click_emphasis_length;
1691
1692         Click *get_click();
1693         void   setup_click_sounds (int which);
1694         void   clear_clicks ();
1695         void   click (jack_nframes_t start, jack_nframes_t nframes, jack_nframes_t offset);
1696
1697         vector<Route*> master_outs;
1698
1699         EditMode _edit_mode;
1700         EditMode pending_edit_mode;
1701
1702         /* range playback */
1703
1704         list<AudioRange> current_audio_range;
1705         bool _play_range;
1706         void set_play_range (bool yn);
1707         void setup_auto_play ();
1708
1709         /* main outs */
1710         uint32_t main_outs;
1711
1712         IO* _master_out;
1713         IO* _control_out;
1714
1715         AutoConnectOption input_auto_connect;
1716         AutoConnectOption output_auto_connect;
1717
1718         gain_t* _gain_automation_buffer;
1719         pan_t** _pan_automation_buffer;
1720         void allocate_pan_automation_buffers (jack_nframes_t nframes, uint32_t howmany, bool force);
1721         uint32_t _npan_buffers;
1722
1723         /* VST support */
1724
1725         long _vst_callback (VSTPlugin*,
1726                             long opcode,
1727                             long index,
1728                             long value,
1729                             void* ptr,
1730                             float opt);
1731
1732         /* number of hardware audio ports we're using,
1733            based on max (requested,available)
1734         */
1735
1736         uint32_t n_physical_outputs;
1737         uint32_t n_physical_inputs;
1738
1739         void remove_pending_capture_state ();
1740
1741         int find_all_sources (std::string path, std::set<std::string>& result);
1742         int find_all_sources_across_snapshots (std::set<std::string>& result, bool exclude_this_snapshot);
1743
1744         LayerModel layer_model;
1745         CrossfadeModel xfade_model;
1746 };
1747
1748 }; /* namespace ARDOUR */
1749
1750 #endif /* __ardour_session_h__ */