X-Git-Url: https://main.carlh.net/gitweb/?a=blobdiff_plain;f=libs%2Fardour%2Fardour%2Fbuffer_set.h;h=9ea6ab7d6ad1d3620d347fb4eea78971d53fb481;hb=eadf9bbef17a1405096ad6ce6966e4265d566cca;hp=df842613cbad44f75b8b9433a26f286faf380310;hpb=bb9cc45cd22af67ac275a5e73accbe14fee664d8;p=ardour.git diff --git a/libs/ardour/ardour/buffer_set.h b/libs/ardour/ardour/buffer_set.h index df842613cb..9ea6ab7d6a 100644 --- a/libs/ardour/ardour/buffer_set.h +++ b/libs/ardour/ardour/buffer_set.h @@ -27,17 +27,27 @@ #include #include "ardour/chan_count.h" #include "ardour/data_type.h" +#include "ardour/libardour_visibility.h" #include "ardour/types.h" +#if defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT +#include "evoral/MIDIEvent.hpp" +struct _VstEvents; +typedef struct _VstEvents VstEvents; +struct _VstMidiEvent; +typedef struct _VstMidiEvent VstMidiEvent; +#endif + +#ifdef LV2_SUPPORT +typedef struct LV2_Evbuf_Impl LV2_Evbuf; +#endif + namespace ARDOUR { class Buffer; class AudioBuffer; class MidiBuffer; class PortSet; -#ifdef HAVE_SLV2 -class LV2EventBuffer; -#endif /** A set of buffers of various types. * @@ -52,7 +62,7 @@ class LV2EventBuffer; * others the form of their output (eg what they did to the BufferSet). * Setting the use counts is realtime safe. */ -class BufferSet +class LIBARDOUR_API BufferSet { public: BufferSet(); @@ -60,7 +70,8 @@ public: void clear(); - void attach_buffers(PortSet& ports, nframes_t nframes, nframes_t offset = 0); + void attach_buffers (PortSet& ports); + void get_backend_port_addresses (PortSet &, framecnt_t); /* the capacity here is a size_t and has a different interpretation depending on the DataType of the buffers. for audio, its a frame count. for MIDI @@ -76,118 +87,133 @@ public: const ChanCount& count() const { return _count; } ChanCount& count() { return _count; } - void is_silent(bool yn) { _is_silent = yn; } - bool is_silent() const { return _is_silent; } - void silence (nframes_t nframes, nframes_t offset); + void silence (framecnt_t nframes, framecnt_t offset); bool is_mirror() const { return _is_mirror; } void set_count(const ChanCount& count) { assert(count <= _available); _count = count; } size_t buffer_capacity(DataType type) const; - Buffer& get(DataType type, size_t i); + Buffer& get(DataType type, size_t i); + const Buffer& get(DataType type, size_t i) const; AudioBuffer& get_audio(size_t i) { return (AudioBuffer&)get(DataType::AUDIO, i); } + const AudioBuffer& get_audio(size_t i) const { + return (const AudioBuffer&)get(DataType::AUDIO, i); + } MidiBuffer& get_midi(size_t i) { return (MidiBuffer&)get(DataType::MIDI, i); } + const MidiBuffer& get_midi(size_t i) const { + return (const MidiBuffer&)get(DataType::MIDI, i); + } + +#ifdef LV2_SUPPORT + /** Get a MIDI buffer translated into an LV2 MIDI buffer for use with + * plugins. The index here corresponds directly to MIDI buffer numbers + * (i.e. the index passed to get_midi), translation back and forth will + * happen as needed. If old_api is true, the returned buffer will be in + * old event format. Otherwise it will be in new atom sequence format. + */ + LV2_Evbuf* get_lv2_midi(bool input, size_t i, bool old_api); -#ifdef HAVE_SLV2 - /** Get a MIDI buffer translated into an LV2 MIDI buffer for use with plugins. - * The index here corresponds directly to MIDI buffer numbers (i.e. the index - * passed to get_midi), translation back and forth will happen as needed */ - LV2EventBuffer& get_lv2_midi(bool input, size_t i); + /** ensure minimum size of LV2 Atom port buffer */ + void ensure_lv2_bufsize(bool input, size_t i, size_t buffer_capacity); /** Flush modified LV2 event output buffers back to Ardour buffers */ void flush_lv2_midi(bool input, size_t i); -#endif - - void read_from(BufferSet& in, nframes_t nframes); - void merge_from(BufferSet& in, nframes_t nframes); - - // ITERATORS - // FIXME: possible to combine these? templates? - - class audio_iterator { - public: - AudioBuffer& operator*() { return _set.get_audio(_index); } - AudioBuffer* operator->() { return &_set.get_audio(_index); } - audio_iterator& operator++() { ++_index; return *this; } // yes, prefix only - bool operator==(const audio_iterator& other) { return (_index == other._index); } - bool operator!=(const audio_iterator& other) { return (_index != other._index); } - - private: - friend class BufferSet; - - audio_iterator(BufferSet& list, size_t index) : _set(list), _index(index) {} - - BufferSet& _set; - size_t _index; - }; - - audio_iterator audio_begin() { return audio_iterator(*this, 0); } - audio_iterator audio_end() { return audio_iterator(*this, _count.n_audio()); } - - class midi_iterator { - public: - MidiBuffer& operator*() { return _set.get_midi(_index); } - MidiBuffer* operator->() { return &_set.get_midi(_index); } - midi_iterator& operator++() { ++_index; return *this; } // yes, prefix only - bool operator==(const midi_iterator& other) { return (_index == other._index); } - bool operator!=(const midi_iterator& other) { return (_index != other._index); } - - private: - friend class BufferSet; - midi_iterator(BufferSet& list, size_t index) : _set(list), _index(index) {} + /** Forward plugin MIDI output to to Ardour buffers */ + void forward_lv2_midi(LV2_Evbuf*, size_t, bool purge_ardour_buffer = true); +#endif - BufferSet& _set; - size_t _index; - }; +#if defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT + VstEvents* get_vst_midi (size_t); +#endif - midi_iterator midi_begin() { return midi_iterator(*this, 0); } - midi_iterator midi_end() { return midi_iterator(*this, _count.n_midi()); } + void read_from(const BufferSet& in, framecnt_t nframes); + void read_from(const BufferSet& in, framecnt_t nframes, DataType); + void merge_from(const BufferSet& in, framecnt_t nframes); - class iterator { + template + class iterator_base { public: - Buffer& operator*() { return _set.get(_type, _index); } - Buffer* operator->() { return &_set.get(_type, _index); } - iterator& operator++() { ++_index; return *this; } // yes, prefix only - bool operator==(const iterator& other) { return (_index == other._index); } - bool operator!=(const iterator& other) { return (_index != other._index); } - iterator operator=(const iterator& other) { + B& operator*() { return (B&)_set.get(_type, _index); } + B* operator->() { return &(B&)_set.get(_type, _index); } + iterator_base& operator++() { ++_index; return *this; } // yes, prefix only + bool operator==(const iterator_base& other) { return (_index == other._index); } + bool operator!=(const iterator_base& other) { return (_index != other._index); } + iterator_base operator=(const iterator_base& other) { _set = other._set; _type = other._type; _index = other._index; return *this; } private: friend class BufferSet; - iterator(BufferSet& list, DataType type, size_t index) + iterator_base(BS& list, DataType type, size_t index) : _set(list), _type(type), _index(index) {} - BufferSet& _set; - DataType _type; - size_t _index; + BS& _set; + DataType _type; + size_t _index; }; + typedef iterator_base iterator; iterator begin(DataType type) { return iterator(*this, type, 0); } iterator end(DataType type) { return iterator(*this, type, _count.get(type)); } + typedef iterator_base const_iterator; + const_iterator begin(DataType type) const { return const_iterator(*this, type, 0); } + const_iterator end(DataType type) const { return const_iterator(*this, type, _count.get(type)); } + + typedef iterator_base audio_iterator; + audio_iterator audio_begin() { return audio_iterator(*this, DataType::AUDIO, 0); } + audio_iterator audio_end() { return audio_iterator(*this, DataType::AUDIO, _count.n_audio()); } + + typedef iterator_base midi_iterator; + midi_iterator midi_begin() { return midi_iterator(*this, DataType::MIDI, 0); } + midi_iterator midi_end() { return midi_iterator(*this, DataType::MIDI, _count.n_midi()); } + private: typedef std::vector BufferVec; /// Vector of vectors, indexed by DataType std::vector _buffers; -#ifdef HAVE_SLV2 +#ifdef LV2_SUPPORT /// LV2 MIDI buffers (for conversion to/from MIDI buffers) - typedef std::vector< std::pair > LV2Buffers; + typedef std::vector< std::pair > LV2Buffers; LV2Buffers _lv2_buffers; #endif +#if defined WINDOWS_VST_SUPPORT || defined LXVST_SUPPORT + class VSTBuffer { + public: + VSTBuffer (size_t); + ~VSTBuffer (); + + void clear (); + void push_back (Evoral::MIDIEvent const &); + VstEvents* events () const { + return _events; + } + + private: + /* prevent copy construction */ + VSTBuffer (VSTBuffer const &); + + VstEvents* _events; /// the parent VSTEvents struct + VstMidiEvent* _midi_events; ///< storage area for VSTMidiEvents + size_t _capacity; + }; + + typedef std::vector VSTBuffers; + VSTBuffers _vst_buffers; +#endif + /// Use counts (there may be more actual buffers than this) ChanCount _count; @@ -196,9 +222,6 @@ private: /// False if we 'own' the contained buffers, if true we mirror a PortSet) bool _is_mirror; - - /// Whether the buffer set should be considered silent - bool _is_silent; };