compressedvideopayload.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <cstdint>
#include <promeki/namespace.h>
#include <promeki/uniqueptr.h>
#include <promeki/videopayload.h>
#include <promeki/buffer.h>
#include <promeki/videocodec.h>
#include <promeki/enums.h>
#include <promeki/variantlookup.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class CompressedVideoPayload : public VideoPayload {
        public:
                PROMEKI_MEDIAPAYLOAD_LOOKUP_DISPATCH(CompressedVideoPayload)
 
                virtual CompressedVideoPayload *_promeki_clone() const override {
                        return new CompressedVideoPayload(*this);
                }
 
                using Ptr = SharedPtr<CompressedVideoPayload, /*CopyOnWrite=*/true, CompressedVideoPayload>;
 
                using PtrList = ::promeki::List<Ptr>;
 
                using UPtr = UniquePtr<CompressedVideoPayload>;
 
                enum VideoFlag : uint64_t {
                        ParameterSet = 1ull << 16, 
                };
 
                CompressedVideoPayload() = default;
 
                explicit CompressedVideoPayload(const ImageDesc &desc) : VideoPayload(desc) {}
 
                CompressedVideoPayload(const ImageDesc &desc, const BufferView &data) : VideoPayload(desc, data) {}
 
                CompressedVideoPayload(const ImageDesc &desc, Buffer buffer)
                    : VideoPayload(desc, buffer ? BufferView(buffer, 0, buffer.size()) : BufferView()) {}
 
                bool isCompressed() const override { return true; }
 
                bool isValid() const override {
                        return MediaPayload::isValid() && desc().pixelFormat().isValid() &&
                               desc().pixelFormat().isCompressed();
                }
 
                virtual const FrameType &frameType() const {
                        if (_frameType.isValid() && _frameType != FrameType::Unknown) {
                                return _frameType;
                        }
                        return hasFlag(Keyframe) ? FrameType::IDR : FrameType::Unknown;
                }
 
                void setFrameType(const FrameType &t) { _frameType = t; }
 
                bool isSafeCutPoint() const override {
                        if (!isValid()) return false;
                        const VideoCodec &codec = desc().pixelFormat().videoCodec();
                        if (!codec.isValid()) return false;
                        if (codec.codingType() != VideoCodec::CodingTemporal) return true;
                        return isKeyframe();
                }
 
                bool isParameterSet() const { return (flags() & ParameterSet) != 0; }
 
                void markParameterSet(bool v = true) {
                        if (v)
                                setFlags(flags() | ParameterSet);
                        else
                                setFlags(flags() & ~ParameterSet);
                }
 
                const Buffer &inBandCodecData() const { return _inBandCodecData; }
 
                void setInBandCodecData(Buffer b) { _inBandCodecData = std::move(b); }
 
        protected:
                bool isExclusiveExtras() const override {
                        return !_inBandCodecData.isValid() || _inBandCodecData.impl().referenceCount() <= 1;
                }
 
                void ensureExclusiveExtras() override {
                        if (_inBandCodecData.isValid() && _inBandCodecData.impl().referenceCount() > 1) {
                                _inBandCodecData.ensureExclusive();
                        }
                }
 
        public:
                static constexpr FourCC kSubclassFourCC{'C', 'V', 'd', 'p'};
 
                uint32_t subclassFourCC() const override { return kSubclassFourCC.value(); }
 
                void serialisePayload(DataStream &s) const override;
 
                void deserialisePayload(DataStream &s) override;
 
                CompressedVideoPayload(const CompressedVideoPayload &) = default;
                CompressedVideoPayload(CompressedVideoPayload &&) = default;
                CompressedVideoPayload &operator=(const CompressedVideoPayload &) = default;
                CompressedVideoPayload &operator=(CompressedVideoPayload &&) = default;
 
        private:
                FrameType   _frameType;
                Buffer _inBandCodecData;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV