mediaiodescription.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/framecount.h>
#include <promeki/framerate.h>
#include <promeki/json.h>
#include <promeki/list.h>
#include <promeki/mediadesc.h>
#include <promeki/metadata.h>
#include <promeki/sharedptr.h>
#include <promeki/string.h>
#include <promeki/stringlist.h>
 
PROMEKI_NAMESPACE_BEGIN
 
struct MediaIOPortDescription {
                enum Role {
                        Source = 0, 
                        Sink        
                };
 
                using List = ::promeki::List<MediaIOPortDescription>;
 
                String name;
 
                int index = -1;
 
                Role role = Source;
 
                int portGroupIndex = -1;
 
                MediaDesc::List producibleFormats;
 
                MediaDesc::List acceptableFormats;
 
                MediaDesc preferredFormat;
};
 
struct MediaIOPortGroupDescription {
                using List = ::promeki::List<MediaIOPortGroupDescription>;
 
                String name;
 
                FrameRate frameRate;
 
                FrameCount frameCount;
 
                bool canSeek = false;
 
                String clockDescription;
};
 
class MediaIODescription {
                PROMEKI_SHARED_FINAL(MediaIODescription)
        public:
                using Ptr = SharedPtr<MediaIODescription>;
 
                using List = ::promeki::List<MediaIODescription>;
 
                using PtrList = ::promeki::List<Ptr>;
 
                static constexpr FrameCount FrameCountUnknown = FrameCount::unknown();
 
                static constexpr FrameCount FrameCountInfinite = FrameCount::infinity();
 
                MediaIODescription() = default;
 
                // ------------------------------------------------------------
                // Backend identity
                // ------------------------------------------------------------
 
                const String &backendName() const { return _backendName; }
 
                void setBackendName(const String &val) { _backendName = val; }
 
                const String &backendDescription() const { return _backendDescription; }
 
                void setBackendDescription(const String &val) { _backendDescription = val; }
 
                // ------------------------------------------------------------
                // Instance identity
                // ------------------------------------------------------------
 
                const String &name() const { return _name; }
 
                void setName(const String &val) { _name = val; }
 
                // ------------------------------------------------------------
                // Role flags
                // ------------------------------------------------------------
 
                bool canBeSource() const { return _canBeSource; }
 
                void setCanBeSource(bool val) { _canBeSource = val; }
 
                bool canBeSink() const { return _canBeSink; }
 
                void setCanBeSink(bool val) { _canBeSink = val; }
 
                bool canBeTransform() const { return _canBeTransform; }
 
                void setCanBeTransform(bool val) { _canBeTransform = val; }
 
                // ------------------------------------------------------------
                // Format landscape
                // ------------------------------------------------------------
 
                const MediaDesc::List &producibleFormats() const { return _producibleFormats; }
 
                MediaDesc::List &producibleFormats() { return _producibleFormats; }
 
                void setProducibleFormats(const MediaDesc::List &val) { _producibleFormats = val; }
 
                const MediaDesc::List &acceptableFormats() const { return _acceptableFormats; }
 
                MediaDesc::List &acceptableFormats() { return _acceptableFormats; }
 
                void setAcceptableFormats(const MediaDesc::List &val) { _acceptableFormats = val; }
 
                const MediaDesc &preferredFormat() const { return _preferredFormat; }
 
                void setPreferredFormat(const MediaDesc &val) { _preferredFormat = val; }
 
                // ------------------------------------------------------------
                // Capabilities
                // ------------------------------------------------------------
 
                bool canSeek() const { return _canSeek; }
 
                void setCanSeek(bool val) { _canSeek = val; }
 
                const FrameCount &frameCount() const { return _frameCount; }
 
                void setFrameCount(const FrameCount &val) { _frameCount = val; }
 
                const FrameRate &frameRate() const { return _frameRate; }
 
                void setFrameRate(const FrameRate &val) { _frameRate = val; }
 
                const Metadata &containerMetadata() const { return _containerMetadata; }
 
                Metadata &containerMetadata() { return _containerMetadata; }
 
                void setContainerMetadata(const Metadata &val) { _containerMetadata = val; }
 
                // ------------------------------------------------------------
                // Diagnostics
                // ------------------------------------------------------------
 
                Error probeStatus() const { return _probeStatus; }
 
                void setProbeStatus(Error val) { _probeStatus = val; }
 
                const String &probeMessage() const { return _probeMessage; }
 
                void setProbeMessage(const String &val) { _probeMessage = val; }
 
                // ------------------------------------------------------------
                // Per-port snapshots (multi-port refactor, Phase 6)
                // ------------------------------------------------------------
 
                const MediaIOPortDescription::List &sources() const { return _sources; }
 
                MediaIOPortDescription::List &sources() { return _sources; }
 
                void setSources(const MediaIOPortDescription::List &val) { _sources = val; }
 
                const MediaIOPortDescription::List &sinks() const { return _sinks; }
 
                MediaIOPortDescription::List &sinks() { return _sinks; }
 
                void setSinks(const MediaIOPortDescription::List &val) { _sinks = val; }
 
                const MediaIOPortGroupDescription::List &portGroups() const { return _portGroups; }
 
                MediaIOPortGroupDescription::List &portGroups() { return _portGroups; }
 
                void setPortGroups(const MediaIOPortGroupDescription::List &val) { _portGroups = val; }
 
                // ------------------------------------------------------------
                // Convenience
                // ------------------------------------------------------------
 
                StringList summary() const;
 
                JsonObject toJson() const;
 
                static MediaIODescription fromJson(const JsonObject &obj, Error *err = nullptr);
 
                bool operator==(const MediaIODescription &other) const;
                bool operator!=(const MediaIODescription &other) const { return !(*this == other); }
 
        private:
                String _backendName;
                String _backendDescription;
 
                String _name;
 
                bool _canBeSource = false;
                bool _canBeSink = false;
                bool _canBeTransform = false;
 
                MediaDesc::List _producibleFormats;
                MediaDesc::List _acceptableFormats;
                MediaDesc       _preferredFormat;
 
                bool       _canSeek = false;
                FrameCount _frameCount;
                FrameRate  _frameRate;
                Metadata   _containerMetadata;
 
                Error  _probeStatus = Error::Ok;
                String _probeMessage;
 
                MediaIOPortDescription::List      _sources;
                MediaIOPortDescription::List      _sinks;
                MediaIOPortGroupDescription::List _portGroups;
};
 
DataStream &operator<<(DataStream &stream, const MediaIODescription &d);
 
DataStream &operator>>(DataStream &stream, MediaIODescription &d);
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV