Some improvements to performance with crossfades: don't recompute a whole track's...

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

diff --git a/libs/ardour/buffer_set.cc b/libs/ardour/buffer_set.cc
index 545d9801784e535650e9018a8c3118c9e15a00ae..e02e2ba2cbb5b7267400d93f635edc7ee8ea0a40 100644 (file)
--- a/libs/ardour/buffer_set.cc
+++ b/libs/ardour/buffer_set.cc
@@ -16,6 +16,11 @@
     675 Mass Ave, Cambridge, MA 02139, USA.
 */
 
+
+#ifdef WAF_BUILD
+#include "libardour-config.h"
+#endif
+
 #include <iostream>
 #include <algorithm>
 #include "ardour/buffer.h"
@@ -34,6 +39,7 @@ namespace ARDOUR {
 /** Create a new, empty BufferSet */
 BufferSet::BufferSet()
        : _is_mirror(false)
+       , _is_silent(false)
 {
        for (size_t i=0; i < DataType::num_types; ++i) {
                _buffers.push_back(BufferVec());
@@ -84,6 +90,7 @@ BufferSet::attach_buffers(PortSet& ports, nframes_t nframes, nframes_t offset)
        }
        
        _count = ports.count();
+       _available = ports.count();
 
        _is_mirror = true;
 }
@@ -97,8 +104,9 @@ BufferSet::ensure_buffers(DataType type, size_t num_buffers, size_t buffer_capac
        assert(type != DataType::NIL);
        assert(type < _buffers.size());
 
-       if (num_buffers == 0)
+       if (num_buffers == 0) {
                return;
+       }
 
        // The vector of buffers of the type we care about
        BufferVec& bufs = _buffers[type];
@@ -127,12 +135,13 @@ BufferSet::ensure_buffers(DataType type, size_t num_buffers, size_t buffer_capac
                }
        
                _available.set(type, num_buffers);
+               _count.set (type, num_buffers);
        }
 
 #ifdef HAVE_SLV2
        // Ensure enough low level MIDI format buffers are available for conversion
        // in both directions (input & output, out-of-place)
-       if (type == DataType::MIDI && _lv2_buffers.size() < _buffers[type].size() * 2) {
+       if (type == DataType::MIDI && _lv2_buffers.size() < _buffers[type].size() * 2 + 1) {
                while (_lv2_buffers.size() < _buffers[type].size() * 2) {
                        _lv2_buffers.push_back(std::make_pair(false, new LV2EventBuffer(buffer_capacity)));
                }
@@ -146,6 +155,76 @@ BufferSet::ensure_buffers(DataType type, size_t num_buffers, size_t buffer_capac
        assert(bufs[0]->capacity() >= buffer_capacity);
 }
 
+/** Ensure that the number of buffers of each type @a type matches @a chns
+ * and each buffer is of size at least @a buffer_capacity
+ */
+void
+BufferSet::ensure_buffers(const ChanCount& chns, size_t buffer_capacity)
+{
+       if (chns == ChanCount::ZERO) {
+               return;
+       }
+
+       // If we're a mirror just make sure we're ok
+       if (_is_mirror) {
+               assert(_count >= chns);
+               return;
+       }
+
+       for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
+
+               // The vector of buffers of this type
+               BufferVec& bufs = _buffers[*t];
+
+               uint32_t nbufs = chns.get (*t);
+               
+               if (nbufs == 0) {
+                       // Nuke it
+                       for (BufferVec::iterator i = bufs.begin(); i != bufs.end(); ++i) {
+                               delete (*i);
+                       }
+                       bufs.clear();
+                       continue;
+               }
+
+               // If there's not enough or they're too small, just nuke the whole thing and
+               // rebuild it (so I'm lazy..)
+               if (bufs.size() < nbufs
+                   || (bufs.size() > 0 && bufs[0]->capacity() < buffer_capacity)) {
+                       
+                       // Nuke it
+                       for (BufferVec::iterator i = bufs.begin(); i != bufs.end(); ++i) {
+                               delete (*i);
+                       }
+                       bufs.clear();
+                       
+                       // Rebuild it
+                       for (size_t i = 0; i < nbufs; ++i) {
+                               bufs.push_back(Buffer::create(*t, buffer_capacity));
+                       }
+                       
+                       _available.set (*t, nbufs);
+               }
+               
+#ifdef HAVE_SLV2
+               // Ensure enough low level MIDI format buffers are available for conversion
+               // in both directions (input & output, out-of-place)
+               if (*t == DataType::MIDI && _lv2_buffers.size() < _buffers[DataType::MIDI].size() * 2 + 1) {
+                       while (_lv2_buffers.size() < _buffers[DataType::MIDI].size() * 2) {
+                               _lv2_buffers.push_back(std::make_pair(false, new LV2EventBuffer(buffer_capacity)));
+                       }
+               }
+#endif
+               
+               // Post-conditions
+               assert(bufs[0]->type() == *t);
+               assert(bufs.size() == _available.get(*t));
+               assert(bufs[0]->capacity() >= buffer_capacity);
+       }
+       
+       assert (available() == chns);
+}
+
 /** Get the capacity (size) of the available buffers of the given type.
  *
  * All buffers of a certain type always have the same capacity.
@@ -160,7 +239,7 @@ BufferSet::buffer_capacity(DataType type) const
 Buffer&
 BufferSet::get(DataType type, size_t i)
 {
-       assert(i <= _count.get(type));
+       assert(i < _available.get(type));
        return *_buffers[type][i];
 }
 
@@ -222,5 +301,34 @@ BufferSet::read_from (BufferSet& in, nframes_t nframes)
        set_count(in.count());
 }
 
+// FIXME: make 'in' const
+void
+BufferSet::merge_from (BufferSet& in, nframes_t nframes)
+{
+       /* merge all input buffers into out existing buffers.
+
+          NOTE: if "in" contains more buffers than this set,
+          we will drop the extra buffers.
+
+       */
+
+       for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
+               BufferSet::iterator o = begin(*t);
+               for (BufferSet::iterator i = in.begin(*t); i != in.end(*t) && o != end (*t); ++i, ++o) {
+                       o->merge_from (*i, nframes);
+               }
+       }
+}
+
+void
+BufferSet::silence (nframes_t nframes, nframes_t offset)
+{
+       for (std::vector<BufferVec>::iterator i = _buffers.begin(); i != _buffers.end(); ++i) {
+               for (BufferVec::iterator b = i->begin(); b != i->end(); ++b) {
+                       (*b)->silence (nframes, offset);
+               }
+       }
+}
+
 } // namespace ARDOUR