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