libs/ardour/ardour/session.h

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