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         Diskstream    *diskstream_by_id (const PBD::ID& id);
 289         Diskstream    *diskstream_by_name (string name);
 290
 291         bool have_captured() const { return _have_captured; }
 292
 293         void refill_all_diskstream_buffers ();
 294         uint32_t diskstream_buffer_size() const { return dstream_buffer_size; }
 295
 296         uint32_t get_next_diskstream_id() const { return n_diskstreams(); }
 297         uint32_t n_diskstreams() const;
 298
 299         typedef list<Diskstream *> DiskstreamList;
 300
 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_remote_id (uint32_t id);
 321
 322         bool route_name_unique (string) const;
 323
 324         bool get_record_enabled() const {
 325                 return (record_status () >= Enabled);
 326         }
 327
 328         RecordState record_status() const {
 329                 return (RecordState) g_atomic_int_get (&_record_status);
 330         }
 331
 332         bool actively_recording () {
 333                 return record_status() == Recording;
 334         }
 335
 336         bool record_enabling_legal () const;
 337         void maybe_enable_record ();
 338         void disable_record (bool rt_context, bool force = false);
 339         void step_back_from_record ();
 340
 341         sigc::signal<void> going_away;
 342
 343         /* Proxy signal for region hidden changes */
 344
 345         sigc::signal<void,Region*> RegionHiddenChange;
 346
 347         /* Emitted when all i/o connections are complete */
 348
 349         sigc::signal<void> IOConnectionsComplete;
 350
 351         /* Record status signals */
 352
 353         sigc::signal<void> RecordStateChanged;
 354
 355         /* Transport mechanism signals */
 356
 357         sigc::signal<void> TransportStateChange; /* generic */
 358         sigc::signal<void,jack_nframes_t> PositionChanged; /* sent after any non-sequential motion */
 359         sigc::signal<void> DurationChanged;
 360         sigc::signal<void> HaltOnXrun;
 361
 362         sigc::signal<void,boost::shared_ptr<Route> > RouteAdded;
 363         sigc::signal<void,Diskstream*> DiskstreamAdded;
 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
 498         static int rename_template (string old_name, string new_name);
 499
 500         static int delete_template (string name);
 501
 502         sigc::signal<void,string> StateSaved;
 503         sigc::signal<void> StateReady;
 504
 505         vector<string*>* possible_states() const;
 506         static vector<string*>* possible_states(string path);
 507
 508         XMLNode& get_state();
 509         int      set_state(const XMLNode& node); // not idempotent
 510         XMLNode& get_template();
 511
 512         void add_instant_xml (XMLNode&, const std::string& dir);
 513
 514         enum StateOfTheState {
 515                 Clean = 0x0,
 516                 Dirty = 0x1,
 517                 CannotSave = 0x2,
 518                 Deletion = 0x4,
 519                 InitialConnecting = 0x8,
 520                 Loading = 0x10,
 521                 InCleanup = 0x20
 522         };
 523
 524         StateOfTheState state_of_the_state() const { return _state_of_the_state; }
 525
 526         RouteGroup* add_edit_group (string);
 527         RouteGroup* add_mix_group (string);
 528
 529         void remove_edit_group (RouteGroup&);
 530         void remove_mix_group (RouteGroup&);
 531
 532         RouteGroup *mix_group_by_name (string);
 533         RouteGroup *edit_group_by_name (string);
 534
 535         sigc::signal<void,RouteGroup*> edit_group_added;
 536         sigc::signal<void,RouteGroup*> mix_group_added;
 537         sigc::signal<void> edit_group_removed;
 538         sigc::signal<void> mix_group_removed;
 539
 540         void foreach_edit_group (sigc::slot<void,RouteGroup*> sl) {
 541                 for (list<RouteGroup *>::iterator i = edit_groups.begin(); i != edit_groups.end(); i++) {
 542                         sl (*i);
 543                 }
 544         }
 545
 546         void foreach_mix_group (sigc::slot<void,RouteGroup*> sl) {
 547                 for (list<RouteGroup *>::iterator i = mix_groups.begin(); i != mix_groups.end(); i++) {
 548                         sl (*i);
 549                 }
 550         }
 551
 552         /* fundamental operations. duh. */
 553
 554         boost::shared_ptr<AudioTrack> new_audio_track (int input_channels, int output_channels, TrackMode mode = Normal);
 555         boost::shared_ptr<Route>      new_audio_route (int input_channels, int output_channels);
 556
 557         boost::shared_ptr<MidiTrack> new_midi_track (TrackMode mode = Normal);
 558         boost::shared_ptr<Route>      new_midi_route ();
 559
 560         void   remove_route (boost::shared_ptr<Route>);
 561         void   resort_routes ();
 562         void   resort_routes_using (boost::shared_ptr<RouteList>);
 563
 564         AudioEngine &engine() { return _engine; };
 565
 566         /* configuration. there should really be accessors/mutators
 567            for these
 568         */
 569
 570         float   meter_hold () { return _meter_hold; }
 571         void    set_meter_hold (float);
 572         sigc::signal<void> MeterHoldChanged;
 573
 574         float   meter_falloff () { return _meter_falloff; }
 575         void    set_meter_falloff (float);
 576         sigc::signal<void> MeterFalloffChanged;
 577
 578         int32_t  max_level;
 579         int32_t  min_level;
 580         string  click_emphasis_sound;
 581         string  click_sound;
 582         bool    click_requested;
 583         jack_nframes_t over_length_short;
 584         jack_nframes_t over_length_long;
 585         bool    send_midi_timecode;
 586         bool    send_midi_machine_control;
 587         float   shuttle_speed_factor;
 588         float   shuttle_speed_threshold;
 589         float   rf_speed;
 590         float   smpte_frames_per_second;
 591         bool    smpte_drop_frames;
 592         AnyTime preroll;
 593         AnyTime postroll;
 594
 595         /* Time */
 596
 597         jack_nframes_t transport_frame () const {return _transport_frame; }
 598         jack_nframes_t audible_frame () const;
 599
 600         int  set_smpte_type (float fps, bool drop_frames);
 601
 602         void bbt_time (jack_nframes_t when, BBT_Time&);
 603         void smpte_to_sample( SMPTE::Time& smpte, jack_nframes_t& sample, bool use_offset, bool use_subframes ) const;
 604         void sample_to_smpte( jack_nframes_t sample, SMPTE::Time& smpte, bool use_offset, bool use_subframes ) const;
 605         void smpte_time (SMPTE::Time &);
 606         void smpte_time (jack_nframes_t when, SMPTE::Time&);
 607         void smpte_time_subframes (jack_nframes_t when, SMPTE::Time&);
 608
 609         void smpte_duration (jack_nframes_t, SMPTE::Time&) const;
 610         void smpte_duration_string (char *, jack_nframes_t) const;
 611
 612         void           set_smpte_offset (jack_nframes_t);
 613         jack_nframes_t smpte_offset () const { return _smpte_offset; }
 614         void           set_smpte_offset_negative (bool);
 615         bool           smpte_offset_negative () const { return _smpte_offset_negative; }
 616
 617         jack_nframes_t convert_to_frames_at (jack_nframes_t position, AnyTime&);
 618
 619         static sigc::signal<void> SMPTEOffsetChanged;
 620         sigc::signal<void> SMPTETypeChanged;
 621
 622         void        request_slave_source (SlaveSource, jack_nframes_t pos = 0);
 623         SlaveSource slave_source() const { return _slave_type; }
 624         bool        synced_to_jack() const { return _slave_type == JACK; }
 625         float       transport_speed() const { return _transport_speed; }
 626         bool        transport_stopped() const { return _transport_speed == 0.0f; }
 627         bool        transport_rolling() const { return _transport_speed != 0.0f; }
 628
 629         int jack_slave_sync (jack_nframes_t);
 630
 631         TempoMap& tempo_map() { return *_tempo_map; }
 632
 633         /* region info  */
 634
 635         sigc::signal<void,AudioRegion *> AudioRegionAdded;
 636         sigc::signal<void,AudioRegion *> AudioRegionRemoved;
 637
 638         int region_name (string& result, string base = string(""), bool newlevel = false) const;
 639         string new_region_name (string);
 640         string path_from_region_name (string name, string identifier);
 641
 642         Region* find_whole_file_parent (Region& child);
 643         void find_equivalent_playlist_regions (Region&, std::vector<Region*>& result);
 644
 645         AudioRegion *XMLRegionFactory (const XMLNode&, bool full);
 646
 647         template<class T> void foreach_audio_region (T *obj, void (T::*func)(AudioRegion *));
 648
 649         /* source management */
 650
 651         struct import_status : public InterThreadInfo {
 652             string doing_what;
 653
 654             /* control info */
 655             bool multichan;
 656             bool sample_convert;
 657             volatile bool freeze;
 658             string pathname;
 659
 660             /* result */
 661             std::vector<AudioRegion*> new_regions;
 662
 663         };
 664
 665         int import_audiofile (import_status&);
 666         bool sample_rate_convert (import_status&, string infile, string& outfile);
 667         string build_tmp_convert_name (string file);
 668
 669         Session::SlaveSource post_export_slave;
 670         jack_nframes_t post_export_position;
 671
 672         int start_audio_export (ARDOUR::AudioExportSpecification&);
 673         int stop_audio_export (ARDOUR::AudioExportSpecification&);
 674
 675         void add_audio_source (AudioSource *);
 676         void remove_source (Source *);
 677         int  cleanup_audio_file_source (AudioFileSource&);
 678
 679         struct cleanup_report {
 680             vector<string> paths;
 681             int32_t space;
 682         };
 683
 684         int  cleanup_sources (cleanup_report&);
 685         int  cleanup_trash_sources (cleanup_report&);
 686
 687         int destroy_region (Region*);
 688         int destroy_regions (list<Region*>);
 689
 690         int remove_last_capture ();
 691
 692         /* handlers should return -1 for "stop cleanup", 0 for
 693            "yes, delete this playlist" and 1 for "no, don't delete
 694            this playlist.
 695         */
 696
 697         sigc::signal<int,ARDOUR::Playlist*> AskAboutPlaylistDeletion;
 698
 699
 700         /* handlers should return !0 for use pending state, 0 for
 701            ignore it.
 702         */
 703
 704         static sigc::signal<int> AskAboutPendingState;
 705
 706         sigc::signal<void,Source *> SourceAdded;
 707         sigc::signal<void,Source *> SourceRemoved;
 708
 709         AudioFileSource *create_audio_source_for_session (ARDOUR::AudioDiskstream&, uint32_t which_channel, bool destructive);
 710
 711         MidiSource *create_midi_source_for_session (ARDOUR::MidiDiskstream&);
 712
 713         Source *source_by_id (const PBD::ID&);
 714
 715         /* playlist management */
 716
 717         Playlist* playlist_by_name (string name);
 718         void add_playlist (Playlist *);
 719         sigc::signal<void,Playlist*> PlaylistAdded;
 720         sigc::signal<void,Playlist*> PlaylistRemoved;
 721
 722         uint32_t n_playlists() const;
 723
 724         template<class T> void foreach_playlist (T *obj, void (T::*func)(Playlist *));
 725
 726         /* named selections */
 727
 728         NamedSelection* named_selection_by_name (string name);
 729         void add_named_selection (NamedSelection *);
 730         void remove_named_selection (NamedSelection *);
 731
 732         template<class T> void foreach_named_selection (T& obj, void (T::*func)(NamedSelection&));
 733         sigc::signal<void> NamedSelectionAdded;
 734         sigc::signal<void> NamedSelectionRemoved;
 735
 736         /* fade curves */
 737
 738         float get_default_fade_length () const { return default_fade_msecs; }
 739         float get_default_fade_steepness () const { return default_fade_steepness; }
 740         void set_default_fade (float steepness, float msecs);
 741
 742         /* auditioning */
 743
 744         boost::shared_ptr<Auditioner> the_auditioner() { return auditioner; }
 745         void audition_playlist ();
 746         void audition_region (Region&);
 747         void cancel_audition ();
 748         bool is_auditioning () const;
 749
 750         sigc::signal<void,bool> AuditionActive;
 751
 752         /* flattening stuff */
 753
 754         int write_one_audio_track (AudioTrack&, jack_nframes_t start, jack_nframes_t cnt, bool overwrite, vector<Source*>&, InterThreadInfo& wot);
 755         int freeze (InterThreadInfo&);
 756
 757         /* session-wide solo/mute/rec-enable */
 758
 759         enum SoloModel {
 760                 InverseMute,
 761                 SoloBus
 762         };
 763
 764         bool soloing() const { return currently_soloing; }
 765
 766         SoloModel solo_model() const { return _solo_model; }
 767         void set_solo_model (SoloModel);
 768
 769         bool solo_latched() const { return _solo_latched; }
 770         void set_solo_latched (bool yn);
 771
 772         void set_all_solo (bool);
 773         void set_all_mute (bool);
 774
 775         sigc::signal<void,bool> SoloActive;
 776
 777         void record_disenable_all ();
 778         void record_enable_all ();
 779
 780         /* control/master out */
 781
 782         boost::shared_ptr<IO> control_out() const { return _control_out; }
 783         boost::shared_ptr<IO> master_out() const { return _master_out; }
 784
 785         /* insert/send management */
 786
 787         uint32_t n_port_inserts() const { return _port_inserts.size(); }
 788         uint32_t n_plugin_inserts() const { return _plugin_inserts.size(); }
 789         uint32_t n_sends() const { return _sends.size(); }
 790
 791         string next_send_name();
 792         string next_insert_name();
 793
 794         /* s/w "RAID" management */
 795
 796         jack_nframes_t available_capture_duration();
 797
 798         /* I/O Connections */
 799
 800         template<class T> void foreach_connection (T *obj, void (T::*func)(Connection *));
 801         void add_connection (Connection *);
 802         void remove_connection (Connection *);
 803         Connection *connection_by_name (string) const;
 804
 805         sigc::signal<void,Connection *> ConnectionAdded;
 806         sigc::signal<void,Connection *> ConnectionRemoved;
 807
 808         /* MIDI */
 809
 810         int set_mtc_port (string port_tag);
 811         int set_mmc_port (string port_tag);
 812         int set_midi_port (string port_tag);
 813         MIDI::Port *mtc_port() const { return _mtc_port; }
 814         MIDI::Port *mmc_port() const { return _mmc_port; }
 815         MIDI::Port *midi_port() const { return _midi_port; }
 816
 817         sigc::signal<void> MTC_PortChanged;
 818         sigc::signal<void> MMC_PortChanged;
 819         sigc::signal<void> MIDI_PortChanged;
 820
 821         void set_trace_midi_input (bool, MIDI::Port* port = 0);
 822         void set_trace_midi_output (bool, MIDI::Port* port = 0);
 823
 824         bool get_trace_midi_input(MIDI::Port *port = 0);
 825         bool get_trace_midi_output(MIDI::Port *port = 0);
 826
 827         void send_midi_message (MIDI::Port * port, MIDI::eventType ev, MIDI::channel_t, MIDI::EventTwoBytes);
 828
 829         void deliver_midi (MIDI::Port*, MIDI::byte*, int32_t size);
 830
 831         /* Scrubbing */
 832
 833         void start_scrub (jack_nframes_t where);
 834         void stop_scrub ();
 835         void set_scrub_speed (float);
 836         jack_nframes_t scrub_buffer_size() const;
 837         sigc::signal<void> ScrubReady;
 838
 839         /* History (for editors, mixers, UIs etc.) */
 840
 841         void undo (uint32_t n) {
 842                 history.undo (n);
 843         }
 844         void redo (uint32_t n) {
 845                 history.redo (n);
 846         }
 847
 848         uint32_t undo_depth() const { return history.undo_depth(); }
 849         uint32_t redo_depth() const { return history.redo_depth(); }
 850         string next_undo() const { return history.next_undo(); }
 851         string next_redo() const { return history.next_redo(); }
 852
 853         void begin_reversible_command (string cmd_name);
 854         void commit_reversible_command (Command* cmd = 0);
 855
 856         void add_command (Command *const cmd) {
 857                 current_trans.add_command (cmd);
 858         }
 859
 860         // these commands are implemented in libs/ardour/session_command.cc
 861         Command *memento_command_factory(XMLNode *n);
 862         class GlobalSoloStateCommand : public Command
 863         {
 864             GlobalRouteBooleanState before, after;
 865             Session &sess;
 866             void *src;
 867         public:
 868             GlobalSoloStateCommand(Session &, void *src);
 869             void operator()();
 870             void undo();
 871             XMLNode &get_state();
 872             void mark();
 873         };
 874
 875         class GlobalMuteStateCommand : public Command
 876         {
 877             GlobalRouteBooleanState before, after;
 878             Session &sess;
 879             void *src;
 880         public:
 881             GlobalMuteStateCommand(Session &, void *src);
 882             void operator()();
 883             void undo();
 884             XMLNode &get_state();
 885             void mark();
 886         };
 887
 888         class GlobalRecordEnableStateCommand : public Command
 889         {
 890             GlobalRouteBooleanState before, after;
 891             Session &sess;
 892             void *src;
 893         public:
 894             GlobalRecordEnableStateCommand(Session &, void *src);
 895             void operator()();
 896             void undo();
 897             XMLNode &get_state();
 898             void mark();
 899         };
 900
 901         class GlobalMeteringStateCommand : public Command
 902         {
 903             GlobalRouteMeterState before, after;
 904             Session &sess;
 905             void *src;
 906         public:
 907             GlobalMeteringStateCommand(Session &, void *src);
 908             void operator()();
 909             void undo();
 910             XMLNode &get_state();
 911             void mark();
 912         };
 913
 914         /* edit mode */
 915
 916         void set_edit_mode (EditMode);
 917         EditMode get_edit_mode () const { return _edit_mode; }
 918
 919         /* clicking */
 920
 921         boost::shared_ptr<IO>  click_io() { return _click_io; }
 922         void set_clicking (bool yn);
 923         bool get_clicking() const;
 924
 925         void set_click_sound (string path);
 926         void set_click_emphasis_sound (string path);
 927
 928         /* tempo FX */
 929
 930         struct TimeStretchRequest {
 931             ARDOUR::AudioRegion* region;
 932             float                fraction; /* session: read ; GUI: write */
 933             float                progress; /* session: write ; GUI: read */
 934             bool                 running;  /* read/write */
 935             bool                 quick_seek; /* GUI: write */
 936             bool                 antialias;  /* GUI: write */
 937
 938             TimeStretchRequest () : region (0) {}
 939         };
 940
 941         AudioRegion* tempoize_region (TimeStretchRequest&);
 942
 943         string raid_path() const;
 944         void   set_raid_path(string);
 945
 946         /* need to call this whenever we change native file formats */
 947
 948         void reset_native_file_format();
 949
 950         /* disk, buffer loads */
 951
 952         uint32_t playback_load ();
 953         uint32_t capture_load ();
 954         uint32_t playback_load_min ();
 955         uint32_t capture_load_min ();
 956
 957         void reset_playback_load_min ();
 958         void reset_capture_load_min ();
 959
 960         float read_data_rate () const;
 961         float write_data_rate () const;
 962
 963         /* ranges */
 964
 965         void set_audio_range (list<AudioRange>&);
 966         void set_music_range (list<MusicRange>&);
 967
 968         void request_play_range (bool yn);
 969         bool get_play_range () const { return _play_range; }
 970
 971         /* favorite dirs */
 972         typedef vector<string> FavoriteDirs;
 973
 974         static int read_favorite_dirs (FavoriteDirs&);
 975
 976         static int write_favorite_dirs (FavoriteDirs&);
 977
 978         /* file suffixes */
 979
 980         static const char* template_suffix() { return _template_suffix; }
 981         static const char* statefile_suffix() { return _statefile_suffix; }
 982         static const char* pending_suffix() { return _pending_suffix; }
 983
 984         /* buffers for gain and pan */
 985
 986         gain_t* gain_automation_buffer () const { return _gain_automation_buffer; }
 987         pan_t** pan_automation_buffer () const  { return _pan_automation_buffer; }
 988
 989         /* buffers for conversion */
 990         enum RunContext {
 991                 ButlerContext = 0,
 992                 TransportContext,
 993                 ExportContext
 994         };
 995
 996         /* VST support */
 997
 998         static long vst_callback (AEffect* effect,
 999                                   long opcode,
1000                                   long index,
1001                                   long value,
1002                                   void* ptr,
1003                                   float opt);
1004
1005         typedef float (*compute_peak_t)                         (Sample *, jack_nframes_t, float);
1006         typedef void  (*apply_gain_to_buffer_t)         (Sample *, jack_nframes_t, float);
1007         typedef void  (*mix_buffers_with_gain_t)        (Sample *, Sample *, jack_nframes_t, float);
1008         typedef void  (*mix_buffers_no_gain_t)          (Sample *, Sample *, jack_nframes_t);
1009
1010         static compute_peak_t                   compute_peak;
1011         static apply_gain_to_buffer_t   apply_gain_to_buffer;
1012         static mix_buffers_with_gain_t  mix_buffers_with_gain;
1013         static mix_buffers_no_gain_t    mix_buffers_no_gain;
1014
1015         static sigc::signal<void> SendFeedback;
1016
1017         /* Controllables */
1018
1019         PBD::Controllable* controllable_by_id (const PBD::ID&);
1020
1021   protected:
1022         friend class AudioEngine;
1023         void set_block_size (jack_nframes_t nframes);
1024         void set_frame_rate (jack_nframes_t nframes);
1025
1026   protected:
1027         friend class Diskstream;
1028         void stop_butler ();
1029         void wait_till_butler_finished();
1030
1031   protected:
1032         friend class Route;
1033         void schedule_curve_reallocation ();
1034         void update_latency_compensation (bool, bool);
1035
1036   private:
1037         int  create (bool& new_session, string* mix_template, jack_nframes_t initial_length);
1038
1039         static const char* _template_suffix;
1040         static const char* _statefile_suffix;
1041         static const char* _pending_suffix;
1042
1043         enum SubState {
1044                 PendingDeclickIn   = 0x1,
1045                 PendingDeclickOut  = 0x2,
1046                 StopPendingCapture = 0x4,
1047                 AutoReturning      = 0x10,
1048                 PendingLocate      = 0x20,
1049                 PendingSetLoop     = 0x40
1050         };
1051
1052         /* stuff used in process() should be close together to
1053            maximise cache hits
1054         */
1055
1056         typedef void (Session::*process_function_type)(jack_nframes_t);
1057
1058         AudioEngine            &_engine;
1059         mutable gint            processing_prohibited;
1060         process_function_type    process_function;
1061         process_function_type    last_process_function;
1062         jack_nframes_t          _current_frame_rate;
1063         int                      transport_sub_state;
1064         mutable gint           _record_status;
1065         jack_nframes_t          _transport_frame;
1066         Location*                end_location;
1067         Location*                start_location;
1068         Slave                  *_slave;
1069         SlaveSource             _slave_type;
1070         volatile float          _transport_speed;
1071         volatile float          _desired_transport_speed;
1072         float                   _last_transport_speed;
1073         jack_nframes_t          _last_slave_transport_frame;
1074         jack_nframes_t           maximum_output_latency;
1075         jack_nframes_t           last_stop_frame;
1076         BufferSet*              _scratch_buffers;
1077         BufferSet*              _silent_buffers;
1078         BufferSet*              _send_buffers;
1079         jack_nframes_t           current_block_size;
1080         jack_nframes_t          _worst_output_latency;
1081         jack_nframes_t          _worst_input_latency;
1082         jack_nframes_t          _worst_track_latency;
1083         bool                    _have_captured;
1084         float                   _meter_hold;
1085         float                   _meter_falloff;
1086         bool                    _end_location_is_free;
1087
1088         void set_worst_io_latencies ();
1089         void set_worst_io_latencies_x (IOChange asifwecare, void *ignored) {
1090                 set_worst_io_latencies ();
1091         }
1092
1093         void update_latency_compensation_proxy (void* ignored);
1094
1095         void ensure_buffers (ChanCount howmany);
1096
1097         void process_scrub          (jack_nframes_t);
1098         void process_without_events (jack_nframes_t);
1099         void process_with_events    (jack_nframes_t);
1100         void process_audition       (jack_nframes_t);
1101         int  process_export         (jack_nframes_t, ARDOUR::AudioExportSpecification*);
1102
1103         /* slave tracking */
1104
1105         static const int delta_accumulator_size = 25;
1106         int delta_accumulator_cnt;
1107         long delta_accumulator[delta_accumulator_size];
1108         long average_slave_delta;
1109         int  average_dir;
1110         bool have_first_delta_accumulator;
1111
1112         enum SlaveState {
1113                 Stopped,
1114                 Waiting,
1115                 Running
1116         };
1117
1118         SlaveState slave_state;
1119         jack_nframes_t slave_wait_end;
1120
1121         void reset_slave_state ();
1122         bool follow_slave (jack_nframes_t, jack_nframes_t);
1123
1124         bool _exporting;
1125         int prepare_to_export (ARDOUR::AudioExportSpecification&);
1126
1127         void prepare_diskstreams ();
1128         void commit_diskstreams (jack_nframes_t, bool& session_requires_butler);
1129         int  process_routes (jack_nframes_t, jack_nframes_t);
1130         int  silent_process_routes (jack_nframes_t, jack_nframes_t);
1131
1132         bool get_rec_monitors_input () {
1133                 if (actively_recording()) {
1134                         return true;
1135                 } else {
1136                         if (auto_input) {
1137                                 return false;
1138                         } else {
1139                                 return true;
1140                         }
1141                 }
1142         }
1143
1144         int get_transport_declick_required () {
1145
1146                 if (transport_sub_state & PendingDeclickIn) {
1147                         transport_sub_state &= ~PendingDeclickIn;
1148                         return 1;
1149                 } else if (transport_sub_state & PendingDeclickOut) {
1150                         return -1;
1151                 } else {
1152                         return 0;
1153                 }
1154         }
1155
1156         bool maybe_stop (jack_nframes_t limit) {
1157                 if ((_transport_speed > 0.0f && _transport_frame >= limit) || (_transport_speed < 0.0f && _transport_frame == 0)) {
1158                         stop_transport ();
1159                         return true;
1160                 }
1161                 return false;
1162         }
1163
1164         void check_declick_out ();
1165
1166         MIDI::MachineControl*    mmc;
1167         MIDI::Port*             _mmc_port;
1168         MIDI::Port*             _mtc_port;
1169         MIDI::Port*             _midi_port;
1170         string                  _path;
1171         string                  _name;
1172         bool                     do_not_record_plugins;
1173
1174         /* toggles */
1175
1176         bool auto_play;
1177         bool punch_in;
1178         bool punch_out;
1179         bool auto_loop;
1180         bool seamless_loop;
1181         bool loop_changing;
1182         jack_nframes_t last_loopend;
1183         bool auto_input;
1184         bool crossfades_active;
1185         bool all_safe;
1186         bool auto_return;
1187         bool monitor_in;
1188         bool send_mtc;
1189         bool send_mmc;
1190         bool mmc_control;
1191         bool midi_control;
1192
1193         RingBuffer<Event*> pending_events;
1194
1195         void hookup_io ();
1196         void when_engine_running ();
1197         sigc::connection first_time_running;
1198         void graph_reordered ();
1199
1200         string _current_snapshot_name;
1201
1202         XMLTree* state_tree;
1203         bool     state_was_pending;
1204         StateOfTheState _state_of_the_state;
1205
1206         void     auto_save();
1207         int      load_options (const XMLNode&);
1208         XMLNode& get_options () const;
1209         int      load_state (string snapshot_name);
1210
1211         jack_nframes_t   _last_roll_location;
1212         jack_nframes_t   _last_record_location;
1213         bool              pending_locate_roll;
1214         jack_nframes_t    pending_locate_frame;
1215
1216         bool              pending_locate_flush;
1217         bool              pending_abort;
1218         bool              pending_auto_loop;
1219
1220         Sample*           butler_mixdown_buffer;
1221         float*            butler_gain_buffer;
1222         pthread_t         butler_thread;
1223         Glib::Mutex       butler_request_lock;
1224         Glib::Cond        butler_paused;
1225         bool              butler_should_run;
1226         mutable gint      butler_should_do_transport_work;
1227         int               butler_request_pipe[2];
1228
1229         struct ButlerRequest {
1230             enum Type {
1231                     Wake,
1232                     Run,
1233                     Pause,
1234                     Quit
1235             };
1236         };
1237
1238         enum PostTransportWork {
1239                 PostTransportStop               = 0x1,
1240                 PostTransportDisableRecord      = 0x2,
1241                 PostTransportPosition           = 0x8,
1242                 PostTransportDidRecord          = 0x20,
1243                 PostTransportDuration           = 0x40,
1244                 PostTransportLocate             = 0x80,
1245                 PostTransportRoll               = 0x200,
1246                 PostTransportAbort              = 0x800,
1247                 PostTransportOverWrite          = 0x1000,
1248                 PostTransportSpeed              = 0x2000,
1249                 PostTransportAudition           = 0x4000,
1250                 PostTransportScrub              = 0x8000,
1251                 PostTransportReverse            = 0x10000,
1252                 PostTransportInputChange        = 0x20000,
1253                 PostTransportCurveRealloc       = 0x40000
1254         };
1255
1256         static const PostTransportWork ProcessCannotProceedMask =
1257                 PostTransportWork (PostTransportInputChange|
1258                                    PostTransportSpeed|
1259                                    PostTransportReverse|
1260                                    PostTransportCurveRealloc|
1261                                    PostTransportScrub|
1262                                    PostTransportAudition|
1263                                    PostTransportLocate|
1264                                    PostTransportStop);
1265
1266         PostTransportWork post_transport_work;
1267
1268         void             summon_butler ();
1269         void             schedule_butler_transport_work ();
1270         int              start_butler_thread ();
1271         void             terminate_butler_thread ();
1272         static void    *_butler_thread_work (void *arg);
1273         void*            butler_thread_work ();
1274
1275         uint32_t    cumulative_rf_motion;
1276         uint32_t    rf_scale;
1277
1278         void set_rf_speed (float speed);
1279         void reset_rf_scale (jack_nframes_t frames_moved);
1280
1281         Locations        _locations;
1282         void              locations_changed ();
1283         void              locations_added (Location*);
1284         void              handle_locations_changed (Locations::LocationList&);
1285
1286         sigc::connection auto_punch_start_changed_connection;
1287         sigc::connection auto_punch_end_changed_connection;
1288         sigc::connection auto_punch_changed_connection;
1289         void             auto_punch_start_changed (Location *);
1290         void             auto_punch_end_changed (Location *);
1291         void             auto_punch_changed (Location *);
1292
1293         sigc::connection auto_loop_start_changed_connection;
1294         sigc::connection auto_loop_end_changed_connection;
1295         sigc::connection auto_loop_changed_connection;
1296         void             auto_loop_changed (Location *);
1297
1298         typedef list<Event *> Events;
1299         Events           events;
1300         Events           immediate_events;
1301         Events::iterator next_event;
1302
1303         /* there can only ever be one of each of these */
1304
1305         Event *auto_loop_event;
1306         Event *punch_out_event;
1307         Event *punch_in_event;
1308
1309         /* events */
1310
1311         void dump_events () const;
1312         void queue_event (Event *ev);
1313         void merge_event (Event*);
1314         void replace_event (Event::Type, jack_nframes_t action_frame, jack_nframes_t target = 0);
1315         bool _replace_event (Event*);
1316         bool _remove_event (Event *);
1317         void _clear_event_type (Event::Type);
1318
1319         void first_stage_init (string path, string snapshot_name);
1320         int  second_stage_init (bool new_tracks);
1321         void find_current_end ();
1322         void remove_empty_sounds ();
1323
1324         void setup_midi_control ();
1325         //int  midi_read (MIDI::Port *);
1326
1327         void enable_record ();
1328
1329         void increment_transport_position (uint32_t val) {
1330                 if (max_frames - val < _transport_frame) {
1331                         _transport_frame = max_frames;
1332                 } else {
1333                         _transport_frame += val;
1334                 }
1335         }
1336
1337         void decrement_transport_position (uint32_t val) {
1338                 if (val < _transport_frame) {
1339                         _transport_frame -= val;
1340                 } else {
1341                         _transport_frame = 0;
1342                 }
1343         }
1344
1345         void post_transport_motion ();
1346         static void *session_loader_thread (void *arg);
1347
1348         void *do_work();
1349
1350         void set_next_event ();
1351         void process_event (Event *ev);
1352
1353         /* MIDI Machine Control */
1354
1355         void deliver_mmc (MIDI::MachineControl::Command, jack_nframes_t);
1356         //void deliver_midi_message (MIDI::Port * port, MIDI::eventType ev, MIDI::channel_t, MIDI::EventTwoBytes);
1357         //void deliver_data (MIDI::Port* port, MIDI::byte*, int32_t size);
1358
1359         void spp_start (MIDI::Parser&);
1360         void spp_continue (MIDI::Parser&);
1361         void spp_stop (MIDI::Parser&);
1362
1363         void mmc_deferred_play (MIDI::MachineControl &);
1364         void mmc_stop (MIDI::MachineControl &);
1365         void mmc_step (MIDI::MachineControl &, int);
1366         void mmc_pause (MIDI::MachineControl &);
1367         void mmc_record_pause (MIDI::MachineControl &);
1368         void mmc_record_strobe (MIDI::MachineControl &);
1369         void mmc_record_exit (MIDI::MachineControl &);
1370         void mmc_track_record_status (MIDI::MachineControl &,
1371                                       uint32_t track, bool enabled);
1372         void mmc_fast_forward (MIDI::MachineControl &);
1373         void mmc_rewind (MIDI::MachineControl &);
1374         void mmc_locate (MIDI::MachineControl &, const MIDI::byte *);
1375         void mmc_shuttle (MIDI::MachineControl &mmc, float speed, bool forw);
1376         void mmc_record_enable (MIDI::MachineControl &mmc, size_t track, bool enabled);
1377
1378         struct timeval last_mmc_step;
1379         double step_speed;
1380
1381         typedef sigc::slot<bool> MidiTimeoutCallback;
1382         typedef list<MidiTimeoutCallback> MidiTimeoutList;
1383
1384         MidiTimeoutList midi_timeouts;
1385         bool mmc_step_timeout ();
1386
1387         MIDI::byte mmc_buffer[32];
1388         MIDI::byte mtc_msg[16];
1389         MIDI::byte mtc_smpte_bits;   /* encoding of SMTPE type for MTC */
1390         MIDI::byte midi_msg[16];
1391         jack_nframes_t  outbound_mtc_smpte_frame;
1392         SMPTE::Time transmitting_smpte_time;
1393         int next_quarter_frame_to_send;
1394
1395         double _frames_per_smpte_frame; /* has to be floating point because of drop frame */
1396         jack_nframes_t _frames_per_hour;
1397         jack_nframes_t _smpte_frames_per_hour;
1398         jack_nframes_t _smpte_offset;
1399         bool _smpte_offset_negative;
1400
1401         /* cache the most-recently requested time conversions. This helps when we
1402          * have multiple clocks showing the same time (e.g. the transport frame) */
1403         bool           last_smpte_valid;
1404         jack_nframes_t last_smpte_when;
1405         SMPTE::Time    last_smpte;
1406
1407         bool _send_smpte_update; ///< Flag to send a full frame (SMPTE) MTC message this cycle
1408
1409         int send_full_time_code(jack_nframes_t nframes);
1410         int send_midi_time_code_for_cycle(jack_nframes_t nframes);
1411
1412         //void send_mmc_in_another_thread (MIDI::MachineControl::Command, jack_nframes_t frame = 0);
1413
1414         jack_nframes_t adjust_apparent_position (jack_nframes_t frames);
1415
1416         void reset_record_status ();
1417
1418         int no_roll (jack_nframes_t nframes, jack_nframes_t offset);
1419
1420         bool non_realtime_work_pending() const { return static_cast<bool>(post_transport_work); }
1421         bool process_can_proceed() const { return !(post_transport_work & ProcessCannotProceedMask); }
1422
1423         struct MIDIRequest {
1424
1425             enum Type {
1426                     SendFullMTC,
1427                     SendMTC,
1428                     SendMMC,
1429                     PortChange,
1430                     SendMessage,
1431                     Deliver,
1432                     Quit
1433             };
1434
1435             Type type;
1436             MIDI::MachineControl::Command mmc_cmd;
1437             jack_nframes_t locate_frame;
1438
1439             // for SendMessage type
1440
1441             MIDI::Port * port;
1442             MIDI::channel_t chan;
1443             union {
1444                 MIDI::EventTwoBytes data;
1445                 MIDI::byte* buf;
1446             };
1447
1448             union {
1449                 MIDI::eventType ev;
1450                 int32_t size;
1451             };
1452
1453             MIDIRequest () {}
1454
1455             void *operator new(size_t ignored) {
1456                     return pool.alloc ();
1457             };
1458
1459             void operator delete(void *ptr, size_t size) {
1460                     pool.release (ptr);
1461             }
1462
1463           private:
1464             static MultiAllocSingleReleasePool pool;
1465         };
1466
1467         mutable  gint   butler_active;
1468
1469         //PBD::Lock       midi_lock;
1470         //pthread_t       midi_thread;
1471         //int             midi_request_pipe[2];
1472
1473         //RingBuffer<MIDIRequest*> midi_requests;
1474         /*int           start_midi_thread ();
1475         void          terminate_midi_thread ();
1476         void          poke_midi_thread ();
1477         static void *_midi_thread_work (void *arg);
1478         void          midi_thread_work ();*/
1479         void          change_midi_ports ();
1480         int           use_config_midi_ports ();
1481
1482         bool waiting_to_start;
1483
1484         void set_auto_loop (bool yn);
1485         void overwrite_some_buffers (Diskstream*);
1486         void flush_all_redirects ();
1487         void locate (jack_nframes_t, bool with_roll, bool with_flush, bool with_loop=false);
1488         void start_locate (jack_nframes_t, bool with_roll, bool with_flush, bool with_loop=false);
1489         void force_locate (jack_nframes_t frame, bool with_roll = false);
1490         void set_diskstream_speed (Diskstream*, float speed);
1491         void set_transport_speed (float speed, bool abort = false);
1492         void stop_transport (bool abort = false);
1493         void start_transport ();
1494         void actually_start_transport ();
1495         void realtime_stop (bool abort);
1496         void non_realtime_start_scrub ();
1497         void non_realtime_set_speed ();
1498         void non_realtime_stop (bool abort);
1499         void non_realtime_overwrite ();
1500         void non_realtime_buffer_fill ();
1501         void butler_transport_work ();
1502         void post_transport ();
1503         void engine_halted ();
1504         void xrun_recovery ();
1505
1506         TempoMap    *_tempo_map;
1507         void          tempo_map_changed (Change);
1508
1509         /* edit/mix groups */
1510
1511         int load_route_groups (const XMLNode&, bool is_edit);
1512         int load_edit_groups (const XMLNode&);
1513         int load_mix_groups (const XMLNode&);
1514
1515
1516         list<RouteGroup *> edit_groups;
1517         list<RouteGroup *> mix_groups;
1518
1519         /* disk-streams */
1520
1521         DiskstreamList  diskstreams;
1522         mutable Glib::RWLock diskstream_lock;
1523         uint32_t dstream_buffer_size;
1524         void add_diskstream (Diskstream*);
1525         int  load_diskstreams (const XMLNode&);
1526
1527         /* routes stuff */
1528
1529         SerializedRCUManager<RouteList>  routes;
1530
1531         void   add_route (boost::shared_ptr<Route>);
1532         uint32_t destructive_index;
1533
1534         int load_routes (const XMLNode&);
1535         boost::shared_ptr<Route> XMLRouteFactory (const XMLNode&);
1536
1537         /* mixer stuff */
1538
1539         bool      _solo_latched;
1540         SoloModel _solo_model;
1541         bool       solo_update_disabled;
1542         bool       currently_soloing;
1543
1544         void route_mute_changed (void *src);
1545         void route_solo_changed (void *src, boost::shared_ptr<Route>);
1546         void catch_up_on_solo ();
1547         void update_route_solo_state ();
1548         void modify_solo_mute (bool, bool);
1549         void strip_portname_for_solo (string& portname);
1550
1551         /* REGION MANAGEMENT */
1552
1553         mutable Glib::Mutex region_lock;
1554         typedef map<PBD::ID,AudioRegion *> AudioRegionList;
1555         AudioRegionList audio_regions;
1556
1557         void region_renamed (Region *);
1558         void region_changed (Change, Region *);
1559         void add_region (Region *);
1560         void remove_region (Region *);
1561
1562         int load_regions (const XMLNode& node);
1563
1564         /* SOURCES */
1565
1566         mutable Glib::Mutex audio_source_lock;
1567         typedef std::map<PBD::ID,AudioSource *> AudioSourceList;
1568
1569         AudioSourceList audio_sources;
1570
1571         int load_sources (const XMLNode& node);
1572         XMLNode& get_sources_as_xml ();
1573
1574         Source *XMLSourceFactory (const XMLNode&);
1575
1576         /* PLAYLISTS */
1577
1578         mutable Glib::Mutex playlist_lock;
1579         typedef set<Playlist *> PlaylistList;
1580         PlaylistList playlists;
1581         PlaylistList unused_playlists;
1582
1583         int load_playlists (const XMLNode&);
1584         int load_unused_playlists (const XMLNode&);
1585         void remove_playlist (Playlist *);
1586         void track_playlist (Playlist *, bool);
1587
1588         Playlist *playlist_factory (string name);
1589         Playlist *XMLPlaylistFactory (const XMLNode&);
1590
1591         void playlist_length_changed (Playlist *);
1592         void diskstream_playlist_changed (Diskstream *);
1593
1594         /* NAMED SELECTIONS */
1595
1596         mutable Glib::Mutex named_selection_lock;
1597         typedef set<NamedSelection *> NamedSelectionList;
1598         NamedSelectionList named_selections;
1599
1600         int load_named_selections (const XMLNode&);
1601
1602         NamedSelection *named_selection_factory (string name);
1603         NamedSelection *XMLNamedSelectionFactory (const XMLNode&);
1604
1605         /* DEFAULT FADE CURVES */
1606
1607         float default_fade_steepness;
1608         float default_fade_msecs;
1609
1610         /* AUDITIONING */
1611
1612         boost::shared_ptr<Auditioner> auditioner;
1613         void set_audition (AudioRegion*);
1614         void non_realtime_set_audition ();
1615         AudioRegion *pending_audition_region;
1616
1617         /* EXPORT */
1618
1619         /* FLATTEN */
1620
1621         int flatten_one_track (AudioTrack&, jack_nframes_t start, jack_nframes_t cnt);
1622
1623         /* INSERT AND SEND MANAGEMENT */
1624
1625         list<PortInsert *>   _port_inserts;
1626         list<PluginInsert *> _plugin_inserts;
1627         list<Send *>         _sends;
1628         uint32_t          send_cnt;
1629         uint32_t          insert_cnt;
1630
1631         void add_redirect (Redirect *);
1632         void remove_redirect (Redirect *);
1633
1634         /* S/W RAID */
1635
1636         struct space_and_path {
1637             uint32_t blocks; /* 4kB blocks */
1638             string path;
1639
1640             space_and_path() {
1641                     blocks = 0;
1642             }
1643         };
1644
1645         struct space_and_path_ascending_cmp {
1646             bool operator() (space_and_path a, space_and_path b) {
1647                     return a.blocks > b.blocks;
1648             }
1649         };
1650
1651         void setup_raid_path (string path);
1652
1653         vector<space_and_path> session_dirs;
1654         vector<space_and_path>::iterator last_rr_session_dir;
1655         uint32_t _total_free_4k_blocks;
1656         Glib::Mutex space_lock;
1657
1658         static const char* sound_dir_name;
1659         static const char* tape_dir_name;
1660         static const char* dead_sound_dir_name;
1661         static const char* peak_dir_name;
1662
1663         string discover_best_sound_dir (bool destructive = false);
1664         int ensure_sound_dir (string, string&);
1665         void refresh_disk_space ();
1666
1667         mutable gint _playback_load;
1668         mutable gint _capture_load;
1669         mutable gint _playback_load_min;
1670         mutable gint _capture_load_min;
1671
1672         /* I/O Connections */
1673
1674         typedef list<Connection *> ConnectionList;
1675         mutable Glib::Mutex connection_lock;
1676         ConnectionList _connections;
1677         int load_connections (const XMLNode&);
1678
1679         int set_slave_source (SlaveSource, jack_nframes_t);
1680
1681         void reverse_diskstream_buffers ();
1682
1683         UndoHistory history;
1684         UndoTransaction current_trans;
1685
1686         GlobalRouteBooleanState get_global_route_boolean (bool (Route::*method)(void) const);
1687         GlobalRouteMeterState get_global_route_metering ();
1688
1689         void set_global_route_boolean (GlobalRouteBooleanState s, void (Route::*method)(bool, void*), void *arg);
1690         void set_global_route_metering (GlobalRouteMeterState s, void *arg);
1691
1692         void set_global_mute (GlobalRouteBooleanState s, void *src);
1693         void set_global_solo (GlobalRouteBooleanState s, void *src);
1694         void set_global_record_enable (GlobalRouteBooleanState s, void *src);
1695
1696         void jack_timebase_callback (jack_transport_state_t, jack_nframes_t, jack_position_t*, int);
1697         int  jack_sync_callback (jack_transport_state_t, jack_position_t*);
1698         void record_enable_change_all (bool yn);
1699
1700         XMLNode& state(bool);
1701
1702         /* click track */
1703
1704         struct Click {
1705             jack_nframes_t start;
1706             jack_nframes_t duration;
1707             jack_nframes_t offset;
1708             const Sample *data;
1709
1710             Click (jack_nframes_t s, jack_nframes_t d, const Sample *b)
1711                     : start (s), duration (d), data (b) { offset = 0; }
1712
1713             void *operator new(size_t ignored) {
1714                     return pool.alloc ();
1715             };
1716
1717             void operator delete(void *ptr, size_t size) {
1718                     pool.release (ptr);
1719             }
1720
1721           private:
1722             static Pool pool;
1723         };
1724
1725         typedef list<Click*> Clicks;
1726
1727         Clicks          clicks;
1728         bool           _clicking;
1729         boost::shared_ptr<IO> _click_io;
1730         Sample*         click_data;
1731         Sample*         click_emphasis_data;
1732         jack_nframes_t  click_length;
1733         jack_nframes_t  click_emphasis_length;
1734         mutable Glib::RWLock click_lock;
1735
1736         static const Sample         default_click[];
1737         static const jack_nframes_t default_click_length;
1738         static const Sample         default_click_emphasis[];
1739         static const jack_nframes_t default_click_emphasis_length;
1740
1741         Click *get_click();
1742         void   setup_click_sounds (int which);
1743         void   clear_clicks ();
1744         void   click (jack_nframes_t start, jack_nframes_t nframes, jack_nframes_t offset);
1745
1746         vector<Route*> master_outs;
1747
1748         EditMode _edit_mode;
1749         EditMode pending_edit_mode;
1750
1751         /* range playback */
1752
1753         list<AudioRange> current_audio_range;
1754         bool _play_range;
1755         void set_play_range (bool yn);
1756         void setup_auto_play ();
1757
1758         /* main outs */
1759         uint32_t main_outs;
1760
1761         boost::shared_ptr<IO> _master_out;
1762         boost::shared_ptr<IO> _control_out;
1763
1764         AutoConnectOption input_auto_connect;
1765         AutoConnectOption output_auto_connect;
1766
1767         gain_t* _gain_automation_buffer;
1768         pan_t** _pan_automation_buffer;
1769         void allocate_pan_automation_buffers (jack_nframes_t nframes, uint32_t howmany, bool force);
1770         uint32_t _npan_buffers;
1771
1772         /* VST support */
1773
1774         long _vst_callback (VSTPlugin*,
1775                             long opcode,
1776                             long index,
1777                             long value,
1778                             void* ptr,
1779                             float opt);
1780
1781         /* number of hardware audio ports we're using,
1782            based on max (requested,available)
1783         */
1784
1785         uint32_t n_physical_outputs;
1786         uint32_t n_physical_inputs;
1787
1788         void remove_pending_capture_state ();
1789
1790         int find_all_sources (std::string path, std::set<std::string>& result);
1791         int find_all_sources_across_snapshots (std::set<std::string>& result, bool exclude_this_snapshot);
1792
1793         LayerModel layer_model;
1794         CrossfadeModel xfade_model;
1795
1796         typedef std::list<PBD::Controllable*> Controllables;
1797         Glib::Mutex controllables_lock;
1798         Controllables controllables;
1799
1800         void add_controllable (PBD::Controllable*);
1801         void remove_controllable (PBD::Controllable*);
1802 };
1803
1804 } // namespace ARDOUR
1805
1806 #endif /* __ardour_session_h__ */