imagefilemediaio.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <promeki/audiodesc.h>
#include <promeki/audiofile.h>
#include <promeki/dedicatedthreadmediaio.h>
#include <promeki/enum.h>
#include <promeki/filepath.h>
#include <promeki/framenumber.h>
#include <promeki/framerate.h>
#include <promeki/imagefile.h>
#include <promeki/mediaconfig.h>
#include <promeki/mediadesc.h>
#include <promeki/mediaiofactory.h>
#include <promeki/metadata.h>
#include <promeki/namespace.h>
#include <promeki/numname.h>
#include <promeki/pixelformat.h>
#include <promeki/size2d.h>
#include <promeki/string.h>
#include <promeki/stringlist.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class ImageFileIO;
 
class ImageFileMediaIO : public DedicatedThreadMediaIO {
                PROMEKI_OBJECT(ImageFileMediaIO, DedicatedThreadMediaIO)
        public:
                static inline const FrameRate DefaultFrameRate{FrameRate::FPS_30};
 
                static inline constexpr int DefaultSequenceHead = 1;
 
                ImageFileMediaIO(ObjectBase *parent = nullptr);
 
                ~ImageFileMediaIO() 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:
                // Maps the extension in @p filename to the preferred writer
                // PixelFormat for that format, taking the source's bit depth
                // into account so we don't drop precision unnecessarily
                // (e.g. 10-bit source -> 10-bit DPX, not 8-bit).
                PixelFormat preferredWriterPixelFormat(const String &filename, const PixelFormat &source) const;
 
                Error openSingle(MediaIOCommandOpen &cmd, MediaDesc &mediaDesc, const String &frSource, bool isWrite,
                                 bool &canSeek, FrameCount &frameCount);
                Error openSequence(MediaIOCommandOpen &cmd, MediaDesc &mediaDesc, const String &frSource, bool isWrite,
                                   bool &canSeek, FrameCount &frameCount);
                Error readSingle(MediaIOCommandRead &cmd);
                Error readSequence(MediaIOCommandRead &cmd);
                Error writeSingle(MediaIOCommandWrite &cmd);
                Error writeSequence(MediaIOCommandWrite &cmd);
 
                Error writeImgSeqSidecar();
 
                // Common state
                String      _filename;
                int         _imageFileID = ImageFile::Invalid;
                bool        _isOpen = false;
                bool        _isWrite = false;
                bool        _sequenceMode = false;
                Metadata    _writeContainerMetadata;
                MediaConfig _ioConfig;
                bool        _saveImgSeqEnabled = true;
                String      _saveImgSeqPath;
                Enum        _saveImgSeqPathMode;
                FrameRate   _writerFrameRate;
 
                // Single-file state
                Frame _frame;
                FrameCount _readCount{0};
                FrameCount _writeCount{0};
                bool       _loaded = false;
 
                // Sequence state
                NumName     _seqName;
                FilePath    _seqDir;
                FrameNumber _seqHead{0};
                FrameNumber _seqTail{0};
                FrameNumber _seqIndex{0};
                bool        _seqAtEnd = false;
                Metadata    _seqMetadata;
                Size2Du32   _seqSize;
                PixelFormat _seqPixelFormat;
 
                // Sidecar audio state (sequence mode only)
                AudioFile _sidecarAudio;
                AudioDesc _sidecarAudioDesc;
                String    _sidecarAudioPath;
                FrameRate _sidecarFrameRate;
                int64_t   _sidecarSampleRate = 0;
                bool      _sidecarAudioOpen = false;
                bool      _sidecarAudioEnabled = true;
                String    _sidecarAudioName;
};
 
class ImageFileFactory : public MediaIOFactory {
        public:
                ImageFileFactory(String name, String displayName, String description, StringList extensions,
                                 bool canBeSource, bool canBeSink);
 
                static ImageFileFactory *buildFactoryFor(const ImageFileIO *io);
 
                String     name() const override { return _name; }
                String     displayName() const override { return _displayName; }
                String     description() const override { return _description; }
                StringList extensions() const override { return _extensions; }
 
                bool canBeSource() const override { return _canBeSource; }
                bool canBeSink() const override { return _canBeSink; }
 
                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;
 
        private:
                String     _name;
                String     _displayName;
                String     _description;
                StringList _extensions;
                bool       _canBeSource;
                bool       _canBeSink;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV