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