audiocodec.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/stringregistry.h>
#include <promeki/list.h>
#include <promeki/fourcc.h>
#include <promeki/enums_codec.h>
#include <promeki/result.h>
#include <promeki/error.h>
#include <promeki/datatype.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class AudioEncoder;
class AudioDecoder;
class AudioFormat;
class MediaConfig;
class DataStream;
 
using AudioCodecBackendRegistry = StringRegistry<"AudioCodecBackend">;
 
class AudioCodec {
        public:
                PROMEKI_DATATYPE(AudioCodec, DataTypeAudioCodec, 1)
 
                
                Error writeToStream(DataStream &s) const;
                template <uint32_t V> static Result<AudioCodec> readFromStream(DataStream &s);
 
                enum ID {
                        Invalid = 0,       
                        AAC = 1,           
                        Opus = 2,          
                        FLAC = 3,          
                        MP3 = 4,           
                        AC3 = 5,           
                        PCM = 6,
                        UserDefined = 1024 
                };
 
                using IDList = ::promeki::List<ID>;
 
                enum CompressionType {
                        CompressionInvalid = 0,  
                        CompressionLossless = 1, 
                        CompressionLossy = 2     
                };
 
                enum PacketIndependence {
                        PacketIndependenceInvalid = 0, 
                        PacketIndependenceEvery = 1,   
                        PacketIndependenceKeyframe =
                                2, 
                        PacketIndependenceInter =
                                3 
                };
 
                class Backend {
                        public:
                                constexpr Backend() : _id(AudioCodecBackendRegistry::InvalidID) {}
 
                                static constexpr Backend fromId(uint64_t id) {
                                        Backend b;
                                        b._id = id;
                                        return b;
                                }
 
                                constexpr uint64_t id() const { return _id; }
 
                                String name() const { return AudioCodecBackendRegistry::instance().name(_id); }
 
                                constexpr bool isValid() const { return _id != AudioCodecBackendRegistry::InvalidID; }
 
                                constexpr bool operator==(const Backend &o) const { return _id == o._id; }
                                constexpr bool operator!=(const Backend &o) const { return _id != o._id; }
                                constexpr bool operator<(const Backend &o) const { return _id < o._id; }
 
                        private:
                                uint64_t _id;
                };
 
                using BackendList = ::promeki::List<Backend>;
 
                struct Data {
                                ID              id = Invalid; 
                                String          name; 
                                String          desc; 
                                FourCC::List    fourccList;                           
                                CompressionType compressionType = CompressionInvalid; 
                                List<RateControlMode> rateControlModes;
                                PacketIndependence    packetIndependence =
                                        PacketIndependenceInvalid; 
                                bool isStreamable =
                                        false; 
                                bool supportsDRC =
                                        false; 
                                bool hasBuiltInSilence =
                                        false; 
                                List<int> supportedSampleFormats;
                                List<float> supportedSampleRates;
                                List<int> supportedChannelCounts;
                                int       maxChannels = 0; 
                                List<int> frameSizeSamples;
                };
 
                static ID registerType();
 
                static void registerData(Data &&data);
 
                static IDList registeredIDs();
 
                static Result<AudioCodec> lookup(const String &name);
 
                static Result<AudioCodec> fromString(const String &spec);
 
                static Result<Backend> registerBackend(const String &name);
 
                static Result<Backend> lookupBackend(const String &name);
 
                static BackendList registeredBackends();
 
                inline AudioCodec(ID id = Invalid, Backend backend = Backend());
 
                bool isValid() const { return d != nullptr && d->id != Invalid; }
 
                ID id() const { return d->id; }
 
                const String &name() const { return d->name; }
 
                const String &description() const { return d->desc; }
 
                const FourCC::List &fourccList() const { return d->fourccList; }
 
                CompressionType compressionType() const { return d->compressionType; }
 
                bool isLossless() const { return d->compressionType == CompressionLossless; }
 
                const List<RateControlMode> &rateControlModes() const { return d->rateControlModes; }
 
                PacketIndependence packetIndependence() const { return d->packetIndependence; }
 
                bool isStreamable() const { return d->isStreamable; }
 
                bool supportsDRC() const { return d->supportsDRC; }
 
                bool hasBuiltInSilence() const { return d->hasBuiltInSilence; }
 
                List<AudioFormat> supportedSampleFormats() const;
 
                const List<float> &supportedSampleRates() const { return d->supportedSampleRates; }
 
                const List<int> &supportedChannelCounts() const { return d->supportedChannelCounts; }
 
                int maxChannels() const { return d->maxChannels; }
 
                const List<int> &frameSizeSamples() const { return d->frameSizeSamples; }
 
                Backend backend() const { return _backend; }
 
                BackendList availableEncoderBackends() const;
 
                BackendList availableDecoderBackends() const;
 
                bool canEncode() const;
 
                bool canDecode() const;
 
                List<AudioFormat> encoderSupportedInputs() const;
 
                List<AudioFormat> decoderSupportedOutputs() const;
 
                Result<AudioEncoder *> createEncoder(const MediaConfig *config = nullptr) const;
 
                Result<AudioDecoder *> createDecoder(const MediaConfig *config = nullptr) const;
 
                String toString() const;
 
                bool operator==(const AudioCodec &o) const { return d == o.d && _backend == o._backend; }
 
                bool operator!=(const AudioCodec &o) const { return !(*this == o); }
 
                const Data *data() const { return d; }
 
        private:
                const Data        *d = nullptr;
                Backend            _backend;
                static const Data *lookupData(ID id);
};
 
inline AudioCodec::AudioCodec(ID id, Backend backend) : d(lookupData(id)), _backend(backend) {}
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV