mediapipelineconfig.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <promeki/namespace.h>
#include <promeki/datastream.h>
#include <promeki/error.h>
#include <promeki/filepath.h>
#include <promeki/framecount.h>
#include <promeki/json.h>
#include <promeki/list.h>
#include <promeki/mediaconfig.h>
#include <promeki/mediaio.h>
#include <promeki/metadata.h>
#include <promeki/sharedptr.h>
#include <promeki/string.h>
#include <promeki/stringlist.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class MediaPipelineConfig {
                PROMEKI_SHARED_FINAL(MediaPipelineConfig)
        public:
                using Ptr = SharedPtr<MediaPipelineConfig>;
 
                using List = ::promeki::List<MediaPipelineConfig>;
 
                using PtrList = ::promeki::List<Ptr>;
 
                enum class StageRole {
                        NotOpen = 0, 
                        Source,      
                        Sink,        
                        Transform    
                };
 
                enum class Kind {
                        Playback = 0, 
                        Capture       
                };
 
                struct Stage {
                                String name;
                                String type;
                                String path;
                                StageRole role = StageRole::NotOpen;
                                MediaConfig config;
                                Metadata metadata;
 
                                bool pacesPipeline = false;
 
                                bool captureSink = false;
 
                                bool operator==(const Stage &other) const;
                                bool operator!=(const Stage &other) const { return !(*this == other); }
                };
 
                struct Route {
                                String from;
                                String to;
                                String fromTrack;
                                String toTrack;
 
                                bool operator==(const Route &other) const {
                                        return from == other.from && to == other.to && fromTrack == other.fromTrack &&
                                               toTrack == other.toTrack;
                                }
                                bool operator!=(const Route &other) const { return !(*this == other); }
                };
 
                using StageList = ::promeki::List<Stage>;
 
                using RouteList = ::promeki::List<Route>;
 
                MediaPipelineConfig() = default;
 
                // ------------------------------------------------------------
                // Stages
                // ------------------------------------------------------------
 
                const StageList &stages() const { return _stages; }
 
                StageList &stages() { return _stages; }
 
                void addStage(const Stage &s) { _stages.pushToBack(s); }
 
                void addStage(Stage &&s) { _stages.pushToBack(std::move(s)); }
 
                const Stage *findStage(const String &name) const;
 
                bool hasStage(const String &name) const { return findStage(name) != nullptr; }
 
                StringList stageNames() const;
 
                // ------------------------------------------------------------
                // Routes
                // ------------------------------------------------------------
 
                const RouteList &routes() const { return _routes; }
 
                RouteList &routes() { return _routes; }
 
                void addRoute(const Route &r) { _routes.pushToBack(r); }
 
                void addRoute(const String &from, const String &to);
 
                // ------------------------------------------------------------
                // Pipeline kind / transport defaults
                // ------------------------------------------------------------
 
                Kind kind() const { return _kind; }
 
                void setKind(Kind k) { _kind = k; }
 
                bool startPaused() const { return _startPaused; }
 
                void setStartPaused(bool v) { _startPaused = v; }
 
                // ------------------------------------------------------------
                // Pipeline-wide metadata
                // ------------------------------------------------------------
 
                const Metadata &pipelineMetadata() const { return _pipelineMetadata; }
 
                Metadata &pipelineMetadata() { return _pipelineMetadata; }
 
                void setPipelineMetadata(const Metadata &m) { _pipelineMetadata = m; }
 
                // ------------------------------------------------------------
                // Frame-count limit
                // ------------------------------------------------------------
 
                const FrameCount &frameCount() const { return _frameCount; }
 
                void setFrameCount(const FrameCount &count) { _frameCount = count; }
 
                // ------------------------------------------------------------
                // Stats window
                // ------------------------------------------------------------
 
                int statsWindowSize() const { return _statsWindowSize; }
 
                void setStatsWindowSize(int n) { _statsWindowSize = n < 0 ? 0 : n; }
 
                // ------------------------------------------------------------
                // Operations
                // ------------------------------------------------------------
 
                bool isResolved(String *diagnostic = nullptr) const;
 
                MediaPipelineConfig resolved(Error *err = nullptr, String *diagnostic = nullptr) const;
 
                Error validate() const;
 
                StringList describe() const;
 
                JsonObject toJson() const;
 
                static MediaPipelineConfig fromJson(const JsonObject &obj, Error *err = nullptr);
 
                Error saveToFile(const FilePath &path, unsigned int indent = 2) const;
 
                static MediaPipelineConfig loadFromFile(const FilePath &path, Error *err = nullptr);
 
                bool operator==(const MediaPipelineConfig &other) const;
                bool operator!=(const MediaPipelineConfig &other) const { return !(*this == other); }
 
                static String roleName(StageRole role);
 
                static StageRole roleFromName(const String &name, Error *err = nullptr);
 
                static String kindName(Kind kind);
 
                static Kind kindFromName(const String &name, Error *err = nullptr);
 
        private:
                StageList  _stages;
                RouteList  _routes;
                Metadata   _pipelineMetadata;
                FrameCount _frameCount;
                int        _statsWindowSize = 256;
                Kind       _kind = Kind::Playback;
                bool       _startPaused = false;
};
 
// ============================================================================
// DataStream serialization
// ============================================================================
//
// Stage and Route are simple value types; their operators are declared
// here and defined in mediapipelineconfig.cpp alongside the rest of the
// serialization code.
 
DataStream &operator<<(DataStream &stream, const MediaPipelineConfig::Stage &s);
 
DataStream &operator>>(DataStream &stream, MediaPipelineConfig::Stage &s);
 
DataStream &operator<<(DataStream &stream, const MediaPipelineConfig::Route &r);
 
DataStream &operator>>(DataStream &stream, MediaPipelineConfig::Route &r);
 
DataStream &operator<<(DataStream &stream, const MediaPipelineConfig &c);
 
DataStream &operator>>(DataStream &stream, MediaPipelineConfig &c);
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV