inet::rtp::RtcpPacketSerializer Class Reference

Converts between RtcpPacket and binary (network byte order) RTCP packet. More...

#include <RtcpPacketSerializer.h>

Inheritance diagram for inet::rtp::RtcpPacketSerializer:

Public Member Functions
	RtcpPacketSerializer ()
Public Member Functions inherited from inet::FieldsChunkSerializer
virtual void	serialize (MemoryOutputStream &stream, const Ptr< const Chunk > &chunk, b offset, b length) const override
	Serializes a chunk into a stream by writing the bytes representing the chunk at the end of the stream. More...
virtual const Ptr< Chunk >	deserialize (MemoryInputStream &stream, const std::type_info &typeInfo) const override
	Deserializes a chunk from a stream by reading the bytes at the current position of the stream. More...

Protected Member Functions
virtual void	serialize (MemoryOutputStream &stream, const Ptr< const Chunk > &chunk) const override
	Serializes a chunk into a stream by writing all bytes representing the chunk at the end of the stream. More...
virtual const Ptr< Chunk >	deserialize (MemoryInputStream &stream) const override
	Deserializes a chunk from a stream by reading the bytes at the current position of the stream. More...

Additional Inherited Members
Static Public Attributes inherited from inet::ChunkSerializer
static b	totalSerializedLength = b(0)
static b	totalDeserializedLength = b(0)

Detailed Description

Converts between RtcpPacket and binary (network byte order) RTCP packet.

Constructor & Destructor Documentation

RtcpPacketSerializer()

inet::rtp::RtcpPacketSerializer::RtcpPacketSerializer ( )

inline

: FieldsChunkSerializer() {}

Member Function Documentation

deserialize()

const Ptr< Chunk > inet::rtp::RtcpPacketSerializer::deserialize ( MemoryInputStream &  stream ) const

overrideprotectedvirtual

Deserializes a chunk from a stream by reading the bytes at the current position of the stream.

The current stream position is updated according to the length of the returned chunk.

Implements inet::FieldsChunkSerializer.

{
    auto rtcpPacket = makeShared<RtcpPacket>();
    rtcpPacket->setVersion(stream.readNBitsToUint64Be(2));
    rtcpPacket->setPadding(stream.readBit());
    short count = stream.readNBitsToUint64Be(5);
    rtcpPacket->setCount(count);
    rtcpPacket->setPacketType((RtcpPacketType)stream.readByte());
    rtcpPacket->setRtcpLength(stream.readUint16Be());
    switch (rtcpPacket->getPacketType()) {
        case RTCP_PT_SR: {
            auto rtcpSenderReportPacket = makeShared<RtcpSenderReportPacket>();
            rtcpSenderReportPacket->setVersion(rtcpPacket->getVersion());
            rtcpSenderReportPacket->setPadding(rtcpPacket->getPadding());
            rtcpSenderReportPacket->setCount(0);
            rtcpSenderReportPacket->setPacketType(rtcpPacket->getPacketType());
            rtcpSenderReportPacket->setRtcpLength(rtcpPacket->getRtcpLength());
            rtcpSenderReportPacket->setSsrc(stream.readUint32Be());
            auto& senderReport = rtcpSenderReportPacket->getSenderReportForUpdate();
            senderReport.setNTPTimeStamp(stream.readUint64Be());
            senderReport.setRTPTimeStamp(stream.readUint32Be());
            senderReport.setPacketCount(stream.readUint32Be());
            senderReport.setByteCount(stream.readUint32Be());
            for (short i = 0; i < count; ++i) {
                ReceptionReport *receptionReport = new ReceptionReport();
                deserializeReceptionReport(stream, *receptionReport);
                rtcpSenderReportPacket->addReceptionReport(receptionReport);
            }
            return rtcpSenderReportPacket;
        }
        case RTCP_PT_RR: {
            auto rtcpReceiverReportPacket = makeShared<RtcpReceiverReportPacket>();
            rtcpReceiverReportPacket->setVersion(rtcpPacket->getVersion());
            rtcpReceiverReportPacket->setPadding(rtcpPacket->getPadding());
            rtcpReceiverReportPacket->setCount(0);
            rtcpReceiverReportPacket->setPacketType(rtcpPacket->getPacketType());
            rtcpReceiverReportPacket->setRtcpLength(rtcpPacket->getRtcpLength());
            rtcpReceiverReportPacket->setSsrc(stream.readUint32Be());
            for (short i = 0; i < count; ++i) {
                ReceptionReport *receptionReport = new ReceptionReport();
                deserializeReceptionReport(stream, *receptionReport);
                rtcpReceiverReportPacket->addReceptionReport(receptionReport);
            }
            return rtcpReceiverReportPacket;
        }
        case RTCP_PT_SDES: {
            auto rtcpSdesPacket = makeShared<RtcpSdesPacket>();
            rtcpSdesPacket->setVersion(rtcpPacket->getVersion());
            rtcpSdesPacket->setPadding(rtcpPacket->getPadding());
            rtcpSdesPacket->setCount(0);
            rtcpSdesPacket->setPacketType(rtcpPacket->getPacketType());
            rtcpSdesPacket->setRtcpLength(rtcpPacket->getRtcpLength());
            for (short i = 0; i < count; ++i) {
                SdesChunk *sdesChunk = new SdesChunk();
                deserializeSdesChunk(stream, rtcpSdesPacket, *sdesChunk);
                rtcpSdesPacket->addSDESChunk(sdesChunk);
            }
            return rtcpSdesPacket;
        }
        case RTCP_PT_BYE: {
            auto rtcpByePacket = makeShared<RtcpByePacket>();
            rtcpByePacket->setVersion(rtcpPacket->getVersion());
            rtcpByePacket->setPadding(rtcpPacket->getPadding());
            rtcpByePacket->setCount(1);
            rtcpByePacket->setPacketType(rtcpPacket->getPacketType());
            rtcpByePacket->setRtcpLength(rtcpPacket->getRtcpLength());
            rtcpByePacket->setSsrc(stream.readUint32Be());
            // more SSRC and optional data may be included
            while (B(stream.getRemainingLength()) != B(0)) {
                stream.readByte();
            }
            return rtcpByePacket;
        }
        default: {
            rtcpPacket->markIncorrect();
            return rtcpPacket;
        }
    }
}

serialize()

void inet::rtp::RtcpPacketSerializer::serialize ( MemoryOutputStream &  stream, const Ptr< const Chunk > &  chunk  ) const

overrideprotectedvirtual

Serializes a chunk into a stream by writing all bytes representing the chunk at the end of the stream.

Implements inet::FieldsChunkSerializer.

{
    const auto& rtcpPacket = staticPtrCast<const RtcpPacket>(chunk);
    B start_position = B(stream.getLength());
    stream.writeNBitsOfUint64Be(rtcpPacket->getVersion(), 2);
    stream.writeBit(rtcpPacket->getPadding());
    short count = rtcpPacket->getCount();
    stream.writeNBitsOfUint64Be(count, 5);
    stream.writeByte(rtcpPacket->getPacketType());
    stream.writeUint16Be(rtcpPacket->getRtcpLength());
    switch (rtcpPacket->getPacketType()) {
        case RTCP_PT_SR: {
            const auto& rtcpSenderReportPacket = staticPtrCast<const RtcpSenderReportPacket>(chunk);
            stream.writeUint32Be(rtcpSenderReportPacket->getSsrc());
            auto& senderReport = rtcpSenderReportPacket->getSenderReport();
            stream.writeUint64Be(senderReport.getNTPTimeStamp());
            stream.writeUint32Be(senderReport.getRTPTimeStamp());
            stream.writeUint32Be(senderReport.getPacketCount());
            stream.writeUint32Be(senderReport.getByteCount());
            ASSERT(count == rtcpSenderReportPacket->getReceptionReports().size());
            for (short i = 0; i < count; ++i) {
                serializeReceptionReport(stream, static_cast<const ReceptionReport *>(rtcpSenderReportPacket->getReceptionReports()[i]));
            }
            ASSERT(rtcpSenderReportPacket->getChunkLength() == B(4) + B(24) + B(count * 24));
            break;
        }
        case RTCP_PT_RR: {
            const auto& rtcpReceiverReportPacket = staticPtrCast<const RtcpReceiverReportPacket>(chunk);
            stream.writeUint32Be(rtcpReceiverReportPacket->getSsrc());
            for (short i = 0; i < count; ++i) {
                serializeReceptionReport(stream, static_cast<const ReceptionReport *>(rtcpReceiverReportPacket->getReceptionReports()[i]));
            }
            ASSERT(rtcpReceiverReportPacket->getChunkLength() == B(4) + B(4) + B(count * 24));
            break;
        }
        case RTCP_PT_SDES: {
            const auto& rtcpSdesPacket = staticPtrCast<const RtcpSdesPacket>(chunk);
            for (short i = 0; i < count; ++i) {
                serializeSdesChunk(stream, static_cast<const SdesChunk *>(rtcpSdesPacket->getSdesChunks()[i]));
            }
            ASSERT(rtcpSdesPacket->getChunkLength() == (stream.getLength() - start_position));
            break;
        }
        case RTCP_PT_BYE: {
            const auto& rtcpByePacket = staticPtrCast<const RtcpByePacket>(chunk);
            stream.writeUint32Be(rtcpByePacket->getSsrc());
            ASSERT(rtcpByePacket->getChunkLength() == (stream.getLength() - start_position));
            break;
        }
        default: {
            throw cRuntimeError("Can not serialize RTCP packet: type %d not supported.", rtcpPacket->getPacketType());
            break;
        }
    }
}

---

The documentation for this class was generated from the following files:

• RtcpPacketSerializer.h
• RtcpPacketSerializer.cc