mediaiocommand.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <cassert>
#include <functional>
#include <promeki/function.h>
#include <promeki/namespace.h>
#include <promeki/error.h>
#include <promeki/list.h>
#include <promeki/sharedptr.h>
#include <promeki/string.h>
#include <promeki/atomic.h>
#include <promeki/mutex.h>
#include <promeki/waitcondition.h>
#include <promeki/frame.h>
#include <promeki/framecount.h>
#include <promeki/framenumber.h>
#include <promeki/framerate.h>
#include <promeki/mediadesc.h>
#include <promeki/audiodesc.h>
#include <promeki/metadata.h>
#include <promeki/mediaconfig.h>
#include <promeki/mediaiostats.h>
#include <promeki/mediaiotypes.h>
#include <promeki/clock.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class EventLoop;
class MediaIOPortGroup;
class MediaIOSink;
 
// ============================================================================
// Command hierarchy — all I/O operations are submitted as commands to the
// MediaIO submit() virtual.  Each command carries inputs (set by the public
// API method that builds it) and outputs (set by the backend's
// executeCmd()), so all data flow is lock-free.
// ============================================================================
 
#define PROMEKI_MEDIAIO_COMMAND(NAME, KIND_TAG)                                                                        \
public:                                                                                                                \
        Kind kind() const override {                                                                                   \
                return KIND_TAG;                                                                                       \
        }                                                                                                              \
        NAME *_promeki_clone() const {                                                                                 \
                assert(false && #NAME " should not be cloned");                                                        \
                return nullptr;                                                                                        \
        }
 
class MediaIOCommand {
        public:
                enum Kind {
                        Open,     
                        Close,    
                        Read,     
                        Write,    
                        Seek,     
                        Params,   
                        Stats,    
                        SetClock  
                };
 
                using Ptr = SharedPtr<MediaIOCommand, false>;
 
                RefCount _promeki_refct;
 
                MediaIOCommand *_promeki_clone() const {
                        assert(false && "MediaIOCommand should never be cloned");
                        return nullptr;
                }
 
                MediaIOCommand() = default;
 
                virtual ~MediaIOCommand() = default;
 
                virtual Kind kind() const = 0;
 
                static const char *kindName(Kind k) {
                        switch (k) {
                                case Open:     return "Open";
                                case Close:    return "Close";
                                case Read:     return "Read";
                                case Write:    return "Write";
                                case Seek:     return "Seek";
                                case Params:   return "Params";
                                case Stats:    return "Stats";
                                case SetClock: return "SetClock";
                        }
                        return "Unknown";
                }
 
                const char *kindName() const { return kindName(kind()); }
 
                // ---- Cancellation ----
 
                Atomic<bool> cancelled{false};
 
                // ---- Strategy hints ----
 
                bool urgent = false;
 
                // ---- Output (filled by the framework after dispatch) ----
 
                Error result = Error::Ok;
 
                MediaIOStats stats;
 
                // ---- Completion synchronization ----
                //
                // Every command carries its own completion latch + a
                // wait condition for blocking waiters and a one-shot
                // continuation callback for asynchronous consumers.
                // @ref MediaIORequest is a thin facade over these
                // primitives — it adds no completion state of its own
                // beyond a shared pointer to this command.
 
                void markCompleted();
 
                Error waitForCompletion(unsigned int timeoutMs = 0) const;
 
                bool isCompleted() const { return _completed.value(); }
 
                void setCompletionCallback(Function<void(Error)> cb, EventLoop *loop);
 
        private:
                Atomic<bool>          _completed{false};
                mutable Mutex         _completionMutex;
                mutable WaitCondition _completionCv;
                Mutex                       _callbackMutex;
                Function<void(Error)>  _callback;
                EventLoop                  *_callbackLoop = nullptr;
};
 
class MediaIOCommandOpen : public MediaIOCommand {
                PROMEKI_MEDIAIO_COMMAND(MediaIOCommandOpen, Open)
        public:
                // ---- Inputs ----
 
                MediaConfig config;
                MediaDesc   pendingMediaDesc;
                Metadata    pendingMetadata;
                AudioDesc   pendingAudioDesc;
                List<int>   videoTracks;
                List<int>   audioTracks;
 
                // ---- Outputs ----
 
                MediaDesc       mediaDesc;
                AudioDesc       audioDesc;
                Metadata        metadata;
                FrameRate       frameRate;
                bool            canSeek = false;
                FrameCount      frameCount = FrameCount::unknown();
                int             defaultStep = 1;
                int             defaultPrefetchDepth = 1;
                int             defaultWriteDepth = 4;
                MediaIOSeekMode defaultSeekMode = MediaIO_SeekExact;
};
 
class MediaIOCommandClose : public MediaIOCommand {
                PROMEKI_MEDIAIO_COMMAND(MediaIOCommandClose, Close)
};
 
class MediaIOCommandRead : public MediaIOCommand {
                PROMEKI_MEDIAIO_COMMAND(MediaIOCommandRead, Read)
        public:
                // ---- Inputs ----
                MediaIOPortGroup *group = nullptr;
                double            rate = 1.0;
 
                // ---- Outputs ----
 
                Frame  frame;
                FrameNumber currentFrame;
 
                // ---- Optional outputs (mid-stream descriptor change) ----
                bool mediaDescChanged = false;
                MediaDesc updatedMediaDesc;
};
 
class MediaIOCommandWrite : public MediaIOCommand {
                PROMEKI_MEDIAIO_COMMAND(MediaIOCommandWrite, Write)
        public:
                // ---- Inputs ----
                MediaIOPortGroup *group = nullptr;
 
                MediaIOSink      *sink = nullptr;
                Frame        frame;
 
                // ---- Outputs ----
 
                FrameNumber currentFrame;
                FrameCount  frameCount;
};
 
class MediaIOCommandSeek : public MediaIOCommand {
                PROMEKI_MEDIAIO_COMMAND(MediaIOCommandSeek, Seek)
        public:
                // ---- Inputs ----
                MediaIOPortGroup *group = nullptr;
                FrameNumber       frameNumber;
                MediaIOSeekMode   mode = MediaIO_SeekDefault;
 
                // ---- Output ----
 
                FrameNumber currentFrame;
};
 
class MediaIOCommandParams : public MediaIOCommand {
                PROMEKI_MEDIAIO_COMMAND(MediaIOCommandParams, Params)
        public:
                // ---- Inputs ----
                String        name;   
                MediaIOParams params; 
 
                // ---- Output ----
                MediaIOParams output; 
};
 
class MediaIOCommandStats : public MediaIOCommand {
                PROMEKI_MEDIAIO_COMMAND(MediaIOCommandStats, Stats)
};
 
class MediaIOCommandSetClock : public MediaIOCommand {
                PROMEKI_MEDIAIO_COMMAND(MediaIOCommandSetClock, SetClock)
        public:
                // ---- Inputs ----
                MediaIOPortGroup *group = nullptr;
 
                Clock::Ptr        clock;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV