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