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