audiodesc.h

Go to the documentation of this file.

 
#pragma once
 
#include <promeki/core/namespace.h>
#include <promeki/core/sharedptr.h>
#include <promeki/core/metadata.h>
#include <promeki/core/string.h>
#include <promeki/core/system.h>
#include <promeki/core/json.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class AudioDesc {
        PROMEKI_SHARED_FINAL(AudioDesc)
        public:
                using Ptr = SharedPtr<AudioDesc>;
 
                static const int32_t MinS24 = -8388608;
                static const int32_t MaxS24 = 8388607;
                static const int32_t MinU24 = 0;
                static const int32_t MaxU24 = 16777215;
 
                template <typename IntegerType, IntegerType Min, IntegerType Max>
                static float integerToFloat(IntegerType value) {
                        static_assert(std::is_integral<IntegerType>::value, "IntegerType must be an integer.");
                        constexpr float min = static_cast<float>(Min);
                        constexpr float max = static_cast<float>(Max);
                        return((static_cast<float>(value) - min) * 2.0f / (max - min)) - 1.0f;
                }
 
                template <typename IntegerType>
                static float integerToFloat(IntegerType value) {
                        static_assert(std::is_integral<IntegerType>::value, "IntegerType must be an integer.");
                        return integerToFloat<IntegerType,
                               std::numeric_limits<IntegerType>::min(),
                               std::numeric_limits<IntegerType>::max()>(value);
                }
 
                template <typename IntegerType, IntegerType Min, IntegerType Max>
                static IntegerType floatToInteger(float value) {
                        static_assert(std::is_integral<IntegerType>::value, "IntegerType must be an integer.");
                        const float min = static_cast<float>(Min);
                        const float max = static_cast<float>(Max);
                        if(value <= -1.0f) return Min;
                        else if(value >= 1.0f) return Max;
                        return static_cast<IntegerType>((value + 1.0f) * 0.5f * (max - min) + min);
                }
 
                template <typename IntegerType>
                static IntegerType floatToInteger(float value) {
                        static_assert(std::is_integral<IntegerType>::value, "IntegerType must be an integer.");
                        return floatToInteger<IntegerType,
                               std::numeric_limits<IntegerType>::min(),
                               std::numeric_limits<IntegerType>::max()>(value);
                }
 
                template <typename IntegerType, bool InputIsBigEndian>
                static void samplesToFloat(float *out, const uint8_t *inbuf, size_t samples) {
                        static_assert(std::is_integral<IntegerType>::value, "IntegerType must be an integer.");
                        const IntegerType *in = reinterpret_cast<const IntegerType *>(inbuf);
                        for(size_t i = 0; i < samples; ++i) {
                                IntegerType val = *in++;
                                if constexpr (InputIsBigEndian != System::isBigEndian()) System::swapEndian(val);
                                *out++ = integerToFloat<IntegerType>(val);
                        }
                        return;
                }
 
                template <typename IntegerType, bool OutputIsBigEndian>
                static void floatToSamples(uint8_t *outbuf, const float *in, size_t samples) {
                        static_assert(std::is_integral<IntegerType>::value, "IntegerType must be an integer.");
                        IntegerType *out = reinterpret_cast<IntegerType *>(outbuf);
                        for(size_t i = 0; i < samples; ++i) {
                                IntegerType val = floatToInteger<IntegerType>(*in++);
                                if constexpr (OutputIsBigEndian != System::isBigEndian()) System::swapEndian(val);
                                *out++ = val;
                        }
                        return;
                }
 
                struct Format {
                        int             id;             
                        String          name;           
                        String          desc;           
                        size_t          bytesPerSample; 
                        size_t          bitsPerSample;  
                        bool            isSigned;       
                        bool            isPlanar;       
                        bool            isBigEndian;    
                        void (*samplesToFloat)(float *out, const uint8_t *in, size_t samples); 
                        void (*floatToSamples)(uint8_t *out, const float *in, size_t samples); 
                };
 
                static const Format *lookupFormat(int id);
 
                enum DataType {
                        Invalid = 0,    
                        PCMI_Float32LE, 
                        PCMI_Float32BE, 
                        PCMI_S8,        
                        PCMI_U8,        
                        PCMI_S16LE,     
                        PCMI_U16LE,     
                        PCMI_S16BE,     
                        PCMI_U16BE,     
                        PCMI_S24LE,     
                        PCMI_U24LE,     
                        PCMI_S24BE,     
                        PCMI_U24BE,     
                        PCMI_S32LE,     
                        PCMI_U32LE,     
                        PCMI_S32BE,     
                        PCMI_U32BE      
                };
 
                static constexpr DataType NativeType = System::isLittleEndian() ? PCMI_Float32LE : PCMI_Float32BE;
 
                static DataType stringToDataType(const String &val);
 
                static AudioDesc fromJson(const JsonObject &json, Error *err = nullptr);
 
                AudioDesc() : _format(lookupFormat(Invalid)) { }
 
                AudioDesc(float sr, unsigned int ch) :
                        _dataType(NativeType), _sampleRate(sr),
                        _channels(ch), _format(lookupFormat(NativeType))
                {
                        if(!isValid()) {
                                _dataType = Invalid;
                                _sampleRate = 0.0f;
                                _channels = 0;
                                _format = lookupFormat(Invalid);
                        }
                }
 
                AudioDesc(DataType dt, float sr, unsigned int ch) :
                        _dataType(dt), _sampleRate(sr),
                        _channels(ch), _format(lookupFormat(dt))
                {
                        if(!isValid()) {
                                _dataType = Invalid;
                                _sampleRate = 0.0f;
                                _channels = 0;
                                _format = lookupFormat(Invalid);
                        }
                }
 
                bool formatEquals(const AudioDesc &other) const {
                        return _dataType == other._dataType &&
                               _sampleRate == other._sampleRate &&
                               _channels == other._channels;
                }
 
                bool operator==(const AudioDesc &other) const {
                        return formatEquals(other) &&
                               _metadata == other._metadata;
                }
 
                bool isValid() const {
                        return _dataType != 0 && _sampleRate > 0.0f && _channels > 0;
                }
 
                bool isNative() const {
                        return _dataType == NativeType;
                }
 
                AudioDesc workingDesc() const {
                        return AudioDesc(NativeType, _sampleRate, _channels);
                }
 
                String toString() const {
                        return String::sprintf("[%s %fHz %uc]",
                                _format->name.cstr(), _sampleRate, _channels);
                }
 
                JsonObject toJson() const {
                        JsonObject ret;
                        ret.set("DataType", _format->name);
                        ret.set("SampleRate", _sampleRate);
                        ret.set("Channels", _channels);
                        if(!_metadata.isEmpty()) ret.set("Metadata", _metadata.toJson());
                        return ret;
                }
 
                size_t bytesPerSample() const {
                        return _format->bytesPerSample;
                }
 
                size_t bytesPerSampleStride() const {
                        return _format->isPlanar ?
                                _format->bytesPerSample :
                                _format->bytesPerSample * _channels;
                }
 
                size_t channelBufferOffset(unsigned int chan, size_t bufferSamples) const {
                        return _format->isPlanar ?
                                _format->bytesPerSample * bufferSamples * chan :
                                _format->bytesPerSample * chan;
                }
 
                size_t bufferSize(size_t samples) const {
                        return _format->bytesPerSample * _channels * samples;
                }
 
                DataType dataType() const {
                        return (DataType)_dataType;
                }
 
                void setDataType(DataType val) {
                        _dataType = val;
                        return;
                }
 
                float sampleRate() const {
                        return _sampleRate;
                }
 
                void setSampleRate(float val) {
                        _sampleRate = val;
                        return;
                }
 
                unsigned int channels() const {
                        return _channels;
                }
 
                void setChannels(unsigned int val) {
                        _channels = val;
                        return;
                }
 
                const Metadata &metadata() const {
                        return _metadata;
                }
 
                Metadata &metadata() {
                        return _metadata;
                }
 
                void samplesToFloat(float *out, const uint8_t *in, size_t samples) const {
                        _format->samplesToFloat(out, in, samples * _channels);
                        return;
                }
 
                void floatToSamples(uint8_t *out, const float *in, size_t samples) const {
                        _format->floatToSamples(out, in, samples * _channels);
                        return;
                }
 
        private:
                int                     _dataType = 0;
                float                   _sampleRate = 0.0f;
                unsigned int            _channels = 0;
                Metadata                _metadata;
                const Format            *_format = nullptr;
};
 
PROMEKI_NAMESPACE_END