libs/ardour/ardour/session.h

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