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