videocodec.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/framerate.h>
#include <promeki/enums.h>
#include <promeki/result.h>
#include <promeki/error.h>
#include <promeki/datatype.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class DataStream;
 
class PixelFormat;
class VideoEncoder;
class VideoDecoder;
class MediaConfig;
 
using VideoCodecBackendRegistry = StringRegistry<"VideoCodecBackend">;
 
class VideoCodec {
        public:
                PROMEKI_DATATYPE(VideoCodec, DataTypeVideoCodec, 1)
 
                
                Error writeToStream(DataStream &s) const;
                template <uint32_t V> static Result<VideoCodec> readFromStream(DataStream &s);
 
                enum ID {
                        Invalid = 0,          
                        H264 = 1,             
                        HEVC = 2,             
                        AV1 = 3,              
                        VP9 = 4,              
                        JPEG = 5,             
                        JPEG_XS = 6,          
                        ProRes_422_Proxy = 7, 
                        ProRes_422_LT = 8,    
                        ProRes_422 = 9,       
                        ProRes_422_HQ = 10,   
                        ProRes_4444 = 11,     
                        ProRes_4444_XQ = 12,  
                        UserDefined = 1024    
                };
 
                using IDList = ::promeki::List<ID>;
 
                enum CodingType {
                        CodingInvalid = 0, 
                        CodingIntraOnly =
                                1, 
                        CodingTemporal = 2 
                };
 
                enum RandomAccessGranularity {
                        AccessInvalid = 0, 
                        AccessFrame = 1,   
                        AccessGOP = 2      
                };
 
                class Backend {
                        public:
                                constexpr Backend() : _id(VideoCodecBackendRegistry::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 VideoCodecBackendRegistry::instance().name(_id); }
 
                                constexpr bool isValid() const { return _id != VideoCodecBackendRegistry::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; 
                                List<int>               compressedPixelFormats;
                                CodingType              codingType = CodingInvalid; 
                                RandomAccessGranularity randomAccessGranularity = AccessInvalid; 
                                bool supportsBFrames = false; 
                                bool supportsLossless =
                                        false; 
                                bool supportsAlpha =
                                        false; 
                                bool supportsVariableFrameSize =
                                        false; 
                                bool supportsHDRMetadata =
                                        false; 
                                bool supportsInterlaced = false; 
                                List<int> supportedBitDepths;
                                List<RateControlMode> rateControlModes;
                                List<FrameRate> supportedFrameRates;
                                int             maxWidth = 0;  
                                int             maxHeight = 0; 
                                int             maxChannels =
                                        0; 
                };
 
                static ID registerType();
 
                static void registerData(Data &&data);
 
                static IDList registeredIDs();
 
                static Result<VideoCodec> lookup(const String &name);
 
                static VideoCodec fromPixelFormat(const PixelFormat &pd);
 
                static Result<VideoCodec> fromString(const String &spec);
 
                static Result<Backend> registerBackend(const String &name);
 
                static Result<Backend> lookupBackend(const String &name);
 
                static BackendList registeredBackends();
 
                inline VideoCodec(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; }
 
                List<PixelFormat> compressedPixelFormats() const;
 
                CodingType codingType() const { return d->codingType; }
 
                bool isIntraOnly() const { return d->codingType == CodingIntraOnly; }
 
                RandomAccessGranularity randomAccessGranularity() const { return d->randomAccessGranularity; }
 
                bool supportsBFrames() const { return d->supportsBFrames; }
 
                bool supportsLossless() const { return d->supportsLossless; }
 
                bool supportsAlpha() const { return d->supportsAlpha; }
 
                bool supportsVariableFrameSize() const { return d->supportsVariableFrameSize; }
 
                bool supportsHDRMetadata() const { return d->supportsHDRMetadata; }
 
                bool supportsInterlaced() const { return d->supportsInterlaced; }
 
                const List<int> &supportedBitDepths() const { return d->supportedBitDepths; }
 
                const List<RateControlMode> &rateControlModes() const { return d->rateControlModes; }
 
                const List<FrameRate> &supportedFrameRates() const { return d->supportedFrameRates; }
 
                int maxWidth() const { return d->maxWidth; }
 
                int maxHeight() const { return d->maxHeight; }
 
                Backend backend() const { return _backend; }
 
                BackendList availableEncoderBackends() const;
 
                BackendList availableDecoderBackends() const;
 
                bool canEncode() const;
 
                bool canDecode() const;
 
                List<PixelFormat> encoderSupportedInputs() const;
 
                List<PixelFormat> decoderSupportedOutputs() const;
 
                Result<VideoEncoder *> createEncoder(const MediaConfig *config = nullptr) const;
 
                Result<VideoDecoder *> createDecoder(const MediaConfig *config = nullptr) const;
 
                String toString() const;
 
                bool operator==(const VideoCodec &o) const { return d == o.d && _backend == o._backend; }
 
                bool operator!=(const VideoCodec &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 VideoCodec::VideoCodec(ID id, Backend backend) : d(lookupData(id)), _backend(backend) {}
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV