ardour/ardour
ardour/ardour
13
1
Fork 0
Code Pull Requests Releases Activity

move disk_{writer,reader} into Route to allow for simple, sensible implementation of DiskIOPoint

Browse Source
This commit is contained in:
Paul Davis 2017-07-25 17:29:19 -04:00
parent 9d355f1390
commit 13d44c4d76
8 changed files with 133 additions and 106 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
libs/ardour/ardour/disk_reader.h
View File

@ -40,7 +40,7 @@ class LIBARDOUR_API DiskReader : public DiskIOProcessor
~DiskReader ();
bool set_name (std::string const & str);
std::string display_name() const { return std::string (_("reader")); }
std::string display_name() const { return std::string (_("player")); }
static framecnt_t chunk_frames() { return _chunk_frames; }
static framecnt_t default_chunk_frames ();

2
libs/ardour/ardour/disk_writer.h
View File

@ -42,7 +42,7 @@ class LIBARDOUR_API DiskWriter : public DiskIOProcessor
~DiskWriter ();
bool set_name (std::string const & str);
std::string display_name() const { return std::string (_("writer")); }
std::string display_name() const { return std::string (_("recorder")); }
virtual bool set_write_source_name (const std::string& str);

11
libs/ardour/ardour/route.h
View File

@ -66,6 +66,8 @@ namespace ARDOUR {
class Amp;
class DelayLine;
class Delivery;
class DiskReader;
class DiskWriter;
class IOProcessor;
class Panner;
class PannerShell;
@ -186,6 +188,9 @@ public:
void set_meter_type (MeterType t) { _meter_type = t; }
MeterType meter_type() const { return _meter_type; }
void set_disk_io_point (DiskIOPoint);
DiskIOPoint disk_io_point() const { return _disk_io_point; }
/* Processors */
boost::shared_ptr<Amp> amp() const { return _amp; }
@ -635,6 +640,10 @@ public:
boost::shared_ptr<InternalReturn> _intreturn;
boost::shared_ptr<MonitorProcessor> _monitor_control;
boost::shared_ptr<Pannable> _pannable;
boost::shared_ptr<DiskReader> _disk_reader;
boost::shared_ptr<DiskWriter> _disk_writer;
DiskIOPoint _disk_io_point;
enum {
EmitNone = 0x00,
@ -740,8 +749,6 @@ private:
framecnt_t update_port_latencies (PortSet& ports, PortSet& feeders, bool playback, framecnt_t) const;
void setup_invisible_processors ();
virtual void setup_invisible_processors_oh_children_of_mine (ProcessorList&) {}
virtual void add_processors_oh_children_of_mine () {}
void unpan ();

8
libs/ardour/ardour/track.h
View File

@ -187,9 +187,6 @@ class LIBARDOUR_API Track : public Route, public Recordable
void adjust_playback_buffering ();
void adjust_capture_buffering ();
void set_disk_io_position (DiskIOPoint);
DiskIOPoint disk_io_point() const { return _disk_io_point; }
PBD::Signal0<void> FreezeChange;
PBD::Signal0<void> PlaylistChanged;
PBD::Signal0<void> SpeedChanged;
@ -198,12 +195,9 @@ class LIBARDOUR_API Track : public Route, public Recordable
protected:
XMLNode& state (bool full);
boost::shared_ptr<DiskReader> _disk_reader;
boost::shared_ptr<DiskWriter> _disk_writer;
boost::shared_ptr<Playlist> _playlists[DataType::num_types];
MeterPoint _saved_meter_point;
DiskIOPoint _disk_io_point;
TrackMode _mode;
bool _needs_butler;
boost::shared_ptr<MonitorControl> _monitoring_control;
@ -257,8 +251,6 @@ class LIBARDOUR_API Track : public Route, public Recordable
private:
void parameter_changed (std::string const & p);
void setup_invisible_processors_oh_children_of_mine (ProcessorList&);
void add_processors_oh_children_of_mine ();
std::string _diskstream_name;
};

2
libs/ardour/disk_reader.cc
View File

@ -116,7 +116,7 @@ DiskReader::default_chunk_frames()
bool
DiskReader::set_name (string const & str)
{
string my_name = X_("playback:");
string my_name = X_("player:");
my_name += str;
if (_name != my_name) {

2
libs/ardour/enums.cc
View File

@ -137,7 +137,7 @@ setup_enum_writer ()
PresentationInfo::Flag _PresentationInfo_Flag;
MusicalMode::Type mode;
MidiPortFlags _MidiPortFlags;
#define REGISTER(e) enum_writer.register_distinct (typeid(e).name(), i, s); i.clear(); s.clear()
#define REGISTER_BITS(e) enum_writer.register_bits (typeid(e).name(), i, s); i.clear(); s.clear()
#define REGISTER_ENUM(e) i.push_back (e); s.push_back (#e)

106
libs/ardour/route.cc
View File

@ -47,6 +47,8 @@
#include "ardour/capturing_processor.h"
#include "ardour/debug.h"
#include "ardour/delivery.h"
#include "ardour/disk_reader.h"
#include "ardour/disk_writer.h"
#include "ardour/event_type_map.h"
#include "ardour/gain_control.h"
#include "ardour/internal_return.h"
@ -96,6 +98,7 @@ Route::Route (Session& sess, string name, PresentationInfo::Flag flag, DataType
, _signal_latency_at_trim_position (0)
, _initial_delay (0)
, _roll_delay (0)
, _disk_io_point (DiskIOPreFader)
, _pending_process_reorder (0)
, _pending_signals (0)
, _pending_declick (true)
@ -239,10 +242,6 @@ Route::init ()
_monitor_control->activate ();
}
/* give derived classes a chance to add processors before we configure */
add_processors_oh_children_of_mine ();
/* now that we have _meter, its safe to connect to this */
{
@ -2340,6 +2339,7 @@ Route::state(bool full_state)
node->set_property ("active", _active);
node->set_property ("denormal-protection", _denormal_protection);
node->set_property ("meter-point", _meter_point);
node->set_property ("disk-io-point", _disk_io_point);
node->set_property ("meter-type", _meter_type);
@ -2496,6 +2496,17 @@ Route::set_state (const XMLNode& node, int version)
}
}
DiskIOPoint diop;
if (node.get_property (X_("disk-io-point"), diop)) {
if (_disk_writer) {
_disk_writer->set_display_to_user (diop == DiskIOCustom);
}
if (_disk_reader) {
_disk_reader->set_display_to_user (diop == DiskIOCustom);
}
set_disk_io_point (diop);
}
node.get_property (X_("meter-type"), _meter_type);
_initial_io_setup = false;
@ -2835,6 +2846,12 @@ Route::set_processor_state (const XMLNode& node)
} else if (prop->value() == "capture") {
/* CapturingProcessor should never be restored, it's always
added explicitly when needed */
} else if (prop->value() == "diskreader" && _disk_reader) {
_disk_reader->set_state (**niter, Stateful::current_state_version);
new_order.push_back (_disk_reader);
} else if (prop->value() == "diskwriter" && _disk_writer) {
_disk_writer->set_state (**niter, Stateful::current_state_version);
new_order.push_back (_disk_writer);
} else {
set_processor_state (**niter, prop, new_order, must_configure);
}
@ -4511,6 +4528,8 @@ Route::setup_invisible_processors ()
*/
ProcessorList new_processors;
ProcessorList::iterator dr;
ProcessorList::iterator dw;
/* find visible processors */
@ -4630,9 +4649,12 @@ Route::setup_invisible_processors ()
/* TRIM CONTROL */
ProcessorList::iterator trim = new_processors.end();
if (_trim && _trim->active()) {
assert (!_trim->display_to_user ());
new_processors.push_front (_trim);
trim = new_processors.begin();
}
/* INTERNAL RETURN */
@ -4653,7 +4675,46 @@ Route::setup_invisible_processors ()
new_processors.push_front (_capturing_processor);
}
setup_invisible_processors_oh_children_of_mine (new_processors);
/* DISK READER & WRITER (for Track objects) */
if (_disk_reader || _disk_writer) {
switch (_disk_io_point) {
case DiskIOPreFader:
if (trim != new_processors.end()) {
/* insert AFTER TRIM */
ProcessorList::iterator insert_pos = trim;
++insert_pos;
if (_disk_writer) {
new_processors.insert (insert_pos, _disk_writer);
}
if (_disk_reader) {
new_processors.insert (insert_pos, _disk_reader);
}
} else {
if (_disk_writer) {
new_processors.push_front (_disk_writer);
}
if (_disk_reader) {
new_processors.push_front (_disk_reader);
}
}
break;
case DiskIOPostFader:
/* insert BEFORE main outs */
if (_disk_writer) {
new_processors.insert (main, _disk_writer);
}
if (_disk_reader) {
new_processors.insert (main, _disk_reader);
}
break;
case DiskIOCustom:
/* reader and writer are visible under this condition, so they
* are not invisible and thus not handled here.
*/
break;
}
}
_processors = new_processors;
@ -5565,3 +5626,38 @@ Route::slavables () const
rv.push_back (_solo_control);
return rv;
}
void
Route::set_disk_io_point (DiskIOPoint diop)
{
bool display = false;
cerr << "set disk io to " << enum_2_string (diop) << endl;
switch (diop) {
case DiskIOCustom:
display = true;
break;
default:
display = false;
}
if (_disk_writer) {
_disk_writer->set_display_to_user (display);
}
if (_disk_reader) {
_disk_reader->set_display_to_user (display);
}
const bool changed = (diop != _disk_io_point);
_disk_io_point = diop;
if (changed) {
Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
configure_processors (0);
}
processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
}

106
libs/ardour/track.cc
View File

@ -55,12 +55,12 @@ using namespace PBD;
Track::Track (Session& sess, string name, PresentationInfo::Flag flag, TrackMode mode, DataType default_type)
: Route (sess, name, flag, default_type)
, _saved_meter_point (_meter_point)
, _disk_io_point (DiskIOPreFader)
, _mode (mode)
, _alignment_choice (Automatic)
{
_freeze_record.state = NoFreeze;
_declickable = true;
}
Track::~Track ()
@ -85,11 +85,23 @@ Track::init ()
return -1;
}
use_new_playlist (data_type());
DiskIOProcessor::Flag dflags = DiskIOProcessor::Recordable;
/* disk writer and reader processors will be added when Route calls
* add_processors_oh_children_of_mine ().
*/
if (_mode == Destructive && !Profile->get_trx()) {
dflags = DiskIOProcessor::Flag (dflags | DiskIOProcessor::Destructive);
} else if (_mode == NonLayered){
dflags = DiskIOProcessor::Flag(dflags | DiskIOProcessor::NonLayered);
}
_disk_reader.reset (new DiskReader (_session, name(), dflags));
_disk_reader->set_block_size (_session.get_block_size ());
_disk_reader->set_route (boost::dynamic_pointer_cast<Route> (shared_from_this()));
_disk_writer.reset (new DiskWriter (_session, name(), dflags));
_disk_writer->set_block_size (_session.get_block_size ());
_disk_writer->set_route (boost::dynamic_pointer_cast<Route> (shared_from_this()));
use_new_playlist (data_type());
boost::shared_ptr<Route> rp (boost::dynamic_pointer_cast<Route> (shared_from_this()));
boost::shared_ptr<Track> rt = boost::dynamic_pointer_cast<Track> (rp);
@ -114,31 +126,6 @@ Track::init ()
return 0;
}
void
Track::add_processors_oh_children_of_mine ()
{
cerr << name() << " ::apocom(), create DW + DR\n";
DiskIOProcessor::Flag dflags = DiskIOProcessor::Recordable;
if (_mode == Destructive && !Profile->get_trx()) {
dflags = DiskIOProcessor::Flag (dflags | DiskIOProcessor::Destructive);
} else if (_mode == NonLayered){
dflags = DiskIOProcessor::Flag(dflags | DiskIOProcessor::NonLayered);
}
if (!_disk_reader) {
_disk_reader.reset (new DiskReader (_session, name(), dflags));
_disk_reader->set_block_size (_session.get_block_size ());
_disk_reader->set_route (boost::dynamic_pointer_cast<Route> (shared_from_this()));
}
if (!_disk_writer) {
_disk_writer.reset (new DiskWriter (_session, name(), dflags));
_disk_writer->set_block_size (_session.get_block_size ());
_disk_writer->set_route (boost::dynamic_pointer_cast<Route> (shared_from_this()));
}
}
void
Track::input_changed ()
{
@ -171,7 +158,6 @@ Track::state (bool full)
root.add_child_nocopy (_record_enable_control->get_state ());
root.set_property (X_("saved-meter-point"), _saved_meter_point);
root.set_property (X_("disk-io-point"), _disk_io_point);
root.set_property (X_("alignment-choice"), _alignment_choice);
return root;
@ -234,9 +220,6 @@ Track::set_state (const XMLNode& node, int version)
_saved_meter_point = _meter_point;
}
if (!node.get_property (X_("saved-meter-point"), _disk_io_point)) {
_disk_io_point = DiskIOPreFader;
}
AlignChoice ac;
@ -1264,6 +1247,8 @@ Track::set_processor_state (XMLNode const & node, XMLProperty const* prop, Proce
return true;
}
cerr << name() << " looking for state for track procs, DR = " << _disk_reader << endl;
if (prop->value() == "diskreader") {
if (_disk_reader) {
_disk_reader->set_state (node, Stateful::current_state_version);
@ -1521,57 +1506,4 @@ Track::use_captured_audio_sources (SourceList& srcs, CaptureInfos const & captur
_session.add_command (new StatefulDiffCommand (pl));
}
#ifdef __clang__
__attribute__((annotate("realtime")))
#endif
void
Track::setup_invisible_processors_oh_children_of_mine (ProcessorList& processors)
{
ProcessorList::iterator insert_pos;
switch (_disk_io_point) {
case DiskIOPreFader:
insert_pos = find (processors.begin(), processors.end(), _trim);
if (insert_pos != processors.end()) {
insert_pos = processors.insert (insert_pos, _disk_writer);
processors.insert (insert_pos, _disk_reader);
}
break;
case DiskIOPostFader:
insert_pos = find (processors.begin(), processors.end(), _main_outs);
if (insert_pos != processors.end()) {
insert_pos = processors.insert (insert_pos, _disk_writer);
processors.insert (insert_pos, _disk_reader);
}
case DiskIOCustom:
break;
}
}
void
Track::set_disk_io_position (DiskIOPoint diop)
{
bool display = false;
switch (diop) {
case DiskIOCustom:
display = true;
break;
default:
display = false;
}
_disk_writer->set_display_to_user (display);
_disk_reader->set_display_to_user (display);
const bool changed = (diop != _disk_io_point);
_disk_io_point = diop;
if (changed) {
Glib::Threads::Mutex::Lock lx (AudioEngine::instance()->process_lock ());
configure_processors (0);
}
processors_changed (RouteProcessorChange ()); /* EMIT SIGNAL */
}