videoencoder.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/ancformat.h>
#include <promeki/ancpacket.h>
#include <promeki/uniqueptr.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class MediaConfig;
class Frame;
 
class VideoEncoder {
        public:
                using UPtr = UniquePtr<VideoEncoder>;
 
                using Factory = Function<VideoEncoder *()>;
 
                struct BackendRecord {
                                VideoCodec::ID codecId; 
                                VideoCodec::Backend
                                        backend; 
                                int     weight = BackendWeight::
                                        Vendored; 
                                List<int> supportedInputs;
                                Factory   factory; 
                };
 
                virtual ~VideoEncoder();
 
                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;
 
                virtual void requestKeyframe();
 
                Error lastError() const { return _lastError; }
 
                const String &lastErrorMessage() const { return _lastErrorMessage; }
 
                // ---- Frame-shaped helpers (public so nested pImpls in concrete backends can use them) ----
 
                static UncompressedVideoPayload::Ptr selectInputPayload(const Frame &frame, int streamIndex = -1);
 
                static AncPacket::List selectAncForSei(const Frame &frame, int pairedVideoStreamIndex,
                                                      const AncFormat::IDList &allowedFormats);
 
                static Frame buildOutputFrame(const Frame &source, CompressedVideoPayload::Ptr emitted);
 
                // ---- Backend registry ----
 
                static Error registerBackend(BackendRecord record);
 
                // ---- Internal bridge from VideoCodec ----
                //
                // These are the lookup surfaces VideoCodec::canEncode /
                // createEncoder / encoderSupportedInputs / availableEncoderBackends
                // call into.  Public only so the VideoCodec wrapper (which
                // lives in a different TU) can reach them without a friend
                // declaration; application code should not use them directly.
 
                static VideoCodec::BackendList availableBackends(VideoCodec::ID codecId);
 
                static List<int> supportedInputsFor(VideoCodec::ID codecId, VideoCodec::Backend backend);
 
                static Result<VideoEncoder *> create(VideoCodec::ID codecId, VideoCodec::Backend pinned,
                                                     const MediaConfig *config);
 
        protected:
                VideoEncoder() = 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();
 
        private:
                UniquePtr<MediaConfig> _stashedConfig;
                VideoCodec             _codec;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV