rtppayload.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_NETWORK
#include <cstdint>
#include <cstddef>
#include <promeki/buffer.h>
#include <promeki/rtppacket.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class RtpPayload {
        public:
                virtual ~RtpPayload() = default;
 
                virtual uint8_t payloadType() const = 0;
 
                virtual uint32_t clockRate() const = 0;
 
                virtual RtpPacket::List pack(const void *mediaData, size_t size) = 0;
 
                virtual Buffer unpack(const RtpPacket::List &packets) = 0;
 
                enum class ValidateResult {
                        Accept,
                        DropSilently,
                        Wait,
                };
 
                virtual ValidateResult validate(const Buffer &unpacked) {
                        return unpacked.size() > 0 ? ValidateResult::Accept
                                                   : ValidateResult::DropSilently;
                }
 
                virtual void clearParamSets() {}
 
                virtual bool isJpeg() const { return false; }
 
                virtual size_t maxPayloadSize() const { return _maxPayloadSize; }
 
                void setMaxPayloadSize(size_t bytes) { _maxPayloadSize = (bytes == 0) ? 1200 : bytes; }
 
        protected:
                RtpPayload() = default;
 
                size_t _maxPayloadSize = 1200;
};
 
class RtpPayloadL24 : public RtpPayload {
        public:
                RtpPayloadL24(uint32_t sampleRate = 48000, int channels = 2);
 
                uint8_t payloadType() const override { return _payloadType; }
                uint32_t clockRate() const override { return _sampleRate; }
                RtpPacket::List pack(const void *mediaData, size_t size) override;
                Buffer unpack(const RtpPacket::List &packets) override;
 
                void setPayloadType(uint8_t pt) { _payloadType = pt; }
 
                int channels() const { return _channels; }
 
                uint32_t sampleRate() const { return _sampleRate; }
 
        private:
                uint32_t _sampleRate;
                int      _channels;
                uint8_t  _payloadType = 97;
};
 
class RtpPayloadL16 : public RtpPayload {
        public:
                RtpPayloadL16(uint32_t sampleRate = 48000, int channels = 2);
 
                uint8_t payloadType() const override { return _payloadType; }
                uint32_t clockRate() const override { return _sampleRate; }
                RtpPacket::List pack(const void *mediaData, size_t size) override;
                Buffer unpack(const RtpPacket::List &packets) override;
 
                void setPayloadType(uint8_t pt) { _payloadType = pt; }
 
                int channels() const { return _channels; }
 
                uint32_t sampleRate() const { return _sampleRate; }
 
        private:
                uint32_t _sampleRate;
                int      _channels;
                uint8_t  _payloadType = 96;
};
 
// RFC 4175 / ST 2110-20 uncompressed video lives in its own header
// (rtppayloadrawvideo.h) so the full SRD / ESN / pgroup machinery can
// be reviewed independently of the other RTP payload classes.
 
class RtpPayloadJson : public RtpPayload {
        public:
                RtpPayloadJson(uint8_t payloadType = 98, uint32_t clockRate = 90000);
 
                uint8_t payloadType() const override { return _payloadType; }
                uint32_t clockRate() const override { return _clockRate; }
                RtpPacket::List pack(const void *mediaData, size_t size) override;
                Buffer unpack(const RtpPacket::List &packets) override;
 
                void setPayloadType(uint8_t pt) { _payloadType = pt; }
 
                void setClockRate(uint32_t hz) { _clockRate = hz; }
 
        private:
                uint8_t  _payloadType;
                uint32_t _clockRate;
};
 
class RtpPayloadJpeg : public RtpPayload {
        public:
                RtpPayloadJpeg(int width, int height, int quality = 85);
 
                uint8_t payloadType() const override { return 26; }
                uint32_t clockRate() const override { return 90000; }
                RtpPacket::List pack(const void *mediaData, size_t size) override;
                Buffer unpack(const RtpPacket::List &packets) override;
                bool isJpeg() const override { return true; }
 
                int width() const { return _width; }
 
                int height() const { return _height; }
 
                int quality() const { return _quality; }
 
                void setQuality(int q) { _quality = q; }
 
        private:
                int _width;
                int _height;
                int _quality;
};
 
class RtpPayloadJpegXs : public RtpPayload {
        public:
                static constexpr size_t HeaderSize = 4;
 
                static constexpr uint32_t ClockRate = 90000;
 
                RtpPayloadJpegXs(int width, int height, uint8_t payloadType = 96);
 
                uint8_t payloadType() const override { return _payloadType; }
                uint32_t clockRate() const override { return ClockRate; }
                RtpPacket::List pack(const void *mediaData, size_t size) override;
                Buffer unpack(const RtpPacket::List &packets) override;
 
                void setPayloadType(uint8_t pt) { _payloadType = pt; }
 
                int width() const { return _width; }
                int height() const { return _height; }
 
                uint8_t frameCounter() const { return _frameCounter; }
 
                void resetFrameCounter() { _frameCounter = 0; }
 
                void setSliceMode(bool sliceMode) { _sliceMode = sliceMode; }
 
                bool isSliceMode() const { return _sliceMode; }
 
        private:
                int     _width;
                int     _height;
                uint8_t _payloadType;
                uint8_t _frameCounter = 0;
                bool    _sliceMode = false;
};
 
class RtpPayloadH264 : public RtpPayload {
        public:
                static constexpr uint32_t ClockRate = 90000;
 
                static constexpr uint8_t NalTypeFuA = 28;
 
                static constexpr uint8_t NalTypeStapA = 24;
 
                static constexpr uint8_t NalTypeIdr = 5;
 
                static constexpr uint8_t NalTypeSps = 7;
 
                static constexpr uint8_t NalTypePps = 8;
 
                explicit RtpPayloadH264(uint8_t payloadType = 96);
 
                uint8_t payloadType() const override { return _payloadType; }
                uint32_t clockRate() const override { return ClockRate; }
                RtpPacket::List pack(const void *mediaData, size_t size) override;
                Buffer unpack(const RtpPacket::List &packets) override;
 
                ValidateResult validate(const Buffer &unpacked) override;
 
                void clearParamSets() override;
 
                void setSpropParameterSets(const String &csv);
 
                bool spsObserved() const { return _spsObserved; }
 
                bool ppsObserved() const { return _ppsObserved; }
 
                bool idrLatched() const { return _idrLatched; }
 
                void setPayloadType(uint8_t pt) { _payloadType = pt; }
 
        private:
                uint8_t _payloadType;
                bool    _spsObserved = false;
                bool    _ppsObserved = false;
                bool    _idrLatched = false;
                bool    _loggedWaitForParamSets = false;
};
 
class RtpPayloadH265 : public RtpPayload {
        public:
                static constexpr uint32_t ClockRate = 90000;
 
                static constexpr uint8_t NalTypeFu = 49;
 
                static constexpr uint8_t NalTypeAp = 48;
 
                static constexpr uint8_t NalTypeVps = 32;
 
                static constexpr uint8_t NalTypeSps = 33;
 
                static constexpr uint8_t NalTypePps = 34;
 
                static constexpr uint8_t IrapNalTypeMin = 16;
 
                static constexpr uint8_t IrapNalTypeMax = 23;
 
                explicit RtpPayloadH265(uint8_t payloadType = 96);
 
                uint8_t payloadType() const override { return _payloadType; }
                uint32_t clockRate() const override { return ClockRate; }
                RtpPacket::List pack(const void *mediaData, size_t size) override;
                Buffer unpack(const RtpPacket::List &packets) override;
 
                ValidateResult validate(const Buffer &unpacked) override;
 
                void clearParamSets() override;
 
                void setSpropVps(const String &csv);
 
                void setSpropSps(const String &csv);
 
                void setSpropPps(const String &csv);
 
                bool vpsObserved() const { return _vpsObserved; }
 
                bool spsObserved() const { return _spsObserved; }
 
                bool ppsObserved() const { return _ppsObserved; }
 
                bool irapLatched() const { return _irapLatched; }
 
                void setPayloadType(uint8_t pt) { _payloadType = pt; }
 
        private:
                uint8_t _payloadType;
                bool    _vpsObserved = false;
                bool    _spsObserved = false;
                bool    _ppsObserved = false;
                bool    _irapLatched = false;
                bool    _loggedWaitForParamSets = false;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_NETWORK