mediaio.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <promeki/namespace.h>
#include <promeki/objectbase.h>
#include <promeki/atomic.h>
#include <promeki/string.h>
#include <promeki/error.h>
#include <promeki/list.h>
#include <promeki/uniqueptr.h>
#include <promeki/frame.h>
#include <promeki/mediadesc.h>
#include <promeki/audiodesc.h>
#include <promeki/metadata.h>
#include <promeki/framerate.h>
#include <promeki/framecount.h>
#include <promeki/mediaconfig.h>
#include <promeki/url.h>
#include <promeki/mediatimestamp.h>
#include <promeki/mediaiotypes.h>
#include <promeki/mediaiocommand.h>
#include <promeki/mediaioallocator.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class IODevice;
class Clock;
class MediaIODescription;
class MediaIOFactory;
class MediaIOPort;
class MediaIOSink;
class MediaIOSource;
class MediaIOPortGroup;
 
// MediaIORequest is forward-declared so MediaIO can return it from public
// methods without pulling in the full mediaiorequest.h here.  Callers that
// consume the returned request (.wait(), .then()) include mediaiorequest.h
// themselves.
class MediaIORequest;
 
// ============================================================================
// MediaIO controller class
// ============================================================================
 
class MediaIO : public ObjectBase {
                PROMEKI_OBJECT(MediaIO, ObjectBase)
        public:
                using UPtr = UniquePtr<MediaIO>;
 
                using SeekMode = MediaIOSeekMode;
 
                static constexpr SeekMode SeekDefault = MediaIO_SeekDefault;
                static constexpr SeekMode SeekExact = MediaIO_SeekExact;
                static constexpr SeekMode SeekNearestKeyframe = MediaIO_SeekNearestKeyframe;
                static constexpr SeekMode SeekKeyframeBefore = MediaIO_SeekKeyframeBefore;
                static constexpr SeekMode SeekKeyframeAfter = MediaIO_SeekKeyframeAfter;
 
                using Config = MediaConfig;
 
                using ConfigID = MediaConfigID;
 
                static constexpr FrameCount FrameCountUnknown = FrameCount::unknown();
 
                static constexpr FrameCount FrameCountInfinite = FrameCount::infinity();
 
 
                static MediaIO *create(const Config &config, ObjectBase *parent = nullptr);
 
                static MediaIO *createForFileRead(const String &filename, ObjectBase *parent = nullptr);
 
                static MediaIO *createForFileWrite(const String &filename, ObjectBase *parent = nullptr);
 
                static MediaIO *createFromUrl(const Url &url, ObjectBase *parent = nullptr);
 
                static MediaIO *createFromUrl(const String &url, ObjectBase *parent = nullptr);
 
                static Error applyQueryToConfig(const Url &url, const Config::SpecMap &specs, Config *outConfig);
 
                static MediaDesc applyOutputOverrides(const MediaDesc &input, const MediaConfig &config);
 
                static PixelFormat defaultUncompressedPixelFormat(const PixelFormat &source);
 
                MediaIO(ObjectBase *parent = nullptr);
 
                ~MediaIO() override;
 
                const Config &config() const { return _config; }
 
                // ---- Ports (multi-port surface) ----
 
                MediaIOSource *source(int N) const;
 
                int sourceCount() const;
 
                MediaIOSink *sink(int N) const;
 
                int sinkCount() const;
 
                MediaIOPortGroup *portGroup(int N) const;
 
                int portGroupCount() const;
 
                bool isSource() const { return sourceCount() > 0; }
 
                bool isSink() const { return sinkCount() > 0; }
 
                // ---- Per-instance identifier ----
 
                String name() const { return _config.getAs<String>(MediaConfig::Name, String()); }
 
                void setName(const String &val) { _config.set(MediaConfig::Name, val); }
 
                bool isOpen() const { return _open.value(); }
 
                SeekMode defaultSeekMode() const { return _defaultSeekMode; }
 
                Error setPendingMediaDesc(const MediaDesc &desc);
 
                const MediaDesc &pendingMediaDesc() const { return _pendingMediaDesc; }
 
                Error setPendingAudioDesc(const AudioDesc &desc);
 
                const AudioDesc &pendingAudioDesc() const { return _pendingAudioDesc; }
 
                Error setPendingMetadata(const Metadata &meta);
 
                const Metadata &pendingMetadata() const { return _pendingMetadata; }
 
                Error setVideoTracks(const List<int> &tracks);
 
                Error setAudioTracks(const List<int> &tracks);
 
                MediaIORequest open();
 
                MediaIORequest close();
 
                bool isClosing() const { return _closing.value(); }
 
                // ---- Cached descriptor accessors ----
 
                const MediaDesc &mediaDesc() const { return _mediaDesc; }
 
                const FrameRate &frameRate() const { return _frameRate; }
 
                const AudioDesc &audioDesc() const { return _audioDesc; }
 
                const Metadata &metadata() const { return _metadata; }
 
                // ---- Introspection / negotiation ----
 
                virtual Error describe(MediaIODescription *out) const;
 
                virtual Error proposeInput(const MediaDesc &offered, MediaDesc *preferred) const;
 
                virtual Error proposeOutput(const MediaDesc &requested, MediaDesc *achievable,
                                            MediaConfig *configDelta = nullptr) const;
 
                virtual bool isIdle() const { return true; }
 
                virtual void cancelBlockingWork() {}
 
                virtual void cancelPendingWork() {}
 
                virtual int pendingInternalWrites() const { return 0; }
 
                virtual void setIngestPaused(bool paused) { (void)paused; }
 
                void setConfig(const Config &config) { _config = config; }
 
                MediaIORequest sendParams(const MediaIOParams &block);
 
                MediaIORequest stats();
 
                MediaIOAllocator::Ptr allocator() const;
 
                void setAllocator(MediaIOAllocator::Ptr a);
 
                PROMEKI_SIGNAL(errorOccurred, Error);
 
                PROMEKI_SIGNAL(descriptorChanged);
 
                PROMEKI_SIGNAL(closed, Error);
 
                PROMEKI_SIGNAL(commandCompleted, MediaIOCommand::Ptr);
 
        protected:
                virtual void submit(MediaIOCommand::Ptr cmd) = 0;
 
                void completeCommand(MediaIOCommand::Ptr cmd);
 
                // ---- Port containers (populated by subclass executeCmd
                //      hooks via @ref CommandMediaIO::addPortGroup etc.) ----
                //
                // Lives on @ref MediaIO so cached-state queries
                // (@ref source, @ref sink, @ref portGroup) are part of
                // the abstract interface, but mutated only by the
                // command-handling subclasses through friend access.
 
                List<MediaIOSource *>    _sources;
                List<MediaIOSink *>      _sinks;
                List<MediaIOPortGroup *> _portGroups;
 
        private:
                friend class CommandMediaIO;
                friend class MediaIOPort;
                friend class MediaIOSink;
                friend class MediaIOSource;
                friend class MediaIOPortGroup;
                friend class MediaIOReadCache;
 
                void resetClosedState();
 
                static int64_t frameByteSize(const Frame &frame);
 
                void populateStandardStats(MediaIOStats &stats) const;
 
                Config                 _config;
                // Allocator policy for buffers vended on behalf of
                // this MediaIO.  Default-initialised lazily through
                // allocator() to MediaIOAllocator::defaultAllocator(),
                // so a freshly-constructed MediaIO that never installs
                // an override transparently routes through the
                // process-wide default.
                MediaIOAllocator::Ptr   _allocator;
                // _open / _closing are read from arbitrary threads
                // (e.g. the EventLoop thread in
                // @ref MediaIOReadCache::submitOneLocked) while the
                // worker strand writes them through
                // @ref completeCommand and @ref resetClosedState.
                // Atomic loads / stores keep those reads safe without
                // forcing isOpen() / isClosing() through the strand.
                Atomic<bool>           _open;
                Atomic<bool>           _closing;
 
 
                // Container-level cached state, written from
                // @ref completeCommand on whatever thread the strategy
                // chose, read by the user thread.  Per-port cached state
                // (current frame, step, frame count, canSeek) lives on
                // @ref MediaIOPortGroup; per-port format shapes live on
                // @ref MediaIOSource / @ref MediaIOSink.
                MediaDesc   _mediaDesc;
                AudioDesc   _audioDesc;
                Metadata    _metadata;
                FrameRate   _frameRate;
                TimeStamp   _originTime;
                SeekMode    _defaultSeekMode = SeekExact;
 
                // Pre-open settings.  Backends consume these on the open
                // command (cmd.pendingMediaDesc / pendingAudioDesc /
                // pendingMetadata) so the planner / pipeline can hand
                // upstream shape to a sink or transform before its ports
                // exist.
                MediaDesc _pendingMediaDesc;
                AudioDesc _pendingAudioDesc;
                Metadata  _pendingMetadata;
                List<int> _pendingVideoTracks;
                List<int> _pendingAudioTracks;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV