ffmpegmediaio.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV && PROMEKI_ENABLE_FFMPEG
#include <promeki/audiodesc.h>
#include <promeki/dedicatedthreadmediaio.h>
#include <promeki/deque.h>
#include <promeki/framecount.h>
#include <promeki/framenumber.h>
#include <promeki/framerate.h>
#include <promeki/mediaiofactory.h>
#include <promeki/namespace.h>
#include <promeki/string.h>
 
// Forward-declare the libav* types we hold by pointer so this promeki
// header never pulls in the libavformat / libavcodec headers — they live
// only in the .cpp.
struct AVFormatContext;
struct AVBSFContext;
struct AVStream;
struct AVPacket;
 
PROMEKI_NAMESPACE_BEGIN
 
class FfmpegMediaIO : public DedicatedThreadMediaIO {
                PROMEKI_OBJECT(FfmpegMediaIO, DedicatedThreadMediaIO)
        public:
                FfmpegMediaIO(ObjectBase *parent = nullptr);
 
                ~FfmpegMediaIO() override;
 
                Error proposeInput(const MediaDesc &offered, MediaDesc *preferred) const override;
 
        protected:
                Error executeCmd(MediaIOCommandOpen &cmd) override;
                Error executeCmd(MediaIOCommandClose &cmd) override;
                Error executeCmd(MediaIOCommandRead &cmd) override;
                Error executeCmd(MediaIOCommandWrite &cmd) override;
                Error executeCmd(MediaIOCommandSeek &cmd) override;
 
        private:
                Error openReader(const MediaIOCommandOpen &cmd, MediaIOCommandOpen &out);
                Error openWriter(const MediaIOCommandOpen &cmd, MediaIOCommandOpen &out);
                Error setupWriterFromFrame(const Frame &frame);
                void  closeContexts();
 
                // Rewrites @p desc's image / audio descriptors to the compressed
                // formats named by MediaConfig::FfmpegVideoCodec /
                // FfmpegAudioCodec, so the planner splices encoders.  Invalid /
                // already-compressed streams are left untouched.
                void rewriteVideoForCodec(MediaDesc &desc) const;
                void rewriteAudioForCodec(MediaDesc &desc) const;
 
                // ---- Shared state ----
                bool   _isOpen = false;
                bool   _isWrite = false;
                String _filename;
 
                // ---- Reader state ----
                AVFormatContext *_inFmt = nullptr;
                AVBSFContext    *_bsf = nullptr; // h264/hevc mp4toannexb, or null
                int              _videoStream = -1;
                int              _audioStream = -1;
                FrameRate        _frameRate;
                FrameCount       _frameCount{FrameCount::unknown()};
                FrameNumber      _currentFrame{0};
                AudioDesc        _audioDesc;
                bool             _eof = false;
 
                // ---- Writer state ----
                AVFormatContext *_outFmt = nullptr;
                AVStream        *_outVideo = nullptr;
                AVStream        *_outAudio = nullptr;
                bool             _headerWritten = false;
                bool             _writerTracksRegistered = false;
                int64_t          _writerVideoPts = 0;
                int64_t          _writerAudioPts = 0;
};
 
class FfmpegFactory : public MediaIOFactory {
        public:
                FfmpegFactory() = default;
 
                String name() const override { return String("FFmpeg"); }
                String displayName() const override { return String("FFmpeg (libavformat)"); }
                String description() const override {
                        return String("Generic FFmpeg container backend (Matroska/WebM, AVI, FLV, …)");
                }
 
                // The fallback extension list deliberately covers only
                // containers no native backend claims; .mov / .mp4 / .wav
                // etc. are intentionally absent so the native backends win
                // the auto-dispatch.  (isFallback() makes the order moot,
                // but keeping the list narrow keeps probe behaviour clear.)
                StringList extensions() const override {
                        return {String("mkv"),  String("webm"), String("avi"), String("flv"),
                                String("wmv"),  String("asf"),  String("ogv"), String("ogg"),
                                String("mpg"),  String("mpeg"), String("vob"), String("3gp"),
                                String("rm"),   String("rmvb"), String("nut"), String("mxf")};
                }
 
                bool canBeSource() const override { return true; }
                bool canBeSink() const override { return true; }
                bool isFallback() const override { return true; }
 
                bool            canHandleDevice(IODevice *device) const override;
                Config::SpecMap configSpecs() const override;
 
                MediaIO *create(const Config &config, ObjectBase *parent = nullptr) const override;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV && PROMEKI_ENABLE_FFMPEG