From b7f3a6350783ffda019c22f74dd67e7d619b387b Mon Sep 17 00:00:00 2001 From: David Robillard Date: Mon, 26 Jun 2006 20:29:45 +0000 Subject: Actually added the code mentioned in my last commit. Whoops. git-svn-id: svn://localhost/ardour2/branches/midi@643 d708f5d6-7413-0410-9779-e7cbd77b26cf --- libs/ardour/ardour/buffer.h | 143 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 143 insertions(+) create mode 100644 libs/ardour/ardour/buffer.h (limited to 'libs/ardour/ardour/buffer.h') diff --git a/libs/ardour/ardour/buffer.h b/libs/ardour/ardour/buffer.h new file mode 100644 index 0000000000..5171f50697 --- /dev/null +++ b/libs/ardour/ardour/buffer.h @@ -0,0 +1,143 @@ +/* + Copyright (C) 2006 Paul Davis + Written by Dave Robillard, 2006 + + 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. +*/ + +#ifndef __ardour_buffer_h__ +#define __ardour_buffer_h__ + +#define _XOPEN_SOURCE 600 +#include // for posix_memalign +#include +#include +#include + +namespace ARDOUR { + + +/** A buffer of recordable/playable data. + * + * This is a datatype-agnostic base class for all buffers (there are no + * 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 +{ +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() {} + + /** Maximum capacity of buffer. + * Note in some cases the entire buffer may not contain valid data, use size. */ + size_t capacity() const { return _capacity; } + + /** Amount of valid data in buffer. Use this over capacity almost always. */ + size_t size() const { return _size; } + + /** 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; +}; + + +/* Since we only have two types, templates aren't worth it, yet.. */ + + +/** 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 +}; + + + +/** 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 +}; + + +} // namespace ARDOUR + +#endif // __ardour_buffer_h__ -- cgit v1.2.3