libs/ardour/ardour/session.h

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