compressedaudiopayload.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_PROAV
#include <promeki/namespace.h>
#include <promeki/uniqueptr.h>
#include <promeki/audiopayload.h>
#include <promeki/buffer.h>
#include <promeki/audiocodec.h>
#include <promeki/variantlookup.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class CompressedAudioPayload : public AudioPayload {
        public:
                PROMEKI_MEDIAPAYLOAD_LOOKUP_DISPATCH(CompressedAudioPayload)
 
                virtual CompressedAudioPayload *_promeki_clone() const override {
                        return new CompressedAudioPayload(*this);
                }
 
                using Ptr = SharedPtr<CompressedAudioPayload, /*CopyOnWrite=*/true, CompressedAudioPayload>;
 
                using PtrList = ::promeki::List<Ptr>;
 
                using UPtr = UniquePtr<CompressedAudioPayload>;
 
                CompressedAudioPayload() = default;
 
                explicit CompressedAudioPayload(const AudioDesc &desc, size_t sampleCount = 0)
                    : AudioPayload(desc, sampleCount) {}
 
                CompressedAudioPayload(const AudioDesc &desc, const BufferView &data, size_t sampleCount = 0)
                    : AudioPayload(desc, sampleCount, data) {}
 
                CompressedAudioPayload(const AudioDesc &desc, Buffer buffer, size_t sampleCount = 0)
                    : AudioPayload(desc, sampleCount, buffer ? BufferView(buffer, 0, buffer.size()) : BufferView()) {}
 
                bool isCompressed() const override { return true; }
 
                bool isValid() const override {
                        return MediaPayload::isValid() && desc().format().isValid() && desc().format().isCompressed();
                }
 
                bool isSafeCutPoint() const override {
                        if (!isValid()) return false;
                        const AudioCodec &codec = desc().format().audioCodec();
                        if (!codec.isValid()) return false;
                        switch (codec.packetIndependence()) {
                                case AudioCodec::PacketIndependenceEvery: return true;
                                case AudioCodec::PacketIndependenceKeyframe: return isKeyframe();
                                case AudioCodec::PacketIndependenceInter:
                                case AudioCodec::PacketIndependenceInvalid: return false;
                        }
                        return false;
                }
 
                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', 'A', 'd', 'p'};
 
                uint32_t subclassFourCC() const override { return kSubclassFourCC.value(); }
 
                void serialisePayload(DataStream &s) const override;
 
                void deserialisePayload(DataStream &s) override;
 
                CompressedAudioPayload(const CompressedAudioPayload &) = default;
                CompressedAudioPayload(CompressedAudioPayload &&) = default;
                CompressedAudioPayload &operator=(const CompressedAudioPayload &) = default;
                CompressedAudioPayload &operator=(CompressedAudioPayload &&) = default;
 
        private:
                Buffer _inBandCodecData;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_PROAV