From fa2639a2a855125c0c09712f7b2266fe84230a5a Mon Sep 17 00:00:00 2001 From: Edouard DUPIN Date: Thu, 6 Mar 2014 21:53:51 +0100 Subject: [PATCH] [DEV] basics ideas of buffer bloks and processing --- eaudiofx/core/Block.cpp | 82 +++++++++++++++ eaudiofx/core/Block.h | 165 ++++++++++++++++++++++++++++-- eaudiofx/core/BlockDecoder.cpp | 11 -- eaudiofx/core/BlockDecoder.h | 24 ----- eaudiofx/core/BlockEncoder.cpp | 11 -- eaudiofx/core/BlockEncoder.h | 25 ----- eaudiofx/core/BlockMeta.cpp | 27 +++++ eaudiofx/core/BlockMeta.h | 28 +++++ eaudiofx/core/Buffer.h | 9 +- eaudiofx/core/BufferAudio.cpp | 7 +- eaudiofx/core/BufferAudio.h | 16 ++- eaudiofx/core/BufferAudioFreq.cpp | 5 + eaudiofx/core/BufferAudioFreq.h | 2 +- eaudiofx/core/BufferAudioRaw.cpp | 5 + eaudiofx/core/BufferAudioRaw.h | 83 +-------------- eaudiofx/core/BufferMessage.cpp | 6 ++ eaudiofx/core/BufferMessage.h | 4 +- eaudiofx/core/BufferStream.cpp | 3 +- eaudiofx/core/BufferStream.h | 2 +- eaudiofx/core/Processing.h | 3 + eaudiofx/core/audio.h | 23 +---- lutin_eaudiofx.py | 3 +- 22 files changed, 347 insertions(+), 197 deletions(-) delete mode 100644 eaudiofx/core/BlockDecoder.cpp delete mode 100644 eaudiofx/core/BlockDecoder.h delete mode 100644 eaudiofx/core/BlockEncoder.cpp delete mode 100644 eaudiofx/core/BlockEncoder.h create mode 100644 eaudiofx/core/BlockMeta.cpp create mode 100644 eaudiofx/core/BlockMeta.h diff --git a/eaudiofx/core/Block.cpp b/eaudiofx/core/Block.cpp index f134fd1..c0bc324 100644 --- a/eaudiofx/core/Block.cpp +++ b/eaudiofx/core/Block.cpp @@ -6,6 +6,88 @@ * @license BSD v3 (see license file) */ +#include #include +#include +#include + +eaudiofx::Block::Block(void) : + m_uid(0), + m_type(), + m_parent(NULL) { + static size_t id=0; + m_uid = id; + id++; +} + +eaudiofx::Block::~Block(void) { + for (auto &it : m_io) { + if (it.second.m_buffer == NULL) { + continue; + } + if (it.second.m_internal != true) { + continue; + } + // just remove pointer from reference system. + eaudiofx::Buffer* tmp = it.second.m_buffer; + it.second.m_buffer = NULL; + // Notify all element that a buffer is removed. + subRemoveBuffer(tmp); + delete(tmp); + } +} + +void eaudiofx::Block::subRemoveBuffer(const eaudiofx::Buffer* _buffer) { + if (_buffer == NULL) { + return; + } + if (m_parent == NULL) { + onRemoveBuffer(_buffer); + } else { + m_parent->subRemoveBuffer(_buffer); + } +} + +void eaudiofx::Block::onRemoveBuffer(const eaudiofx::Buffer* _buffer) { + // For every buffer, remove internal reference... + for (auto &it : m_io) { + if (it.second.m_buffer == _buffer) { + it.second.m_buffer = NULL; + } + } +} + +int32_t eaudiofx::Block::linkBuffer(eaudiofx::Buffer* _buffer, const std::string& _name) { + for (auto &it : m_io) { + if (it.first == _name) { + if (it.second.m_type == ioOutput) { + EAUDIOFX_ERROR("[" << getUID() << "Can not overwrite output buffer..."); + return eaudiofx::ERR_FORBIDEN; + } + it.second.m_buffer = _buffer; + return eaudiofx::ERR_NONE; + } + } + return eaudiofx::ERR_NO_IO; +} + +int32_t eaudiofx::Block::getBuffer(eaudiofx::Buffer*& _buffer, const std::string& _name) { + for (auto &it : m_io) { + if (it.first == _name) { + if (it.second.m_type == ioInput) { + EAUDIOFX_ERROR("[" << getUID() << "Can not Request Input buffer..."); + return eaudiofx::ERR_FORBIDEN; + } + if (it.second.m_type == ioParameter) { + EAUDIOFX_ERROR("[" << getUID() << "Can not Request Parameter buffer..."); + return eaudiofx::ERR_FORBIDEN; + } + _buffer = it.second.m_buffer; + return eaudiofx::ERR_NONE; + } + } + return eaudiofx::ERR_NO_IO; +} + diff --git a/eaudiofx/core/Block.h b/eaudiofx/core/Block.h index e9e4b1c..c978947 100644 --- a/eaudiofx/core/Block.h +++ b/eaudiofx/core/Block.h @@ -10,29 +10,87 @@ #define __EAUDIOFX_BLOCK_H__ #include -#include #include +#include +#include namespace eaudiofx { + class Buffer; + class BlockMeta; + enum blockType { + blockTypeUnknow, + blockTypeFilter, + blockTypeGenerator, + blockTypeReceiver, + blockTypeDecoder, + blockTypeEncoder, + }; class Block { public: - Block(void) {}; - ~Block(void) {}; + Block(void); + ~Block(void); + protected: + std::mutex m_mutex; //!< Block mutex access + private: + size_t m_uid; //!< Unique block ID + public: + /** + * @brief Get the Block Unique ID + * @return the UID + */ + size_t getUID(void) { + return m_uid; + } private: std::string m_name; //!< name of the block public: /** * @brief Set the block name + * @param[in] _name New name of the Block */ - void setName(const std::string& _name) { + virtual void setName(const std::string& _name) { m_name = _name; } /** - * @brief Set the block name + * @brief Set the block name. + * @return The block name. */ - const std::string& setName(void) { + virtual const std::string& setName(void) { return m_name; } + private: + enum blockType m_type; // Type of the current block + public: + /** + * @brief Get block type + */ + virtual enum blockType getType(void) { + return m_type; + }; + protected: + /** + * @brief Set type of the block ==> detect generator and receiver + */ + virtual void setType(enum blockType _type) { + m_type = _type; + }; + protected: + eaudiofx::BlockMeta* m_parent; + public: + /** + * @brief Get parrent ob this block + * @return Pointer on the parrent if one is set. + */ + virtual eaudiofx::BlockMeta* getParrent(void) { + return m_parent; + }; + /** + * @brief Set the parrent pointer. + * @param[in] _meta Pointer on the parrent. + */ + virtual void setParrent(eaudiofx::BlockMeta* _meta) { + m_parent = _meta; + }; protected: // TODO : set properties ... public: @@ -48,13 +106,100 @@ namespace eaudiofx { }; public: /** - * + * @brief Call by downstream to request some data + * @param[in] _currentTime Current stream time (in second) + * @param[in] _requestTime Data requested (can be chunk number 256 samples, or data byte for stream) (-1 for automatic) + * @param[in] _timeout system time to be obsolet (for realTime streaming) (-1 for no realTime streaming) + * @return generic error */ - virtual int32_t push(int32_t _interface, eaudiofx::Buffer& _buffer, float _timeout) { }; + virtual int32_t pull(double _currentTime, int32_t _request, float _timeout) { + return eaudiofx::ERR_NONE; + }; /** - * + * @brief Get The total stream size (in byte for streaming byte element, in second for time streaming) + * @param[out] _value Get total streaming time (-1 for unknown) + * @return generic error */ - virtual int32_t pull(int32_t _interface, eaudiofx::Buffer& _buffer, float _timeout) { }; + virtual int32_t getTotal(double& _value) { + _value = -1; + return eaudiofx::ERR_NONE; + }; + /** + * @brief Seek to a specific position in the stream (in byte for streaming byte element, in second for time streaming) + * @param[out] _pos position to seek (0 for starting) + * @return generic error + */ + virtual int32_t seekTo(double _pos) { + return eaudiofx::ERR_NONE; + }; + /** + * @brief Request a flush of the current buffer + * @param[in] _currentTime Current stream time (in second) + * @param[in] _timeout system time to be obsolet (for realTime streaming) (-1 for no realTime streaming) + * @return generic error + */ + virtual int32_t flush(double _currentTime, float _timeout) { + return eaudiofx::ERR_NONE; + }; + /** + * @brief Reset the block + * @return generic error + */ + virtual int32_t reset(void) { + return eaudiofx::ERR_NONE; + }; + public: + /** + * @brief Call when a block is removed from the system (current) + * @param[in] _block Pointer on the removed block + */ + virtual void onRemoveBlock(const eaudiofx::Block* _block) {}; + /** + * @brief Call when a buffer is removed from the system (current). + * @param[in] _buffer Pointer on the removed buffer. + */ + virtual void onRemoveBuffer(const eaudiofx::Buffer* _buffer); + /** + * @brief A child call his parrent that it is removing a buffer. + * @param[in] _buffer Pointer on the removed buffer. + */ + virtual void subRemoveBuffer(const eaudiofx::Buffer* _buffer); + protected: + enum typeIO { + ioUnknow, + ioInput, + ioOutput, + ioParameter, + }; + class IOProperty { + public: + enum typeIO m_type; + std::string m_description; + bool m_internal; + eaudiofx::Buffer* m_buffer; + IOProperty(void) : + m_type(ioUnknow), + m_internal(false), + m_buffer(NULL) { + + } + }; + std::map m_io; //!< All IO in the Block + /** + * @brief Link the provided buffer to the IO name. + * @param[in] _buffer Pointer on the buffer to link. + * @param[in] _name Name of the IO; + * @return A generic error. + */ + virtual int32_t linkBuffer(eaudiofx::Buffer* _buffer, const std::string& _name); + /** + * @brief Request a buffer pointer on the IO named. + * @param[out] _buffer Pointer on the buffer to link. + * @param[in] _name Name of the IO; + * @return A generic error. + */ + virtual int32_t getBuffer(eaudiofx::Buffer*& _buffer, const std::string& _name); + }; }; diff --git a/eaudiofx/core/BlockDecoder.cpp b/eaudiofx/core/BlockDecoder.cpp deleted file mode 100644 index 189ba09..0000000 --- a/eaudiofx/core/BlockDecoder.cpp +++ /dev/null @@ -1,11 +0,0 @@ -/** - * @author Edouard DUPIN - * - * @copyright 2014, Edouard DUPIN, all right reserved - * - * @license BSD v3 (see license file) - */ - -#include - - diff --git a/eaudiofx/core/BlockDecoder.h b/eaudiofx/core/BlockDecoder.h deleted file mode 100644 index 5dd89dd..0000000 --- a/eaudiofx/core/BlockDecoder.h +++ /dev/null @@ -1,24 +0,0 @@ -/** - * @author Edouard DUPIN - * - * @copyright 2014, Edouard DUPIN, all right reserved - * - * @license BSD v3 (see license file) - */ - -#ifndef __EAUDIOFX_BLOCK_DECODER_H__ -#define __EAUDIOFX_BLOCK_DECODER_H__ - -#include - -namespace eaudiofx { - class BlockDecoder : public eaudiofx::Block { - public: - BlockDecoder(void) {}; - ~BlockDecoder(void) {}; - }; -}; - -#endif - - diff --git a/eaudiofx/core/BlockEncoder.cpp b/eaudiofx/core/BlockEncoder.cpp deleted file mode 100644 index 53c231b..0000000 --- a/eaudiofx/core/BlockEncoder.cpp +++ /dev/null @@ -1,11 +0,0 @@ -/** - * @author Edouard DUPIN - * - * @copyright 2014, Edouard DUPIN, all right reserved - * - * @license BSD v3 (see license file) - */ - -#include - - diff --git a/eaudiofx/core/BlockEncoder.h b/eaudiofx/core/BlockEncoder.h deleted file mode 100644 index b58d1e2..0000000 --- a/eaudiofx/core/BlockEncoder.h +++ /dev/null @@ -1,25 +0,0 @@ -/** - * @author Edouard DUPIN - * - * @copyright 2014, Edouard DUPIN, all right reserved - * - * @license BSD v3 (see license file) - */ - -#ifndef __EAUDIOFX_BLOCK_ENCODER_H__ -#define __EAUDIOFX_BLOCK_ENCODER_H__ - -#include - -namespace eaudiofx { - class BlockEncoder : public eaudiofx::Block { - public: - BlockEncoder(void) {}; - ~BlockEncoder(void) {}; - }; - -}; - -#endif - - diff --git a/eaudiofx/core/BlockMeta.cpp b/eaudiofx/core/BlockMeta.cpp new file mode 100644 index 0000000..ce2540c --- /dev/null +++ b/eaudiofx/core/BlockMeta.cpp @@ -0,0 +1,27 @@ +/** + * @author Edouard DUPIN + * + * @copyright 2014, Edouard DUPIN, all right reserved + * + * @license BSD v3 (see license file) + */ + +#include + + + +eaudiofx::BlockMeta::BlockMeta(void) { + +} + +eaudiofx::BlockMeta::~BlockMeta(void) { + for (auto &it : m_list) { + if (it == NULL) { + continue; + } + eaudiofx::Block* tmp = it; + it = NULL; + delete(tmp); + } +} + diff --git a/eaudiofx/core/BlockMeta.h b/eaudiofx/core/BlockMeta.h new file mode 100644 index 0000000..b7af03d --- /dev/null +++ b/eaudiofx/core/BlockMeta.h @@ -0,0 +1,28 @@ +/** + * @author Edouard DUPIN + * + * @copyright 2014, Edouard DUPIN, all right reserved + * + * @license BSD v3 (see license file) + */ + +#ifndef __EAUDIOFX_BLOCK_META_H__ +#define __EAUDIOFX_BLOCK_META_H__ + +#include +#include + +namespace eaudiofx { + class BlockMeta : public eaudiofx::Block { + public: + BlockMeta(void); + ~BlockMeta(void); + private: + std::vector m_list; //!< list of all block to process. + + }; +}; + +#endif + + diff --git a/eaudiofx/core/Buffer.h b/eaudiofx/core/Buffer.h index fc9e4a7..3084022 100644 --- a/eaudiofx/core/Buffer.h +++ b/eaudiofx/core/Buffer.h @@ -10,12 +10,19 @@ #define __EAUDIOFX_BUFFER_H__ #include +#include namespace eaudiofx { + class Block; class Buffer { public: - Buffer(void) {}; + Buffer(eaudiofx::Block& _parent) : + m_parent(_parent) { + + }; ~Buffer(void) {}; + protected: + eaudiofx::Block& m_parent; //!< parrent Block of this Buffer protected: double m_timestamp; //!< current buffer time; double m_time; //!< current buffer data time size; diff --git a/eaudiofx/core/BufferAudio.cpp b/eaudiofx/core/BufferAudio.cpp index f7b567f..c203e69 100644 --- a/eaudiofx/core/BufferAudio.cpp +++ b/eaudiofx/core/BufferAudio.cpp @@ -9,7 +9,8 @@ #include #include -eaudiofx::BufferAudio::BufferAudio(void) : +eaudiofx::BufferAudio::BufferAudio(eaudiofx::Block& _parent) : + eaudiofx::Buffer(_parent), m_frequency(0), m_nbChannel(0), m_data(0), @@ -24,12 +25,12 @@ eaudiofx::BufferAudio::~BufferAudio(void) { } } -void eaudiofx::BufferAudio::resize(size_t _newSizeByte) { +void eaudiofx::BufferAudio::resize(size_t _newSize) { if (m_data != NULL) { delete[] m_data; m_data = NULL; } - m_data = new uint8_t[_newSizeByte]; + m_data = new float[_newSize]; if (m_data == NULL) { EAUDIOFX_ERROR("Can not allocate Buffer Audio"); } diff --git a/eaudiofx/core/BufferAudio.h b/eaudiofx/core/BufferAudio.h index 11220b2..fdee8e2 100644 --- a/eaudiofx/core/BufferAudio.h +++ b/eaudiofx/core/BufferAudio.h @@ -14,20 +14,28 @@ namespace eaudiofx { class BufferAudio : public eaudiofx::Buffer { public: - BufferAudio(void); + BufferAudio(eaudiofx::Block& _parent); ~BufferAudio(void); protected: int32_t m_frequency; int32_t m_nbChannel; enum channelPosition m_channelType[MAX_NUMBER_OF_SIMULTANEOUS_CHANNEL]; protected: - uint8_t* m_data; //!< pointer on the data. - size_t m_allocated; //!< number of byte allocated + float* m_data; //!< pointer on the data. + size_t m_allocated; //!< number of sample allocated protected: /** * @brief Reallocate the Buffer data. */ - virtual void resize(size_t _newSizeByte); + virtual void resize(size_t _newSize); + public: + /** + * @brief Get the buffer casted in float* + * @return Pointer on the buffer with correct cast. + */ + float* getData(void) { + return m_data; + } }; }; diff --git a/eaudiofx/core/BufferAudioFreq.cpp b/eaudiofx/core/BufferAudioFreq.cpp index c2d0842..319a2dd 100644 --- a/eaudiofx/core/BufferAudioFreq.cpp +++ b/eaudiofx/core/BufferAudioFreq.cpp @@ -9,3 +9,8 @@ #include +eaudiofx::BufferAudioFreq::BufferAudioFreq(eaudiofx::Block& _parent) : + eaudiofx::BufferAudio(_parent) { + +} + diff --git a/eaudiofx/core/BufferAudioFreq.h b/eaudiofx/core/BufferAudioFreq.h index c4e9e63..761967a 100644 --- a/eaudiofx/core/BufferAudioFreq.h +++ b/eaudiofx/core/BufferAudioFreq.h @@ -14,7 +14,7 @@ namespace eaudiofx { class BufferAudioFreq : public eaudiofx::BufferAudio { public: - BufferAudioFreq(void) {}; + BufferAudioFreq(eaudiofx::Block& _parent); ~BufferAudioFreq(void) {}; }; }; diff --git a/eaudiofx/core/BufferAudioRaw.cpp b/eaudiofx/core/BufferAudioRaw.cpp index ae06593..8b8a5e7 100644 --- a/eaudiofx/core/BufferAudioRaw.cpp +++ b/eaudiofx/core/BufferAudioRaw.cpp @@ -9,3 +9,8 @@ #include +eaudiofx::BufferAudioRaw::BufferAudioRaw(eaudiofx::Block& _parent) : + eaudiofx::BufferAudio(_parent) { + +} + diff --git a/eaudiofx/core/BufferAudioRaw.h b/eaudiofx/core/BufferAudioRaw.h index 09a09bc..3f6708c 100644 --- a/eaudiofx/core/BufferAudioRaw.h +++ b/eaudiofx/core/BufferAudioRaw.h @@ -14,7 +14,7 @@ namespace eaudiofx { class BufferAudioRaw : public eaudiofx::BufferAudio { public: - BufferAudioRaw(void) {}; + BufferAudioRaw(eaudiofx::Block& _parent); ~BufferAudioRaw(void) {}; protected: size_t m_allocatedSample; //!< generate with m_allocatedBytes/sizeof(**m_audioFormat**) / m_nbChannel; @@ -22,87 +22,6 @@ namespace eaudiofx { size_t m_size; //!< number of sample for each channels provided in this buffer ... (write by the upstream (can be 0)) protected: size_t m_sizeRequested; //!< in pull mode, number of sample for each channels requested by the next Filter - protected: - enum audioRawFormat m_audioFormat; - public: - /** - * @brief Get the buffer casted in void* - * @return Pointer on the buffer with correct cast. - */ - void* getDataVoid(void) { - return (void*)m_data; - } - /** - * @brief Get the buffer casted in int8_t* - * @return Pointer on the buffer with correct cast. - */ - int8_t* getDataI8(void) { - return (int8_t*)m_data; - } - /** - * @brief Get the buffer casted in int16_t* - * @return Pointer on the buffer with correct cast. - */ - int16_t* getDataI16(void) { - return (int16_t*)m_data; - } - /** - * @brief Get the buffer casted in int32_t* - * @return Pointer on the buffer with correct cast. - */ - int32_t* getDataI32(void) { - return (int32_t*)m_data; - } - /** - * @brief Get the buffer casted in int64_t* - * @return Pointer on the buffer with correct cast. - */ - int64_t* getDataI64(void) { - return (int64_t*)m_data; - } - /** - * @brief Get the buffer casted in uint8_t* - * @return Pointer on the buffer with correct cast. - */ - uint8_t* getDataU8(void) { - return (uint8_t*)m_data; - } - /** - * @brief Get the buffer casted in uint16_t* - * @return Pointer on the buffer with correct cast. - */ - uint16_t* getDataU16(void) { - return (uint16_t*)m_data; - } - /** - * @brief Get the buffer casted in uint32_t* - * @return Pointer on the buffer with correct cast. - */ - uint32_t* getDataU32(void) { - return (uint32_t*)m_data; - } - /** - * @brief Get the buffer casted in uint64_t* - * @return Pointer on the buffer with correct cast. - */ - uint64_t* getDataU64(void) { - return (uint64_t*)m_data; - } - - /** - * @brief Get the buffer casted in float* - * @return Pointer on the buffer with correct cast. - */ - float* getDataF(void) { - return (float*)m_data; - } - /** - * @brief Get the buffer casted in double* - * @return Pointer on the buffer with correct cast. - */ - double* getDataD(void) { - return (double*)m_data; - } }; }; diff --git a/eaudiofx/core/BufferMessage.cpp b/eaudiofx/core/BufferMessage.cpp index e07a8fa..c107402 100644 --- a/eaudiofx/core/BufferMessage.cpp +++ b/eaudiofx/core/BufferMessage.cpp @@ -9,3 +9,9 @@ #include + +eaudiofx::BufferMessage::BufferMessage(eaudiofx::Block& _parent, int32_t _message) : + eaudiofx::Buffer(_parent), + m_messageId(_message) { + +} diff --git a/eaudiofx/core/BufferMessage.h b/eaudiofx/core/BufferMessage.h index 4a4e2ab..3b3559e 100644 --- a/eaudiofx/core/BufferMessage.h +++ b/eaudiofx/core/BufferMessage.h @@ -21,7 +21,7 @@ namespace eaudiofx { }; class BufferMessage : public eaudiofx::Buffer { public: - BufferMessage(int32_t _message = bufferMessageEndOfStream) {}; + BufferMessage(eaudiofx::Block& _parent, int32_t _message = eaudiofx::bufferMessageEndOfStream); ~BufferMessage(void) {}; protected: int32_t m_messageId; //!< message ID @@ -37,7 +37,7 @@ namespace eaudiofx { * @brief Set the message. * @param[in] _message The ID of the message (if value is < 0 : custom message ...) */ - int32_t getMessage(int32_t _messageId) { + void getMessage(int32_t _messageId) { m_messageId = _messageId; } private: diff --git a/eaudiofx/core/BufferStream.cpp b/eaudiofx/core/BufferStream.cpp index 3ee38e7..631b518 100644 --- a/eaudiofx/core/BufferStream.cpp +++ b/eaudiofx/core/BufferStream.cpp @@ -8,7 +8,8 @@ #include -eaudiofx::BufferStream::BufferStream(void) { +eaudiofx::BufferStream::BufferStream(eaudiofx::Block& _parent) : + eaudiofx::Buffer(_parent) { } eaudiofx::BufferStream::~BufferStream(void) { diff --git a/eaudiofx/core/BufferStream.h b/eaudiofx/core/BufferStream.h index d5cf3ff..ca9e144 100644 --- a/eaudiofx/core/BufferStream.h +++ b/eaudiofx/core/BufferStream.h @@ -14,7 +14,7 @@ namespace eaudiofx { class BufferStream : public eaudiofx::Buffer { public: - BufferStream(void); + BufferStream(eaudiofx::Block& _parent); ~BufferStream(void); protected: void* m_data; //!< buffer data diff --git a/eaudiofx/core/Processing.h b/eaudiofx/core/Processing.h index bfa11a5..8f7b6b9 100644 --- a/eaudiofx/core/Processing.h +++ b/eaudiofx/core/Processing.h @@ -11,12 +11,15 @@ #include #include +#include +#include namespace eaudiofx { class Processing { public: Processing(void) {}; ~Processing(void) {}; + private: }; }; diff --git a/eaudiofx/core/audio.h b/eaudiofx/core/audio.h index 5c5a04e..750af96 100644 --- a/eaudiofx/core/audio.h +++ b/eaudiofx/core/audio.h @@ -74,26 +74,11 @@ namespace eaudiofx { #define CHANNEL_HEIGHT_TOP 0x04 #define CHANNEL_HEIGHT_BOTTOM 0x08 - enum audioRawFormat { - // fix-point mode - audioRawFormatS8, - audioRawFormatS16, - audioRawFormatS32, - audioRawFormatS64, - audioRawFormatU8, - audioRawFormatU16, - audioRawFormatU32, - audioRawFormatU64, - // float mode - audioRawFormatFloat, - audioRawFormatDouble + enum { + ERR_NONE = 0, + ERR_FORBIDEN, + ERR_NO_IO, }; - - - - - - }; #endif diff --git a/lutin_eaudiofx.py b/lutin_eaudiofx.py index f438d7a..ff65d78 100644 --- a/lutin_eaudiofx.py +++ b/lutin_eaudiofx.py @@ -14,11 +14,10 @@ def create(target): 'eaudiofx/debug.cpp', 'eaudiofx/core/Processing.cpp', 'eaudiofx/core/Block.cpp', + 'eaudiofx/core/BlockMeta.cpp', 'eaudiofx/core/BlockGenerator.cpp', 'eaudiofx/core/BlockReceiver.cpp', 'eaudiofx/core/BlockFilter.cpp', - 'eaudiofx/core/BlockEncoder.cpp', - 'eaudiofx/core/BlockDecoder.cpp', 'eaudiofx/core/Buffer.cpp', 'eaudiofx/core/BufferMessage.cpp', 'eaudiofx/core/BufferStream.cpp',