X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;ds=sidebyside;f=libs%2Fardour%2Fardour%2Fbuffer.h;h=cbb92e7c4ab988b5f8ba5d2c5825cac36d0b99b3;hb=99fb7346f07be28f548855b3e9c1ff2a174d994f;hp=5171f506972b5b44b4cdff48882fe6b1aba1f516;hpb=b7f3a6350783ffda019c22f74dd67e7d619b387b;p=ardour.git diff --git a/libs/ardour/ardour/buffer.h b/libs/ardour/ardour/buffer.h index 5171f50697..cbb92e7c4a 100644 --- a/libs/ardour/ardour/buffer.h +++ b/libs/ardour/ardour/buffer.h @@ -1,17 +1,16 @@ /* - Copyright (C) 2006 Paul Davis - Written by Dave Robillard, 2006 - + Copyright (C) 2006 Paul Davis + This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version. - + This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. - + You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. @@ -20,11 +19,12 @@ #ifndef __ardour_buffer_h__ #define __ardour_buffer_h__ -#define _XOPEN_SOURCE 600 -#include // for posix_memalign -#include -#include -#include +#include + +#include + +#include "ardour/types.h" +#include "ardour/data_type.h" namespace ARDOUR { @@ -35,23 +35,17 @@ namespace ARDOUR { * methods to actually access the data). This provides a way for code that * doesn't care about the data type to still deal with buffers (which is * why the base class can't be a template). - * + * * To actually read/write buffer contents, use the appropriate derived class. */ -class Buffer +class Buffer : public boost::noncopyable { public: - /** Unfortunately using RTTI and dynamic_cast to find the type of the - * buffer is just too slow, this is done in very performance critical - * bits of the code. */ - enum Type { NIL = 0, AUDIO, MIDI }; - - Buffer(Type type, size_t capacity) - : _type(type), _capacity(capacity), _size(0) - {} - virtual ~Buffer() {} + /** Factory function */ + static Buffer* create(DataType type, size_t capacity); + /** Maximum capacity of buffer. * Note in some cases the entire buffer may not contain valid data, use size. */ size_t capacity() const { return _capacity; } @@ -59,82 +53,41 @@ public: /** Amount of valid data in buffer. Use this over capacity almost always. */ size_t size() const { return _size; } + /** Return true if the buffer contains no data, false otherwise */ + virtual bool empty() const { return _size == 0; } + /** Type of this buffer. - * Based on this you can cast a Buffer* to the desired type. */ - virtual Type type() const { return _type; } - - /** Jack type (eg JACK_DEFAULT_AUDIO_TYPE) */ - const char* jack_type() const { return type_to_jack_type(type()); } - - /** Separate for creating ports (before a buffer exists to call jack_type on) */ - static const char* type_to_jack_type(Type t) { - switch (t) { - case AUDIO: return JACK_DEFAULT_AUDIO_TYPE; - case MIDI: return JACK_DEFAULT_MIDI_TYPE; - default: return ""; - } - } - -protected: - Type _type; - size_t _capacity; - size_t _size; -}; + * Based on this you can static cast a Buffer* to the desired type. */ + DataType type() const { return _type; } + bool silent() const { return _silent; } + void set_is_silent(bool yn) { _silent = yn; } -/* Since we only have two types, templates aren't worth it, yet.. */ + /** Reallocate the buffer used internally to handle at least @a size_t units of data. + * + * The buffer is not silent after this operation. the @a capacity argument + * passed to the constructor must have been non-zero. + */ + virtual void resize (size_t) = 0; + /** Clear (eg zero, or empty) buffer */ + virtual void silence (framecnt_t len, framecnt_t offset = 0) = 0; -/** Buffer containing 32-bit floating point (audio) data. */ -class AudioBuffer : public Buffer -{ -public: - AudioBuffer(size_t capacity) - : Buffer(AUDIO, capacity) - , _data(NULL) - { - _size = capacity; // For audio buffers, size = capacity always - posix_memalign((void**)_data, 16, sizeof(Sample) * capacity); - assert(_data); - memset(_data, 0, sizeof(Sample) * capacity); - } - - const Sample* data() const { return _data; } - Sample* data() { return _data; } - -private: - // These are undefined (prevent copies) - AudioBuffer(const AudioBuffer& copy); - AudioBuffer& operator=(const AudioBuffer& copy); - - Sample* const _data; ///< Actual buffer contents -}; + /** Clear the entire buffer */ + virtual void clear() { silence(_capacity, 0); } + virtual void read_from (const Buffer& src, framecnt_t len, framecnt_t dst_offset = 0, framecnt_t src_offset = 0) = 0; + virtual void merge_from (const Buffer& src, framecnt_t len, framecnt_t dst_offset = 0, framecnt_t src_offset = 0) = 0; + protected: + Buffer(DataType type, size_t capacity) + : _type(type), _capacity(capacity), _size(0), _silent(true) + {} -/** Buffer containing 8-bit unsigned char (MIDI) data. */ -class MidiBuffer : public Buffer -{ -public: - MidiBuffer(size_t capacity) - : Buffer(MIDI, capacity) - , _data(NULL) - { - posix_memalign((void**)_data, 16, sizeof(RawMidi) * capacity); - assert(_data); - assert(_size == 0); - memset(_data, 0, sizeof(Sample) * capacity); - } - - const RawMidi* data() const { return _data; } - RawMidi* data() { return _data; } - -private: - // These are undefined (prevent copies) - MidiBuffer(const MidiBuffer& copy); - MidiBuffer& operator=(const MidiBuffer& copy); - - RawMidi* const _data; ///< Actual buffer contents + DataType _type; + pframes_t _capacity; + pframes_t _size; + bool _silent; };