audiodecoder.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/uniqueptr.h>
#include <promeki/audiocodec.h>
#include <promeki/backendweight.h>
#include <promeki/pcmaudiopayload.h>
#include <promeki/compressedaudiopayload.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class MediaConfig;
class Frame;
 
class AudioDecoder {
        public:
                using UPtr = UniquePtr<AudioDecoder>;
 
                using Factory = Function<AudioDecoder *()>;
 
                struct BackendRecord {
                                AudioCodec::ID      codecId;
                                AudioCodec::Backend backend;
                                int                 weight = BackendWeight::Vendored;
                                List<int> supportedOutputs;
                                Factory   factory;
                };
 
                virtual ~AudioDecoder();
 
                AudioCodec 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; }
 
                // ---- Backend registry ----
 
                static Error registerBackend(BackendRecord record);
 
                // ---- Internal bridge from AudioCodec ----
 
                static AudioCodec::BackendList availableBackends(AudioCodec::ID codecId);
                static List<int>               supportedOutputsFor(AudioCodec::ID codecId, AudioCodec::Backend backend);
                static Result<AudioDecoder *>  create(AudioCodec::ID codecId, AudioCodec::Backend pinned,
                                                      const MediaConfig *config);
 
        protected:
                AudioDecoder() = default;
 
                void setCodec(AudioCodec 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();
 
        public:
                // ---- Frame-shaped helpers (public so nested pImpls in concrete backends can use them) ----
 
                static CompressedAudioPayload::Ptr selectInputPayload(const Frame &frame, int streamIndex = -1);
 
                static Frame buildOutputFrame(const Frame &source, PcmAudioPayload::Ptr emitted);
 
        private:
                UniquePtr<MediaConfig> _stashedConfig;
                AudioCodec             _codec;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV