2008-06-02 17:41:35 -04:00
|
|
|
/*
|
2008-08-04 18:37:24 -04:00
|
|
|
Copyright (C) 2000 Paul Davis
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
This program is free software; you can redistribute it and/or modify
|
|
|
|
it under the terms of the GNU General Public License as published by
|
|
|
|
the Free Software Foundation; either version 2 of the License, or
|
|
|
|
(at your option) any later version.
|
|
|
|
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
GNU General Public License for more details.
|
|
|
|
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
|
|
along with this program; if not, write to the Free Software
|
|
|
|
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
|
|
|
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifndef __ardour_session_h__
|
|
|
|
#define __ardour_session_h__
|
|
|
|
|
|
|
|
#include <list>
|
|
|
|
#include <map>
|
|
|
|
#include <set>
|
|
|
|
#include <stack>
|
2009-01-30 15:18:31 -05:00
|
|
|
#include <string>
|
|
|
|
#include <vector>
|
|
|
|
#include <stdint.h>
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-01-30 15:18:31 -05:00
|
|
|
#include <boost/dynamic_bitset.hpp>
|
2008-06-02 17:41:35 -04:00
|
|
|
#include <boost/scoped_ptr.hpp>
|
|
|
|
#include <boost/weak_ptr.hpp>
|
2009-02-16 22:49:32 -05:00
|
|
|
#include <boost/utility.hpp>
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
#include <glibmm/thread.h>
|
|
|
|
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "pbd/error.h"
|
|
|
|
#include "pbd/rcu.h"
|
|
|
|
#include "pbd/statefuldestructible.h"
|
2009-12-19 15:26:31 -05:00
|
|
|
#include "pbd/signals.h"
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "pbd/undo.h"
|
|
|
|
|
|
|
|
#include "midi++/mmc.h"
|
|
|
|
#include "midi++/types.h"
|
|
|
|
|
|
|
|
#include "ardour/ardour.h"
|
2009-12-03 21:15:12 -05:00
|
|
|
#include "ardour/click.h"
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "ardour/chan_count.h"
|
2009-05-13 20:13:27 -04:00
|
|
|
#include "ardour/rc_configuration.h"
|
|
|
|
#include "ardour/session_configuration.h"
|
2009-12-03 21:15:12 -05:00
|
|
|
#include "ardour/session_event.h"
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "ardour/location.h"
|
2009-10-26 10:38:58 -04:00
|
|
|
#include "ardour/timecode.h"
|
2009-06-09 20:03:47 -04:00
|
|
|
#include "ardour/interpolation.h"
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
class XMLTree;
|
|
|
|
class XMLNode;
|
|
|
|
class AEffect;
|
|
|
|
|
|
|
|
namespace MIDI {
|
|
|
|
class Port;
|
|
|
|
}
|
|
|
|
|
|
|
|
namespace PBD {
|
|
|
|
class Controllable;
|
|
|
|
}
|
|
|
|
|
2009-01-30 15:18:31 -05:00
|
|
|
namespace Evoral {
|
|
|
|
class Curve;
|
|
|
|
}
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
namespace ARDOUR {
|
|
|
|
|
2009-01-30 15:18:31 -05:00
|
|
|
class AudioDiskstream;
|
2008-06-02 17:41:35 -04:00
|
|
|
class AudioEngine;
|
2009-01-30 15:18:31 -05:00
|
|
|
class AudioFileSource;
|
|
|
|
class AudioRegion;
|
2008-06-02 17:41:35 -04:00
|
|
|
class AudioSource;
|
2009-01-30 15:18:31 -05:00
|
|
|
class AudioTrack;
|
|
|
|
class Auditioner;
|
|
|
|
class AutomationList;
|
|
|
|
class AuxInput;
|
2008-06-02 17:41:35 -04:00
|
|
|
class BufferSet;
|
2009-01-30 15:18:31 -05:00
|
|
|
class Bundle;
|
2009-10-30 11:30:22 -04:00
|
|
|
class Butler;
|
2009-01-30 15:18:31 -05:00
|
|
|
class ControlProtocolInfo;
|
2008-06-02 17:41:35 -04:00
|
|
|
class Diskstream;
|
2009-01-30 15:18:31 -05:00
|
|
|
class ExportHandler;
|
|
|
|
class ExportStatus;
|
|
|
|
class IO;
|
|
|
|
class IOProcessor;
|
2009-10-30 11:30:22 -04:00
|
|
|
class ImportStatus;
|
2008-06-02 17:41:35 -04:00
|
|
|
class MidiDiskstream;
|
2009-01-30 15:18:31 -05:00
|
|
|
class MidiRegion;
|
2008-06-02 17:41:35 -04:00
|
|
|
class MidiSource;
|
2009-01-30 15:18:31 -05:00
|
|
|
class MidiTrack;
|
2009-12-08 22:05:14 -05:00
|
|
|
class MidiControlUI;
|
2008-06-02 17:41:35 -04:00
|
|
|
class NamedSelection;
|
|
|
|
class Playlist;
|
2009-01-30 15:18:31 -05:00
|
|
|
class PluginInsert;
|
|
|
|
class Port;
|
|
|
|
class PortInsert;
|
|
|
|
class Processor;
|
|
|
|
class Region;
|
2009-05-07 13:31:18 -04:00
|
|
|
class Return;
|
2009-01-30 15:18:31 -05:00
|
|
|
class Route;
|
|
|
|
class RouteGroup;
|
2008-06-02 17:41:35 -04:00
|
|
|
class SMFSource;
|
2009-01-30 15:18:31 -05:00
|
|
|
class Send;
|
2008-06-02 17:41:35 -04:00
|
|
|
class SessionDirectory;
|
2008-09-17 04:44:51 -04:00
|
|
|
class SessionMetadata;
|
2009-12-04 14:09:08 -05:00
|
|
|
class SessionPlaylists;
|
2009-01-30 15:18:31 -05:00
|
|
|
class Slave;
|
|
|
|
class Source;
|
|
|
|
class TempoMap;
|
|
|
|
class VSTPlugin;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-11-30 11:12:13 -05:00
|
|
|
extern void setup_enum_writer ();
|
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
class Session : public PBD::StatefulDestructible, public PBD::ScopedConnectionList, public SessionEventManager
|
2008-06-02 17:41:35 -04:00
|
|
|
{
|
|
|
|
public:
|
|
|
|
enum RecordState {
|
|
|
|
Disabled = 0,
|
|
|
|
Enabled = 1,
|
|
|
|
Recording = 2
|
|
|
|
};
|
|
|
|
|
|
|
|
/* creating from an XML file */
|
|
|
|
|
|
|
|
Session (AudioEngine&,
|
2009-10-14 12:10:01 -04:00
|
|
|
const std::string& fullpath,
|
|
|
|
const std::string& snapshot_name,
|
|
|
|
std::string mix_template = "");
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* creating a new Session */
|
|
|
|
|
|
|
|
Session (AudioEngine&,
|
2009-10-14 12:10:01 -04:00
|
|
|
std::string fullpath,
|
|
|
|
std::string snapshot_name,
|
2009-01-30 15:18:31 -05:00
|
|
|
AutoConnectOption input_auto_connect,
|
|
|
|
AutoConnectOption output_auto_connect,
|
|
|
|
uint32_t control_out_channels,
|
|
|
|
uint32_t master_out_channels,
|
|
|
|
uint32_t n_physical_in,
|
|
|
|
uint32_t n_physical_out,
|
|
|
|
nframes_t initial_length);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
virtual ~Session ();
|
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
std::string path() const { return _path; }
|
|
|
|
std::string name() const { return _name; }
|
|
|
|
std::string snap_name() const { return _current_snapshot_name; }
|
|
|
|
std::string raid_path () const;
|
2009-11-30 08:16:38 -05:00
|
|
|
bool path_is_within_session (const std::string&);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
void set_snap_name ();
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-10-13 16:43:28 -04:00
|
|
|
bool writable() const { return _writable; }
|
2008-06-02 17:41:35 -04:00
|
|
|
void set_dirty ();
|
|
|
|
void set_clean ();
|
|
|
|
bool dirty() const { return _state_of_the_state & Dirty; }
|
|
|
|
void set_deletion_in_progress ();
|
The great audio processing overhaul.
The vast majority of Route signal processing is now simply in the list of
processors. There are definitely regressions here, but there's also
a lot of things fixed. It's far too much work to let diverge anymore
regardless, so here it is.
The basic model is: A route has a fixed set of input channels (matching
its JACK input ports and diskstream). The first processor takes this
as input. The next processor is configured using the first processor's
output as input, and is allowed to choose whatever output it wants
given that input... and so on, and so on. Finally, the last processor's
requested output is used to set up the panner and create whatever Jack
ports are needed to output the data.
All 'special' internal processors (meter, fader, amp, insert, send) are
currently transparent: they read any input, and return the same set
of channels back (unmodified, except for amp).
User visible changes:
* LV2 Instrument support (tracks with both MIDI and audio channels)
* MIDI in/out plugin support
* Generic plugin replication (for MIDI plugins, MIDI/audio plugins)
* Movable meter point
Known Bugs:
* Things seem to get weird on loaded sessions
* Output delivery is sketchy
* 2.0 session loading was probably already broken...
but it's definitely broken now :)
Please test this and file bugs if you have any time...
git-svn-id: svn://localhost/ardour2/branches/3.0@5055 d708f5d6-7413-0410-9779-e7cbd77b26cf
2009-05-07 02:30:50 -04:00
|
|
|
void clear_deletion_in_progress ();
|
2008-06-02 17:41:35 -04:00
|
|
|
bool deletion_in_progress() const { return _state_of_the_state & Deletion; }
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::Signal0<void> DirtyChanged;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
const SessionDirectory& session_directory () const { return *(_session_dir.get()); }
|
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
static PBD::Signal0<void> AutoBindingOn;
|
|
|
|
static PBD::Signal0<void> AutoBindingOff;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
static PBD::Signal1<void,std::string> Dialog;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
std::string sound_dir (bool with_path = true) const;
|
|
|
|
std::string peak_dir () const;
|
|
|
|
std::string dead_sound_dir () const;
|
|
|
|
std::string automation_dir () const;
|
|
|
|
std::string analysis_dir() const;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
int ensure_subdirs ();
|
|
|
|
|
|
|
|
Glib::ustring peak_path (Glib::ustring) const;
|
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
static std::string change_source_path_by_name (std::string oldpath, std::string oldname, std::string newname, bool destructive);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
std::string peak_path_from_audio_path (std::string) const;
|
|
|
|
std::string new_audio_source_name (const std::string&, uint32_t nchans, uint32_t chan, bool destructive);
|
|
|
|
std::string new_midi_source_name (const std::string&);
|
|
|
|
std::string new_source_path_from_name (DataType type, const std::string&);
|
2009-03-02 11:52:40 -05:00
|
|
|
RouteList new_route_from_template (uint32_t how_many, const std::string& template_path);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
void process (nframes_t nframes);
|
|
|
|
|
|
|
|
BufferSet& get_silent_buffers (ChanCount count = ChanCount::ZERO);
|
|
|
|
BufferSet& get_scratch_buffers (ChanCount count = ChanCount::ZERO);
|
|
|
|
BufferSet& get_mix_buffers (ChanCount count = ChanCount::ZERO);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
void add_diskstream (boost::shared_ptr<Diskstream>);
|
|
|
|
boost::shared_ptr<Diskstream> diskstream_by_id (const PBD::ID& id);
|
2009-05-12 13:03:42 -04:00
|
|
|
boost::shared_ptr<Diskstream> diskstream_by_name (std::string name);
|
2009-04-29 13:30:35 -04:00
|
|
|
bool have_rec_enabled_diskstream () const;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
bool have_captured() const { return _have_captured; }
|
|
|
|
|
|
|
|
void refill_all_diskstream_buffers ();
|
2009-10-23 20:39:28 -04:00
|
|
|
Butler* butler() { return _butler; }
|
|
|
|
void butler_transport_work ();
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
uint32_t get_next_diskstream_id() const { return n_diskstreams(); }
|
|
|
|
uint32_t n_diskstreams() const;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-10-23 20:39:28 -04:00
|
|
|
void refresh_disk_space ();
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
typedef std::list<boost::shared_ptr<Diskstream> > DiskstreamList;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-10-23 20:39:28 -04:00
|
|
|
SerializedRCUManager<DiskstreamList>& diskstream_list() { return diskstreams; }
|
|
|
|
|
2009-10-14 20:57:55 -04:00
|
|
|
int load_routes (const XMLNode&, int);
|
2008-06-02 17:41:35 -04:00
|
|
|
boost::shared_ptr<RouteList> get_routes() const {
|
|
|
|
return routes.reader ();
|
|
|
|
}
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-11-18 23:25:46 -05:00
|
|
|
boost::shared_ptr<RouteList> get_routes_with_internal_returns() const;
|
|
|
|
|
2009-11-29 07:47:59 -05:00
|
|
|
boost::shared_ptr<RouteList> get_routes_with_regions_at (nframes64_t const) const;
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
uint32_t nroutes() const { return routes.reader()->size(); }
|
|
|
|
uint32_t ntracks () const;
|
|
|
|
uint32_t nbusses () const;
|
|
|
|
|
2009-01-25 01:47:11 -05:00
|
|
|
boost::shared_ptr<BundleList> bundles () {
|
|
|
|
return _bundles.reader ();
|
|
|
|
}
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
struct RoutePublicOrderSorter {
|
2009-10-14 12:10:01 -04:00
|
|
|
bool operator() (boost::shared_ptr<Route>, boost::shared_ptr<Route> b);
|
2008-06-02 17:41:35 -04:00
|
|
|
};
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-07-04 08:40:26 -04:00
|
|
|
void sync_order_keys (std::string const &);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
template<class T> void foreach_route (T *obj, void (T::*func)(Route&));
|
|
|
|
template<class T> void foreach_route (T *obj, void (T::*func)(boost::shared_ptr<Route>));
|
|
|
|
template<class T, class A> void foreach_route (T *obj, void (T::*func)(Route&, A), A arg);
|
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
boost::shared_ptr<Route> route_by_name (std::string);
|
2008-06-02 17:41:35 -04:00
|
|
|
boost::shared_ptr<Route> route_by_id (PBD::ID);
|
|
|
|
boost::shared_ptr<Route> route_by_remote_id (uint32_t id);
|
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
bool route_name_unique (std::string) const;
|
|
|
|
bool route_name_internal (std::string) const;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2008-08-04 18:37:24 -04:00
|
|
|
bool get_record_enabled() const {
|
2008-06-02 17:41:35 -04:00
|
|
|
return (record_status () >= Enabled);
|
|
|
|
}
|
|
|
|
|
|
|
|
RecordState record_status() const {
|
|
|
|
return (RecordState) g_atomic_int_get (&_record_status);
|
|
|
|
}
|
|
|
|
|
|
|
|
bool actively_recording () {
|
|
|
|
return record_status() == Recording;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool record_enabling_legal () const;
|
|
|
|
void maybe_enable_record ();
|
|
|
|
void disable_record (bool rt_context, bool force = false);
|
|
|
|
void step_back_from_record ();
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
void maybe_write_autosave ();
|
|
|
|
|
|
|
|
/* Proxy signal for region hidden changes */
|
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::Signal1<void,boost::shared_ptr<Region> > RegionHiddenChange;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* Emitted when all i/o connections are complete */
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::Signal0<void> IOConnectionsComplete;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* Record status signals */
|
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::Signal0<void> RecordStateChanged;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* Transport mechanism signals */
|
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::Signal0<void> TransportStateChange; /* generic */
|
|
|
|
PBD::Signal1<void,nframes64_t> PositionChanged; /* sent after any non-sequential motion */
|
|
|
|
PBD::Signal0<void> DurationChanged;
|
|
|
|
PBD::Signal1<void,nframes64_t> Xrun;
|
|
|
|
PBD::Signal0<void> TransportLooped;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-02-16 19:12:22 -05:00
|
|
|
/** emitted when a locate has occurred */
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::Signal0<void> Located;
|
2009-02-16 19:12:22 -05:00
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::Signal1<void,RouteList&> RouteAdded;
|
|
|
|
PBD::Signal0<void> RouteGroupChanged;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-12-07 18:51:46 -05:00
|
|
|
void queue_event (SessionEvent*);
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
void request_roll_at_and_return (nframes_t start, nframes_t return_to);
|
|
|
|
void request_bounded_roll (nframes_t start, nframes_t end);
|
2009-11-08 11:28:21 -05:00
|
|
|
void request_stop (bool abort = false, bool clear_state = false);
|
2008-06-02 17:41:35 -04:00
|
|
|
void request_locate (nframes_t frame, bool with_roll = false);
|
|
|
|
|
2009-10-30 14:14:25 -04:00
|
|
|
void request_play_loop (bool yn, bool leave_rolling = false);
|
2008-06-02 17:41:35 -04:00
|
|
|
bool get_play_loop () const { return play_loop; }
|
|
|
|
|
|
|
|
nframes_t last_transport_start() const { return _last_roll_location; }
|
|
|
|
void goto_end () { request_locate (end_location->start(), false);}
|
|
|
|
void goto_start () { request_locate (start_location->start(), false); }
|
|
|
|
void set_session_start (nframes_t start) { start_location->set_start(start); }
|
2009-05-13 20:13:27 -04:00
|
|
|
void set_session_end (nframes_t end) { end_location->set_start(end); config.set_end_marker_is_free (false); }
|
2008-06-02 17:41:35 -04:00
|
|
|
void use_rf_shuttle_speed ();
|
|
|
|
void allow_auto_play (bool yn);
|
2009-01-09 04:18:24 -05:00
|
|
|
void request_transport_speed (double speed);
|
2008-06-02 17:41:35 -04:00
|
|
|
void request_overwrite_buffer (Diskstream*);
|
2009-01-09 04:18:24 -05:00
|
|
|
void request_diskstream_speed (Diskstream&, double speed);
|
2008-06-02 17:41:35 -04:00
|
|
|
void request_input_change_handling ();
|
|
|
|
|
2009-11-08 11:28:21 -05:00
|
|
|
bool locate_pending() const { return static_cast<bool>(post_transport_work()&PostTransportLocate); }
|
2008-06-02 17:41:35 -04:00
|
|
|
bool transport_locked () const;
|
|
|
|
|
|
|
|
int wipe ();
|
|
|
|
|
|
|
|
int remove_region_from_region_list (boost::shared_ptr<Region>);
|
|
|
|
|
|
|
|
nframes_t get_maximum_extent () const;
|
|
|
|
nframes_t current_end_frame() const { return end_location->start(); }
|
|
|
|
nframes_t current_start_frame() const { return start_location->start(); }
|
2009-02-16 21:11:49 -05:00
|
|
|
/// "actual" sample rate of session, set by current audioengine rate, pullup/down etc.
|
2008-06-02 17:41:35 -04:00
|
|
|
nframes_t frame_rate() const { return _current_frame_rate; }
|
2009-02-16 21:11:49 -05:00
|
|
|
/// "native" sample rate of session, regardless of current audioengine rate, pullup/down etc
|
2008-06-02 17:41:35 -04:00
|
|
|
nframes_t nominal_frame_rate() const { return _nominal_frame_rate; }
|
|
|
|
nframes_t frames_per_hour() const { return _frames_per_hour; }
|
|
|
|
|
2009-10-26 10:38:58 -04:00
|
|
|
double frames_per_timecode_frame() const { return _frames_per_timecode_frame; }
|
|
|
|
nframes_t timecode_frames_per_hour() const { return _timecode_frames_per_hour; }
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-10-26 10:38:58 -04:00
|
|
|
MIDI::byte get_mtc_timecode_bits() const {
|
|
|
|
return mtc_timecode_bits; /* encoding of SMTPE type for MTC */
|
2008-12-12 09:43:24 -05:00
|
|
|
}
|
|
|
|
|
2009-10-26 10:38:58 -04:00
|
|
|
float timecode_frames_per_second() const;
|
|
|
|
bool timecode_drop_frames() const;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* Locations */
|
|
|
|
|
|
|
|
Locations *locations() { return &_locations; }
|
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::Signal1<void,Location*> auto_loop_location_changed;
|
|
|
|
PBD::Signal1<void,Location*> auto_punch_location_changed;
|
|
|
|
PBD::Signal0<void> locations_modified;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
void set_auto_punch_location (Location *);
|
|
|
|
void set_auto_loop_location (Location *);
|
2009-05-12 13:03:42 -04:00
|
|
|
int location_name(std::string& result, std::string base = std::string(""));
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
void reset_input_monitor_state ();
|
|
|
|
|
2009-02-16 21:11:49 -05:00
|
|
|
nframes_t get_block_size() const { return current_block_size; }
|
2008-06-02 17:41:35 -04:00
|
|
|
nframes_t worst_output_latency () const { return _worst_output_latency; }
|
2009-02-16 21:11:49 -05:00
|
|
|
nframes_t worst_input_latency () const { return _worst_input_latency; }
|
|
|
|
nframes_t worst_track_latency () const { return _worst_track_latency; }
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
int save_state (std::string snapshot_name, bool pending = false);
|
|
|
|
int restore_state (std::string snapshot_name);
|
|
|
|
int save_template (std::string template_name);
|
|
|
|
int save_history (std::string snapshot_name = "");
|
|
|
|
int restore_history (std::string snapshot_name);
|
|
|
|
void remove_state (std::string snapshot_name);
|
|
|
|
void rename_state (std::string old_name, std::string new_name);
|
2008-06-02 17:41:35 -04:00
|
|
|
void remove_pending_capture_state ();
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
static int rename_template (std::string old_name, std::string new_name);
|
|
|
|
static int delete_template (std::string name);
|
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::Signal1<void,std::string> StateSaved;
|
|
|
|
PBD::Signal0<void> StateReady;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
std::vector<std::string*>* possible_states() const;
|
|
|
|
static std::vector<std::string*>* possible_states (std::string path);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
XMLNode& get_state();
|
2009-10-15 14:56:11 -04:00
|
|
|
int set_state(const XMLNode& node, int version); // not idempotent
|
2008-06-02 17:41:35 -04:00
|
|
|
XMLNode& get_template();
|
|
|
|
|
|
|
|
/// The instant xml file is written to the session directory
|
2008-09-17 04:44:51 -04:00
|
|
|
void add_instant_xml (XMLNode&, bool write_to_config = true);
|
2009-02-16 21:11:49 -05:00
|
|
|
XMLNode* instant_xml (const std::string& str);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
enum StateOfTheState {
|
|
|
|
Clean = 0x0,
|
|
|
|
Dirty = 0x1,
|
|
|
|
CannotSave = 0x2,
|
|
|
|
Deletion = 0x4,
|
|
|
|
InitialConnecting = 0x8,
|
|
|
|
Loading = 0x10,
|
|
|
|
InCleanup = 0x20
|
|
|
|
};
|
|
|
|
|
|
|
|
StateOfTheState state_of_the_state() const { return _state_of_the_state; }
|
|
|
|
|
2009-06-21 15:59:56 -04:00
|
|
|
void add_route_group (RouteGroup *);
|
|
|
|
void remove_route_group (RouteGroup&);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-06-21 15:59:56 -04:00
|
|
|
RouteGroup *route_group_by_name (std::string);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::Signal1<void,RouteGroup*> route_group_added;
|
|
|
|
PBD::Signal0<void> route_group_removed;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-12-17 13:24:23 -05:00
|
|
|
void foreach_route_group (boost::function<void(RouteGroup*)> f) {
|
2009-06-21 15:59:56 -04:00
|
|
|
for (std::list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); i++) {
|
2009-12-17 13:24:23 -05:00
|
|
|
f (*i);
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* fundamental operations. duh. */
|
|
|
|
|
2009-02-16 21:11:49 -05:00
|
|
|
std::list<boost::shared_ptr<AudioTrack> > new_audio_track (
|
2009-06-21 15:59:56 -04:00
|
|
|
int input_channels, int output_channels, TrackMode mode = Normal, RouteGroup* route_group = 0, uint32_t how_many = 1
|
2009-06-20 11:40:26 -04:00
|
|
|
);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-11-18 23:25:46 -05:00
|
|
|
RouteList new_audio_route (bool aux, int input_channels, int output_channels, RouteGroup* route_group, uint32_t how_many);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-02-16 21:11:49 -05:00
|
|
|
std::list<boost::shared_ptr<MidiTrack> > new_midi_track (
|
2009-06-21 15:59:56 -04:00
|
|
|
TrackMode mode = Normal, RouteGroup* route_group = 0, uint32_t how_many = 1
|
2009-06-20 11:40:26 -04:00
|
|
|
);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
void remove_route (boost::shared_ptr<Route>);
|
|
|
|
void resort_routes ();
|
|
|
|
void resort_routes_using (boost::shared_ptr<RouteList>);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
void set_remote_control_ids();
|
|
|
|
|
|
|
|
AudioEngine & engine() { return _engine; }
|
|
|
|
AudioEngine const & engine () const { return _engine; }
|
|
|
|
|
|
|
|
int32_t max_level;
|
|
|
|
int32_t min_level;
|
|
|
|
|
|
|
|
/* Time */
|
|
|
|
|
2009-11-08 11:28:21 -05:00
|
|
|
nframes64_t transport_frame () const {return _transport_frame; }
|
|
|
|
nframes64_t audible_frame () const;
|
2008-06-02 17:41:35 -04:00
|
|
|
nframes64_t requested_return_frame() const { return _requested_return_frame; }
|
|
|
|
|
|
|
|
enum PullupFormat {
|
|
|
|
pullup_Plus4Plus1,
|
|
|
|
pullup_Plus4,
|
|
|
|
pullup_Plus4Minus1,
|
|
|
|
pullup_Plus1,
|
|
|
|
pullup_None,
|
|
|
|
pullup_Minus1,
|
|
|
|
pullup_Minus4Plus1,
|
|
|
|
pullup_Minus4,
|
|
|
|
pullup_Minus4Minus1
|
|
|
|
};
|
|
|
|
|
|
|
|
void sync_time_vars();
|
|
|
|
|
|
|
|
void bbt_time (nframes_t when, BBT_Time&);
|
2009-10-26 10:38:58 -04:00
|
|
|
void timecode_to_sample(Timecode::Time& timecode, nframes_t& sample, bool use_offset, bool use_subframes) const;
|
|
|
|
void sample_to_timecode(nframes_t sample, Timecode::Time& timecode, bool use_offset, bool use_subframes) const;
|
|
|
|
void timecode_time (Timecode::Time &);
|
|
|
|
void timecode_time (nframes_t when, Timecode::Time&);
|
|
|
|
void timecode_time_subframes (nframes_t when, Timecode::Time&);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-10-26 10:38:58 -04:00
|
|
|
void timecode_duration (nframes_t, Timecode::Time&) const;
|
|
|
|
void timecode_duration_string (char *, nframes_t) const;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-10-26 10:38:58 -04:00
|
|
|
void set_timecode_offset (nframes_t);
|
|
|
|
nframes_t timecode_offset () const { return _timecode_offset; }
|
|
|
|
void set_timecode_offset_negative (bool);
|
|
|
|
bool timecode_offset_negative () const { return _timecode_offset_negative; }
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2008-09-17 04:44:51 -04:00
|
|
|
nframes_t convert_to_frames_at (nframes_t position, AnyTime const &);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
static PBD::Signal0<void> StartTimeChanged;
|
|
|
|
static PBD::Signal0<void> EndTimeChanged;
|
|
|
|
static PBD::Signal0<void> TimecodeOffsetChanged;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-11-09 15:05:18 -05:00
|
|
|
std::vector<SyncSource> get_available_sync_options() const;
|
2009-12-03 13:44:06 -05:00
|
|
|
void request_sync_source (Slave*);
|
2009-11-09 15:05:18 -05:00
|
|
|
bool synced_to_jack() const { return config.get_external_sync() && config.get_sync_source() == JACK; }
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-01-30 15:18:31 -05:00
|
|
|
double transport_speed() const { return _transport_speed; }
|
|
|
|
bool transport_stopped() const { return _transport_speed == 0.0f; }
|
|
|
|
bool transport_rolling() const { return _transport_speed != 0.0f; }
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
void set_silent (bool yn);
|
|
|
|
bool silent () { return _silent; }
|
|
|
|
|
|
|
|
int jack_slave_sync (nframes_t);
|
|
|
|
|
|
|
|
TempoMap& tempo_map() { return *_tempo_map; }
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-10-26 10:38:58 -04:00
|
|
|
/// signals the current transport position in frames, bbt and timecode time (in that order)
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::Signal3<void,const nframes_t&, const BBT_Time&, const Timecode::Time&> tick;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* region info */
|
|
|
|
|
|
|
|
void add_regions (std::vector<boost::shared_ptr<Region> >&);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::Signal1<void,boost::weak_ptr<Region> > RegionAdded;
|
|
|
|
PBD::Signal1<void,std::vector<boost::weak_ptr<Region> >&> RegionsAdded;
|
|
|
|
PBD::Signal1<void,boost::weak_ptr<Region> > RegionRemoved;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
int region_name (std::string& result, std::string base = std::string(""), bool newlevel = false);
|
|
|
|
std::string new_region_name (std::string);
|
|
|
|
std::string path_from_region_name (DataType type, std::string name, std::string identifier);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
boost::shared_ptr<Region> find_whole_file_parent (boost::shared_ptr<Region const>);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
boost::shared_ptr<Region> XMLRegionFactory (const XMLNode&, bool full);
|
|
|
|
boost::shared_ptr<AudioRegion> XMLAudioRegionFactory (const XMLNode&, bool full);
|
|
|
|
boost::shared_ptr<MidiRegion> XMLMidiRegionFactory (const XMLNode&, bool full);
|
|
|
|
|
|
|
|
template<class T> void foreach_region (T *obj, void (T::*func)(boost::shared_ptr<Region>));
|
|
|
|
|
|
|
|
/* source management */
|
|
|
|
|
2009-02-15 21:51:16 -05:00
|
|
|
void import_audiofiles (ImportStatus&);
|
2009-05-12 13:03:42 -04:00
|
|
|
bool sample_rate_convert (ImportStatus&, std::string infile, std::string& outfile);
|
|
|
|
std::string build_tmp_convert_name (std::string file);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2008-09-17 04:44:51 -04:00
|
|
|
boost::shared_ptr<ExportHandler> get_export_handler ();
|
2008-09-28 07:11:38 -04:00
|
|
|
boost::shared_ptr<ExportStatus> get_export_status ();
|
2008-09-17 04:44:51 -04:00
|
|
|
|
2009-10-14 12:10:01 -04:00
|
|
|
int start_audio_export (nframes_t position, bool realtime);
|
2008-09-17 04:44:51 -04:00
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::Signal1<int,nframes_t> ProcessExport;
|
|
|
|
PBD::Signal0<void> ExportReadFinished;
|
|
|
|
static PBD::Signal2<void,std::string, std::string> Exported;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
void add_source (boost::shared_ptr<Source>);
|
|
|
|
void remove_source (boost::weak_ptr<Source>);
|
|
|
|
|
2009-10-30 11:30:22 -04:00
|
|
|
int cleanup_sources (CleanupReport&);
|
|
|
|
int cleanup_trash_sources (CleanupReport&);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
int destroy_region (boost::shared_ptr<Region>);
|
|
|
|
int destroy_regions (std::list<boost::shared_ptr<Region> >);
|
|
|
|
|
|
|
|
int remove_last_capture ();
|
|
|
|
|
2009-02-16 21:11:49 -05:00
|
|
|
/** handlers should return -1 for "stop cleanup",
|
|
|
|
0 for "yes, delete this playlist",
|
|
|
|
1 for "no, don't delete this playlist".
|
2008-06-02 17:41:35 -04:00
|
|
|
*/
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::Signal1<void,boost::shared_ptr<Playlist> > AskAboutPlaylistDeletion;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-02-16 21:11:49 -05:00
|
|
|
/** handlers should return 0 for "ignore the rate mismatch",
|
|
|
|
!0 for "do not use this session"
|
2008-06-02 17:41:35 -04:00
|
|
|
*/
|
2009-12-19 15:26:31 -05:00
|
|
|
static PBD::Signal2<int,nframes_t, nframes_t> AskAboutSampleRateMismatch;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-02-16 21:11:49 -05:00
|
|
|
/** handlers should return !0 for use pending state, 0 for ignore it.
|
2008-06-02 17:41:35 -04:00
|
|
|
*/
|
2009-12-19 15:26:31 -05:00
|
|
|
static PBD::Signal0<int> AskAboutPendingState;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
boost::shared_ptr<AudioFileSource> create_audio_source_for_session (ARDOUR::AudioDiskstream&, uint32_t which_channel, bool destructive);
|
|
|
|
|
|
|
|
boost::shared_ptr<MidiSource> create_midi_source_for_session (ARDOUR::MidiDiskstream&);
|
|
|
|
|
|
|
|
boost::shared_ptr<Source> source_by_id (const PBD::ID&);
|
|
|
|
boost::shared_ptr<Source> source_by_path_and_channel (const Glib::ustring&, uint16_t);
|
|
|
|
|
2008-09-26 04:29:30 -04:00
|
|
|
void add_playlist (boost::shared_ptr<Playlist>, bool unused = false);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* named selections */
|
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
NamedSelection* named_selection_by_name (std::string name);
|
2008-06-02 17:41:35 -04:00
|
|
|
void add_named_selection (NamedSelection *);
|
|
|
|
void remove_named_selection (NamedSelection *);
|
|
|
|
|
|
|
|
template<class T> void foreach_named_selection (T& obj, void (T::*func)(NamedSelection&));
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::Signal0<void> NamedSelectionAdded;
|
|
|
|
PBD::Signal0<void> NamedSelectionRemoved;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* Curves and AutomationLists (TODO when they go away) */
|
|
|
|
void add_automation_list(AutomationList*);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* fade curves */
|
|
|
|
|
|
|
|
float get_default_fade_length () const { return default_fade_msecs; }
|
|
|
|
float get_default_fade_steepness () const { return default_fade_steepness; }
|
|
|
|
void set_default_fade (float steepness, float msecs);
|
|
|
|
|
|
|
|
/* auditioning */
|
|
|
|
|
|
|
|
boost::shared_ptr<Auditioner> the_auditioner() { return auditioner; }
|
|
|
|
void audition_playlist ();
|
|
|
|
void audition_region (boost::shared_ptr<Region>);
|
|
|
|
void cancel_audition ();
|
|
|
|
bool is_auditioning () const;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::Signal1<void,bool> AuditionActive;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* flattening stuff */
|
|
|
|
|
2009-01-30 15:18:31 -05:00
|
|
|
boost::shared_ptr<Region> write_one_track (AudioTrack&, nframes_t start, nframes_t end,
|
2009-10-14 12:10:01 -04:00
|
|
|
bool overwrite, std::vector<boost::shared_ptr<Source> >&, InterThreadInfo& wot,
|
|
|
|
bool enable_processing = true);
|
2008-06-02 17:41:35 -04:00
|
|
|
int freeze (InterThreadInfo&);
|
|
|
|
|
|
|
|
/* session-wide solo/mute/rec-enable */
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-06-09 16:21:19 -04:00
|
|
|
bool soloing() const { return _non_soloed_outs_muted; }
|
2009-07-01 09:36:50 -04:00
|
|
|
bool listening() const { return _listen_cnt > 0; }
|
|
|
|
|
2009-12-11 18:30:48 -05:00
|
|
|
static const SessionEvent::RTeventCallback rt_cleanup;
|
2009-12-10 12:45:18 -05:00
|
|
|
|
2009-12-11 18:30:48 -05:00
|
|
|
void set_solo (boost::shared_ptr<RouteList>, bool, SessionEvent::RTeventCallback after = rt_cleanup, bool group_override = false);
|
|
|
|
void set_just_one_solo (boost::shared_ptr<Route>, bool, SessionEvent::RTeventCallback after = rt_cleanup);
|
|
|
|
void set_mute (boost::shared_ptr<RouteList>, bool, SessionEvent::RTeventCallback after = rt_cleanup, bool group_override = false);
|
|
|
|
void set_listen (boost::shared_ptr<RouteList>, bool, SessionEvent::RTeventCallback after = rt_cleanup, bool group_override = false);
|
|
|
|
void set_record_enable (boost::shared_ptr<RouteList>, bool, SessionEvent::RTeventCallback after = rt_cleanup, bool group_override = false);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::Signal1<void,bool> SoloActive;
|
|
|
|
PBD::Signal0<void> SoloChanged;
|
2009-12-07 18:51:46 -05:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* control/master out */
|
|
|
|
|
2009-06-09 16:21:19 -04:00
|
|
|
boost::shared_ptr<Route> control_out() const { return _control_out; }
|
|
|
|
boost::shared_ptr<Route> master_out() const { return _master_out; }
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-07-14 20:47:34 -04:00
|
|
|
void globally_add_internal_sends (boost::shared_ptr<Route> dest, Placement p);
|
2009-07-21 08:05:44 -04:00
|
|
|
void globally_set_send_gains_from_track (boost::shared_ptr<Route> dest);
|
|
|
|
void globally_set_send_gains_to_zero (boost::shared_ptr<Route> dest);
|
|
|
|
void globally_set_send_gains_to_unity (boost::shared_ptr<Route> dest);
|
2009-07-14 20:47:34 -04:00
|
|
|
void add_internal_sends (boost::shared_ptr<Route> dest, Placement p, boost::shared_ptr<RouteList> senders);
|
2009-06-25 16:46:39 -04:00
|
|
|
|
2008-08-04 18:37:24 -04:00
|
|
|
static void set_disable_all_loaded_plugins (bool yn) {
|
2008-06-02 17:41:35 -04:00
|
|
|
_disable_all_loaded_plugins = yn;
|
|
|
|
}
|
2008-08-04 18:37:24 -04:00
|
|
|
static bool get_disable_all_loaded_plugins() {
|
2008-06-02 17:41:35 -04:00
|
|
|
return _disable_all_loaded_plugins;
|
|
|
|
}
|
|
|
|
|
|
|
|
uint32_t next_send_id();
|
2009-05-07 13:31:18 -04:00
|
|
|
uint32_t next_return_id();
|
2008-06-02 17:41:35 -04:00
|
|
|
uint32_t next_insert_id();
|
|
|
|
void mark_send_id (uint32_t);
|
2009-05-07 13:31:18 -04:00
|
|
|
void mark_return_id (uint32_t);
|
2008-06-02 17:41:35 -04:00
|
|
|
void mark_insert_id (uint32_t);
|
|
|
|
|
|
|
|
/* s/w "RAID" management */
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
nframes_t available_capture_duration();
|
|
|
|
|
|
|
|
/* I/O bundles */
|
|
|
|
|
|
|
|
void add_bundle (boost::shared_ptr<Bundle>);
|
|
|
|
void remove_bundle (boost::shared_ptr<Bundle>);
|
2009-05-12 13:03:42 -04:00
|
|
|
boost::shared_ptr<Bundle> bundle_by_name (std::string) const;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::Signal1<void,boost::shared_ptr<Bundle> > BundleAdded;
|
|
|
|
PBD::Signal1<void,boost::shared_ptr<Bundle> > BundleRemoved;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-02-16 21:11:49 -05:00
|
|
|
/* MIDI control */
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
void midi_panic(void);
|
2009-05-12 13:03:42 -04:00
|
|
|
int set_mtc_port (std::string port_tag);
|
|
|
|
int set_mmc_port (std::string port_tag);
|
|
|
|
int set_midi_port (std::string port_tag);
|
|
|
|
int set_midi_clock_port (std::string port_tag);
|
2008-06-02 17:41:35 -04:00
|
|
|
MIDI::Port *mtc_port() const { return _mtc_port; }
|
|
|
|
MIDI::Port *mmc_port() const { return _mmc_port; }
|
|
|
|
MIDI::Port *midi_port() const { return _midi_port; }
|
2008-08-04 18:37:24 -04:00
|
|
|
MIDI::Port *midi_clock_port() const { return _midi_clock_port; }
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::Signal0<void> MTC_PortChanged;
|
|
|
|
PBD::Signal0<void> MMC_PortChanged;
|
|
|
|
PBD::Signal0<void> MIDI_PortChanged;
|
|
|
|
PBD::Signal0<void> MIDIClock_PortChanged;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
void set_trace_midi_input (bool, MIDI::Port* port = 0);
|
|
|
|
void set_trace_midi_output (bool, MIDI::Port* port = 0);
|
|
|
|
|
|
|
|
bool get_trace_midi_input(MIDI::Port *port = 0);
|
|
|
|
bool get_trace_midi_output(MIDI::Port *port = 0);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
void set_mmc_receive_device_id (uint32_t id);
|
|
|
|
void set_mmc_send_device_id (uint32_t id);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* Scrubbing */
|
|
|
|
|
|
|
|
void start_scrub (nframes_t where);
|
|
|
|
void stop_scrub ();
|
|
|
|
void set_scrub_speed (float);
|
|
|
|
nframes_t scrub_buffer_size() const;
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::Signal0<void> ScrubReady;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* History (for editors, mixers, UIs etc.) */
|
|
|
|
|
|
|
|
/** Undo some transactions.
|
|
|
|
* @param n Number of transactions to undo.
|
|
|
|
*/
|
|
|
|
void undo (uint32_t n) {
|
|
|
|
_history.undo (n);
|
|
|
|
}
|
|
|
|
|
|
|
|
void redo (uint32_t n) {
|
|
|
|
_history.redo (n);
|
|
|
|
}
|
|
|
|
|
|
|
|
UndoHistory& history() { return _history; }
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
uint32_t undo_depth() const { return _history.undo_depth(); }
|
|
|
|
uint32_t redo_depth() const { return _history.redo_depth(); }
|
2009-05-12 13:03:42 -04:00
|
|
|
std::string next_undo() const { return _history.next_undo(); }
|
|
|
|
std::string next_redo() const { return _history.next_redo(); }
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
void begin_reversible_command (const std::string& cmd_name);
|
2008-06-02 17:41:35 -04:00
|
|
|
void commit_reversible_command (Command* cmd = 0);
|
|
|
|
|
2009-12-07 16:37:35 -05:00
|
|
|
UndoTransaction* start_reversible_command (const std::string& cmd_name);
|
|
|
|
void finish_reversible_command (UndoTransaction&);
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
void add_command (Command *const cmd) {
|
2009-05-04 21:53:30 -04:00
|
|
|
assert(!_current_trans.empty ());
|
|
|
|
_current_trans.top()->add_command (cmd);
|
2008-06-02 17:41:35 -04:00
|
|
|
}
|
|
|
|
|
2009-12-17 13:24:23 -05:00
|
|
|
std::map<PBD::ID,PBD::StatefulDestructible*> registry;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
// these commands are implemented in libs/ardour/session_command.cc
|
|
|
|
Command* memento_command_factory(XMLNode* n);
|
2009-12-17 13:24:23 -05:00
|
|
|
void register_with_memento_command_factory(PBD::ID, PBD::StatefulDestructible*);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* clicking */
|
|
|
|
|
2009-02-16 21:11:49 -05:00
|
|
|
boost::shared_ptr<IO> click_io() { return _click_io; }
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* disk, buffer loads */
|
|
|
|
|
|
|
|
uint32_t playback_load ();
|
|
|
|
uint32_t capture_load ();
|
|
|
|
uint32_t playback_load_min ();
|
|
|
|
uint32_t capture_load_min ();
|
|
|
|
|
|
|
|
void reset_playback_load_min ();
|
|
|
|
void reset_capture_load_min ();
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* ranges */
|
|
|
|
|
2009-11-08 11:28:21 -05:00
|
|
|
void request_play_range (std::list<AudioRange>*, bool leave_rolling = false);
|
2008-06-02 17:41:35 -04:00
|
|
|
bool get_play_range () const { return _play_range; }
|
|
|
|
|
|
|
|
/* buffers for gain and pan */
|
|
|
|
|
|
|
|
gain_t* gain_automation_buffer () const { return _gain_automation_buffer; }
|
|
|
|
pan_t** pan_automation_buffer () const { return _pan_automation_buffer; }
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-05-04 11:50:51 -04:00
|
|
|
void ensure_buffer_set (BufferSet& buffers, const ChanCount& howmany);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* VST support */
|
|
|
|
|
|
|
|
static long vst_callback (AEffect* effect,
|
2009-01-30 15:18:31 -05:00
|
|
|
long opcode,
|
|
|
|
long index,
|
|
|
|
long value,
|
|
|
|
void* ptr,
|
|
|
|
float opt);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
static PBD::Signal0<void> SendFeedback;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* Controllables */
|
|
|
|
|
|
|
|
boost::shared_ptr<PBD::Controllable> controllable_by_id (const PBD::ID&);
|
|
|
|
|
|
|
|
void add_controllable (boost::shared_ptr<PBD::Controllable>);
|
|
|
|
void remove_controllable (PBD::Controllable*);
|
|
|
|
|
2008-12-12 09:43:24 -05:00
|
|
|
SessionMetadata & metadata () { return *_metadata; }
|
|
|
|
|
2009-05-13 20:13:27 -04:00
|
|
|
SessionConfiguration config;
|
|
|
|
|
2009-09-01 16:13:23 -04:00
|
|
|
bool exporting () const {
|
|
|
|
return _exporting;
|
|
|
|
}
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-11-30 11:12:13 -05:00
|
|
|
/* this is a private enum, but setup_enum_writer() needs it,
|
|
|
|
and i can't find a way to give that function
|
|
|
|
friend access. sigh.
|
|
|
|
*/
|
|
|
|
|
|
|
|
enum PostTransportWork {
|
|
|
|
PostTransportStop = 0x1,
|
|
|
|
PostTransportDisableRecord = 0x2,
|
|
|
|
PostTransportPosition = 0x8,
|
|
|
|
PostTransportDidRecord = 0x20,
|
|
|
|
PostTransportDuration = 0x40,
|
|
|
|
PostTransportLocate = 0x80,
|
|
|
|
PostTransportRoll = 0x200,
|
|
|
|
PostTransportAbort = 0x800,
|
|
|
|
PostTransportOverWrite = 0x1000,
|
|
|
|
PostTransportSpeed = 0x2000,
|
|
|
|
PostTransportAudition = 0x4000,
|
|
|
|
PostTransportScrub = 0x8000,
|
|
|
|
PostTransportReverse = 0x10000,
|
|
|
|
PostTransportInputChange = 0x20000,
|
|
|
|
PostTransportCurveRealloc = 0x40000,
|
|
|
|
PostTransportClearSubstate = 0x80000
|
|
|
|
};
|
|
|
|
|
2009-12-02 16:26:26 -05:00
|
|
|
enum SlaveState {
|
|
|
|
Stopped,
|
|
|
|
Waiting,
|
|
|
|
Running
|
|
|
|
};
|
|
|
|
|
|
|
|
SlaveState slave_state() const { return _slave_state; }
|
2009-11-30 11:12:13 -05:00
|
|
|
|
2009-12-04 14:09:08 -05:00
|
|
|
boost::shared_ptr<SessionPlaylists> playlists;
|
2009-12-03 16:52:10 -05:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
protected:
|
|
|
|
friend class AudioEngine;
|
|
|
|
void set_block_size (nframes_t nframes);
|
|
|
|
void set_frame_rate (nframes_t nframes);
|
|
|
|
|
|
|
|
protected:
|
|
|
|
friend class Route;
|
|
|
|
void schedule_curve_reallocation ();
|
|
|
|
void update_latency_compensation (bool, bool);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
private:
|
2009-05-12 13:03:42 -04:00
|
|
|
int create (bool& new_session, const std::string& mix_template, nframes_t initial_length);
|
2008-06-02 17:41:35 -04:00
|
|
|
void destroy ();
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
nframes_t compute_initial_length ();
|
|
|
|
|
|
|
|
enum SubState {
|
|
|
|
PendingDeclickIn = 0x1,
|
|
|
|
PendingDeclickOut = 0x2,
|
|
|
|
StopPendingCapture = 0x4,
|
|
|
|
AutoReturning = 0x10,
|
|
|
|
PendingLocate = 0x20,
|
|
|
|
PendingSetLoop = 0x40
|
|
|
|
};
|
|
|
|
|
|
|
|
/* stuff used in process() should be close together to
|
|
|
|
maximise cache hits
|
|
|
|
*/
|
|
|
|
|
|
|
|
typedef void (Session::*process_function_type)(nframes_t);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
AudioEngine& _engine;
|
|
|
|
mutable gint processing_prohibited;
|
|
|
|
process_function_type process_function;
|
|
|
|
process_function_type last_process_function;
|
|
|
|
bool waiting_for_sync_offset;
|
|
|
|
nframes_t _base_frame_rate;
|
|
|
|
nframes_t _current_frame_rate; //this includes video pullup offset
|
|
|
|
nframes_t _nominal_frame_rate; //ignores audioengine setting, "native" SR
|
|
|
|
int transport_sub_state;
|
|
|
|
mutable gint _record_status;
|
2009-11-08 11:28:21 -05:00
|
|
|
volatile nframes64_t _transport_frame;
|
2008-06-02 17:41:35 -04:00
|
|
|
Location* end_location;
|
|
|
|
Location* start_location;
|
|
|
|
Slave* _slave;
|
|
|
|
bool _silent;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-06-23 05:50:02 -04:00
|
|
|
// varispeed playback
|
2009-06-23 05:50:17 -04:00
|
|
|
volatile double _transport_speed;
|
|
|
|
double _last_transport_speed;
|
|
|
|
double _target_transport_speed;
|
2009-07-23 12:55:45 -04:00
|
|
|
CubicInterpolation interpolation;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
bool auto_play_legal;
|
2009-11-08 11:28:21 -05:00
|
|
|
nframes64_t _last_slave_transport_frame;
|
2008-06-02 17:41:35 -04:00
|
|
|
nframes_t maximum_output_latency;
|
|
|
|
volatile nframes64_t _requested_return_frame;
|
|
|
|
BufferSet* _scratch_buffers;
|
|
|
|
BufferSet* _silent_buffers;
|
|
|
|
BufferSet* _mix_buffers;
|
|
|
|
nframes_t current_block_size;
|
|
|
|
nframes_t _worst_output_latency;
|
|
|
|
nframes_t _worst_input_latency;
|
|
|
|
nframes_t _worst_track_latency;
|
|
|
|
bool _have_captured;
|
|
|
|
float _meter_hold;
|
|
|
|
float _meter_falloff;
|
2009-06-09 16:21:19 -04:00
|
|
|
bool _non_soloed_outs_muted;
|
2009-07-01 09:36:50 -04:00
|
|
|
uint32_t _listen_cnt;
|
2009-10-13 16:43:28 -04:00
|
|
|
bool _writable;
|
2009-11-08 11:28:21 -05:00
|
|
|
bool _was_seamless;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
void set_worst_io_latencies ();
|
2009-07-21 11:55:17 -04:00
|
|
|
void set_worst_io_latencies_x (IOChange, void *) {
|
2008-06-02 17:41:35 -04:00
|
|
|
set_worst_io_latencies ();
|
|
|
|
}
|
|
|
|
|
|
|
|
void update_latency_compensation_proxy (void* ignored);
|
|
|
|
|
|
|
|
void ensure_buffers (ChanCount howmany);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
void process_scrub (nframes_t);
|
|
|
|
void process_without_events (nframes_t);
|
|
|
|
void process_with_events (nframes_t);
|
|
|
|
void process_audition (nframes_t);
|
2008-09-17 04:44:51 -04:00
|
|
|
void process_export (nframes_t);
|
|
|
|
int process_export_fw (nframes_t);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-04-16 12:02:25 -04:00
|
|
|
void block_processing() { g_atomic_int_set (&processing_prohibited, 1); }
|
|
|
|
void unblock_processing() { g_atomic_int_set (&processing_prohibited, 0); }
|
|
|
|
bool processing_blocked() const { return g_atomic_int_get (&processing_prohibited); }
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* slave tracking */
|
|
|
|
|
|
|
|
static const int delta_accumulator_size = 25;
|
|
|
|
int delta_accumulator_cnt;
|
|
|
|
long delta_accumulator[delta_accumulator_size];
|
|
|
|
long average_slave_delta;
|
|
|
|
int average_dir;
|
|
|
|
bool have_first_delta_accumulator;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-12-02 16:26:26 -05:00
|
|
|
SlaveState _slave_state;
|
2008-06-02 17:41:35 -04:00
|
|
|
nframes_t slave_wait_end;
|
|
|
|
|
|
|
|
void reset_slave_state ();
|
2009-04-23 13:48:37 -04:00
|
|
|
bool follow_slave (nframes_t);
|
2009-01-01 16:26:23 -05:00
|
|
|
void calculate_moving_average_of_slave_delta(int dir, nframes_t this_delta);
|
2009-12-02 16:26:26 -05:00
|
|
|
void track_slave_state(float slave_speed, nframes_t slave_transport_frame, nframes_t this_delta);
|
2009-04-23 13:48:37 -04:00
|
|
|
void follow_slave_silently(nframes_t nframes, float slave_speed);
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-12-03 13:44:06 -05:00
|
|
|
void switch_to_sync_source (SyncSource); /* !RT context */
|
|
|
|
void drop_sync_source (); /* !RT context */
|
|
|
|
void use_sync_source (Slave*); /* RT context */
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-11-09 15:05:18 -05:00
|
|
|
bool post_export_sync;
|
2008-09-28 07:11:38 -04:00
|
|
|
nframes_t post_export_position;
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
bool _exporting;
|
2008-09-17 04:44:51 -04:00
|
|
|
bool _exporting_realtime;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-09-17 04:44:51 -04:00
|
|
|
boost::shared_ptr<ExportHandler> export_handler;
|
2008-09-28 07:11:38 -04:00
|
|
|
boost::shared_ptr<ExportStatus> export_status;
|
|
|
|
|
|
|
|
int pre_export ();
|
|
|
|
int stop_audio_export ();
|
|
|
|
void finalize_audio_export ();
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2009-12-19 15:26:31 -05:00
|
|
|
PBD::ScopedConnection export_freewheel_connection;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
void prepare_diskstreams ();
|
|
|
|
void commit_diskstreams (nframes_t, bool& session_requires_butler);
|
2009-04-23 13:48:37 -04:00
|
|
|
int process_routes (nframes_t);
|
|
|
|
int silent_process_routes (nframes_t);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
bool get_rec_monitors_input () {
|
|
|
|
if (actively_recording()) {
|
|
|
|
return true;
|
|
|
|
} else {
|
2009-05-13 20:13:27 -04:00
|
|
|
if (config.get_auto_input()) {
|
2008-06-02 17:41:35 -04:00
|
|
|
return false;
|
|
|
|
} else {
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
int get_transport_declick_required () {
|
|
|
|
if (transport_sub_state & PendingDeclickIn) {
|
|
|
|
transport_sub_state &= ~PendingDeclickIn;
|
|
|
|
return 1;
|
|
|
|
} else if (transport_sub_state & PendingDeclickOut) {
|
|
|
|
return -1;
|
|
|
|
} else {
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2009-10-30 14:14:25 -04:00
|
|
|
bool maybe_stop (nframes_t limit);
|
2009-04-23 13:48:37 -04:00
|
|
|
bool maybe_sync_start (nframes_t&);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
void check_declick_out ();
|
|
|
|
|
|
|
|
MIDI::MachineControl* mmc;
|
|
|
|
MIDI::Port* _mmc_port;
|
|
|
|
MIDI::Port* _mtc_port;
|
|
|
|
MIDI::Port* _midi_port;
|
2008-08-04 18:37:24 -04:00
|
|
|
MIDI::Port* _midi_clock_port;
|
2009-05-12 13:03:42 -04:00
|
|
|
std::string _path;
|
|
|
|
std::string _name;
|
2008-06-02 17:41:35 -04:00
|
|
|
bool session_send_mmc;
|
|
|
|
bool session_send_mtc;
|
|
|
|
bool session_midi_feedback;
|
|
|
|
bool play_loop;
|
|
|
|
bool loop_changing;
|
|
|
|
nframes_t last_loopend;
|
|
|
|
|
|
|
|
boost::scoped_ptr<SessionDirectory> _session_dir;
|
|
|
|
|
|
|
|
void hookup_io ();
|
|
|
|
void when_engine_running ();
|
|
|
|
void graph_reordered ();
|
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
std::string _current_snapshot_name;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-10-15 14:56:11 -04:00
|
|
|
XMLTree* state_tree;
|
|
|
|
bool state_was_pending;
|
2008-06-02 17:41:35 -04:00
|
|
|
StateOfTheState _state_of_the_state;
|
|
|
|
|
|
|
|
void auto_save();
|
|
|
|
int load_options (const XMLNode&);
|
2009-05-12 13:03:42 -04:00
|
|
|
int load_state (std::string snapshot_name);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
nframes_t _last_roll_location;
|
|
|
|
nframes_t _last_record_location;
|
|
|
|
|
|
|
|
bool pending_locate_roll;
|
|
|
|
nframes_t pending_locate_frame;
|
|
|
|
bool pending_locate_flush;
|
|
|
|
bool pending_abort;
|
|
|
|
bool pending_auto_loop;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-10-23 20:39:28 -04:00
|
|
|
Butler* _butler;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-11-30 11:12:13 -05:00
|
|
|
#if 0 // these should be here, see comments in their other location above
|
2008-06-02 17:41:35 -04:00
|
|
|
enum PostTransportWork {
|
|
|
|
PostTransportStop = 0x1,
|
|
|
|
PostTransportDisableRecord = 0x2,
|
|
|
|
PostTransportPosition = 0x8,
|
|
|
|
PostTransportDidRecord = 0x20,
|
|
|
|
PostTransportDuration = 0x40,
|
|
|
|
PostTransportLocate = 0x80,
|
|
|
|
PostTransportRoll = 0x200,
|
|
|
|
PostTransportAbort = 0x800,
|
|
|
|
PostTransportOverWrite = 0x1000,
|
|
|
|
PostTransportSpeed = 0x2000,
|
|
|
|
PostTransportAudition = 0x4000,
|
|
|
|
PostTransportScrub = 0x8000,
|
|
|
|
PostTransportReverse = 0x10000,
|
|
|
|
PostTransportInputChange = 0x20000,
|
2009-11-08 11:28:21 -05:00
|
|
|
PostTransportCurveRealloc = 0x40000,
|
|
|
|
PostTransportClearSubstate = 0x80000
|
2008-06-02 17:41:35 -04:00
|
|
|
};
|
2009-11-30 11:12:13 -05:00
|
|
|
#endif
|
2008-08-04 18:37:24 -04:00
|
|
|
static const PostTransportWork ProcessCannotProceedMask =
|
2009-01-30 15:18:31 -05:00
|
|
|
PostTransportWork (
|
|
|
|
PostTransportInputChange|
|
|
|
|
PostTransportSpeed|
|
|
|
|
PostTransportReverse|
|
|
|
|
PostTransportCurveRealloc|
|
|
|
|
PostTransportScrub|
|
|
|
|
PostTransportAudition|
|
|
|
|
PostTransportLocate|
|
2009-11-08 11:28:21 -05:00
|
|
|
PostTransportStop|
|
|
|
|
PostTransportClearSubstate);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-11-08 11:28:21 -05:00
|
|
|
gint _post_transport_work; /* accessed only atomic ops */
|
|
|
|
PostTransportWork post_transport_work() const { return (PostTransportWork) g_atomic_int_get (&_post_transport_work); }
|
|
|
|
void set_post_transport_work (PostTransportWork ptw) { g_atomic_int_set (&_post_transport_work, (gint) ptw); }
|
|
|
|
void add_post_transport_work (PostTransportWork ptw);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
uint32_t cumulative_rf_motion;
|
|
|
|
uint32_t rf_scale;
|
|
|
|
|
|
|
|
void set_rf_speed (float speed);
|
|
|
|
void reset_rf_scale (nframes_t frames_moved);
|
|
|
|
|
|
|
|
Locations _locations;
|
|
|
|
void locations_changed ();
|
|
|
|
void locations_added (Location*);
|
|
|
|
void handle_locations_changed (Locations::LocationList&);
|
|
|
|
|
2009-12-17 13:24:23 -05:00
|
|
|
PBD::ScopedConnectionList punch_connections;
|
2008-06-02 17:41:35 -04:00
|
|
|
void auto_punch_start_changed (Location *);
|
|
|
|
void auto_punch_end_changed (Location *);
|
|
|
|
void auto_punch_changed (Location *);
|
|
|
|
|
2009-12-17 13:24:23 -05:00
|
|
|
PBD::ScopedConnectionList loop_connections;
|
2008-06-02 17:41:35 -04:00
|
|
|
void auto_loop_changed (Location *);
|
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
void first_stage_init (std::string path, std::string snapshot_name);
|
2008-06-02 17:41:35 -04:00
|
|
|
int second_stage_init (bool new_tracks);
|
|
|
|
void find_current_end ();
|
|
|
|
void remove_empty_sounds ();
|
|
|
|
|
|
|
|
void setup_midi_control ();
|
|
|
|
int midi_read (MIDI::Port *);
|
|
|
|
|
|
|
|
void enable_record ();
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
void increment_transport_position (uint32_t val) {
|
|
|
|
if (max_frames - val < _transport_frame) {
|
|
|
|
_transport_frame = max_frames;
|
|
|
|
} else {
|
|
|
|
_transport_frame += val;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void decrement_transport_position (uint32_t val) {
|
|
|
|
if (val < _transport_frame) {
|
|
|
|
_transport_frame -= val;
|
|
|
|
} else {
|
|
|
|
_transport_frame = 0;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
void post_transport_motion ();
|
|
|
|
static void *session_loader_thread (void *arg);
|
|
|
|
|
|
|
|
void *do_work();
|
|
|
|
|
2009-12-03 21:15:12 -05:00
|
|
|
/* SessionEventManager interface */
|
|
|
|
|
|
|
|
void process_event (SessionEvent*);
|
2008-06-02 17:41:35 -04:00
|
|
|
void set_next_event ();
|
2009-12-03 21:15:12 -05:00
|
|
|
void cleanup_event (SessionEvent*,int);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* MIDI Machine Control */
|
|
|
|
|
|
|
|
void deliver_mmc (MIDI::MachineControl::Command, nframes_t);
|
|
|
|
|
2008-10-25 04:28:10 -04:00
|
|
|
void spp_start (MIDI::Parser&, nframes_t timestamp);
|
|
|
|
void spp_continue (MIDI::Parser&, nframes_t timestamp);
|
|
|
|
void spp_stop (MIDI::Parser&, nframes_t timestamp);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
void mmc_deferred_play (MIDI::MachineControl &);
|
|
|
|
void mmc_stop (MIDI::MachineControl &);
|
|
|
|
void mmc_step (MIDI::MachineControl &, int);
|
|
|
|
void mmc_pause (MIDI::MachineControl &);
|
|
|
|
void mmc_record_pause (MIDI::MachineControl &);
|
|
|
|
void mmc_record_strobe (MIDI::MachineControl &);
|
|
|
|
void mmc_record_exit (MIDI::MachineControl &);
|
|
|
|
void mmc_track_record_status (MIDI::MachineControl &, uint32_t track, bool enabled);
|
|
|
|
void mmc_fast_forward (MIDI::MachineControl &);
|
|
|
|
void mmc_rewind (MIDI::MachineControl &);
|
|
|
|
void mmc_locate (MIDI::MachineControl &, const MIDI::byte *);
|
|
|
|
void mmc_shuttle (MIDI::MachineControl &mmc, float speed, bool forw);
|
|
|
|
void mmc_record_enable (MIDI::MachineControl &mmc, size_t track, bool enabled);
|
|
|
|
|
|
|
|
struct timeval last_mmc_step;
|
|
|
|
double step_speed;
|
|
|
|
|
2009-12-17 13:24:23 -05:00
|
|
|
typedef boost::function<bool()> MidiTimeoutCallback;
|
2009-05-12 13:03:42 -04:00
|
|
|
typedef std::list<MidiTimeoutCallback> MidiTimeoutList;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
MidiTimeoutList midi_timeouts;
|
|
|
|
bool mmc_step_timeout ();
|
|
|
|
|
|
|
|
MIDI::byte mmc_buffer[32];
|
|
|
|
MIDI::byte mtc_msg[16];
|
2009-10-26 10:38:58 -04:00
|
|
|
MIDI::byte mtc_timecode_bits; /* encoding of SMTPE type for MTC */
|
2008-06-02 17:41:35 -04:00
|
|
|
MIDI::byte midi_msg[16];
|
2009-10-26 10:38:58 -04:00
|
|
|
nframes_t outbound_mtc_timecode_frame;
|
|
|
|
Timecode::Time transmitting_timecode_time;
|
2008-06-02 17:41:35 -04:00
|
|
|
int next_quarter_frame_to_send;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-10-26 10:38:58 -04:00
|
|
|
double _frames_per_timecode_frame; /* has to be floating point because of drop frame */
|
2008-06-02 17:41:35 -04:00
|
|
|
nframes_t _frames_per_hour;
|
2009-10-26 10:38:58 -04:00
|
|
|
nframes_t _timecode_frames_per_hour;
|
|
|
|
nframes_t _timecode_offset;
|
|
|
|
bool _timecode_offset_negative;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* cache the most-recently requested time conversions. This helps when we
|
|
|
|
* have multiple clocks showing the same time (e.g. the transport frame) */
|
2009-10-26 10:38:58 -04:00
|
|
|
bool last_timecode_valid;
|
|
|
|
nframes_t last_timecode_when;
|
|
|
|
Timecode::Time last_timecode;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-10-26 10:38:58 -04:00
|
|
|
bool _send_timecode_update; ///< Flag to send a full frame (Timecode) MTC message this cycle
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
int send_full_time_code(nframes_t nframes);
|
|
|
|
int send_midi_time_code_for_cycle(nframes_t nframes);
|
|
|
|
|
|
|
|
nframes_t adjust_apparent_position (nframes_t frames);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
void reset_record_status ();
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-04-23 13:48:37 -04:00
|
|
|
int no_roll (nframes_t nframes);
|
|
|
|
int fail_roll (nframes_t nframes);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-11-08 11:28:21 -05:00
|
|
|
bool non_realtime_work_pending() const { return static_cast<bool>(post_transport_work()); }
|
|
|
|
bool process_can_proceed() const { return !(post_transport_work() & ProcessCannotProceedMask); }
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-12-08 22:05:14 -05:00
|
|
|
MidiControlUI* midi_control_ui;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
int start_midi_thread ();
|
|
|
|
void terminate_midi_thread ();
|
2009-12-08 22:05:14 -05:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
int use_config_midi_ports ();
|
|
|
|
|
2009-11-08 11:28:21 -05:00
|
|
|
void set_play_loop (bool yn);
|
|
|
|
void unset_play_loop ();
|
2008-06-02 17:41:35 -04:00
|
|
|
void overwrite_some_buffers (Diskstream*);
|
|
|
|
void flush_all_inserts ();
|
2008-09-10 11:03:30 -04:00
|
|
|
int micro_locate (nframes_t distance);
|
2009-11-08 11:28:21 -05:00
|
|
|
void locate (nframes64_t, bool with_roll, bool with_flush, bool with_loop=false, bool force=false);
|
|
|
|
void start_locate (nframes64_t, bool with_roll, bool with_flush, bool with_loop=false, bool force=false);
|
|
|
|
void force_locate (nframes64_t frame, bool with_roll = false);
|
2009-01-09 04:18:24 -05:00
|
|
|
void set_diskstream_speed (Diskstream*, double speed);
|
2009-11-08 11:28:21 -05:00
|
|
|
void set_transport_speed (double speed, bool abort = false, bool clear_state = false);
|
|
|
|
void stop_transport (bool abort = false, bool clear_state = false);
|
2008-06-02 17:41:35 -04:00
|
|
|
void start_transport ();
|
2009-11-08 11:28:21 -05:00
|
|
|
void realtime_stop (bool abort, bool clear_state);
|
2008-06-02 17:41:35 -04:00
|
|
|
void non_realtime_start_scrub ();
|
|
|
|
void non_realtime_set_speed ();
|
|
|
|
void non_realtime_locate ();
|
|
|
|
void non_realtime_stop (bool abort, int entry_request_count, bool& finished);
|
|
|
|
void non_realtime_overwrite (int entry_request_count, bool& finished);
|
|
|
|
void post_transport ();
|
|
|
|
void engine_halted ();
|
|
|
|
void xrun_recovery ();
|
|
|
|
|
|
|
|
TempoMap *_tempo_map;
|
|
|
|
void tempo_map_changed (Change);
|
|
|
|
|
|
|
|
/* edit/mix groups */
|
|
|
|
|
2009-10-14 20:57:55 -04:00
|
|
|
int load_route_groups (const XMLNode&, int);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-06-21 15:59:56 -04:00
|
|
|
std::list<RouteGroup *> _route_groups;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* disk-streams */
|
|
|
|
|
2008-08-04 18:37:24 -04:00
|
|
|
SerializedRCUManager<DiskstreamList> diskstreams;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-02-18 20:24:34 -05:00
|
|
|
int load_diskstreams (const XMLNode&);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* routes stuff */
|
|
|
|
|
|
|
|
SerializedRCUManager<RouteList> routes;
|
|
|
|
|
2009-02-18 20:24:34 -05:00
|
|
|
void add_routes (RouteList&, bool save);
|
2008-06-02 17:41:35 -04:00
|
|
|
uint32_t destructive_index;
|
|
|
|
|
2009-10-14 20:57:55 -04:00
|
|
|
boost::shared_ptr<Route> XMLRouteFactory (const XMLNode&, int);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-11-30 18:16:28 -05:00
|
|
|
void route_processors_changed (RouteProcessorChange);
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* mixer stuff */
|
|
|
|
|
2009-07-01 09:36:50 -04:00
|
|
|
bool solo_update_disabled;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-07-01 09:36:50 -04:00
|
|
|
void route_listen_changed (void *src, boost::weak_ptr<Route>);
|
2008-06-02 17:41:35 -04:00
|
|
|
void route_mute_changed (void *src);
|
|
|
|
void route_solo_changed (void *src, boost::weak_ptr<Route>);
|
2009-06-10 14:10:07 -04:00
|
|
|
void update_route_solo_state (boost::shared_ptr<RouteList> r = boost::shared_ptr<RouteList>());
|
2009-07-01 09:36:50 -04:00
|
|
|
|
|
|
|
void listen_position_changed ();
|
|
|
|
void solo_control_mode_changed ();
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* REGION MANAGEMENT */
|
|
|
|
|
2008-09-10 11:03:30 -04:00
|
|
|
std::map<std::string,uint32_t> region_name_map;
|
|
|
|
void update_region_name_map (boost::shared_ptr<Region>);
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
mutable Glib::Mutex region_lock;
|
2009-05-12 13:03:42 -04:00
|
|
|
typedef std::map<PBD::ID,boost::shared_ptr<Region> > RegionList;
|
2008-06-02 17:41:35 -04:00
|
|
|
RegionList regions;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
void add_region (boost::shared_ptr<Region>);
|
|
|
|
void region_changed (Change, boost::weak_ptr<Region>);
|
|
|
|
void remove_region (boost::weak_ptr<Region>);
|
|
|
|
|
|
|
|
int load_regions (const XMLNode& node);
|
|
|
|
|
2009-06-21 15:59:56 -04:00
|
|
|
void route_group_changed ();
|
2009-06-20 09:41:55 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* SOURCES */
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
mutable Glib::Mutex source_lock;
|
|
|
|
typedef std::map<PBD::ID,boost::shared_ptr<Source> > SourceMap;
|
|
|
|
|
|
|
|
SourceMap sources;
|
|
|
|
|
|
|
|
public:
|
|
|
|
SourceMap get_sources() { return sources; }
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
private:
|
|
|
|
int load_sources (const XMLNode& node);
|
|
|
|
XMLNode& get_sources_as_xml ();
|
|
|
|
|
|
|
|
boost::shared_ptr<Source> XMLSourceFactory (const XMLNode&);
|
|
|
|
|
|
|
|
/* PLAYLISTS */
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
void remove_playlist (boost::weak_ptr<Playlist>);
|
|
|
|
void playlist_length_changed ();
|
2009-11-10 18:54:04 -05:00
|
|
|
void diskstream_playlist_changed (boost::weak_ptr<Diskstream>);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* NAMED SELECTIONS */
|
|
|
|
|
|
|
|
mutable Glib::Mutex named_selection_lock;
|
2009-05-12 13:03:42 -04:00
|
|
|
typedef std::set<NamedSelection *> NamedSelectionList;
|
2008-06-02 17:41:35 -04:00
|
|
|
NamedSelectionList named_selections;
|
|
|
|
|
|
|
|
int load_named_selections (const XMLNode&);
|
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
NamedSelection *named_selection_factory (std::string name);
|
2008-06-02 17:41:35 -04:00
|
|
|
NamedSelection *XMLNamedSelectionFactory (const XMLNode&);
|
|
|
|
|
|
|
|
/* CURVES and AUTOMATION LISTS */
|
|
|
|
std::map<PBD::ID, AutomationList*> automation_lists;
|
|
|
|
|
|
|
|
/* DEFAULT FADE CURVES */
|
|
|
|
|
|
|
|
float default_fade_steepness;
|
|
|
|
float default_fade_msecs;
|
|
|
|
|
|
|
|
/* AUDITIONING */
|
|
|
|
|
|
|
|
boost::shared_ptr<Auditioner> auditioner;
|
|
|
|
void set_audition (boost::shared_ptr<Region>);
|
|
|
|
void non_realtime_set_audition ();
|
|
|
|
boost::shared_ptr<Region> pending_audition_region;
|
|
|
|
|
|
|
|
/* EXPORT */
|
|
|
|
|
|
|
|
/* FLATTEN */
|
|
|
|
|
|
|
|
int flatten_one_track (AudioTrack&, nframes_t start, nframes_t cnt);
|
|
|
|
|
|
|
|
/* INSERT AND SEND MANAGEMENT */
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
boost::dynamic_bitset<uint32_t> send_bitset;
|
2009-05-07 13:31:18 -04:00
|
|
|
boost::dynamic_bitset<uint32_t> return_bitset;
|
2008-06-02 17:41:35 -04:00
|
|
|
boost::dynamic_bitset<uint32_t> insert_bitset;
|
|
|
|
|
|
|
|
void add_processor (Processor *);
|
|
|
|
void remove_processor (Processor *);
|
|
|
|
|
|
|
|
/* S/W RAID */
|
|
|
|
|
|
|
|
struct space_and_path {
|
2009-01-30 15:18:31 -05:00
|
|
|
uint32_t blocks; /* 4kB blocks */
|
2009-05-12 13:03:42 -04:00
|
|
|
std::string path;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-01-30 15:18:31 -05:00
|
|
|
space_and_path() {
|
|
|
|
blocks = 0;
|
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
struct space_and_path_ascending_cmp {
|
2009-01-30 15:18:31 -05:00
|
|
|
bool operator() (space_and_path a, space_and_path b) {
|
|
|
|
return a.blocks > b.blocks;
|
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
};
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
void setup_raid_path (std::string path);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
std::vector<space_and_path> session_dirs;
|
|
|
|
std::vector<space_and_path>::iterator last_rr_session_dir;
|
2008-06-02 17:41:35 -04:00
|
|
|
uint32_t _total_free_4k_blocks;
|
|
|
|
Glib::Mutex space_lock;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
std::string get_best_session_directory_for_new_source ();
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
mutable gint _playback_load;
|
|
|
|
mutable gint _capture_load;
|
|
|
|
mutable gint _playback_load_min;
|
|
|
|
mutable gint _capture_load_min;
|
|
|
|
|
|
|
|
/* I/O bundles */
|
|
|
|
|
2009-01-25 01:47:11 -05:00
|
|
|
SerializedRCUManager<BundleList> _bundles;
|
2008-06-02 17:41:35 -04:00
|
|
|
XMLNode* _bundle_xml_node;
|
|
|
|
int load_bundles (XMLNode const &);
|
|
|
|
|
|
|
|
void reverse_diskstream_buffers ();
|
|
|
|
|
2009-05-04 21:53:30 -04:00
|
|
|
UndoHistory _history;
|
|
|
|
std::stack<UndoTransaction*> _current_trans;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
void jack_timebase_callback (jack_transport_state_t, nframes_t, jack_position_t*, int);
|
|
|
|
int jack_sync_callback (jack_transport_state_t, jack_position_t*);
|
|
|
|
void reset_jack_connection (jack_client_t* jack);
|
2009-12-07 16:37:35 -05:00
|
|
|
void process_rtop (SessionEvent*);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
XMLNode& state(bool);
|
|
|
|
|
|
|
|
/* click track */
|
|
|
|
|
2009-01-30 15:18:31 -05:00
|
|
|
Clicks clicks;
|
|
|
|
bool _clicking;
|
2008-06-02 17:41:35 -04:00
|
|
|
boost::shared_ptr<IO> _click_io;
|
2009-01-30 15:18:31 -05:00
|
|
|
Sample* click_data;
|
|
|
|
Sample* click_emphasis_data;
|
|
|
|
nframes_t click_length;
|
|
|
|
nframes_t click_emphasis_length;
|
|
|
|
mutable Glib::RWLock click_lock;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
static const Sample default_click[];
|
|
|
|
static const nframes_t default_click_length;
|
|
|
|
static const Sample default_click_emphasis[];
|
|
|
|
static const nframes_t default_click_emphasis_length;
|
|
|
|
|
|
|
|
Click *get_click();
|
|
|
|
void setup_click_sounds (int which);
|
|
|
|
void clear_clicks ();
|
2009-04-23 13:48:37 -04:00
|
|
|
void click (nframes_t start, nframes_t nframes);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
std::vector<Route*> master_outs;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* range playback */
|
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
std::list<AudioRange> current_audio_range;
|
2008-06-02 17:41:35 -04:00
|
|
|
bool _play_range;
|
2009-11-08 11:28:21 -05:00
|
|
|
void set_play_range (std::list<AudioRange>&, bool leave_rolling);
|
|
|
|
void unset_play_range ();
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* main outs */
|
|
|
|
uint32_t main_outs;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-06-09 16:21:19 -04:00
|
|
|
boost::shared_ptr<Route> _master_out;
|
|
|
|
boost::shared_ptr<Route> _control_out;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
gain_t* _gain_automation_buffer;
|
|
|
|
pan_t** _pan_automation_buffer;
|
|
|
|
void allocate_pan_automation_buffers (nframes_t nframes, uint32_t howmany, bool force);
|
|
|
|
uint32_t _npan_buffers;
|
|
|
|
|
|
|
|
/* VST support */
|
|
|
|
|
|
|
|
long _vst_callback (VSTPlugin*,
|
2009-01-30 15:18:31 -05:00
|
|
|
long opcode,
|
|
|
|
long index,
|
|
|
|
long value,
|
|
|
|
void* ptr,
|
|
|
|
float opt);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
/* number of hardware ports we're using,
|
|
|
|
based on max (requested,available)
|
|
|
|
*/
|
|
|
|
|
|
|
|
uint32_t n_physical_outputs;
|
|
|
|
uint32_t n_physical_inputs;
|
|
|
|
|
2008-12-12 09:43:24 -05:00
|
|
|
uint32_t n_physical_audio_outputs;
|
|
|
|
uint32_t n_physical_audio_inputs;
|
|
|
|
|
|
|
|
uint32_t n_physical_midi_outputs;
|
|
|
|
uint32_t n_physical_midi_inputs;
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
int find_all_sources (std::string path, std::set<std::string>& result);
|
|
|
|
int find_all_sources_across_snapshots (std::set<std::string>& result, bool exclude_this_snapshot);
|
|
|
|
|
|
|
|
typedef std::set<boost::shared_ptr<PBD::Controllable> > Controllables;
|
|
|
|
Glib::Mutex controllables_lock;
|
|
|
|
Controllables controllables;
|
|
|
|
|
|
|
|
void reset_native_file_format();
|
|
|
|
bool first_file_data_format_reset;
|
|
|
|
bool first_file_header_format_reset;
|
|
|
|
|
2009-05-15 21:22:43 -04:00
|
|
|
void config_changed (std::string, bool);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
XMLNode& get_control_protocol_state ();
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
void set_history_depth (uint32_t depth);
|
|
|
|
void sync_order_keys ();
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
static bool _disable_all_loaded_plugins;
|
2009-10-14 12:10:01 -04:00
|
|
|
|
2008-09-17 04:44:51 -04:00
|
|
|
SessionMetadata * _metadata;
|
2008-12-12 09:43:24 -05:00
|
|
|
|
2009-01-30 15:18:31 -05:00
|
|
|
mutable bool have_looped; ///< Used in ::audible_frame(*)
|
2009-04-29 13:30:35 -04:00
|
|
|
|
|
|
|
void update_have_rec_enabled_diskstream ();
|
|
|
|
gint _have_rec_enabled_diskstream;
|
2009-12-10 12:45:18 -05:00
|
|
|
|
|
|
|
/* realtime "apply to set of routes" operations */
|
2009-12-11 18:30:48 -05:00
|
|
|
SessionEvent* get_rt_event (boost::shared_ptr<RouteList> rl, bool yn, SessionEvent::RTeventCallback after, bool group_override,
|
|
|
|
void (Session::*method) (boost::shared_ptr<RouteList>, bool, bool));
|
2009-12-10 12:45:18 -05:00
|
|
|
|
|
|
|
void rt_set_solo (boost::shared_ptr<RouteList>, bool yn, bool group_override);
|
|
|
|
void rt_set_just_one_solo (boost::shared_ptr<RouteList>, bool yn, bool /* ignored*/ );
|
|
|
|
void rt_set_mute (boost::shared_ptr<RouteList>, bool yn, bool group_override);
|
|
|
|
void rt_set_listen (boost::shared_ptr<RouteList>, bool yn, bool group_override);
|
|
|
|
void rt_set_record_enable (boost::shared_ptr<RouteList>, bool yn, bool group_override);
|
2008-06-02 17:41:35 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
} // namespace ARDOUR
|
|
|
|
|
|
|
|
#endif /* __ardour_session_h__ */
|