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             /* result */
 652             std::vector<AudioRegion*> new_regions;
 653
 654         };
 655
 656         int import_audiofile (import_status&);
 657         bool sample_rate_convert (import_status&, string infile, string& outfile);
 658         string build_tmp_convert_name (string file);
 659
 660         Session::SlaveSource post_export_slave;
 661         jack_nframes_t post_export_position;
 662
 663         int start_audio_export (ARDOUR::AudioExportSpecification&);
 664         int stop_audio_export (ARDOUR::AudioExportSpecification&);
 665
 666         void add_source (Source *);
 667         int  remove_file_source (FileSource&);
 668
 669         struct cleanup_report {
 670             vector<string> paths;
 671             int32_t space;
 672         };
 673
 674         int  cleanup_sources (cleanup_report&);
 675         int  cleanup_trash_sources (cleanup_report&);
 676
 677         int destroy_region (Region*);
 678         int destroy_regions (list<Region*>);
 679
 680         int remove_last_capture ();
 681
 682         /* handlers should return -1 for "stop cleanup", 0 for
 683            "yes, delete this playlist" and 1 for "no, don't delete
 684            this playlist.
 685         */
 686
 687         sigc::signal<int,ARDOUR::Playlist*> AskAboutPlaylistDeletion;
 688
 689
 690         /* handlers should return !0 for use pending state, 0 for
 691            ignore it.
 692         */
 693
 694         static sigc::signal<int> AskAboutPendingState;
 695
 696         sigc::signal<void,Source *> SourceAdded;
 697         sigc::signal<void,Source *> SourceRemoved;
 698
 699         FileSource *create_file_source (ARDOUR::DiskStream&, int32_t chan, bool destructive);
 700         Source *get_source (ARDOUR::id_t);
 701
 702         /* playlist management */
 703
 704         Playlist* playlist_by_name (string name);
 705         void add_playlist (Playlist *);
 706         sigc::signal<void,Playlist*> PlaylistAdded;
 707         sigc::signal<void,Playlist*> PlaylistRemoved;
 708
 709         Playlist *get_playlist (string name);
 710
 711         uint32_t n_playlists() const;
 712
 713         template<class T> void foreach_playlist (T *obj, void (T::*func)(Playlist *));
 714
 715         /* named selections */
 716
 717         NamedSelection* named_selection_by_name (string name);
 718         void add_named_selection (NamedSelection *);
 719         void remove_named_selection (NamedSelection *);
 720
 721         template<class T> void foreach_named_selection (T& obj, void (T::*func)(NamedSelection&));
 722         sigc::signal<void> NamedSelectionAdded;
 723         sigc::signal<void> NamedSelectionRemoved;
 724
 725         /* fade curves */
 726
 727         float get_default_fade_length () const { return default_fade_msecs; }
 728         float get_default_fade_steepness () const { return default_fade_steepness; }
 729         void set_default_fade (float steepness, float msecs);
 730
 731         /* auditioning */
 732
 733         Auditioner& the_auditioner() { return *auditioner; }
 734         void audition_playlist ();
 735         void audition_region (AudioRegion&);
 736         void cancel_audition ();
 737         bool is_auditioning () const;
 738
 739         sigc::signal<void,bool> AuditionActive;
 740
 741         /* flattening stuff */
 742
 743         int write_one_track (AudioTrack&, jack_nframes_t start, jack_nframes_t cnt, bool overwrite, vector<Source*>&,
 744                              InterThreadInfo& wot);
 745         int freeze (InterThreadInfo&);
 746
 747         /* session-wide solo/mute/rec-enable */
 748
 749         enum SoloModel {
 750                 InverseMute,
 751                 SoloBus
 752         };
 753
 754         bool soloing() const { return currently_soloing; }
 755
 756         SoloModel solo_model() const { return _solo_model; }
 757         void set_solo_model (SoloModel);
 758
 759         bool solo_latched() const { return _solo_latched; }
 760         void set_solo_latched (bool yn);
 761
 762         void set_all_solo (bool);
 763         void set_all_mute (bool);
 764
 765         sigc::signal<void,bool> SoloActive;
 766
 767         void record_disenable_all ();
 768         void record_enable_all ();
 769
 770         /* control/master out */
 771
 772         IO* control_out() const { return _control_out; }
 773         IO* master_out() const { return _master_out; }
 774
 775         /* insert/send management */
 776
 777         uint32_t n_port_inserts() const { return _port_inserts.size(); }
 778         uint32_t n_plugin_inserts() const { return _plugin_inserts.size(); }
 779         uint32_t n_sends() const { return _sends.size(); }
 780
 781         string next_send_name();
 782         string next_insert_name();
 783
 784         /* s/w "RAID" management */
 785
 786         jack_nframes_t available_capture_duration();
 787
 788         /* I/O Connections */
 789
 790         template<class T> void foreach_connection (T *obj, void (T::*func)(Connection *));
 791         void add_connection (Connection *);
 792         void remove_connection (Connection *);
 793         Connection *connection_by_name (string) const;
 794
 795         sigc::signal<void,Connection *> ConnectionAdded;
 796         sigc::signal<void,Connection *> ConnectionRemoved;
 797
 798         /* MIDI */
 799
 800         int set_mtc_port (string port_tag);
 801         int set_mmc_port (string port_tag);
 802         int set_midi_port (string port_tag);
 803         MIDI::Port *mtc_port() const { return _mtc_port; }
 804         MIDI::Port *mmc_port() const { return _mmc_port; }
 805         MIDI::Port *midi_port() const { return _midi_port; }
 806
 807         sigc::signal<void> MTC_PortChanged;
 808         sigc::signal<void> MMC_PortChanged;
 809         sigc::signal<void> MIDI_PortChanged;
 810
 811         void set_trace_midi_input (bool, MIDI::Port* port = 0);
 812         void set_trace_midi_output (bool, MIDI::Port* port = 0);
 813
 814         bool get_trace_midi_input(MIDI::Port *port = 0);
 815         bool get_trace_midi_output(MIDI::Port *port = 0);
 816
 817         void send_midi_message (MIDI::Port * port, MIDI::eventType ev, MIDI::channel_t, MIDI::EventTwoBytes);
 818         void send_all_midi_feedback ();
 819
 820         void deliver_midi (MIDI::Port*, MIDI::byte*, int32_t size);
 821
 822         /* Scrubbing */
 823
 824         void start_scrub (jack_nframes_t where);
 825         void stop_scrub ();
 826         void set_scrub_speed (float);
 827         jack_nframes_t scrub_buffer_size() const;
 828         sigc::signal<void> ScrubReady;
 829
 830         /* History (for editors, mixers, UIs etc.) */
 831
 832         void undo (uint32_t n) {
 833                 history.undo (n);
 834         }
 835         void redo (uint32_t n) {
 836                 history.redo (n);
 837         }
 838
 839         uint32_t undo_depth() const { return history.undo_depth(); }
 840         uint32_t redo_depth() const { return history.redo_depth(); }
 841         string next_undo() const { return history.next_undo(); }
 842         string next_redo() const { return history.next_redo(); }
 843
 844         void begin_reversible_command (string cmd_name, UndoAction *private_undo = 0);
 845         void commit_reversible_command (UndoAction* private_redo = 0);
 846
 847         void add_undo (const UndoAction& ua) {
 848                 current_cmd.add_undo (ua);
 849         }
 850         void add_redo (const UndoAction& ua) {
 851                 current_cmd.add_redo (ua);
 852         }
 853         void add_redo_no_execute (const UndoAction& ua) {
 854                 current_cmd.add_redo_no_execute (ua);
 855         }
 856
 857         UndoAction global_solo_memento (void *src);
 858         UndoAction global_mute_memento (void *src);
 859         UndoAction global_record_enable_memento (void *src);
 860         UndoAction global_metering_memento (void *src);
 861
 862         /* edit mode */
 863
 864         void set_edit_mode (EditMode);
 865         EditMode get_edit_mode () const { return _edit_mode; }
 866
 867         /* clicking */
 868
 869         IO&  click_io() { return *_click_io; }
 870         void set_clicking (bool yn);
 871         bool get_clicking() const;
 872
 873         void set_click_sound (string path);
 874         void set_click_emphasis_sound (string path);
 875
 876         /* tempo FX */
 877
 878         struct TimeStretchRequest {
 879             ARDOUR::AudioRegion* region;
 880             float                fraction; /* session: read ; GUI: write */
 881             float                progress; /* session: write ; GUI: read */
 882             bool                 running;  /* read/write */
 883             bool                 quick_seek; /* GUI: write */
 884             bool                 antialias;  /* GUI: write */
 885
 886             TimeStretchRequest () : region (0) {}
 887         };
 888
 889         AudioRegion* tempoize_region (TimeStretchRequest&);
 890
 891         string raid_path() const;
 892         void   set_raid_path(string);
 893
 894         /* need to call this whenever we change native file formats */
 895
 896         void reset_native_file_format();
 897
 898         /* disk, buffer loads */
 899
 900         uint32_t playback_load ();
 901         uint32_t capture_load ();
 902         uint32_t playback_load_min ();
 903         uint32_t capture_load_min ();
 904
 905         void reset_playback_load_min ();
 906         void reset_capture_load_min ();
 907
 908         float read_data_rate () const;
 909         float write_data_rate () const;
 910
 911         /* ranges */
 912
 913         void set_audio_range (list<AudioRange>&);
 914         void set_music_range (list<MusicRange>&);
 915
 916         void request_play_range (bool yn);
 917         bool get_play_range () const { return _play_range; }
 918
 919         /* favorite dirs */
 920         typedef vector<string> FavoriteDirs;
 921
 922         static int read_favorite_dirs (FavoriteDirs&);
 923
 924         static int write_favorite_dirs (FavoriteDirs&);
 925
 926         /* file suffixes */
 927
 928         static const char* template_suffix() { return _template_suffix; }
 929         static const char* statefile_suffix() { return _statefile_suffix; }
 930         static const char* pending_suffix() { return _pending_suffix; }
 931
 932         /* buffers for gain and pan */
 933
 934         gain_t* gain_automation_buffer () const { return _gain_automation_buffer; }
 935         pan_t** pan_automation_buffer() const { return _pan_automation_buffer; }
 936
 937         /* buffers for conversion */
 938         enum RunContext {
 939                 ButlerContext = 0,
 940                 TransportContext,
 941                 ExportContext
 942         };
 943
 944         char *  conversion_buffer(RunContext context) { return _conversion_buffers[context]; }
 945
 946         /* VST support */
 947
 948         static long vst_callback (AEffect* effect,
 949                                   long opcode,
 950                                   long index,
 951                                   long value,
 952                                   void* ptr,
 953                                   float opt);
 954
 955         typedef float (*compute_peak_t)                         (Sample *, jack_nframes_t, float);
 956         typedef void  (*apply_gain_to_buffer_t)         (Sample *, jack_nframes_t, float);
 957         typedef void  (*mix_buffers_with_gain_t)        (Sample *, Sample *, jack_nframes_t, float);
 958         typedef void  (*mix_buffers_no_gain_t)          (Sample *, Sample *, jack_nframes_t);
 959
 960         static compute_peak_t                   compute_peak;
 961         static apply_gain_to_buffer_t   apply_gain_to_buffer;
 962         static mix_buffers_with_gain_t  mix_buffers_with_gain;
 963         static mix_buffers_no_gain_t    mix_buffers_no_gain;
 964
 965   protected:
 966         friend class AudioEngine;
 967         void set_block_size (jack_nframes_t nframes);
 968         void set_frame_rate (jack_nframes_t nframes);
 969
 970   protected:
 971         friend class DiskStream;
 972         void stop_butler ();
 973         void wait_till_butler_finished();
 974
 975   protected:
 976         friend class Route;
 977         void schedule_curve_reallocation ();
 978         void update_latency_compensation (bool, bool);
 979
 980   private:
 981         int  create (bool& new_session, string* mix_template, jack_nframes_t initial_length);
 982
 983         static const char* _template_suffix;
 984         static const char* _statefile_suffix;
 985         static const char* _pending_suffix;
 986
 987         enum SubState {
 988                 PendingDeclickIn   = 0x1,
 989                 PendingDeclickOut  = 0x2,
 990                 StopPendingCapture = 0x4,
 991                 AutoReturning      = 0x10,
 992                 PendingLocate      = 0x20,
 993                 PendingSetLoop     = 0x40
 994         };
 995
 996         /* stuff used in process() should be close together to
 997            maximise cache hits
 998         */
 999
1000         typedef void (Session::*process_function_type)(jack_nframes_t);
1001
1002         AudioEngine            &_engine;
1003         atomic_t                 processing_prohibited;
1004         process_function_type    process_function;
1005         process_function_type    last_process_function;
1006         jack_nframes_t          _current_frame_rate;
1007         int                      transport_sub_state;
1008         atomic_t                _record_status;
1009         jack_nframes_t          _transport_frame;
1010         Location*                end_location;
1011         Location*                start_location;
1012         Slave                  *_slave;
1013         SlaveSource             _slave_type;
1014         volatile float          _transport_speed;
1015         volatile float          _desired_transport_speed;
1016         float                   _last_transport_speed;
1017         jack_nframes_t          _last_slave_transport_frame;
1018         jack_nframes_t           maximum_output_latency;
1019         jack_nframes_t           last_stop_frame;
1020         vector<Sample *>        _passthru_buffers;
1021         vector<Sample *>        _silent_buffers;
1022         vector<Sample *>        _send_buffers;
1023         map<RunContext,char*>   _conversion_buffers;
1024         jack_nframes_t           current_block_size;
1025         jack_nframes_t          _worst_output_latency;
1026         jack_nframes_t          _worst_input_latency;
1027         jack_nframes_t          _worst_track_latency;
1028         bool                    _have_captured;
1029         float                   _meter_hold;
1030         float                   _meter_falloff;
1031         bool                    _end_location_is_free;
1032
1033         void set_worst_io_latencies (bool take_lock);
1034         void set_worst_io_latencies_x (IOChange asifwecare, void *ignored) {
1035                 set_worst_io_latencies (true);
1036         }
1037
1038         void update_latency_compensation_proxy (void* ignored);
1039
1040         void ensure_passthru_buffers (uint32_t howmany);
1041
1042         void process_scrub          (jack_nframes_t);
1043         void process_without_events (jack_nframes_t);
1044         void process_with_events    (jack_nframes_t);
1045         void process_audition       (jack_nframes_t);
1046         int  process_export         (jack_nframes_t, ARDOUR::AudioExportSpecification*);
1047
1048         /* slave tracking */
1049
1050         static const int delta_accumulator_size = 25;
1051         int delta_accumulator_cnt;
1052         long delta_accumulator[delta_accumulator_size];
1053         long average_slave_delta;
1054         int  average_dir;
1055         bool have_first_delta_accumulator;
1056
1057         enum SlaveState {
1058                 Stopped,
1059                 Waiting,
1060                 Running
1061         };
1062
1063         SlaveState slave_state;
1064         jack_nframes_t slave_wait_end;
1065
1066         void reset_slave_state ();
1067         bool follow_slave (jack_nframes_t, jack_nframes_t);
1068
1069         bool _exporting;
1070         int prepare_to_export (ARDOUR::AudioExportSpecification&);
1071
1072         void prepare_diskstreams ();
1073         void commit_diskstreams (jack_nframes_t, bool& session_requires_butler);
1074         int  process_routes (jack_nframes_t, jack_nframes_t);
1075         int  silent_process_routes (jack_nframes_t, jack_nframes_t);
1076
1077         bool get_rec_monitors_input () {
1078                 if (actively_recording()) {
1079                         return true;
1080                 } else {
1081                         if (auto_input) {
1082                                 return false;
1083                         } else {
1084                                 return true;
1085                         }
1086                 }
1087         }
1088
1089         int get_transport_declick_required () {
1090
1091                 if (transport_sub_state & PendingDeclickIn) {
1092                         transport_sub_state &= ~PendingDeclickIn;
1093                         return 1;
1094                 } else if (transport_sub_state & PendingDeclickOut) {
1095                         return -1;
1096                 } else {
1097                         return 0;
1098                 }
1099         }
1100
1101         bool maybe_stop (jack_nframes_t limit) {
1102                 if ((_transport_speed > 0.0f && _transport_frame >= limit) || (_transport_speed < 0.0f && _transport_frame == 0)) {
1103                         stop_transport ();
1104                         return true;
1105                 }
1106                 return false;
1107         }
1108
1109         void check_declick_out ();
1110
1111         MIDI::MachineControl*    mmc;
1112         MIDI::Port*             _mmc_port;
1113         MIDI::Port*             _mtc_port;
1114         MIDI::Port*             _midi_port;
1115         string                  _path;
1116         string                  _name;
1117         bool                     do_not_record_plugins;
1118
1119         /* toggles */
1120
1121         bool auto_play;
1122         bool punch_in;
1123         bool punch_out;
1124         bool auto_loop;
1125         bool seamless_loop;
1126         bool loop_changing;
1127         jack_nframes_t last_loopend;
1128         bool auto_input;
1129         bool crossfades_active;
1130         bool all_safe;
1131         bool auto_return;
1132         bool monitor_in;
1133         bool send_mtc;
1134         bool send_mmc;
1135         bool mmc_control;
1136         bool midi_feedback;
1137         bool midi_control;
1138
1139         RingBuffer<Event*> pending_events;
1140
1141         void hookup_io ();
1142         void when_engine_running ();
1143         sigc::connection first_time_running;
1144         void graph_reordered ();
1145
1146         string _current_snapshot_name;
1147
1148         XMLTree* state_tree;
1149         bool     state_was_pending;
1150         StateOfTheState _state_of_the_state;
1151
1152         void     auto_save();
1153         int      load_options (const XMLNode&);
1154         XMLNode& get_options () const;
1155         int      load_state (string snapshot_name);
1156
1157         jack_nframes_t   _last_roll_location;
1158         jack_nframes_t   _last_record_location;
1159         bool              pending_locate_roll;
1160         jack_nframes_t    pending_locate_frame;
1161
1162         bool              pending_locate_flush;
1163         bool              pending_abort;
1164         bool              pending_auto_loop;
1165
1166         Sample*              butler_mixdown_buffer;
1167         float*               butler_gain_buffer;
1168         pthread_t            butler_thread;
1169         PBD::NonBlockingLock butler_request_lock;
1170         pthread_cond_t       butler_paused;
1171         bool                 butler_should_run;
1172         atomic_t             butler_should_do_transport_work;
1173         int                  butler_request_pipe[2];
1174
1175         struct ButlerRequest {
1176             enum Type {
1177                     Wake,
1178                     Run,
1179                     Pause,
1180                     Quit
1181             };
1182         };
1183
1184         enum PostTransportWork {
1185                 PostTransportStop               = 0x1,
1186                 PostTransportDisableRecord      = 0x2,
1187                 PostTransportPosition           = 0x8,
1188                 PostTransportDidRecord          = 0x20,
1189                 PostTransportDuration           = 0x40,
1190                 PostTransportLocate             = 0x80,
1191                 PostTransportRoll               = 0x200,
1192                 PostTransportAbort              = 0x800,
1193                 PostTransportOverWrite          = 0x1000,
1194                 PostTransportSpeed              = 0x2000,
1195                 PostTransportAudition           = 0x4000,
1196                 PostTransportScrub              = 0x8000,
1197                 PostTransportReverse            = 0x10000,
1198                 PostTransportInputChange        = 0x20000,
1199                 PostTransportCurveRealloc       = 0x40000
1200         };
1201
1202         static const PostTransportWork ProcessCannotProceedMask =
1203                 PostTransportWork (PostTransportInputChange|
1204                                    PostTransportSpeed|
1205                                    PostTransportReverse|
1206                                    PostTransportCurveRealloc|
1207                                    PostTransportScrub|
1208                                    PostTransportAudition|
1209                                    PostTransportLocate|
1210                                    PostTransportStop);
1211
1212         PostTransportWork post_transport_work;
1213
1214         void             summon_butler ();
1215         void             schedule_butler_transport_work ();
1216         int              start_butler_thread ();
1217         void             terminate_butler_thread ();
1218         static void    *_butler_thread_work (void *arg);
1219         void*            butler_thread_work ();
1220
1221         uint32_t    cumulative_rf_motion;
1222         uint32_t    rf_scale;
1223
1224         void set_rf_speed (float speed);
1225         void reset_rf_scale (jack_nframes_t frames_moved);
1226
1227         Locations        _locations;
1228         void              locations_changed ();
1229         void              locations_added (Location*);
1230         void              handle_locations_changed (Locations::LocationList&);
1231
1232         sigc::connection auto_punch_start_changed_connection;
1233         sigc::connection auto_punch_end_changed_connection;
1234         sigc::connection auto_punch_changed_connection;
1235         void             auto_punch_start_changed (Location *);
1236         void             auto_punch_end_changed (Location *);
1237         void             auto_punch_changed (Location *);
1238
1239         sigc::connection auto_loop_start_changed_connection;
1240         sigc::connection auto_loop_end_changed_connection;
1241         sigc::connection auto_loop_changed_connection;
1242         void             auto_loop_changed (Location *);
1243
1244         typedef list<Event *> Events;
1245         Events           events;
1246         Events           immediate_events;
1247         Events::iterator next_event;
1248
1249         /* there can only ever be one of each of these */
1250
1251         Event *auto_loop_event;
1252         Event *punch_out_event;
1253         Event *punch_in_event;
1254
1255         /* events */
1256
1257         void dump_events () const;
1258         void queue_event (Event *ev);
1259         void merge_event (Event*);
1260         void replace_event (Event::Type, jack_nframes_t action_frame, jack_nframes_t target = 0);
1261         bool _replace_event (Event*);
1262         bool _remove_event (Event *);
1263         void _clear_event_type (Event::Type);
1264
1265         void first_stage_init (string path, string snapshot_name);
1266         int  second_stage_init (bool new_tracks);
1267         void find_current_end ();
1268         void remove_empty_sounds ();
1269
1270         void setup_midi_control ();
1271         int  midi_read (MIDI::Port *);
1272
1273         void enable_record ();
1274
1275         void increment_transport_position (uint32_t val) {
1276                 if (max_frames - val < _transport_frame) {
1277                         _transport_frame = max_frames;
1278                 } else {
1279                         _transport_frame += val;
1280                 }
1281         }
1282
1283         void decrement_transport_position (uint32_t val) {
1284                 if (val < _transport_frame) {
1285                         _transport_frame -= val;
1286                 } else {
1287                         _transport_frame = 0;
1288                 }
1289         }
1290
1291         void post_transport_motion ();
1292         static void *session_loader_thread (void *arg);
1293
1294         void *do_work();
1295
1296         void set_next_event ();
1297         void process_event (Event *);
1298
1299         /* MIDI Machine Control */
1300
1301         void deliver_mmc (MIDI::MachineControl::Command, jack_nframes_t);
1302         void deliver_midi_message (MIDI::Port * port, MIDI::eventType ev, MIDI::channel_t, MIDI::EventTwoBytes);
1303         void deliver_data (MIDI::Port* port, MIDI::byte*, int32_t size);
1304
1305         void spp_start (MIDI::Parser&);
1306         void spp_continue (MIDI::Parser&);
1307         void spp_stop (MIDI::Parser&);
1308
1309         void mmc_deferred_play (MIDI::MachineControl &);
1310         void mmc_stop (MIDI::MachineControl &);
1311         void mmc_step (MIDI::MachineControl &, int);
1312         void mmc_pause (MIDI::MachineControl &);
1313         void mmc_record_pause (MIDI::MachineControl &);
1314         void mmc_record_strobe (MIDI::MachineControl &);
1315         void mmc_record_exit (MIDI::MachineControl &);
1316         void mmc_track_record_status (MIDI::MachineControl &,
1317                                       uint32_t track, bool enabled);
1318         void mmc_fast_forward (MIDI::MachineControl &);
1319         void mmc_rewind (MIDI::MachineControl &);
1320         void mmc_locate (MIDI::MachineControl &, const MIDI::byte *);
1321         void mmc_shuttle (MIDI::MachineControl &mmc, float speed, bool forw);
1322         void mmc_record_enable (MIDI::MachineControl &mmc, size_t track, bool enabled);
1323
1324         struct timeval last_mmc_step;
1325         double step_speed;
1326
1327         typedef sigc::slot<bool> MidiTimeoutCallback;
1328         typedef list<MidiTimeoutCallback> MidiTimeoutList;
1329
1330         MidiTimeoutList midi_timeouts;
1331         bool mmc_step_timeout ();
1332
1333         MIDI::byte mmc_buffer[32];
1334         MIDI::byte mtc_msg[16];
1335         MIDI::byte mtc_smpte_bits;   /* encoding of SMTPE type for MTC */
1336         MIDI::byte midi_msg[16];
1337         jack_nframes_t  outbound_mtc_smpte_frame;
1338         SMPTE_Time transmitting_smpte_time;
1339         int next_quarter_frame_to_send;
1340
1341         double _frames_per_smpte_frame; /* has to be floating point because of drop frame */
1342         jack_nframes_t _frames_per_hour;
1343         jack_nframes_t _smpte_frames_per_hour;
1344         jack_nframes_t _smpte_offset;
1345         bool _smpte_offset_negative;
1346
1347         /* cache the most-recently requested time conversions.
1348            this helps when we have multiple clocks showing the
1349            same time (e.g. the transport frame)
1350         */
1351
1352         bool       last_smpte_valid;
1353         jack_nframes_t  last_smpte_when;
1354         SMPTE_Time last_smpte;
1355
1356         int send_full_time_code ();
1357         int send_midi_time_code ();
1358
1359         void send_full_time_code_in_another_thread ();
1360         void send_midi_time_code_in_another_thread ();
1361         void send_time_code_in_another_thread (bool full);
1362         void send_mmc_in_another_thread (MIDI::MachineControl::Command, jack_nframes_t frame = 0);
1363
1364         /* Feedback */
1365
1366         typedef sigc::slot<int> FeedbackFunctionPtr;
1367         static void* _feedback_thread_work (void *);
1368         void* feedback_thread_work ();
1369         int feedback_generic_midi_function ();
1370         std::list<FeedbackFunctionPtr> feedback_functions;
1371         int active_feedback;
1372         int feedback_request_pipe[2];
1373         pthread_t feedback_thread;
1374
1375         struct FeedbackRequest {
1376             enum Type {
1377                     Start,
1378                     Stop,
1379                     Quit
1380             };
1381         };
1382
1383         int init_feedback();
1384         int start_feedback ();
1385         int stop_feedback ();
1386         void terminate_feedback ();
1387         int  poke_feedback (FeedbackRequest::Type);
1388
1389         jack_nframes_t adjust_apparent_position (jack_nframes_t frames);
1390
1391         void reset_record_status ();
1392
1393         int no_roll (jack_nframes_t nframes, jack_nframes_t offset);
1394
1395         bool non_realtime_work_pending() const { return static_cast<bool>(post_transport_work); }
1396         bool process_can_proceed() const { return !(post_transport_work & ProcessCannotProceedMask); }
1397
1398         struct MIDIRequest {
1399
1400             enum Type {
1401                     SendFullMTC,
1402                     SendMTC,
1403                     SendMMC,
1404                     PortChange,
1405                     SendMessage,
1406                     Deliver,
1407                     Quit
1408             };
1409
1410             Type type;
1411             MIDI::MachineControl::Command mmc_cmd;
1412             jack_nframes_t locate_frame;
1413
1414             // for SendMessage type
1415
1416             MIDI::Port * port;
1417             MIDI::channel_t chan;
1418             union {
1419                 MIDI::EventTwoBytes data;
1420                 MIDI::byte* buf;
1421             };
1422
1423             union {
1424                 MIDI::eventType ev;
1425                 int32_t size;
1426             };
1427
1428             MIDIRequest () {}
1429
1430             void *operator new(size_t ignored) {
1431                     return pool.alloc ();
1432             };
1433
1434             void operator delete(void *ptr, size_t size) {
1435                     pool.release (ptr);
1436             }
1437
1438           private:
1439             static MultiAllocSingleReleasePool pool;
1440         };
1441
1442         PBD::Lock       midi_lock;
1443         pthread_t       midi_thread;
1444         int             midi_request_pipe[2];
1445         atomic_t        butler_active;
1446         RingBuffer<MIDIRequest*> midi_requests;
1447
1448         int           start_midi_thread ();
1449         void          terminate_midi_thread ();
1450         void          poke_midi_thread ();
1451         static void *_midi_thread_work (void *arg);
1452         void          midi_thread_work ();
1453         void          change_midi_ports ();
1454         int           use_config_midi_ports ();
1455
1456         bool waiting_to_start;
1457
1458         void set_auto_loop (bool yn);
1459         void overwrite_some_buffers (DiskStream*);
1460         void flush_all_redirects ();
1461         void locate (jack_nframes_t, bool with_roll, bool with_flush, bool with_loop=false);
1462         void start_locate (jack_nframes_t, bool with_roll, bool with_flush, bool with_loop=false);
1463         void force_locate (jack_nframes_t frame, bool with_roll = false);
1464         void set_diskstream_speed (DiskStream*, float speed);
1465         void set_transport_speed (float speed, bool abort = false);
1466         void stop_transport (bool abort = false);
1467         void start_transport ();
1468         void actually_start_transport ();
1469         void realtime_stop (bool abort);
1470         void non_realtime_start_scrub ();
1471         void non_realtime_set_speed ();
1472         void non_realtime_stop (bool abort);
1473         void non_realtime_overwrite ();
1474         void non_realtime_buffer_fill ();
1475         void butler_transport_work ();
1476         void post_transport ();
1477         void engine_halted ();
1478         void xrun_recovery ();
1479
1480         TempoMap    *_tempo_map;
1481         void          tempo_map_changed (Change);
1482
1483         /* edit/mix groups */
1484
1485         int load_route_groups (const XMLNode&, bool is_edit);
1486         int load_edit_groups (const XMLNode&);
1487         int load_mix_groups (const XMLNode&);
1488
1489
1490         list<RouteGroup *> edit_groups;
1491         list<RouteGroup *> mix_groups;
1492
1493         /* disk-streams */
1494
1495         DiskStreamList  diskstreams;
1496         mutable PBD::NonBlockingRWLock diskstream_lock;
1497         uint32_t dstream_buffer_size;
1498         void add_diskstream (DiskStream*);
1499         int  load_diskstreams (const XMLNode&);
1500
1501         /* routes stuff */
1502
1503         RouteList       routes;
1504         mutable PBD::NonBlockingRWLock route_lock;
1505         void   add_route (Route*);
1506         uint32_t destructive_index;
1507
1508         int load_routes (const XMLNode&);
1509         Route* XMLRouteFactory (const XMLNode&);
1510
1511         /* mixer stuff */
1512
1513         bool      _solo_latched;
1514         SoloModel _solo_model;
1515         bool       solo_update_disabled;
1516         bool       currently_soloing;
1517
1518         void route_mute_changed (void *src);
1519         void route_solo_changed (void *src, Route *);
1520         void catch_up_on_solo ();
1521         void update_route_solo_state ();
1522         void modify_solo_mute (bool, bool);
1523         void strip_portname_for_solo (string& portname);
1524
1525         /* REGION MANAGEMENT */
1526
1527         mutable PBD::Lock region_lock;
1528         typedef map<ARDOUR::id_t,AudioRegion *> AudioRegionList;
1529         AudioRegionList audio_regions;
1530
1531         void region_renamed (Region *);
1532         void region_changed (Change, Region *);
1533         void add_region (Region *);
1534         void remove_region (Region *);
1535
1536         int load_regions (const XMLNode& node);
1537
1538         /* SOURCES */
1539
1540         mutable PBD::Lock source_lock;
1541         typedef std::map<id_t, Source *>    SourceList;
1542
1543         SourceList sources;
1544
1545         int load_sources (const XMLNode& node);
1546         XMLNode& get_sources_as_xml ();
1547
1548         void remove_source (Source *);
1549
1550         Source *XMLSourceFactory (const XMLNode&);
1551
1552         /* PLAYLISTS */
1553
1554         mutable PBD::Lock playlist_lock;
1555         typedef set<Playlist *> PlaylistList;
1556         PlaylistList playlists;
1557         PlaylistList unused_playlists;
1558
1559         int load_playlists (const XMLNode&);
1560         int load_unused_playlists (const XMLNode&);
1561         void remove_playlist (Playlist *);
1562         void track_playlist (Playlist *, bool);
1563
1564         Playlist *playlist_factory (string name);
1565         Playlist *XMLPlaylistFactory (const XMLNode&);
1566
1567         void playlist_length_changed (Playlist *);
1568         void diskstream_playlist_changed (DiskStream *);
1569
1570         /* NAMED SELECTIONS */
1571
1572         mutable PBD::Lock named_selection_lock;
1573         typedef set<NamedSelection *> NamedSelectionList;
1574         NamedSelectionList named_selections;
1575
1576         int load_named_selections (const XMLNode&);
1577
1578         NamedSelection *named_selection_factory (string name);
1579         NamedSelection *XMLNamedSelectionFactory (const XMLNode&);
1580
1581         /* DEFAULT FADE CURVES */
1582
1583         float default_fade_steepness;
1584         float default_fade_msecs;
1585
1586         /* AUDITIONING */
1587
1588         Auditioner *auditioner;
1589         void set_audition (AudioRegion*);
1590         void non_realtime_set_audition ();
1591         AudioRegion *pending_audition_region;
1592
1593         /* EXPORT */
1594
1595         /* FLATTEN */
1596
1597         int flatten_one_track (AudioTrack&, jack_nframes_t start, jack_nframes_t cnt);
1598
1599         /* INSERT AND SEND MANAGEMENT */
1600
1601         slist<PortInsert *>   _port_inserts;
1602         slist<PluginInsert *> _plugin_inserts;
1603         slist<Send *>         _sends;
1604         uint32_t          send_cnt;
1605         uint32_t          insert_cnt;
1606
1607         void add_redirect (Redirect *);
1608         void remove_redirect (Redirect *);
1609
1610         /* S/W RAID */
1611
1612         struct space_and_path {
1613             uint32_t blocks; /* 4kB blocks */
1614             string path;
1615
1616             space_and_path() {
1617                     blocks = 0;
1618             }
1619         };
1620
1621         struct space_and_path_ascending_cmp {
1622             bool operator() (space_and_path a, space_and_path b) {
1623                     return a.blocks > b.blocks;
1624             }
1625         };
1626
1627         void setup_raid_path (string path);
1628
1629         vector<space_and_path> session_dirs;
1630         vector<space_and_path>::iterator last_rr_session_dir;
1631         uint32_t _total_free_4k_blocks;
1632         PBD::Lock space_lock;
1633
1634         static const char* sound_dir_name;
1635         static const char* tape_dir_name;
1636         static const char* dead_sound_dir_name;
1637         static const char* peak_dir_name;
1638
1639         string discover_best_sound_dir (bool destructive = false);
1640         int ensure_sound_dir (string, string&);
1641         void refresh_disk_space ();
1642
1643         atomic_t _playback_load;
1644         atomic_t _capture_load;
1645         atomic_t _playback_load_min;
1646         atomic_t _capture_load_min;
1647
1648         /* I/O Connections */
1649
1650         typedef list<Connection *> ConnectionList;
1651         mutable PBD::Lock connection_lock;
1652         ConnectionList _connections;
1653         int load_connections (const XMLNode&);
1654
1655         int set_slave_source (SlaveSource, jack_nframes_t);
1656
1657         void reverse_diskstream_buffers ();
1658
1659         UndoHistory history;
1660         UndoCommand current_cmd;
1661
1662         GlobalRouteBooleanState get_global_route_boolean (bool (Route::*method)(void) const);
1663         GlobalRouteMeterState get_global_route_metering ();
1664
1665         void set_global_route_boolean (GlobalRouteBooleanState s, void (Route::*method)(bool, void*), void *arg);
1666         void set_global_route_metering (GlobalRouteMeterState s, void *arg);
1667
1668         void set_global_mute (GlobalRouteBooleanState s, void *src);
1669         void set_global_solo (GlobalRouteBooleanState s, void *src);
1670         void set_global_record_enable (GlobalRouteBooleanState s, void *src);
1671
1672         void jack_timebase_callback (jack_transport_state_t, jack_nframes_t, jack_position_t*, int);
1673         int  jack_sync_callback (jack_transport_state_t, jack_position_t*);
1674         void record_enable_change_all (bool yn);
1675
1676         XMLNode& state(bool);
1677
1678         /* click track */
1679
1680         struct Click {
1681             jack_nframes_t start;
1682             jack_nframes_t duration;
1683             jack_nframes_t offset;
1684             const Sample *data;
1685
1686             Click (jack_nframes_t s, jack_nframes_t d, const Sample *b)
1687                     : start (s), duration (d), data (b) { offset = 0; }
1688
1689             void *operator new(size_t ignored) {
1690                     return pool.alloc ();
1691             };
1692
1693             void operator delete(void *ptr, size_t size) {
1694                     pool.release (ptr);
1695             }
1696
1697           private:
1698             static Pool pool;
1699         };
1700
1701         typedef list<Click*> Clicks;
1702
1703         Clicks          clicks;
1704         bool           _clicking;
1705         IO*            _click_io;
1706         Sample*         click_data;
1707         Sample*         click_emphasis_data;
1708         jack_nframes_t  click_length;
1709         jack_nframes_t  click_emphasis_length;
1710         mutable PBD::NonBlockingRWLock click_lock;
1711
1712         static const Sample         default_click[];
1713         static const jack_nframes_t default_click_length;
1714         static const Sample         default_click_emphasis[];
1715         static const jack_nframes_t default_click_emphasis_length;
1716
1717         Click *get_click();
1718         void   setup_click_sounds (int which);
1719         void   clear_clicks ();
1720         void   click (jack_nframes_t start, jack_nframes_t nframes, jack_nframes_t offset);
1721
1722         vector<Route*> master_outs;
1723
1724         EditMode _edit_mode;
1725         EditMode pending_edit_mode;
1726
1727         /* range playback */
1728
1729         list<AudioRange> current_audio_range;
1730         bool _play_range;
1731         void set_play_range (bool yn);
1732         void setup_auto_play ();
1733
1734         /* main outs */
1735         uint32_t main_outs;
1736
1737         IO* _master_out;
1738         IO* _control_out;
1739
1740         AutoConnectOption input_auto_connect;
1741         AutoConnectOption output_auto_connect;
1742
1743         gain_t* _gain_automation_buffer;
1744         pan_t** _pan_automation_buffer;
1745         void allocate_pan_automation_buffers (jack_nframes_t nframes, uint32_t howmany, bool force);
1746         uint32_t _npan_buffers;
1747
1748         /* VST support */
1749
1750         long _vst_callback (VSTPlugin*,
1751                             long opcode,
1752                             long index,
1753                             long value,
1754                             void* ptr,
1755                             float opt);
1756
1757         /* number of hardware audio ports we're using,
1758            based on max (requested,available)
1759         */
1760
1761         uint32_t n_physical_outputs;
1762         uint32_t n_physical_inputs;
1763
1764         void remove_pending_capture_state ();
1765
1766         int find_all_sources (std::string path, std::set<std::string>& result);
1767         int find_all_sources_across_snapshots (std::set<std::string>& result, bool exclude_this_snapshot);
1768
1769         LayerModel layer_model;
1770         CrossfadeModel xfade_model;
1771 };
1772
1773 }; /* namespace ARDOUR */
1774
1775 #endif /* __ardour_session_h__ */