patch to prevent (mostly) CD marker being set for the start of the session

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

diff --git a/libs/ardour/buffer_set.cc b/libs/ardour/buffer_set.cc
index c479b6c405c1a9ea518bb216baf19321c81d6d2a..3dc580caa221b3da79ddc7e2d1e4709b18fb2ad0 100644 (file)
--- a/libs/ardour/buffer_set.cc
+++ b/libs/ardour/buffer_set.cc
@@ -18,26 +18,12 @@
 
 #include <algorithm>
 #include <ardour/buffer_set.h>
+#include <ardour/buffer.h>
+#include <ardour/port.h>
+#include <ardour/port_set.h>
 
 namespace ARDOUR {
 
-
-/** Create a BufferSet to mirror a PortSet */
-BufferSet::BufferSet(const PortSet& ports)
-       : _count(ports.chan_count())
-       , _is_mirror(true)
-{
-       for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
-               BufferVec v;
-
-               for (size_t j=0; j < ports.num_ports(*t); ++j) {
-                       v.push_back(&ports.nth_port_of_type(*t, j)->get_buffer());
-               }
-
-               _buffers.push_back(v);
-       }
-}
-
 /** Create a new, empty BufferSet */
 BufferSet::BufferSet()
        : _is_mirror(false)
@@ -46,36 +32,60 @@ BufferSet::BufferSet()
                _buffers.push_back( BufferVec() );
 
        _count.reset();
+       _available.reset();
 }
 
-
 BufferSet::~BufferSet()
 {
-       if (!_is_mirror)
-               clear();
+       clear();
 }
 
-
 /** Destroy all contained buffers.
  */
 void
 BufferSet::clear()
 {
-       for (std::vector<BufferVec>::iterator i = _buffers.begin(); i != _buffers.end(); ++i) {
-               for (BufferVec::iterator j = (*i).begin(); j != (*i).end(); ++j) {
-                       delete *j;
+       if (!_is_mirror) {
+               for (std::vector<BufferVec>::iterator i = _buffers.begin(); i != _buffers.end(); ++i) {
+                       for (BufferVec::iterator j = (*i).begin(); j != (*i).end(); ++j) {
+                               delete *j;
+                       }
+                       (*i).clear();
                }
-               (*i).clear();
        }
        _buffers.clear();
+       _count.reset();
+       _available.reset();
 }
 
+/** Make this BufferSet a direct mirror of a PortSet's buffers.
+ */
+void
+BufferSet::attach_buffers(PortSet& ports)
+{
+       clear();
+
+       for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
+               _buffers.push_back(BufferVec());
+               BufferVec& v = _buffers[*t];
+
+               for (PortSet::iterator p = ports.begin(*t); p != ports.end(*t); ++p) {
+                       assert(p->type() == *t);
+                       v.push_back(&(p->get_buffer()));
+               }
+
+       }
+       
+       _count = ports.count();
+
+       _is_mirror = true;
+}
 
 void
-BufferSet::ensure_buffers(const ChanCount& chan_count, size_t buffer_capacity)
+BufferSet::ensure_buffers(const ChanCount& count, size_t buffer_capacity)
 {
        for (DataType::iterator t = DataType::begin(); t != DataType::end(); ++t) {
-               ensure_buffers(chan_count.get(*t), *t, buffer_capacity);
+               ensure_buffers(*t, count.get(*t), buffer_capacity);
        }
 }
 
@@ -84,16 +94,24 @@ BufferSet::ensure_buffers(const ChanCount& chan_count, size_t buffer_capacity)
  * each of size at least @a buffer_size
  */
 void
-BufferSet::ensure_buffers(size_t num_buffers, DataType type, size_t buffer_capacity)
+BufferSet::ensure_buffers(DataType type, size_t num_buffers, size_t buffer_capacity)
 {
        assert(type != DataType::NIL);
-       assert(type.to_index() < _buffers.size());
+       assert(type < _buffers.size());
+       assert(buffer_capacity > 0);
 
        if (num_buffers == 0)
                return;
 
        // The vector of buffers of the type we care about
-       BufferVec& bufs = _buffers[type.to_index()];
+       BufferVec& bufs = _buffers[type];
+       
+       // If we're a mirror just make sure we're ok
+       if (_is_mirror) {
+               assert(_count.get(type) >= num_buffers);
+               assert(bufs[0]->type() == type);
+               return;
+       }
 
        // If there's not enough or they're too small, just nuke the whole thing and
        // rebuild it (so I'm lazy..)
@@ -110,21 +128,17 @@ BufferSet::ensure_buffers(size_t num_buffers, DataType type, size_t buffer_capac
                for (size_t i=0; i < num_buffers; ++i) {
                        bufs.push_back(Buffer::create(type, buffer_capacity));
                }
+       
+               _available.set(type, num_buffers);
        }
 
        // Post-conditions
+       assert(bufs[0]->type() == type);
        assert(bufs.size() >= num_buffers);
-       assert((bufs[0])->type() == type);
+       assert(bufs.size() == _available.get(type));
        assert(bufs[0]->capacity() >= buffer_capacity);
 }
 
-size_t
-BufferSet::available_buffers(DataType type) const
-{
-       return _buffers[type.to_symbol()-1].size();
-}
-
-
 /** Get the capacity (size) of the available buffers of the given type.
  *
  * All buffers of a certain type always have the same capacity.
@@ -132,10 +146,26 @@ BufferSet::available_buffers(DataType type) const
 size_t
 BufferSet::buffer_capacity(DataType type) const
 {
-       assert(available_buffers(type) > 0);
-       return _buffers[type.to_index()][0]->capacity();
+       assert(_available.get(type) > 0);
+       return _buffers[type][0]->capacity();
 }
 
+// FIXME: make 'in' const
+void
+BufferSet::read_from(BufferSet& in, nframes_t nframes, nframes_t offset)
+{
+       assert(available() >= in.count());
+
+       // Copy all buffers 1:1
+       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); ++i, ++o) {
+                       o->read_from(*i, nframes, offset);
+               }
+       }
+
+       set_count(in.count());
+}
 
 } // namespace ARDOUR