Collect plugin runtime profile statistics.

[ardour.git] / libs / ardour / port_insert.cc

diff --git a/libs/ardour/port_insert.cc b/libs/ardour/port_insert.cc
index 2519451b8960f8cbda91d26c62ff8f3d8014d65d..a6a05cede7998de8218131d548bbd808e25db036 100644 (file)
--- a/libs/ardour/port_insert.cc
+++ b/libs/ardour/port_insert.cc
@@ -30,7 +30,7 @@
 #include "ardour/session.h"
 #include "ardour/types.h"
 
 #include "ardour/session.h"
 #include "ardour/types.h"
 

-#include "i18n.h"
+#include "pbd/i18n.h"

 
 using namespace std;
 using namespace ARDOUR;
 
 using namespace std;
 using namespace ARDOUR;


@@ -49,7 +49,7 @@ PortInsert::PortInsert (Session& s, boost::shared_ptr<Pannable> pannable, boost:
 {
         _mtdm = 0;
         _latency_detect = false;
 {
         _mtdm = 0;
         _latency_detect = false;

-        _latency_flush_frames = 0;
+        _latency_flush_samples = 0;

         _measured_latency = 0;
 }
 
         _measured_latency = 0;
 }
 


@@ -59,12 +59,19 @@ PortInsert::~PortInsert ()
         delete _mtdm;
 }
 
         delete _mtdm;
 }
 

+void
+PortInsert::set_pre_fader (bool p)
+{
+       Processor::set_pre_fader (p);
+       _out->set_pre_fader (p);
+}
+

 void
 PortInsert::start_latency_detection ()
 {
        delete _mtdm;
 void
 PortInsert::start_latency_detection ()
 {
        delete _mtdm;

-        _mtdm = new MTDM (_session.frame_rate());
-        _latency_flush_frames = 0;
+        _mtdm = new MTDM (_session.sample_rate());
+        _latency_flush_samples = 0;

         _latency_detect = true;
         _measured_latency = 0;
 }
         _latency_detect = true;
         _measured_latency = 0;
 }


@@ -72,21 +79,21 @@ PortInsert::start_latency_detection ()
 void
 PortInsert::stop_latency_detection ()
 {
 void
 PortInsert::stop_latency_detection ()
 {

-        _latency_flush_frames = signal_latency() + _session.engine().samples_per_cycle();
+        _latency_flush_samples = signal_latency() + _session.engine().samples_per_cycle();

         _latency_detect = false;
 }
 
 void
         _latency_detect = false;
 }
 
 void

-PortInsert::set_measured_latency (framecnt_t n)
+PortInsert::set_measured_latency (samplecnt_t n)

 {
         _measured_latency = n;
 }
 
 {
         _measured_latency = n;
 }
 

-framecnt_t
+samplecnt_t

 PortInsert::latency() const
 {
        /* because we deliver and collect within the same cycle,
 PortInsert::latency() const
 {
        /* because we deliver and collect within the same cycle,

-          all I/O is necessarily delayed by at least frames_per_cycle().
+          all I/O is necessarily delayed by at least samples_per_cycle().

 
           if the return port for insert has its own latency, we
           need to take that into account too.
 
           if the return port for insert has its own latency, we
           need to take that into account too.


@@ -100,7 +107,7 @@ PortInsert::latency() const
 }
 
 void
 }
 
 void

-PortInsert::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame, pframes_t nframes, bool)
+PortInsert::run (BufferSet& bufs, samplepos_t start_sample, samplepos_t end_sample, double speed, pframes_t nframes, bool)

 {
        if (_output->n_ports().n_total() == 0) {
                return;
 {
        if (_output->n_ports().n_total() == 0) {
                return;


@@ -115,25 +122,24 @@ PortInsert::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame,
                         Sample* out = outbuf.data();
 
                         _mtdm->process (nframes, in, out);
                         Sample* out = outbuf.data();
 
                         _mtdm->process (nframes, in, out);

-                       
-                        outbuf.set_is_silent (false);
+

                         outbuf.set_written (true);
                 }
 
                 return;
 
                         outbuf.set_written (true);
                 }
 
                 return;
 

-        } else if (_latency_flush_frames) {
+        } else if (_latency_flush_samples) {

 
                 /* wait for the entire input buffer to drain before picking up input again so that we can't
                    hear the remnants of whatever MTDM pumped into the pipeline.
                 */
 
 
                 /* wait for the entire input buffer to drain before picking up input again so that we can't
                    hear the remnants of whatever MTDM pumped into the pipeline.
                 */
 

-                silence (nframes);
+                silence (nframes, start_sample);

 
 

-                if (_latency_flush_frames > nframes) {
-                        _latency_flush_frames -= nframes;
+                if (_latency_flush_samples > nframes) {
+                        _latency_flush_samples -= nframes;

                 } else {
                 } else {

-                        _latency_flush_frames = 0;
+                        _latency_flush_samples = 0;

                 }
 
                 return;
                 }
 
                 return;


@@ -141,11 +147,11 @@ PortInsert::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame,
 
        if (!_active && !_pending_active) {
                /* deliver silence */
 
        if (!_active && !_pending_active) {
                /* deliver silence */

-               silence (nframes);
+               silence (nframes, start_sample);

                goto out;
        }
 
                goto out;
        }
 

-       _out->run (bufs, start_frame, end_frame, nframes, true);
+       _out->run (bufs, start_sample, end_sample, speed, nframes, true);

        _input->collect_input (bufs, nframes, ChanCount::ZERO);
 
   out:
        _input->collect_input (bufs, nframes, ChanCount::ZERO);
 
   out:


@@ -153,23 +159,13 @@ PortInsert::run (BufferSet& bufs, framepos_t start_frame, framepos_t end_frame,
 }
 
 XMLNode&
 }
 
 XMLNode&

-PortInsert::get_state(void)
-{
-       return state (true);
-}
-
-XMLNode&
-PortInsert::state (bool full)
+PortInsert::state ()

 {
 {

-       XMLNode& node = IOProcessor::state(full);
-       char buf[32];
-       node.add_property ("type", "port");
-       snprintf (buf, sizeof (buf), "%" PRIu32, _bitslot);
-       node.add_property ("bitslot", buf);
-        snprintf (buf, sizeof (buf), "%" PRId64, _measured_latency);
-        node.add_property("latency", buf);
-        snprintf (buf, sizeof (buf), "%u", _session.get_block_size());
-        node.add_property("block_size", buf);
+       XMLNode& node = IOProcessor::state ();
+       node.set_property ("type", "port");
+       node.set_property ("bitslot", _bitslot);
+       node.set_property ("latency", _measured_latency);
+       node.set_property ("block-size", _session.get_block_size());

 
        return node;
 }
 
        return node;
 }


@@ -180,7 +176,6 @@ PortInsert::set_state (const XMLNode& node, int version)
        XMLNodeList nlist = node.children();
        XMLNodeIterator niter;
        XMLPropertyList plist;
        XMLNodeList nlist = node.children();
        XMLNodeIterator niter;
        XMLPropertyList plist;

-       const XMLProperty *prop;

 
        const XMLNode* insert_node = &node;
 
 
        const XMLNode* insert_node = &node;
 


@@ -194,46 +189,44 @@ PortInsert::set_state (const XMLNode& node, int version)
 
        IOProcessor::set_state (*insert_node, version);
 
 
        IOProcessor::set_state (*insert_node, version);
 

-       if ((prop = node.property ("type")) == 0) {
+       std::string type_str;
+       if (!node.get_property ("type", type_str)) {

                error << _("XML node describing port insert is missing the `type' field") << endmsg;
                return -1;
        }
 
                error << _("XML node describing port insert is missing the `type' field") << endmsg;
                return -1;
        }
 

-       if (prop->value() != "port") {
+       if (type_str != "port") {

                error << _("non-port insert XML used for port plugin insert") << endmsg;
                return -1;
        }
 
                error << _("non-port insert XML used for port plugin insert") << endmsg;
                return -1;
        }
 

-        uint32_t blocksize = 0;
-        if ((prop = node.property ("block_size")) != 0) {
-                sscanf (prop->value().c_str(), "%u", &blocksize);
-        }
+       uint32_t blocksize = 0;
+       node.get_property ("block-size", blocksize);

 
 

-        //if the jack period is the same as when the value was saved, we can recall our latency..
-        if ( (_session.get_block_size() == blocksize) && (prop = node.property ("latency")) != 0) {
-                uint32_t latency = 0;
-                sscanf (prop->value().c_str(), "%u", &latency);
-                _measured_latency = latency;
-        }
+       //if the jack period is the same as when the value was saved, we can recall our latency..
+       if ( (_session.get_block_size() == blocksize) ) {
+               node.get_property ("latency", _measured_latency);
+       }

 
        if (!node.property ("ignore-bitslot")) {
 
        if (!node.property ("ignore-bitslot")) {

-               if ((prop = node.property ("bitslot")) == 0) {
-                       _bitslot = _session.next_insert_id();
-               } else {
+               uint32_t bitslot;
+               if (node.get_property ("bitslot", bitslot)) {

                        _session.unmark_insert_id (_bitslot);
                        _session.unmark_insert_id (_bitslot);

-                       sscanf (prop->value().c_str(), "%" PRIu32, &_bitslot);
+                       _bitslot = bitslot;

                        _session.mark_insert_id (_bitslot);
                        _session.mark_insert_id (_bitslot);

+               } else {
+                       _bitslot = _session.next_insert_id();

                }
        }
 
        return 0;
 }
 
                }
        }
 
        return 0;
 }
 

-ARDOUR::framecnt_t
+ARDOUR::samplecnt_t

 PortInsert::signal_latency() const
 {
        /* because we deliver and collect within the same cycle,
 PortInsert::signal_latency() const
 {
        /* because we deliver and collect within the same cycle,

-          all I/O is necessarily delayed by at least frames_per_cycle().
+          all I/O is necessarily delayed by at least samples_per_cycle().

 
           if the return port for insert has its own latency, we
           need to take that into account too.
 
           if the return port for insert has its own latency, we
           need to take that into account too.