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

diff --git a/libs/ardour/ardour/disk_reader.h b/libs/ardour/ardour/disk_reader.h
index cc98a1174b43f525f62962a58dc5292379c80d51..88657d56f125be36d2cc8451ea32b16ed8cdb748 100644 (file)
--- a/libs/ardour/ardour/disk_reader.h
+++ b/libs/ardour/ardour/disk_reader.h
@@ -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 ();

diff --git a/libs/ardour/ardour/disk_writer.h b/libs/ardour/ardour/disk_writer.h
index 218d1fc1fab6311f130409291d40a1fef5f8f45d..45fc37bdcf2a97bd47ec576bf177f984d913c806 100644 (file)
--- a/libs/ardour/ardour/disk_writer.h
+++ b/libs/ardour/ardour/disk_writer.h
@@ -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);
 

diff --git a/libs/ardour/ardour/route.h b/libs/ardour/ardour/route.h
index 2590be291b87fae81a13033a1b6239baa21c411b..dc693d3a7e20b87bd92bec5cbd3e29d3d3e9d152 100644 (file)
--- a/libs/ardour/ardour/route.h
+++ b/libs/ardour/ardour/route.h
@@ -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 ();
 

diff --git a/libs/ardour/ardour/track.h b/libs/ardour/ardour/track.h
index 65513e46a1b28b31b9390eda23411eea96825832..b1d3ec75e773e9fc8e8d9b460ffc5db8f91bb0b8 100644 (file)
--- a/libs/ardour/ardour/track.h
+++ b/libs/ardour/ardour/track.h
@@ -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;
 };

diff --git a/libs/ardour/disk_reader.cc b/libs/ardour/disk_reader.cc
index 69eb2e43ae17baf3c6a6a2e4b83be32911c3342c..4250cd5991640718e59988c8547a6a815d28e5b6 100644 (file)
--- a/libs/ardour/disk_reader.cc
+++ b/libs/ardour/disk_reader.cc
@@ -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) {

diff --git a/libs/ardour/enums.cc b/libs/ardour/enums.cc
index 103e42402bd98921a519b07c07fe71f029bad2ba..5c792f1b6d2e0565ea9f7cbd5a8a0b4928bb55a3 100644 (file)
--- a/libs/ardour/enums.cc
+++ b/libs/ardour/enums.cc
@@ -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)

diff --git a/libs/ardour/route.cc b/libs/ardour/route.cc
index f83a9d4d13dd5c695ec8547b31960dabb8ec7022..c447f26875deb074526cd14e5c32165c33c9bbdf 100644 (file)
--- a/libs/ardour/route.cc
+++ b/libs/ardour/route.cc
@@ -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 */
+}

diff --git a/libs/ardour/track.cc b/libs/ardour/track.cc
index 448ac02ec7ab9b414d8a7439cfe010c20e2ea3f8..669a30190ec1dd4c1c3cfe70b645553cd43dba96 100644 (file)
--- a/libs/ardour/track.cc
+++ b/libs/ardour/track.cc
@@ -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 */
-}