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 <sndfile.h>
|
|
|
|
|
|
|
|
#include <glibmm/thread.h>
|
|
|
|
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "pbd/error.h"
|
|
|
|
#include "pbd/pool.h"
|
|
|
|
#include "pbd/rcu.h"
|
|
|
|
#include "pbd/statefuldestructible.h"
|
|
|
|
#include "pbd/undo.h"
|
|
|
|
|
|
|
|
#include "midi++/mmc.h"
|
|
|
|
#include "midi++/types.h"
|
|
|
|
|
|
|
|
#include "pbd/destructible.h"
|
|
|
|
#include "pbd/stateful.h"
|
|
|
|
|
|
|
|
#include "ardour/ardour.h"
|
|
|
|
#include "ardour/chan_count.h"
|
2009-05-13 20:13:27 -04:00
|
|
|
#include "ardour/rc_configuration.h"
|
|
|
|
#include "ardour/session_configuration.h"
|
2009-02-25 13:26:51 -05:00
|
|
|
#include "ardour/location.h"
|
|
|
|
#include "ardour/smpte.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;
|
|
|
|
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;
|
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;
|
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-01-30 15:18:31 -05:00
|
|
|
class Slave;
|
|
|
|
class Source;
|
|
|
|
class TempoMap;
|
|
|
|
class VSTPlugin;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-02-16 22:49:32 -05:00
|
|
|
class Session : public PBD::StatefulDestructible, public boost::noncopyable
|
2008-06-02 17:41:35 -04:00
|
|
|
{
|
|
|
|
private:
|
|
|
|
typedef std::pair<boost::weak_ptr<Route>,bool> RouteBooleanState;
|
2009-05-12 13:03:42 -04:00
|
|
|
typedef std::vector<RouteBooleanState> GlobalRouteBooleanState;
|
2008-06-02 17:41:35 -04:00
|
|
|
typedef std::pair<boost::weak_ptr<Route>,MeterPoint> RouteMeterState;
|
2009-05-12 13:03:42 -04:00
|
|
|
typedef std::vector<RouteMeterState> GlobalRouteMeterState;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
public:
|
|
|
|
enum RecordState {
|
|
|
|
Disabled = 0,
|
|
|
|
Enabled = 1,
|
|
|
|
Recording = 2
|
|
|
|
};
|
|
|
|
|
|
|
|
struct Event {
|
2009-01-30 15:18:31 -05:00
|
|
|
enum Type {
|
|
|
|
SetTransportSpeed,
|
|
|
|
SetDiskstreamSpeed,
|
|
|
|
Locate,
|
|
|
|
LocateRoll,
|
|
|
|
LocateRollLocate,
|
|
|
|
SetLoop,
|
|
|
|
PunchIn,
|
|
|
|
PunchOut,
|
|
|
|
RangeStop,
|
|
|
|
RangeLocate,
|
|
|
|
Overwrite,
|
|
|
|
SetSlaveSource,
|
|
|
|
Audition,
|
|
|
|
InputConfigurationChange,
|
|
|
|
SetAudioRange,
|
|
|
|
SetPlayRange,
|
|
|
|
|
2009-02-16 21:11:49 -05:00
|
|
|
/* only one of each of these events can be queued at any one time */
|
2009-01-30 15:18:31 -05:00
|
|
|
|
|
|
|
StopOnce,
|
|
|
|
AutoLoop
|
|
|
|
};
|
|
|
|
|
|
|
|
enum Action {
|
|
|
|
Add,
|
|
|
|
Remove,
|
|
|
|
Replace,
|
|
|
|
Clear
|
|
|
|
};
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-02-16 21:11:49 -05:00
|
|
|
Type type;
|
|
|
|
Action action;
|
|
|
|
nframes_t action_frame;
|
|
|
|
nframes_t target_frame;
|
|
|
|
double speed;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-01-30 15:18:31 -05:00
|
|
|
union {
|
2009-02-16 21:11:49 -05:00
|
|
|
void* ptr;
|
|
|
|
bool yes_or_no;
|
|
|
|
nframes_t target2_frame;
|
|
|
|
SlaveSource slave;
|
|
|
|
Route* route;
|
2009-01-30 15:18:31 -05:00
|
|
|
};
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
std::list<AudioRange> audio_range;
|
|
|
|
std::list<MusicRange> music_range;
|
2009-02-16 21:11:49 -05:00
|
|
|
|
|
|
|
boost::shared_ptr<Region> region;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-01-30 15:18:31 -05:00
|
|
|
Event(Type t, Action a, nframes_t when, nframes_t where, double spd, bool yn = false)
|
2009-02-16 21:11:49 -05:00
|
|
|
: type (t)
|
|
|
|
, action (a)
|
|
|
|
, action_frame (when)
|
|
|
|
, target_frame (where)
|
|
|
|
, speed (spd)
|
|
|
|
, yes_or_no (yn)
|
|
|
|
{}
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-01-30 15:18:31 -05:00
|
|
|
void set_ptr (void* p) {
|
|
|
|
ptr = p;
|
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-01-30 15:18:31 -05:00
|
|
|
bool before (const Event& other) const {
|
|
|
|
return action_frame < other.action_frame;
|
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-01-30 15:18:31 -05:00
|
|
|
bool after (const Event& other) const {
|
|
|
|
return action_frame > other.action_frame;
|
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-01-30 15:18:31 -05:00
|
|
|
static bool compare (const Event *e1, const Event *e2) {
|
|
|
|
return e1->before (*e2);
|
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-01-30 15:18:31 -05:00
|
|
|
void *operator new (size_t ignored) {
|
|
|
|
return pool.alloc ();
|
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-01-30 15:18:31 -05:00
|
|
|
void operator delete(void *ptr, size_t size) {
|
|
|
|
pool.release (ptr);
|
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-01-30 15:18:31 -05:00
|
|
|
static const nframes_t Immediate = 0;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-01-30 15:18:31 -05:00
|
|
|
private:
|
|
|
|
static MultiAllocSingleReleasePool pool;
|
2008-06-02 17:41:35 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
/* creating from an XML file */
|
|
|
|
|
|
|
|
Session (AudioEngine&,
|
2009-05-12 13:03:42 -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-05-12 13:03:42 -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;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
void set_snap_name ();
|
|
|
|
|
|
|
|
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; }
|
|
|
|
sigc::signal<void> DirtyChanged;
|
|
|
|
|
|
|
|
const SessionDirectory& session_directory () const { return *(_session_dir.get()); }
|
|
|
|
|
|
|
|
static sigc::signal<void> AutoBindingOn;
|
|
|
|
static sigc::signal<void> AutoBindingOff;
|
|
|
|
|
|
|
|
static sigc::signal<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 ();
|
|
|
|
uint32_t audio_diskstream_buffer_size() const { return audio_dstream_buffer_size; }
|
|
|
|
uint32_t midi_diskstream_buffer_size() const { return midi_dstream_buffer_size; }
|
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
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
typedef std::list<boost::shared_ptr<Diskstream> > DiskstreamList;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-11-29 15:16:16 -05:00
|
|
|
int load_routes (const XMLNode&);
|
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
|
|
|
|
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 {
|
|
|
|
bool operator() (boost::shared_ptr<Route>, boost::shared_ptr<Route> b);
|
|
|
|
};
|
2008-12-08 13:16:12 -05: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 */
|
|
|
|
|
|
|
|
sigc::signal<void,boost::shared_ptr<Region> > RegionHiddenChange;
|
|
|
|
|
|
|
|
/* Emitted when all i/o connections are complete */
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
sigc::signal<void> IOConnectionsComplete;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
/* Record status signals */
|
|
|
|
|
|
|
|
sigc::signal<void> RecordStateChanged;
|
|
|
|
|
|
|
|
/* Transport mechanism signals */
|
|
|
|
|
|
|
|
sigc::signal<void> TransportStateChange; /* generic */
|
|
|
|
sigc::signal<void,nframes_t> PositionChanged; /* sent after any non-sequential motion */
|
|
|
|
sigc::signal<void> DurationChanged;
|
|
|
|
sigc::signal<void,nframes_t> Xrun;
|
|
|
|
sigc::signal<void> TransportLooped;
|
|
|
|
|
2009-02-16 19:12:22 -05:00
|
|
|
/** emitted when a locate has occurred */
|
|
|
|
sigc::signal<void> Located;
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
sigc::signal<void,RouteList&> RouteAdded;
|
2009-06-21 15:59:56 -04:00
|
|
|
sigc::signal<void> RouteGroupChanged;
|
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);
|
|
|
|
void request_stop (bool abort = false);
|
|
|
|
void request_locate (nframes_t frame, bool with_roll = false);
|
|
|
|
|
|
|
|
void request_play_loop (bool yn);
|
|
|
|
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 ();
|
|
|
|
|
|
|
|
bool locate_pending() const { return static_cast<bool>(post_transport_work&PostTransportLocate); }
|
|
|
|
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; }
|
|
|
|
|
|
|
|
double frames_per_smpte_frame() const { return _frames_per_smpte_frame; }
|
|
|
|
nframes_t smpte_frames_per_hour() const { return _smpte_frames_per_hour; }
|
|
|
|
|
2008-12-12 09:43:24 -05:00
|
|
|
MIDI::byte get_mtc_smpte_bits() const {
|
|
|
|
return mtc_smpte_bits; /* encoding of SMTPE type for MTC */
|
|
|
|
}
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
float smpte_frames_per_second() const;
|
|
|
|
bool smpte_drop_frames() const;
|
|
|
|
|
|
|
|
/* Locations */
|
|
|
|
|
|
|
|
Locations *locations() { return &_locations; }
|
|
|
|
|
|
|
|
sigc::signal<void,Location*> auto_loop_location_changed;
|
|
|
|
sigc::signal<void,Location*> auto_punch_location_changed;
|
|
|
|
sigc::signal<void> locations_modified;
|
|
|
|
|
|
|
|
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 ();
|
|
|
|
|
|
|
|
void add_event (nframes_t action_frame, Event::Type type, nframes_t target_frame = 0);
|
|
|
|
void remove_event (nframes_t frame, Event::Type type);
|
|
|
|
void clear_events (Event::Type type);
|
|
|
|
|
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-05-12 13:03:42 -04:00
|
|
|
sigc::signal<void,std::string> StateSaved;
|
2008-06-02 17:41:35 -04:00
|
|
|
sigc::signal<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();
|
|
|
|
int set_state(const XMLNode& node); // not idempotent
|
|
|
|
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-06-21 15:59:56 -04:00
|
|
|
sigc::signal<void,RouteGroup*> route_group_added;
|
|
|
|
sigc::signal<void> route_group_removed;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-06-21 15:59:56 -04:00
|
|
|
void foreach_route_group (sigc::slot<void,RouteGroup*> sl) {
|
|
|
|
for (std::list<RouteGroup *>::iterator i = _route_groups.begin(); i != _route_groups.end(); i++) {
|
2008-06-02 17:41:35 -04:00
|
|
|
sl (*i);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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-02-16 21:11:49 -05:00
|
|
|
|
2009-06-21 15:59:56 -04:00
|
|
|
RouteList new_audio_route (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 */
|
|
|
|
|
|
|
|
nframes_t transport_frame () const {return _transport_frame; }
|
|
|
|
nframes_t audible_frame () const;
|
|
|
|
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-02-16 21:11:49 -05:00
|
|
|
void smpte_to_sample(SMPTE::Time& smpte, nframes_t& sample, bool use_offset, bool use_subframes) const;
|
|
|
|
void sample_to_smpte(nframes_t sample, SMPTE::Time& smpte, bool use_offset, bool use_subframes) const;
|
2008-06-02 17:41:35 -04:00
|
|
|
void smpte_time (SMPTE::Time &);
|
|
|
|
void smpte_time (nframes_t when, SMPTE::Time&);
|
|
|
|
void smpte_time_subframes (nframes_t when, SMPTE::Time&);
|
|
|
|
|
|
|
|
void smpte_duration (nframes_t, SMPTE::Time&) const;
|
|
|
|
void smpte_duration_string (char *, nframes_t) const;
|
|
|
|
|
|
|
|
void set_smpte_offset (nframes_t);
|
2009-02-13 03:29:23 -05:00
|
|
|
nframes_t smpte_offset () const { return _smpte_offset; }
|
2008-06-02 17:41:35 -04:00
|
|
|
void set_smpte_offset_negative (bool);
|
|
|
|
bool smpte_offset_negative () const { return _smpte_offset_negative; }
|
|
|
|
|
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
|
|
|
|
|
|
|
static sigc::signal<void> StartTimeChanged;
|
|
|
|
static sigc::signal<void> EndTimeChanged;
|
|
|
|
static sigc::signal<void> SMPTEOffsetChanged;
|
|
|
|
|
2009-01-30 15:18:31 -05:00
|
|
|
void request_slave_source (SlaveSource);
|
|
|
|
bool synced_to_jack() const { return Config->get_slave_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
|
|
|
|
2008-11-26 04:50:29 -05:00
|
|
|
/// signals the current transport position in frames, bbt and smpte time (in that order)
|
|
|
|
sigc::signal<void, const nframes_t&, const BBT_Time&, const SMPTE::Time&> tick;
|
|
|
|
|
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
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
sigc::signal<void,boost::weak_ptr<Region> > RegionAdded;
|
|
|
|
sigc::signal<void,std::vector<boost::weak_ptr<Region> >& > RegionsAdded;
|
|
|
|
sigc::signal<void,boost::weak_ptr<Region> > RegionRemoved;
|
|
|
|
|
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
|
|
|
void find_equivalent_playlist_regions (boost::shared_ptr<Region>, std::vector<boost::shared_ptr<Region> >& result);
|
|
|
|
|
|
|
|
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
|
|
|
struct ImportStatus : public InterThreadInfo {
|
2009-05-12 13:03:42 -04:00
|
|
|
std::string doing_what;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-01-30 15:18:31 -05:00
|
|
|
/* control info */
|
|
|
|
uint32_t total;
|
|
|
|
SrcQuality quality;
|
|
|
|
volatile bool freeze;
|
|
|
|
std::vector<Glib::ustring> paths;
|
|
|
|
bool replace_existing_source;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-01-30 15:18:31 -05:00
|
|
|
/* result */
|
|
|
|
SourceList sources;
|
2008-06-02 17:41:35 -04:00
|
|
|
};
|
|
|
|
|
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
|
|
|
|
2008-09-28 07:11:38 -04:00
|
|
|
int start_audio_export (nframes_t position, bool realtime);
|
2008-09-17 04:44:51 -04:00
|
|
|
|
|
|
|
sigc::signal<int, nframes_t> ProcessExport;
|
2008-09-28 07:11:38 -04:00
|
|
|
sigc::signal<void> ExportReadFinished;
|
2008-09-10 11:03:30 -04:00
|
|
|
static sigc::signal<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>);
|
|
|
|
|
|
|
|
struct cleanup_report {
|
2009-05-12 13:03:42 -04:00
|
|
|
std::vector<std::string> paths;
|
2008-06-02 17:41:35 -04:00
|
|
|
int64_t space;
|
|
|
|
};
|
|
|
|
|
|
|
|
int cleanup_sources (cleanup_report&);
|
|
|
|
int cleanup_trash_sources (cleanup_report&);
|
|
|
|
|
|
|
|
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
|
|
|
*/
|
|
|
|
sigc::signal<int,boost::shared_ptr<ARDOUR::Playlist> > AskAboutPlaylistDeletion;
|
|
|
|
|
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
|
|
|
*/
|
|
|
|
static sigc::signal<int,nframes_t, nframes_t> AskAboutSampleRateMismatch;
|
|
|
|
|
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
|
|
|
*/
|
|
|
|
static sigc::signal<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);
|
|
|
|
|
|
|
|
/* playlist management */
|
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
boost::shared_ptr<Playlist> playlist_by_name (std::string name);
|
2008-09-26 04:29:30 -04:00
|
|
|
void unassigned_playlists (std::list<boost::shared_ptr<Playlist> > & list);
|
|
|
|
void add_playlist (boost::shared_ptr<Playlist>, bool unused = false);
|
2008-06-02 17:41:35 -04:00
|
|
|
sigc::signal<void,boost::shared_ptr<Playlist> > PlaylistAdded;
|
|
|
|
sigc::signal<void,boost::shared_ptr<Playlist> > PlaylistRemoved;
|
|
|
|
|
|
|
|
uint32_t n_playlists() const;
|
|
|
|
|
|
|
|
template<class T> void foreach_playlist (T *obj, void (T::*func)(boost::shared_ptr<Playlist>));
|
|
|
|
void get_playlists (std::vector<boost::shared_ptr<Playlist> >&);
|
|
|
|
|
|
|
|
/* 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&));
|
|
|
|
sigc::signal<void> NamedSelectionAdded;
|
|
|
|
sigc::signal<void> NamedSelectionRemoved;
|
|
|
|
|
|
|
|
/* 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
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
sigc::signal<void,bool> AuditionActive;
|
|
|
|
|
|
|
|
/* 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-05-12 13:03:42 -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; }
|
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
void set_all_solo (bool);
|
|
|
|
void set_all_mute (bool);
|
2009-07-01 09:36:50 -04:00
|
|
|
void set_all_listen (bool);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
sigc::signal<void,bool> SoloActive;
|
|
|
|
sigc::signal<void> SoloChanged;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
void record_disenable_all ();
|
|
|
|
void record_enable_all ();
|
|
|
|
|
|
|
|
/* 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-06-25 16:46:39 -04:00
|
|
|
void globally_add_internal_sends (boost::shared_ptr<Route> dest);
|
|
|
|
void add_internal_sends (boost::shared_ptr<Route> dest, boost::shared_ptr<RouteList> senders);
|
|
|
|
|
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
|
|
|
|
|
|
|
sigc::signal<void,boost::shared_ptr<Bundle> > BundleAdded;
|
|
|
|
sigc::signal<void,boost::shared_ptr<Bundle> > BundleRemoved;
|
|
|
|
|
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
|
|
|
|
|
|
|
sigc::signal<void> MTC_PortChanged;
|
|
|
|
sigc::signal<void> MMC_PortChanged;
|
|
|
|
sigc::signal<void> MIDI_PortChanged;
|
2008-08-04 18:37:24 -04:00
|
|
|
sigc::signal<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;
|
|
|
|
sigc::signal<void> ScrubReady;
|
|
|
|
|
|
|
|
/* 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);
|
|
|
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
|
|
|
std::map<PBD::ID, PBD::StatefulThingWithGoingAway*> registry;
|
|
|
|
|
|
|
|
// these commands are implemented in libs/ardour/session_command.cc
|
|
|
|
Command* memento_command_factory(XMLNode* n);
|
|
|
|
void register_with_memento_command_factory(PBD::ID, PBD::StatefulThingWithGoingAway*);
|
|
|
|
|
|
|
|
Command* global_state_command_factory (const XMLNode& n);
|
|
|
|
|
|
|
|
class GlobalRouteStateCommand : public Command
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
GlobalRouteStateCommand (Session&, void*);
|
|
|
|
GlobalRouteStateCommand (Session&, const XMLNode& node);
|
|
|
|
int set_state (const XMLNode&);
|
|
|
|
XMLNode& get_state ();
|
|
|
|
|
|
|
|
protected:
|
|
|
|
GlobalRouteBooleanState before, after;
|
|
|
|
Session& sess;
|
|
|
|
void* src;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
class GlobalSoloStateCommand : public GlobalRouteStateCommand
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
GlobalSoloStateCommand (Session &, void *src);
|
|
|
|
GlobalSoloStateCommand (Session&, const XMLNode&);
|
|
|
|
void operator()(); //redo
|
|
|
|
void undo();
|
|
|
|
XMLNode &get_state();
|
|
|
|
void mark();
|
|
|
|
};
|
|
|
|
|
|
|
|
class GlobalMuteStateCommand : public GlobalRouteStateCommand
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
GlobalMuteStateCommand(Session &, void *src);
|
|
|
|
GlobalMuteStateCommand (Session&, const XMLNode&);
|
|
|
|
void operator()(); // redo
|
|
|
|
void undo();
|
|
|
|
XMLNode &get_state();
|
|
|
|
void mark();
|
|
|
|
};
|
|
|
|
|
|
|
|
class GlobalRecordEnableStateCommand : public GlobalRouteStateCommand
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
GlobalRecordEnableStateCommand(Session &, void *src);
|
|
|
|
GlobalRecordEnableStateCommand (Session&, const XMLNode&);
|
|
|
|
void operator()(); // redo
|
|
|
|
void undo();
|
|
|
|
XMLNode &get_state();
|
|
|
|
void mark();
|
|
|
|
};
|
|
|
|
|
|
|
|
class GlobalMeteringStateCommand : public Command
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
GlobalMeteringStateCommand(Session &, void *src);
|
|
|
|
GlobalMeteringStateCommand (Session&, const XMLNode&);
|
|
|
|
void operator()();
|
|
|
|
void undo();
|
|
|
|
XMLNode &get_state();
|
|
|
|
int set_state (const XMLNode&);
|
|
|
|
void mark();
|
|
|
|
|
|
|
|
protected:
|
|
|
|
Session& sess;
|
|
|
|
void* src;
|
|
|
|
GlobalRouteMeterState before;
|
|
|
|
GlobalRouteMeterState after;
|
|
|
|
};
|
|
|
|
|
|
|
|
/* 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-09-10 11:03:30 -04:00
|
|
|
float read_data_rate () const; // in usec
|
2008-06-02 17:41:35 -04:00
|
|
|
float write_data_rate () const;
|
|
|
|
|
|
|
|
/* ranges */
|
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
void set_audio_range (std::list<AudioRange>&);
|
|
|
|
void set_music_range (std::list<MusicRange>&);
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
void request_play_range (bool yn);
|
|
|
|
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-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
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
static sigc::signal<void> SendFeedback;
|
|
|
|
|
|
|
|
/* 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;
|
|
|
|
|
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 Diskstream;
|
|
|
|
void stop_butler ();
|
|
|
|
void wait_till_butler_finished();
|
|
|
|
|
|
|
|
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;
|
|
|
|
volatile nframes_t _transport_frame;
|
|
|
|
Location* end_location;
|
|
|
|
Location* start_location;
|
|
|
|
Slave* _slave;
|
|
|
|
bool _silent;
|
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-06-23 05:50:39 -04:00
|
|
|
FixedPointLinearInterpolation interpolation;
|
2009-06-23 05:50:02 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
bool auto_play_legal;
|
|
|
|
nframes_t _last_slave_transport_frame;
|
|
|
|
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;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
void set_worst_io_latencies ();
|
|
|
|
void set_worst_io_latencies_x (IOChange asifwecare, void *ignored) {
|
|
|
|
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
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
enum SlaveState {
|
|
|
|
Stopped,
|
|
|
|
Waiting,
|
|
|
|
Running
|
|
|
|
};
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
SlaveState slave_state;
|
|
|
|
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-04-23 13:48:37 -04:00
|
|
|
void track_slave_state(float slave_speed, nframes_t slave_transport_frame,
|
|
|
|
nframes_t this_delta, bool starting);
|
|
|
|
void follow_slave_silently(nframes_t nframes, float slave_speed);
|
2009-01-01 16:26:23 -05:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
void set_slave_source (SlaveSource);
|
|
|
|
|
2008-09-28 07:11:38 -04:00
|
|
|
SlaveSource post_export_slave;
|
|
|
|
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;
|
2008-09-28 07:11:38 -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 ();
|
|
|
|
|
|
|
|
sigc::connection 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;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
bool maybe_stop (nframes_t limit) {
|
2009-02-16 21:11:49 -05:00
|
|
|
if ( (_transport_speed > 0.0f && _transport_frame >= limit)
|
|
|
|
|| (_transport_speed < 0.0f && _transport_frame == 0) ) {
|
2008-06-02 17:41:35 -04:00
|
|
|
stop_transport ();
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
RingBuffer<Event*> pending_events;
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
XMLTree* state_tree;
|
|
|
|
bool state_was_pending;
|
|
|
|
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
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
Sample* butler_mixdown_buffer;
|
|
|
|
float* butler_gain_buffer;
|
|
|
|
pthread_t butler_thread;
|
|
|
|
Glib::Mutex butler_request_lock;
|
|
|
|
Glib::Cond butler_paused;
|
|
|
|
bool butler_should_run;
|
|
|
|
mutable gint butler_should_do_transport_work;
|
|
|
|
int butler_request_pipe[2];
|
|
|
|
|
2009-02-16 21:11:49 -05:00
|
|
|
inline bool transport_work_requested() const {
|
|
|
|
return g_atomic_int_get(&butler_should_do_transport_work);
|
|
|
|
}
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
struct ButlerRequest {
|
2009-01-30 15:18:31 -05:00
|
|
|
enum Type {
|
|
|
|
Wake,
|
|
|
|
Run,
|
|
|
|
Pause,
|
|
|
|
Quit
|
|
|
|
};
|
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,
|
|
|
|
PostTransportCurveRealloc = 0x40000
|
|
|
|
};
|
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|
|
|
|
|
PostTransportStop);
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
PostTransportWork post_transport_work;
|
|
|
|
|
|
|
|
void summon_butler ();
|
|
|
|
void schedule_butler_transport_work ();
|
|
|
|
int start_butler_thread ();
|
|
|
|
void terminate_butler_thread ();
|
|
|
|
static void *_butler_thread_work (void *arg);
|
|
|
|
void* butler_thread_work ();
|
|
|
|
|
|
|
|
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&);
|
|
|
|
|
|
|
|
sigc::connection auto_punch_start_changed_connection;
|
|
|
|
sigc::connection auto_punch_end_changed_connection;
|
|
|
|
sigc::connection auto_punch_changed_connection;
|
|
|
|
void auto_punch_start_changed (Location *);
|
|
|
|
void auto_punch_end_changed (Location *);
|
|
|
|
void auto_punch_changed (Location *);
|
|
|
|
|
|
|
|
sigc::connection auto_loop_start_changed_connection;
|
|
|
|
sigc::connection auto_loop_end_changed_connection;
|
|
|
|
sigc::connection auto_loop_changed_connection;
|
|
|
|
void auto_loop_changed (Location *);
|
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
typedef std::list<Event *> Events;
|
2008-06-02 17:41:35 -04:00
|
|
|
Events events;
|
|
|
|
Events immediate_events;
|
|
|
|
Events::iterator next_event;
|
|
|
|
|
|
|
|
/* there can only ever be one of each of these */
|
|
|
|
|
|
|
|
Event *auto_loop_event;
|
|
|
|
Event *punch_out_event;
|
|
|
|
Event *punch_in_event;
|
|
|
|
|
|
|
|
/* events */
|
|
|
|
|
|
|
|
void dump_events () const;
|
|
|
|
void queue_event (Event *ev);
|
|
|
|
void merge_event (Event*);
|
|
|
|
void replace_event (Event::Type, nframes_t action_frame, nframes_t target = 0);
|
|
|
|
bool _replace_event (Event*);
|
|
|
|
bool _remove_event (Event *);
|
|
|
|
void _clear_event_type (Event::Type);
|
|
|
|
|
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();
|
|
|
|
|
|
|
|
void set_next_event ();
|
|
|
|
void process_event (Event *ev);
|
|
|
|
|
|
|
|
/* 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;
|
|
|
|
|
|
|
|
typedef sigc::slot<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];
|
|
|
|
MIDI::byte mtc_smpte_bits; /* encoding of SMTPE type for MTC */
|
|
|
|
MIDI::byte midi_msg[16];
|
|
|
|
nframes_t outbound_mtc_smpte_frame;
|
|
|
|
SMPTE::Time transmitting_smpte_time;
|
|
|
|
int next_quarter_frame_to_send;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
double _frames_per_smpte_frame; /* has to be floating point because of drop frame */
|
|
|
|
nframes_t _frames_per_hour;
|
|
|
|
nframes_t _smpte_frames_per_hour;
|
|
|
|
nframes_t _smpte_offset;
|
|
|
|
bool _smpte_offset_negative;
|
|
|
|
|
|
|
|
/* cache the most-recently requested time conversions. This helps when we
|
|
|
|
* have multiple clocks showing the same time (e.g. the transport frame) */
|
|
|
|
bool last_smpte_valid;
|
|
|
|
nframes_t last_smpte_when;
|
|
|
|
SMPTE::Time last_smpte;
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
bool _send_smpte_update; ///< Flag to send a full frame (SMPTE) MTC message this cycle
|
|
|
|
|
|
|
|
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
|
|
|
|
2008-06-02 17:41:35 -04:00
|
|
|
bool non_realtime_work_pending() const { return static_cast<bool>(post_transport_work); }
|
|
|
|
bool process_can_proceed() const { return !(post_transport_work & ProcessCannotProceedMask); }
|
|
|
|
|
|
|
|
struct MIDIRequest {
|
2009-01-30 15:18:31 -05:00
|
|
|
enum Type {
|
|
|
|
PortChange,
|
|
|
|
Quit
|
|
|
|
};
|
|
|
|
Type type;
|
2008-06-02 17:41:35 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
Glib::Mutex midi_lock;
|
|
|
|
pthread_t midi_thread;
|
|
|
|
int midi_request_pipe[2];
|
|
|
|
RingBuffer<MIDIRequest*> midi_requests;
|
|
|
|
|
|
|
|
int start_midi_thread ();
|
|
|
|
void terminate_midi_thread ();
|
|
|
|
void poke_midi_thread ();
|
|
|
|
static void *_midi_thread_work (void *arg);
|
|
|
|
void midi_thread_work ();
|
|
|
|
void change_midi_ports ();
|
|
|
|
int use_config_midi_ports ();
|
|
|
|
|
|
|
|
void set_play_loop (bool yn);
|
|
|
|
void overwrite_some_buffers (Diskstream*);
|
|
|
|
void flush_all_inserts ();
|
2008-09-10 11:03:30 -04:00
|
|
|
int micro_locate (nframes_t distance);
|
2008-06-02 17:41:35 -04:00
|
|
|
void locate (nframes_t, bool with_roll, bool with_flush, bool with_loop=false);
|
|
|
|
void start_locate (nframes_t, bool with_roll, bool with_flush, bool with_loop=false);
|
|
|
|
void force_locate (nframes_t frame, bool with_roll = false);
|
2009-01-09 04:18:24 -05:00
|
|
|
void set_diskstream_speed (Diskstream*, double speed);
|
|
|
|
void set_transport_speed (double speed, bool abort = false);
|
2008-06-02 17:41:35 -04:00
|
|
|
void stop_transport (bool abort = false);
|
|
|
|
void start_transport ();
|
|
|
|
void realtime_stop (bool abort);
|
|
|
|
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 butler_transport_work ();
|
|
|
|
void post_transport ();
|
|
|
|
void engine_halted ();
|
|
|
|
void xrun_recovery ();
|
|
|
|
|
|
|
|
TempoMap *_tempo_map;
|
|
|
|
void tempo_map_changed (Change);
|
|
|
|
|
|
|
|
/* edit/mix groups */
|
|
|
|
|
2009-06-21 15:59:56 -04:00
|
|
|
int load_route_groups (const XMLNode&);
|
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
|
|
|
|
|
|
|
uint32_t audio_dstream_buffer_size;
|
|
|
|
uint32_t midi_dstream_buffer_size;
|
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;
|
|
|
|
|
|
|
|
boost::shared_ptr<Route> XMLRouteFactory (const XMLNode&);
|
|
|
|
|
|
|
|
/* 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
|
|
|
mutable Glib::Mutex playlist_lock;
|
2009-05-12 13:03:42 -04:00
|
|
|
typedef std::set<boost::shared_ptr<Playlist> > PlaylistList;
|
2008-06-02 17:41:35 -04:00
|
|
|
PlaylistList playlists;
|
|
|
|
PlaylistList unused_playlists;
|
|
|
|
|
|
|
|
int load_playlists (const XMLNode&);
|
|
|
|
int load_unused_playlists (const XMLNode&);
|
|
|
|
void remove_playlist (boost::weak_ptr<Playlist>);
|
|
|
|
void track_playlist (bool, boost::weak_ptr<Playlist>);
|
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
boost::shared_ptr<Playlist> playlist_factory (std::string name);
|
2008-06-02 17:41:35 -04:00
|
|
|
boost::shared_ptr<Playlist> XMLPlaylistFactory (const XMLNode&);
|
|
|
|
|
|
|
|
void playlist_length_changed ();
|
|
|
|
void diskstream_playlist_changed (boost::shared_ptr<Diskstream>);
|
|
|
|
|
|
|
|
/* 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
|
|
|
void refresh_disk_space ();
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
GlobalRouteBooleanState get_global_route_boolean (bool (Route::*method)(void) const);
|
|
|
|
GlobalRouteMeterState get_global_route_metering ();
|
|
|
|
|
|
|
|
void set_global_route_boolean (GlobalRouteBooleanState s, void (Route::*method)(bool, void*), void *arg);
|
|
|
|
void set_global_route_metering (GlobalRouteMeterState s, void *arg);
|
|
|
|
|
|
|
|
void set_global_mute (GlobalRouteBooleanState s, void *src);
|
|
|
|
void set_global_solo (GlobalRouteBooleanState s, void *src);
|
|
|
|
void set_global_record_enable (GlobalRouteBooleanState s, void *src);
|
|
|
|
|
|
|
|
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);
|
|
|
|
void record_enable_change_all (bool yn);
|
|
|
|
|
|
|
|
XMLNode& state(bool);
|
|
|
|
|
|
|
|
/* click track */
|
|
|
|
|
|
|
|
struct Click {
|
2009-01-30 15:18:31 -05:00
|
|
|
nframes_t start;
|
|
|
|
nframes_t duration;
|
|
|
|
nframes_t offset;
|
|
|
|
const Sample *data;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-01-30 15:18:31 -05:00
|
|
|
Click (nframes_t s, nframes_t d, const Sample *b)
|
|
|
|
: start (s), duration (d), data (b) { offset = 0; }
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-01-30 15:18:31 -05:00
|
|
|
void *operator new(size_t ignored) {
|
|
|
|
return pool.alloc ();
|
|
|
|
};
|
2008-06-02 17:41:35 -04:00
|
|
|
|
2009-01-30 15:18:31 -05:00
|
|
|
void operator delete(void *ptr, size_t size) {
|
|
|
|
pool.release (ptr);
|
|
|
|
}
|
2008-06-02 17:41:35 -04:00
|
|
|
|
|
|
|
private:
|
2009-01-30 15:18:31 -05:00
|
|
|
static Pool pool;
|
2008-06-02 17:41:35 -04:00
|
|
|
};
|
2008-08-04 18:37:24 -04:00
|
|
|
|
2009-05-12 13:03:42 -04:00
|
|
|
typedef std::list<Click*> Clicks;
|
2008-06-02 17:41:35 -04:00
|
|
|
|
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;
|
|
|
|
void set_play_range (bool yn);
|
|
|
|
void setup_auto_play ();
|
|
|
|
|
|
|
|
/* 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;
|
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;
|
2008-06-02 17:41:35 -04:00
|
|
|
};
|
|
|
|
|
|
|
|
} // namespace ARDOUR
|
|
|
|
|
|
|
|
#endif /* __ardour_session_h__ */
|