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