quicktimemediaio.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <promeki/ancdesc.h>
#include <promeki/audiobuffer.h>
#include <promeki/audiodesc.h>
#include <promeki/dedicatedthreadmediaio.h>
#include <promeki/enums_mediaio.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);
 
                // Rewrites @p desc's audio descriptors to the compressed
                // AudioFormat named by MediaConfig::QuickTimeAudioCodec when it
                // selects a real codec, so the planner splices an AudioEncoder.
                // PCM / Invalid leaves the audio untouched.
                void rewriteAudioForCodec(MediaDesc &desc) const;
 
                // Rewrites @p desc's (uncompressed) image descriptors to the
                // compressed PixelFormat of MediaConfig::QuickTimeVideoCodec when
                // it selects a real codec, so the planner splices a VideoEncoder
                // (the codec is recovered via VideoCodec::fromPixelFormat).
                // Invalid / already-compressed video is left untouched.
                void rewriteVideoForCodec(MediaDesc &desc) const;
 
                // Resolves the scan mode to write into the video track's fiel
                // box: MediaConfig::VideoScanMode when it names a concrete mode,
                // else the source ImageDesc's @p descScanMode, else Unknown
                // (progressive).
                VideoScanMode resolveWriteScanMode(const VideoScanMode &descScanMode) const;
 
                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;
                int         _ancTrackIndex = -1;
                int         _captionTrackIndex = -1;
                QuickTimeCaptionReadPolicy _captionReadPolicy{QuickTimeCaptionReadPolicy::Auto};
                FrameNumber _currentFrame{0};
                FrameCount  _frameCount{0};
                FrameRate   _frameRate;
                Timecode    _anchorTimecode;
                uint64_t    _audioSampleCursor = 0;
                // PCM samples produced by one compressed audio access unit
                // (e.g. 1024 for AAC-LC).  Zero for PCM tracks.  Used to pace
                // compressed-audio reads against the video timeline so the
                // decoded PCM keeps up with the frame rate.
                uint64_t    _audioCompressedFrameSamples = 0;
                AudioDesc   _audioDesc;
                AncDesc     _ancDesc;
 
                bool        _writerTracksRegistered = false;
                uint32_t    _writerVideoTrackId = 0;
                uint32_t    _writerAudioTrackId = 0;
                uint32_t    _writerAncTrackId = 0;
                uint32_t    _writerCaptionTrackId = 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