rtppacket.h

Go to the documentation of this file.

 
#pragma once
 
 
#include <promeki/config.h>
#if PROMEKI_ENABLE_NETWORK
#include <cassert>
#include <cstring>
#include <promeki/bufferview.h>
#include <promeki/queue.h>
#include <promeki/timestamp.h>
 
PROMEKI_NAMESPACE_BEGIN
 
class RtpPacket : public BufferView {
        public:
                using List = promeki::List<RtpPacket>;
 
                using Queue = promeki::Queue<RtpPacket>;
 
                using SizeList = promeki::List<size_t>;
 
                static constexpr size_t HeaderSize = 12;
 
                RtpPacket() = default;
 
                RtpPacket(Buffer 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(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;
                        // F9 hot-path: RTP packets are wire-format byte
                        // streams; no consumer requires page (4 KB)
                        // alignment, and the default Buffer ctor rounds
                        // the request *up* to a page for the underlying
                        // aligned_alloc.  A ~200 byte ANC keep-alive
                        // therefore allocates a whole 4 KB page.  16-byte
                        // alignment matches malloc's natural alignment
                        // and lets the small-block fast path serve every
                        // sub-MTU packet without page-table churn.
                        auto   buf = Buffer(totalSize, /*align=*/16);
                        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;
                        // F9 hot-path: see the uniform-size overload —
                        // 16-byte alignment avoids the 4 KB-per-allocation
                        // page-rounding tax on small ANC / audio / data
                        // packets.
                        auto buf = Buffer(totalSize, /*align=*/16);
                        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);
                }
 
                TimeStamp arrivalSteady;
 
        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
 
#endif // PROMEKI_ENABLE_NETWORK