videodecoder.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <functional>
#include <promeki/function.h>
#include <promeki/namespace.h>
#include <promeki/string.h>
#include <promeki/error.h>
#include <promeki/list.h>
#include <promeki/result.h>
#include <promeki/videocodec.h>
#include <promeki/backendweight.h>
#include <promeki/compressedvideopayload.h>
#include <promeki/uncompressedvideopayload.h>
#include <promeki/ancpacket.h>
#include <promeki/mediaioallocator.h>
#include <promeki/uniqueptr.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class MediaConfig;
class Frame;
 
class VideoDecoder {
        public:
                using UPtr = UniquePtr<VideoDecoder>;
 
                using Factory = Function<VideoDecoder *()>;
 
                struct BackendRecord {
                                VideoCodec::ID      codecId; 
                                VideoCodec::Backend backend; 
                                int                 weight = BackendWeight::Vendored; 
                                List<int> supportedOutputs;
                                Factory   factory; 
                };
 
                virtual ~VideoDecoder();
 
                VideoCodec codec() const { return _codec; }
 
                void configure(const MediaConfig &config);
 
                virtual Error submitFrame(const Frame &frame) = 0;
 
                virtual Frame receiveFrame() = 0;
 
                virtual Error flush() = 0;
 
                virtual Error reset() = 0;
 
                Error lastError() const { return _lastError; }
 
                const String &lastErrorMessage() const { return _lastErrorMessage; }
 
                MediaIOAllocator::Ptr allocator() const;
 
                virtual void setAllocator(MediaIOAllocator::Ptr a);
 
                // ---- Backend registry ----
 
                static Error registerBackend(BackendRecord record);
 
                // ---- Internal bridge from VideoCodec (see VideoEncoder's equivalents) ----
 
                static VideoCodec::BackendList availableBackends(VideoCodec::ID codecId);
                static List<int>               supportedOutputsFor(VideoCodec::ID codecId, VideoCodec::Backend backend);
                static Result<VideoDecoder *>  create(VideoCodec::ID codecId, VideoCodec::Backend pinned,
                                                      const MediaConfig *config);
 
        protected:
                VideoDecoder() = default;
 
                void setCodec(VideoCodec codec) { _codec = codec; }
 
                virtual void onConfigure(const MediaConfig &config);
 
                const MediaConfig &config() const;
 
                Error  _lastError;
                String _lastErrorMessage;
 
                void setError(Error err, const String &msg = String());
 
                void clearError();
 
                MediaIOAllocator::Ptr _allocator;
 
        public:
                // ---- Frame-shaped helpers (public so nested pImpls in concrete backends can use them) ----
 
                static CompressedVideoPayload::Ptr selectInputPayload(const Frame &frame, int streamIndex = -1);
 
                static void attachExtractedAnc(Frame &frame, AncPacket pkt, int pairedVideoStreamIndex);
 
                static Frame buildOutputFrame(const Frame &source, UncompressedVideoPayload::Ptr emitted);
 
        private:
                UniquePtr<MediaConfig> _stashedConfig;
                VideoCodec             _codec;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV