mediapayload.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <cstdint>
#include <optional>
#include <promeki/optional.h>
#include <promeki/namespace.h>
#include <promeki/sharedptr.h>
#include <promeki/buffer.h>
#include <promeki/bufferview.h>
#include <promeki/mediatimestamp.h>
#include <promeki/duration.h>
#include <promeki/metadata.h>
#include <promeki/string.h>
#include <promeki/list.h>
#include <promeki/enums.h>
#include <promeki/variant.h>
#include <promeki/error.h>
 
#include <promeki/fourcc.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class DataStream;
class VariantSpec;
 
class MediaPayload {
        public:
                RefCount              _promeki_refct;
                virtual MediaPayload *_promeki_clone() const = 0;
 
                using Ptr = SharedPtr<MediaPayload, /*CopyOnWrite=*/true, MediaPayload>;
 
                using PtrList = ::promeki::List<Ptr>;
 
                enum Flag : uint64_t {
                        None = 0, 
                        Keyframe =
                                1ull
                                << 0, 
                        Discardable = 1ull
                                      << 1, 
                        Corrupt =
                                1ull
                                << 2, 
                        EndOfStream = 1ull << 3, 
                        IntraRefresh =
                                1ull
                                << 4, 
                };
 
                MediaPayload() = default;
 
                explicit MediaPayload(const BufferView &data) : _data(data) {}
 
                MediaPayload(const MediaPayload &) = default;
                MediaPayload(MediaPayload &&) = default;
                MediaPayload &operator=(const MediaPayload &) = default;
                MediaPayload &operator=(MediaPayload &&) = default;
 
                virtual ~MediaPayload() = default;
 
                virtual const MediaPayloadKind &kind() const = 0;
 
                virtual bool isCompressed() const = 0;
 
                virtual bool isValid() const {
                        if (_data.isEmpty()) return false;
                        for (auto v : _data) {
                                if (v.isValid()) return true;
                        }
                        return false;
                }
 
                // ---- Plane data -------------------------------------------
 
                const BufferView &data() const { return _data; }
 
                BufferView &data() { return _data; }
 
                void setData(const BufferView &d) { _data = d; }
 
                size_t planeCount() const { return _data.count(); }
 
                BufferView::Entry plane(size_t index) const { return _data[index]; }
 
                size_t size() const { return _data.totalSize(); }
 
                // ---- Stream index -----------------------------------------
 
                int streamIndex() const { return _streamIndex; }
 
                void setStreamIndex(int idx) { _streamIndex = idx; }
 
                // ---- Timing -----------------------------------------------
 
                const MediaTimeStamp &pts() const { return _pts; }
 
                void setPts(const MediaTimeStamp &ts) { _pts = ts; }
 
                const MediaTimeStamp &dts() const { return _dts; }
 
                void setDts(const MediaTimeStamp &ts) { _dts = ts; }
 
                virtual Duration duration() const { return Duration(); }
 
                virtual Error setDuration(const Duration &val) {
                        (void)val;
                        return Error::NotSupported;
                }
 
                virtual bool hasDuration() const { return false; }
 
                // ---- Flags ------------------------------------------------
 
                uint64_t flags() const { return _flags; }
 
                void setFlags(uint64_t f) { _flags = f; }
 
                void addFlag(Flag f) { _flags |= static_cast<uint64_t>(f); }
 
                void removeFlag(Flag f) { _flags &= ~static_cast<uint64_t>(f); }
 
                void setFlag(Flag f, bool on) {
                        if (on)
                                addFlag(f);
                        else
                                removeFlag(f);
                }
 
                bool hasFlag(Flag f) const { return (_flags & static_cast<uint64_t>(f)) != 0; }
 
                static const char *flagName(Flag f);
 
                virtual bool isKeyframe() const { return hasFlag(Keyframe); }
 
                virtual bool isSafeCutPoint() const { return isKeyframe(); }
 
                bool isDiscardable() const { return hasFlag(Discardable); }
 
                bool isCorrupt() const { return hasFlag(Corrupt); }
 
                bool isEndOfStream() const { return hasFlag(EndOfStream); }
 
                bool isIntraRefresh() const { return hasFlag(IntraRefresh); }
 
                void markEndOfStream(bool v = true) {
                        if (v)
                                addFlag(EndOfStream);
                        else
                                removeFlag(EndOfStream);
                }
 
                void markCorrupt(const String &reason = String()) {
                        addFlag(Corrupt);
                        if (!reason.isEmpty()) metadata().set(Metadata::CorruptReason, reason);
                }
 
                String corruptReason() const { return metadata().getAs<String>(Metadata::CorruptReason); }
 
                // ---- Metadata ---------------------------------------------
 
                virtual const Metadata &metadata() const = 0;
 
                virtual Metadata &metadata() = 0;
 
                // ---- Safe downcast ----------------------------------------
 
                template <typename T> const T *as() const { return dynamic_cast<const T *>(this); }
 
                template <typename T> T *as() { return dynamic_cast<T *>(this); }
 
                // ---- Exclusive ownership ----------------------------------
 
                bool isExclusive() const { return _data.isExclusive() && isExclusiveExtras(); }
 
                // ---- DataStream serialisation ------------------------------
 
                virtual uint32_t subclassFourCC() const = 0;
 
                virtual void serialisePayload(DataStream &s) const = 0;
 
                virtual void deserialisePayload(DataStream &s) = 0;
 
                using Factory = Ptr (*)();
 
                static void registerSubclass(uint32_t fourcc, Factory factory);
 
                static Ptr createEmpty(uint32_t fourcc);
 
                void ensureExclusive() {
                        _data.ensureExclusive();
                        ensureExclusiveExtras();
                }
 
                // ---- VariantLookup polymorphic dispatch -------------------
 
                virtual Optional<Variant> variantLookupResolve(const String &key, Error *err = nullptr) const = 0;
 
                virtual bool variantLookupAssign(const String &key, const Variant &value, Error *err = nullptr) = 0;
 
                virtual const VariantSpec *variantLookupSpecFor(const String &key, Error *err = nullptr) const = 0;
 
                virtual StringList variantLookupScalarNames() const = 0;
 
                virtual StringList variantLookupDump(const String &indent = String()) const = 0;
 
        protected:
                virtual bool isExclusiveExtras() const { return true; }
 
                virtual void ensureExclusiveExtras() {}
 
        public:
        private:
                BufferView     _data;
                MediaTimeStamp _pts;
                MediaTimeStamp _dts;
                int            _streamIndex = 0;
                uint64_t       _flags = 0;
};
 
DataStream &operator<<(DataStream &s, const MediaPayload::Ptr &p);
 
DataStream &operator>>(DataStream &s, MediaPayload::Ptr &p);
 
#define PROMEKI_REGISTER_MEDIAPAYLOAD(Cls, fourccStr)                                                                  \
        namespace {                                                                                                    \
                struct Cls##_MediaPayloadRegistrar {                                                                   \
                                Cls##_MediaPayloadRegistrar() {                                                        \
                                        ::promeki::MediaPayload::registerSubclass(                                     \
                                                ::promeki::FourCC(fourccStr).value(),                                  \
                                                []() -> ::promeki::MediaPayload::Ptr {                                 \
                                                        return ::promeki::Cls::Ptr::create();                          \
                                                });                                                                    \
                                }                                                                                      \
                };                                                                                                     \
                static Cls##_MediaPayloadRegistrar s_##Cls##_mediaPayloadRegistrar;                                    \
        }
 
#define PROMEKI_MEDIAPAYLOAD_LOOKUP_DISPATCH(Self)                                                                     \
        Optional<::promeki::Variant> variantLookupResolve(const ::promeki::String &key,                           \
                                                               ::promeki::Error        *err = nullptr) const override {       \
                return ::promeki::VariantLookup<Self>::resolveDirect(*this, key, err);                                 \
        }                                                                                                              \
        bool variantLookupAssign(const ::promeki::String &key, const ::promeki::Variant &value,                        \
                                 ::promeki::Error *err = nullptr) override {                                           \
                return ::promeki::VariantLookup<Self>::assignDirect(*this, key, value, err);                           \
        }                                                                                                              \
        const ::promeki::VariantSpec *variantLookupSpecFor(const ::promeki::String &key,                               \
                                                           ::promeki::Error        *err = nullptr) const override {           \
                return ::promeki::VariantLookup<Self>::specForDirect(key, err);                                        \
        }                                                                                                              \
        ::promeki::StringList variantLookupScalarNames() const override {                                              \
                return ::promeki::VariantLookup<Self>::registeredScalars();                                            \
        }                                                                                                              \
        ::promeki::StringList variantLookupDump(const ::promeki::String &indent = ::promeki::String())                 \
                const override {                                                                                       \
                return ::promeki::VariantLookup<Self>::dump(*this, indent);                                            \
        }
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV