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