rtppayloadrawvideo.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_NETWORK
#include <cstddef>
#include <cstdint>
#include <promeki/buffer.h>
#include <promeki/enums_st2110.h>
#include <promeki/enums_video.h>
#include <promeki/namespace.h>
#include <promeki/rtppacket.h>
#include <promeki/rtppayload.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class RtpPayloadRawVideo : public RtpPayload {
        public:
                static constexpr uint32_t ClockRate = 90000;
 
                static constexpr uint8_t DefaultPayloadType = 96;
 
                static constexpr size_t ExtSeqSize = 2;
 
                static constexpr size_t SrdHeaderSize = 6;
 
                static constexpr size_t MaxSrdsPerPacket = 3;
 
                static constexpr size_t BpmBlockOctets = 180;
 
                static constexpr size_t BpmStandardBlocksPerPacket = 7;
 
                static size_t bpmBlocksPerPacket(size_t maxPayloadSize);
 
                static size_t bpmTargetPayloadSize(size_t maxPayloadSize);
 
                static constexpr size_t GpmShortPacketFloor = 1000;
 
                static RtpPacket makeKeepAlive(uint32_t packetCounter,
                                               uint16_t srdRow      = 0,
                                               bool     fieldBit    = false,
                                               uint8_t  payloadType = DefaultPayloadType);
 
                RtpPayloadRawVideo(int width, int height, int bitsPerPixel, int pgroupBytes = 0, int rowsPerSrd = 1);
 
                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; }
 
                int bitsPerPixel() const { return _bitsPerPixel; }
 
                int pgroupBytes() const { return _pgroupBytes; }
 
                int rowsPerSrd() const { return _rowsPerSrd; }
 
                void setPacketCounter(uint32_t value) { _packetCounter = value; }
 
                uint32_t packetCounter() const { return _packetCounter; }
 
                void setFieldBit(bool f) { _fieldBit = f; }
 
                bool fieldBit() const { return _fieldBit; }
 
                void setScanMode(VideoScanMode m) { _scanMode = m; }
 
                VideoScanMode scanMode() const { return _scanMode; }
 
                void setPackingMode(St2110PackingMode pm) { _packingMode = pm; }
 
                St2110PackingMode packingMode() const { return _packingMode; }
 
        private:
                int               _width;
                int               _height;
                int               _bitsPerPixel;
                int               _pgroupBytes;
                int               _rowsPerSrd = 1;
                uint8_t           _payloadType = DefaultPayloadType;
                uint32_t          _packetCounter = 0;
                bool              _fieldBit = false;
                St2110PackingMode _packingMode = St2110PackingMode::Gpm;
                VideoScanMode     _scanMode = VideoScanMode::Progressive;
};
 
PROMEKI_NAMESPACE_END
 
#endif // PROMEKI_ENABLE_NETWORK