audiodesc.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <promeki/namespace.h>
#include <promeki/sharedptr.h>
#include <promeki/audioformat.h>
#include <promeki/audiochannelmap.h>
#include <promeki/metadata.h>
#include <promeki/string.h>
#include <promeki/json.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class SdpMediaDescription;
 
class AudioDesc {
                PROMEKI_SHARED_FINAL(AudioDesc)
        public:
                using Ptr = SharedPtr<AudioDesc>;
 
                using List = ::promeki::List<AudioDesc>;
 
                using PtrList = ::promeki::List<Ptr>;
 
                static AudioDesc fromJson(const JsonObject &json, Error *err = nullptr);
 
                static AudioDesc fromSdp(const SdpMediaDescription &md);
 
                AudioDesc() = default;
 
                AudioDesc(float sr, unsigned int ch)
                    : _format(AudioFormat::NativeFloat), _sampleRate(sr), _channels(ch),
                      _channelMap(AudioChannelMap::defaultForChannels(ch)) {
                        if (!validParams()) reset();
                }
 
                AudioDesc(const AudioFormat &fmt, float sr, unsigned int ch)
                    : _format(fmt), _sampleRate(sr), _channels(ch),
                      _channelMap(AudioChannelMap::defaultForChannels(ch)) {
                        if (!validParams()) reset();
                }
 
                AudioDesc(const AudioFormat &fmt, float sr, AudioChannelMap map)
                    : _format(fmt), _sampleRate(sr), _channels(static_cast<unsigned int>(map.channels())),
                      _channelMap(std::move(map)) {
                        if (!validParams()) reset();
                }
 
                SdpMediaDescription toSdp(uint8_t payloadType) const;
 
                bool formatEquals(const AudioDesc &other) const {
                        return _format == other._format && _sampleRate == other._sampleRate &&
                               _channels == other._channels && _channelMap == other._channelMap;
                }
 
                bool operator==(const AudioDesc &other) const {
                        return formatEquals(other) && _metadata == other._metadata;
                }
 
                bool isValid() const { return _format.isValid() && _sampleRate > 0.0f && _channels > 0; }
 
                bool isCompressed() const { return _format.isCompressed(); }
 
                bool isNative() const { return _format.id() == AudioFormat::NativeFloat; }
 
                AudioDesc workingDesc() const {
                        return AudioDesc(AudioFormat(AudioFormat::NativeFloat), _sampleRate, _channels);
                }
 
                String toString() const {
                        return String::sprintf("[%s %fHz %uc]", _format.name().cstr(), _sampleRate, _channels);
                }
 
                JsonObject toJson() const {
                        JsonObject ret;
                        ret.set("Format", _format.name());
                        ret.set("SampleRate", _sampleRate);
                        ret.set("Channels", _channels);
                        // Only emit the channel map when it differs from the default
                        // mapping for this channel count — keeps simple descriptors clean.
                        if (_channelMap != AudioChannelMap::defaultForChannels(_channels)) {
                                ret.set("ChannelMap", _channelMap.toString());
                        }
                        if (!_metadata.isEmpty()) ret.set("Metadata", _metadata.toJson());
                        return ret;
                }
 
                const AudioFormat &format() const { return _format; }
 
                void setFormat(const AudioFormat &val) { _format = val; }
 
                float sampleRate() const { return _sampleRate; }
 
                void setSampleRate(float val) { _sampleRate = val; }
 
                unsigned int channels() const { return _channels; }
 
                void setChannels(unsigned int val) {
                        _channels = val;
                        _channelMap = AudioChannelMap::defaultForChannels(val);
                }
 
                const AudioChannelMap &channelMap() const { return _channelMap; }
 
                void setChannelMap(const AudioChannelMap &map) {
                        if (map.channels() == _channels) _channelMap = map;
                }
 
                const Metadata &metadata() const { return _metadata; }
 
                Metadata &metadata() { return _metadata; }
 
                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; }
 
                void samplesToFloat(float *out, const uint8_t *in, size_t samples) const {
                        _format.samplesToFloat(out, in, samples * _channels);
                }
 
                void floatToSamples(uint8_t *out, const float *in, size_t samples) const {
                        _format.floatToSamples(out, in, samples * _channels);
                }
 
        private:
                AudioFormat     _format;
                float           _sampleRate = 0.0f;
                unsigned int    _channels = 0;
                AudioChannelMap _channelMap;
                Metadata        _metadata;
 
                bool validParams() const { return _format.isValid() && _sampleRate > 0.0f && _channels > 0; }
 
                void reset() {
                        _format = AudioFormat();
                        _sampleRate = 0.0f;
                        _channels = 0;
                        _channelMap = AudioChannelMap();
                }
};
 
inline DataStream &operator<<(DataStream &stream, const AudioDesc &desc) {
        stream.beginFrame(DataTypeAudioDesc, 1);
        stream << desc.format();
        stream << desc.sampleRate();
        stream << static_cast<uint32_t>(desc.channels());
        stream << desc.channelMap();
        stream << desc.metadata();
        stream.endFrame();
        return stream;
}
 
inline DataStream &operator>>(DataStream &stream, AudioDesc &desc) {
        if (!stream.readFrame(DataTypeAudioDesc)) {
                desc = AudioDesc();
                return stream;
        }
        AudioFormat     fmt;
        float           sr = 0.0f;
        uint32_t        ch = 0;
        AudioChannelMap map;
        Metadata        meta;
        stream >> fmt >> sr >> ch >> map >> meta;
        if (stream.status() != DataStream::Ok) {
                desc = AudioDesc();
                return stream;
        }
        desc = AudioDesc(fmt, sr, ch);
        // Restore the explicit channel map if it parsed validly; otherwise keep
        // the default that the (fmt, sr, ch) constructor installs.
        if (map.channels() == ch) desc.setChannelMap(map);
        desc.metadata() = std::move(meta);
        return stream;
}
 
PROMEKI_NAMESPACE_END
 
PROMEKI_FORMAT_VIA_TOSTRING(promeki::AudioDesc);
 
#endif // PROMEKI_ENABLE_PROAV