quicktimemediaio.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <promeki/audiobuffer.h>
#include <promeki/audiodesc.h>
#include <promeki/dedicatedthreadmediaio.h>
#include <promeki/framecount.h>
#include <promeki/framenumber.h>
#include <promeki/framerate.h>
#include <promeki/mediaiofactory.h>
#include <promeki/mediapayload.h>
#include <promeki/namespace.h>
#include <promeki/quicktime.h>
#include <promeki/string.h>
#include <promeki/timecode.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class QuickTimeMediaIO : public DedicatedThreadMediaIO {
                PROMEKI_OBJECT(QuickTimeMediaIO, DedicatedThreadMediaIO)
        public:
                static inline constexpr int DefaultFragmentFrames = 30;
 
                QuickTimeMediaIO(ObjectBase *parent = nullptr);
 
                ~QuickTimeMediaIO() 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:
                // True when @p pd is a PixelFormat this writer knows how
                // to serialise into a valid QuickTime sample entry plus
                // mdat payload.  See proposeInput() for the supported
                // set and the rationale for each omission.
                static bool isSupportedPixelFormat(const PixelFormat &pd);
 
                // Picks the closest writer-supported PixelFormat for an
                // offered shape, preserving bit depth, chroma
                // subsampling, and YUV / RGB family where possible so
                // the planner-inserted CSC stays cheap.
                static PixelFormat pickSupportedPixelFormat(const PixelFormat &offered);
 
                Error readVideoFrame(const FrameNumber &frameIndex, Frame &outFrame);
                Error readAudioSlice(uint64_t startSample, size_t samples, MediaPayload::Ptr &out);
                Error setupWriterFromFrame(const Frame &frame);
                Error drainWriterAudio(bool flush);
 
                QuickTime   _qt;
                bool        _isOpen = false;
                bool        _isWrite = false;
                String      _filename;
                int         _videoTrackIndex = -1;
                int         _audioTrackIndex = -1;
                FrameNumber _currentFrame{0};
                FrameCount  _frameCount{0};
                FrameRate   _frameRate;
                Timecode    _anchorTimecode;
                uint64_t    _audioSampleCursor = 0;
                AudioDesc   _audioDesc;
 
                bool        _writerTracksRegistered = false;
                uint32_t    _writerVideoTrackId = 0;
                uint32_t    _writerAudioTrackId = 0;
                uint32_t    _writerTimecodeTrackId = 0;
                FrameCount  _writerFrameCount{0};
                int         _writerFragmentFrames = DefaultFragmentFrames;
                FrameCount  _writerFramesSinceFlush{0};
                AudioBuffer _writerAudioFifo;
                AudioDesc   _writerAudioStorage;
};
 
class QuickTimeFactory : public MediaIOFactory {
        public:
                QuickTimeFactory() = default;
 
                String name() const override { return String("QuickTime"); }
                String displayName() const override { return String("QuickTime / MOV"); }
                String description() const override {
                        return String("QuickTime / ISO-BMFF container files (.mov, .mp4, .m4v)");
                }
                StringList extensions() const override {
                        return {String("mov"), String("qt"), String("mp4"), String("m4v")};
                }
 
                bool canBeSource() const override { return true; }
                bool canBeSink() const override { return true; }
 
                bool            canHandleDevice(IODevice *device) const override;
                Config::SpecMap configSpecs() const override;
                Metadata        defaultMetadata() const override;
 
                MediaIO *create(const Config &config, ObjectBase *parent = nullptr) const override;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV