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