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