rtppacket.h

Go to the documentation of this file.

 
#pragma once
 
#include <cassert>
#include <cstring>
#include <promeki/core/bufferview.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class RtpPacket : public BufferView {
        public:
                using List = promeki::List<RtpPacket>;
 
                using SizeList = promeki::List<size_t>;
 
                static constexpr size_t HeaderSize = 12;
 
                RtpPacket() = default;
 
                RtpPacket(Buffer::Ptr buf, size_t offset, size_t size)
                        : BufferView(std::move(buf), offset, size) { }
 
                bool isNull() const { return data() == nullptr; }
 
                bool isValid() const {
                        if(data() == nullptr) return false;
                        if(size() < HeaderSize) return false;
                        if(((data()[0] >> 6) & 0x03) != 2) return false;
                        return headerSize() != 0;
                }
 
                explicit RtpPacket(size_t packetSize)
                        : BufferView(Buffer::Ptr::create(packetSize), 0, packetSize)
                {
                        std::memset(data(), 0, packetSize);
                        setVersion(2);
                }
 
                static List createList(size_t count, size_t packetSize) {
                        List ret;
                        if(count == 0 || packetSize == 0) return ret;
                        size_t totalSize = count * packetSize;
                        auto buf = Buffer::Ptr::create(totalSize);
                        std::memset(buf->data(), 0, totalSize);
                        ret.reserve(count);
                        for(size_t i = 0; i < count; ++i) {
                                RtpPacket pkt(buf, i * packetSize, packetSize);
                                pkt.setVersion(2);
                                ret.pushToBack(std::move(pkt));
                        }
                        return ret;
                }
 
                static List createList(const SizeList &sizes) {
                        List ret;
                        if(sizes.isEmpty()) return ret;
                        size_t totalSize = 0;
                        for(size_t i = 0; i < sizes.size(); ++i) totalSize += sizes[i];
                        if(totalSize == 0) return ret;
                        auto buf = Buffer::Ptr::create(totalSize);
                        std::memset(buf->data(), 0, totalSize);
                        ret.reserve(sizes.size());
                        size_t offset = 0;
                        for(size_t i = 0; i < sizes.size(); ++i) {
                                RtpPacket pkt(buf, offset, sizes[i]);
                                if(sizes[i] >= HeaderSize) pkt.setVersion(2);
                                ret.pushToBack(std::move(pkt));
                                offset += sizes[i];
                        }
                        return ret;
                }
 
                uint8_t version() const { return (hdr()[0] >> 6) & 0x03; }
 
                void setVersion(uint8_t v) { hdr()[0] = (hdr()[0] & 0x3F) | ((v & 0x03) << 6); }
 
                bool padding() const { return (hdr()[0] >> 5) & 0x01; }
 
                void setPadding(bool p) { hdr()[0] = (hdr()[0] & 0xDF) | (p ? 0x20 : 0x00); }
 
                bool extension() const { return (hdr()[0] >> 4) & 0x01; }
 
                void setExtension(bool x) { hdr()[0] = (hdr()[0] & 0xEF) | (x ? 0x10 : 0x00); }
 
                uint8_t csrcCount() const { return hdr()[0] & 0x0F; }
 
                bool marker() const { return (hdr()[1] >> 7) & 0x01; }
 
                void setMarker(bool m) { hdr()[1] = (hdr()[1] & 0x7F) | (m ? 0x80 : 0x00); }
 
                uint8_t payloadType() const { return hdr()[1] & 0x7F; }
 
                void setPayloadType(uint8_t pt) { hdr()[1] = (hdr()[1] & 0x80) | (pt & 0x7F); }
 
                uint16_t sequenceNumber() const {
                        return (static_cast<uint16_t>(hdr()[2]) << 8) | hdr()[3];
                }
 
                void setSequenceNumber(uint16_t seq) {
                        hdr()[2] = static_cast<uint8_t>(seq >> 8);
                        hdr()[3] = static_cast<uint8_t>(seq & 0xFF);
                }
 
                uint32_t timestamp() const {
                        return (static_cast<uint32_t>(hdr()[4]) << 24) |
                               (static_cast<uint32_t>(hdr()[5]) << 16) |
                               (static_cast<uint32_t>(hdr()[6]) << 8) |
                               static_cast<uint32_t>(hdr()[7]);
                }
 
                void setTimestamp(uint32_t ts) {
                        hdr()[4] = static_cast<uint8_t>((ts >> 24) & 0xFF);
                        hdr()[5] = static_cast<uint8_t>((ts >> 16) & 0xFF);
                        hdr()[6] = static_cast<uint8_t>((ts >> 8) & 0xFF);
                        hdr()[7] = static_cast<uint8_t>(ts & 0xFF);
                }
 
                uint32_t ssrc() const {
                        return (static_cast<uint32_t>(hdr()[8]) << 24) |
                               (static_cast<uint32_t>(hdr()[9]) << 16) |
                               (static_cast<uint32_t>(hdr()[10]) << 8) |
                               static_cast<uint32_t>(hdr()[11]);
                }
 
                void setSsrc(uint32_t s) {
                        hdr()[8]  = static_cast<uint8_t>((s >> 24) & 0xFF);
                        hdr()[9]  = static_cast<uint8_t>((s >> 16) & 0xFF);
                        hdr()[10] = static_cast<uint8_t>((s >> 8) & 0xFF);
                        hdr()[11] = static_cast<uint8_t>(s & 0xFF);
                }
 
                size_t headerSize() const {
                        if(size() < HeaderSize) return 0;
                        size_t hs = HeaderSize + csrcCount() * 4;
                        if(hs > size()) return 0;
                        if(extension()) {
                                // Need at least 4 bytes for the extension header
                                if(hs + 4 > size()) return 0;
                                const uint8_t *ext = data() + hs;
                                uint16_t extLen = (static_cast<uint16_t>(ext[2]) << 8) | ext[3];
                                hs += 4 + extLen * 4;
                                if(hs > size()) return 0;
                        }
                        return hs;
                }
 
                uint16_t extensionProfile() const {
                        if(!extension()) return 0;
                        size_t extOffset = HeaderSize + csrcCount() * 4;
                        if(extOffset + 4 > size()) return 0;
                        const uint8_t *ext = data() + extOffset;
                        return (static_cast<uint16_t>(ext[0]) << 8) | ext[1];
                }
 
                uint16_t extensionLength() const {
                        if(!extension()) return 0;
                        size_t extOffset = HeaderSize + csrcCount() * 4;
                        if(extOffset + 4 > size()) return 0;
                        const uint8_t *ext = data() + extOffset;
                        return (static_cast<uint16_t>(ext[2]) << 8) | ext[3];
                }
 
                const uint8_t *payload() const {
                        size_t hs = headerSize();
                        if(hs == 0 || hs >= size()) return nullptr;
                        return data() + hs;
                }
 
                uint8_t *payload() {
                        size_t hs = headerSize();
                        if(hs == 0 || hs >= size()) return nullptr;
                        return data() + hs;
                }
 
                size_t payloadSize() const {
                        size_t hs = headerSize();
                        if(hs == 0 || hs >= size()) return 0;
                        return size() - hs;
                }
 
                void clear() {
                        if(isNull()) return;
                        std::memset(data(), 0, size());
                        setVersion(2);
                }
 
        private:
                const uint8_t *hdr() const {
                        assert(data() != nullptr && size() >= HeaderSize);
                        return data();
                }
                uint8_t *hdr() {
                        assert(data() != nullptr && size() >= HeaderSize);
                        return data();
                }
};
 
PROMEKI_NAMESPACE_END