quicktime.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <cstdint>
#include <promeki/namespace.h>
#include <promeki/sharedptr.h>
#include <promeki/string.h>
#include <promeki/error.h>
#include <promeki/result.h>
#include <promeki/list.h>
#include <promeki/buffer.h>
#include <promeki/fourcc.h>
#include <promeki/framerate.h>
#include <promeki/size2d.h>
#include <promeki/pixelformat.h>
#include <promeki/audiodesc.h>
#include <promeki/mediadesc.h>
#include <promeki/metadata.h>
#include <promeki/timecode.h>
#include <promeki/iodevice.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class QuickTime {
        public:
                using Ptr = SharedPtr<QuickTime>;
 
                enum Operation {
                        InvalidOperation = 0, 
                        Reader,               
                        Writer                
                };
 
                enum TrackType {
                        InvalidTrack = 0,
                        Video,
                        Audio,
                        TimecodeTrack,
                        Subtitle,
                        Data
                };
 
                enum Layout {
                        LayoutClassic = 0,
                        LayoutFragmented = 1
                };
 
                class Track {
                        public:
                                Track() = default;
 
                                bool isValid() const { return _type != InvalidTrack; }
 
                                TrackType type() const { return _type; }
                                uint32_t id() const { return _id; }
                                uint32_t timescale() const { return _timescale; }
                                uint64_t duration() const { return _duration; }
                                const FrameRate &frameRate() const { return _frameRate; }
                                uint64_t sampleCount() const { return _sampleCount; }
                                const String &language() const { return _language; }
                                const String &name() const { return _name; }
                                const PixelFormat &pixelFormat() const { return _pixelFormat; }
                                const Size2Du32 &size() const { return _size; }
                                const AudioDesc &audioDesc() const { return _audioDesc; }
                                const Metadata &metadata() const { return _metadata; }
                                int64_t editStartOffset() const { return _editStartOffset; }
                                const Buffer &codecConfig() const { return _codecConfig; }
                                FourCC codecConfigType() const { return _codecConfigType; }
 
                                void setType(TrackType t) { _type = t; }
                                void setId(uint32_t id) { _id = id; }
                                void setTimescale(uint32_t ts) { _timescale = ts; }
                                void setDuration(uint64_t d) { _duration = d; }
                                void setFrameRate(const FrameRate &r) { _frameRate = r; }
                                void setSampleCount(uint64_t n) { _sampleCount = n; }
                                void setLanguage(const String &s) { _language = s; }
                                void setName(const String &s) { _name = s; }
                                void setPixelFormat(const PixelFormat &pd) { _pixelFormat = pd; }
                                void setSize(const Size2Du32 &s) { _size = s; }
                                void setAudioDesc(const AudioDesc &ad) { _audioDesc = ad; }
                                Metadata &metadata() { return _metadata; }
                                void setEditStartOffset(int64_t v) { _editStartOffset = v; }
                                void setCodecConfig(const Buffer &b) { _codecConfig = b; }
                                void setCodecConfigType(FourCC t) { _codecConfigType = t; }
 
                        private:
                                TrackType   _type = InvalidTrack;
                                uint32_t    _id = 0;
                                uint32_t    _timescale = 0;
                                uint64_t    _duration = 0;
                                FrameRate   _frameRate;
                                uint64_t    _sampleCount = 0;
                                String      _language;
                                String      _name;
                                PixelFormat _pixelFormat;
                                Size2Du32   _size;
                                AudioDesc   _audioDesc;
                                Metadata    _metadata;
                                int64_t     _editStartOffset = 0;
                                Buffer _codecConfig;
                                FourCC      _codecConfigType{'\0', '\0', '\0', '\0'};
                };
 
                using TrackList = ::promeki::List<Track>;
 
                struct Sample {
                                uint32_t    trackId = 0;      
                                uint64_t    index = 0;        
                                int64_t     dts = 0;          
                                int64_t     pts = 0;          
                                uint64_t    duration = 0;     
                                bool        keyframe = false; 
                                Buffer data;             
                };
 
                class Impl {
                                PROMEKI_SHARED_BASE(Impl)
                        public:
                                explicit Impl(Operation op) : _operation(op) {}
 
                                virtual ~Impl();
 
                                Operation operation() const { return _operation; }
 
                                const String &filename() const { return _filename; }
 
                                void setFilename(const String &fn) { _filename = fn; }
 
                                IODevice *device() const { return _device; }
 
                                void setDevice(IODevice *dev, bool takeOwnership = false) {
                                        _device = dev;
                                        _ownsDevice = takeOwnership;
                                }
 
                                virtual Error open();
 
                                virtual void close();
 
                                virtual bool isOpen() const;
 
                                virtual Error readSample(size_t trackIndex, uint64_t sampleIndex, Sample &out);
 
                                virtual Error readSampleRange(size_t trackIndex, uint64_t startSampleIndex,
                                                              uint64_t count, Sample &out);
 
                                virtual Error addVideoTrack(const PixelFormat &codec, const Size2Du32 &size,
                                                            const FrameRate &frameRate, uint32_t *outTrackId);
 
                                virtual Error addAudioTrack(const AudioDesc &desc, uint32_t *outTrackId);
 
                                virtual Error addTimecodeTrack(const Timecode  &startTimecode,
                                                               const FrameRate &frameRate, uint32_t *outTrackId);
 
                                virtual Error writeSample(uint32_t trackId, const Sample &sample);
 
                                virtual void setContainerMetadata(const Metadata &meta);
 
                                Layout layout() const { return _layout; }
 
                                virtual Error setLayout(Layout layout);
 
                                bool flushSync() const { return _flushSync; }
 
                                void setFlushSync(bool enable) { _flushSync = enable; }
 
                                virtual Error flush();
 
                                virtual Error finalize();
 
                                const TrackList &tracks() const { return _tracks; }
 
                                const MediaDesc &mediaDesc() const { return _mediaDesc; }
 
                                const Metadata &containerMetadata() const { return _containerMetadata; }
 
                                const Timecode &startTimecode() const { return _startTimecode; }
 
                        protected:
                                Operation _operation;
                                Layout    _layout = LayoutClassic;
                                bool      _flushSync = false;
                                String    _filename;
                                IODevice *_device = nullptr;
                                bool      _ownsDevice = false;
                                TrackList _tracks;
                                MediaDesc _mediaDesc;
                                Metadata  _containerMetadata;
                                Timecode  _startTimecode;
                };
 
                static QuickTime createReader(const String &filename);
 
                static QuickTime createWriter(const String &filename);
 
                static Result<QuickTime> createForOperation(Operation op, IODevice *device);
 
                QuickTime() : d(SharedPtr<Impl>::create(InvalidOperation)) {}
 
                explicit QuickTime(Impl *impl) : d(SharedPtr<Impl>::takeOwnership(impl)) {}
 
                bool isValid() const { return d->operation() != InvalidOperation; }
 
                Operation operation() const { return d->operation(); }
 
                const String &filename() const { return d->filename(); }
 
                void setFilename(const String &fn) { d.modify()->setFilename(fn); }
 
                IODevice *device() const { return d->device(); }
 
                Error open() { return d.modify()->open(); }
 
                void close() { d.modify()->close(); }
 
                bool isOpen() const { return d->isOpen(); }
 
                Error readSample(size_t trackIndex, uint64_t sampleIndex, Sample &out) {
                        return d.modify()->readSample(trackIndex, sampleIndex, out);
                }
 
                Error readSampleRange(size_t trackIndex, uint64_t startSampleIndex, uint64_t count, Sample &out) {
                        return d.modify()->readSampleRange(trackIndex, startSampleIndex, count, out);
                }
 
                Error addVideoTrack(const PixelFormat &codec, const Size2Du32 &size, const FrameRate &frameRate,
                                    uint32_t *outTrackId = nullptr) {
                        return d.modify()->addVideoTrack(codec, size, frameRate, outTrackId);
                }
 
                Error addAudioTrack(const AudioDesc &desc, uint32_t *outTrackId = nullptr) {
                        return d.modify()->addAudioTrack(desc, outTrackId);
                }
 
                Error addTimecodeTrack(const Timecode &startTimecode, const FrameRate &frameRate,
                                       uint32_t *outTrackId = nullptr) {
                        return d.modify()->addTimecodeTrack(startTimecode, frameRate, outTrackId);
                }
 
                Error writeSample(uint32_t trackId, const Sample &sample) {
                        return d.modify()->writeSample(trackId, sample);
                }
 
                void setContainerMetadata(const Metadata &meta) { d.modify()->setContainerMetadata(meta); }
 
                Layout layout() const { return d->layout(); }
 
                Error setLayout(Layout layout) { return d.modify()->setLayout(layout); }
 
                bool flushSync() const { return d->flushSync(); }
 
                void setFlushSync(bool enable) { d.modify()->setFlushSync(enable); }
 
                Error flush() { return d.modify()->flush(); }
 
                Error finalize() { return d.modify()->finalize(); }
 
                const TrackList &tracks() const { return d->tracks(); }
 
                const MediaDesc &mediaDesc() const { return d->mediaDesc(); }
 
                const Metadata &containerMetadata() const { return d->containerMetadata(); }
 
                const Timecode &startTimecode() const { return d->startTimecode(); }
 
        private:
                SharedPtr<Impl> d;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV