qrtplib::RTCPCompoundPacketBuilder Class Reference

#include <rtcpcompoundpacketbuilder.h>

Inheritance diagram for qrtplib::RTCPCompoundPacketBuilder:

Collaboration diagram for qrtplib::RTCPCompoundPacketBuilder:

Classes
class	Buffer
class	Report
class	SDES
class	SDESSource

Public Member Functions
	RTCPCompoundPacketBuilder ()
	~RTCPCompoundPacketBuilder ()
int	InitBuild (std::size_t maxpacketsize)
int	InitBuild (void *externalbuffer, std::size_t buffersize)
int	StartSenderReport (uint32_t senderssrc, const RTPNTPTime &ntptimestamp, uint32_t rtptimestamp, uint32_t packetcount, uint32_t octetcount)
int	StartReceiverReport (uint32_t senderssrc)
int	AddReportBlock (uint32_t ssrc, uint8_t fractionlost, int32_t packetslost, uint32_t exthighestseq, uint32_t jitter, uint32_t lsr, uint32_t dlsr)
int	AddSDESSource (uint32_t ssrc)
int	AddSDESNormalItem (RTCPSDESPacket::ItemType t, const void *itemdata, uint8_t itemlength)
int	AddSDESPrivateItem (const void *prefixdata, uint8_t prefixlength, const void *valuedata, uint8_t valuelength)
int	AddBYEPacket (uint32_t *ssrcs, uint8_t numssrcs, const void *reasondata, uint8_t reasonlength)
int	AddAPPPacket (uint8_t subtype, uint32_t ssrc, const uint8_t name[4], const void *appdata, std::size_t appdatalen)
int	EndBuild ()
Public Member Functions inherited from qrtplib::RTCPCompoundPacket
	RTCPCompoundPacket (RTPRawPacket &rawpack)
	RTCPCompoundPacket (uint8_t *packet, std::size_t len)
virtual	~RTCPCompoundPacket ()
int	GetCreationError ()
uint8_t *	GetCompoundPacketData ()
std::size_t	GetCompoundPacketLength ()
void	GotoFirstPacket ()
RTCPPacket *	GetNextPacket ()

Private Member Functions
void	ClearBuildBuffers ()

Private Attributes
RTPEndian	m_endian
std::size_t	maximumpacketsize
uint8_t *	buffer
bool	external
bool	arebuilding
Report	report
SDES	sdes
std::list< Buffer >	byepackets
std::size_t	byesize
std::list< Buffer >	apppackets
std::size_t	appsize

Additional Inherited Members
Protected Member Functions inherited from qrtplib::RTCPCompoundPacket
	RTCPCompoundPacket ()
void	ClearPacketList ()
int	ParseData (uint8_t *packet, std::size_t len)
Protected Attributes inherited from qrtplib::RTCPCompoundPacket
RTPEndian	m_endian
int	error
uint8_t *	compoundpacket
std::size_t	compoundpacketlength
std::list< RTCPPacket * >	rtcppacklist
std::list< RTCPPacket * >::const_iterator	rtcppackit

Detailed Description

This class can be used to construct an RTCP compound packet. The RTCPCompoundPacketBuilder class can be used to construct an RTCP compound packet. It inherits the member functions of RTCPCompoundPacket which can be used to access the information in the compound packet once it has been built successfully. The member functions described below return ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT if the action would cause the maximum allowed size to be exceeded.

Definition at line 62 of file rtcpcompoundpacketbuilder.h.

Constructor & Destructor Documentation

RTCPCompoundPacketBuilder()

qrtplib::RTCPCompoundPacketBuilder::RTCPCompoundPacketBuilder

(

)

Constructs an RTCPCompoundPacketBuilder instance, optionally installing a memory manager.

Definition at line 44 of file rtcpcompoundpacketbuilder.cpp.

References appsize, arebuilding, buffer, byesize, external, and maximumpacketsize.

{
    byesize = 0;
    appsize = 0;
    maximumpacketsize = 0;
    buffer = 0;
    external = false;
    arebuilding = false;
}

~RTCPCompoundPacketBuilder()

qrtplib::RTCPCompoundPacketBuilder::~RTCPCompoundPacketBuilder

(

)

Definition at line 54 of file rtcpcompoundpacketbuilder.cpp.

References ClearBuildBuffers(), qrtplib::RTCPCompoundPacket::compoundpacket, and external.

{
    if (external)
        compoundpacket = 0; // make sure RTCPCompoundPacket doesn't delete the external buffer
    ClearBuildBuffers();
}

Here is the call graph for this function:

Member Function Documentation

AddAPPPacket()

int qrtplib::RTCPCompoundPacketBuilder::AddAPPPacket	(	uint8_t	subtype,
		uint32_t	ssrc,
		const uint8_t	name[4],
		const void *	appdata,
		std::size_t	appdatalen
	)

Adds the APP packet specified by the arguments to the compound packet. Adds the APP packet specified by the arguments to the compound packet. Note that appdatalen has to be a multiple of four.

Definition at line 397 of file rtcpcompoundpacketbuilder.cpp.

References apppackets, appsize, arebuilding, byesize, qrtplib::RTCPCommonHeader::count, ERR_RTP_RTCPCOMPPACKBUILDER_APPDATALENTOOBIG, ERR_RTP_RTCPCOMPPACKBUILDER_ILLEGALAPPDATALENGTH, ERR_RTP_RTCPCOMPPACKBUILDER_ILLEGALSUBTYPE, ERR_RTP_RTCPCOMPPACKBUILDER_NOTBUILDING, ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT, qrtplib::RTCPCommonHeader::length, maximumpacketsize, qrtplib::RTCPCompoundPacketBuilder::Report::NeededBytes(), qrtplib::RTCPCompoundPacketBuilder::SDES::NeededBytes(), qrtplib::RTCPCommonHeader::packettype, qrtplib::RTCPCommonHeader::padding, report, RTP_RTCPTYPE_APP, sdes, and qrtplib::RTCPCommonHeader::version.

Referenced by qrtplib::RTPSession::SendRTCPAPPPacket().

{
    if (!arebuilding)
        return ERR_RTP_RTCPCOMPPACKBUILDER_NOTBUILDING;
    if (subtype > 31)
        return ERR_RTP_RTCPCOMPPACKBUILDER_ILLEGALSUBTYPE;
    if ((appdatalen % 4) != 0)
        return ERR_RTP_RTCPCOMPPACKBUILDER_ILLEGALAPPDATALENGTH;

    std::size_t appdatawords = appdatalen / 4;

    if ((appdatawords + 2) > 65535)
        return ERR_RTP_RTCPCOMPPACKBUILDER_APPDATALENTOOBIG;

    std::size_t packsize = sizeof(RTCPCommonHeader) + sizeof(uint32_t) * 2 + appdatalen;
    std::size_t totalotherbytes = appsize + byesize + sdes.NeededBytes() + report.NeededBytes();

    if ((totalotherbytes + packsize) > maximumpacketsize)
        return ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT;

    uint8_t *buf;

    buf = new uint8_t[packsize];

    RTCPCommonHeader *hdr = (RTCPCommonHeader *) buf;

    hdr->version = 2;
    hdr->padding = 0;
    hdr->count = subtype;

    hdr->length = qToBigEndian((uint16_t) (appdatawords + 2));
    hdr->packettype = RTP_RTCPTYPE_APP;

    uint32_t *source = (uint32_t *) (buf + sizeof(RTCPCommonHeader));
    *source = qToBigEndian(ssrc);

    buf[sizeof(RTCPCommonHeader) + sizeof(uint32_t) + 0] = name[0];
    buf[sizeof(RTCPCommonHeader) + sizeof(uint32_t) + 1] = name[1];
    buf[sizeof(RTCPCommonHeader) + sizeof(uint32_t) + 2] = name[2];
    buf[sizeof(RTCPCommonHeader) + sizeof(uint32_t) + 3] = name[3];

    if (appdatalen > 0)
        memcpy((buf + sizeof(RTCPCommonHeader) + sizeof(uint32_t) * 2), appdata, appdatalen);

    apppackets.push_back(Buffer(buf, packsize));
    appsize += packsize;

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

AddBYEPacket()

int qrtplib::RTCPCompoundPacketBuilder::AddBYEPacket	(	uint32_t *	ssrcs,
		uint8_t	numssrcs,
		const void *	reasondata,
		uint8_t	reasonlength
	)

Adds a BYE packet to the compound packet. Adds a BYE packet to the compound packet. It will contain numssrcs source identifiers specified in ssrcs and will indicate as reason for leaving the string of length reasonlength containing data reasondata.

Definition at line 331 of file rtcpcompoundpacketbuilder.cpp.

References appsize, arebuilding, byepackets, byesize, qrtplib::RTCPCommonHeader::count, ERR_RTP_RTCPCOMPPACKBUILDER_NOTBUILDING, ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT, ERR_RTP_RTCPCOMPPACKBUILDER_TOOMANYSSRCS, i, qrtplib::RTCPCommonHeader::length, maximumpacketsize, qrtplib::RTCPCompoundPacketBuilder::Report::NeededBytes(), qrtplib::RTCPCompoundPacketBuilder::SDES::NeededBytes(), qrtplib::RTCPCommonHeader::packettype, qrtplib::RTCPCommonHeader::padding, report, RTP_RTCPTYPE_BYE, sdes, and qrtplib::RTCPCommonHeader::version.

Referenced by qrtplib::RTCPPacketBuilder::BuildBYEPacket().

{
    if (!arebuilding)
        return ERR_RTP_RTCPCOMPPACKBUILDER_NOTBUILDING;

    if (numssrcs > 31)
        return ERR_RTP_RTCPCOMPPACKBUILDER_TOOMANYSSRCS;

    std::size_t packsize = sizeof(RTCPCommonHeader) + sizeof(uint32_t) * ((std::size_t) numssrcs);
    std::size_t zerobytes = 0;

    if (reasonlength > 0)
    {
        packsize += 1; // 1 byte for the length;
        packsize += (std::size_t) reasonlength;

        std::size_t r = (packsize & 0x03);
        if (r != 0)
        {
            zerobytes = 4 - r;
            packsize += zerobytes;
        }
    }

    std::size_t totalotherbytes = appsize + byesize + sdes.NeededBytes() + report.NeededBytes();

    if ((totalotherbytes + packsize) > maximumpacketsize)
        return ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT;

    uint8_t *buf;
    std::size_t numwords;

    buf = new uint8_t[packsize];

    RTCPCommonHeader *hdr = (RTCPCommonHeader *) buf;

    hdr->version = 2;
    hdr->padding = 0;
    hdr->count = numssrcs;

    numwords = packsize / sizeof(uint32_t);
    hdr->length = qToBigEndian((uint16_t) (numwords - 1));
    hdr->packettype = RTP_RTCPTYPE_BYE;

    uint32_t *sources = (uint32_t *) (buf + sizeof(RTCPCommonHeader));
    uint8_t srcindex;

    for (srcindex = 0; srcindex < numssrcs; srcindex++)
        sources[srcindex] = qToBigEndian(ssrcs[srcindex]);

    if (reasonlength != 0)
    {
        std::size_t offset = sizeof(RTCPCommonHeader) + ((std::size_t) numssrcs) * sizeof(uint32_t);

        buf[offset] = reasonlength;
        memcpy((buf + offset + 1), reasondata, (std::size_t) reasonlength);
        for (std::size_t i = 0; i < zerobytes; i++)
            buf[packsize - 1 - i] = 0;
    }

    byepackets.push_back(Buffer(buf, packsize));
    byesize += packsize;

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

AddReportBlock()

int qrtplib::RTCPCompoundPacketBuilder::AddReportBlock	(	uint32_t	ssrc,
		uint8_t	fractionlost,
		int32_t	packetslost,
		uint32_t	exthighestseq,
		uint32_t	jitter,
		uint32_t	lsr,
		uint32_t	dlsr
	)

Adds the report block information specified by the function's arguments. Adds the report block information specified by the function's arguments. If more than 31 report blocks are added, the builder will automatically use a new RTCP receiver report packet.

Definition at line 181 of file rtcpcompoundpacketbuilder.cpp.

References appsize, arebuilding, byesize, ERR_RTP_RTCPCOMPPACKBUILDER_NOTBUILDING, ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT, ERR_RTP_RTCPCOMPPACKBUILDER_REPORTNOTSTARTED, qrtplib::RTCPCompoundPacketBuilder::Report::headerlength, maximumpacketsize, qrtplib::RTCPCompoundPacketBuilder::SDES::NeededBytes(), qrtplib::RTCPCompoundPacketBuilder::Report::NeededBytesWithExtraReportBlock(), report, qrtplib::RTCPCompoundPacketBuilder::Report::reportblocks, sdes, and qrtplib::RTCPReceiverReport::ssrc.

Referenced by qrtplib::RTCPPacketBuilder::FillInReportBlocks().

{
    if (!arebuilding)
        return ERR_RTP_RTCPCOMPPACKBUILDER_NOTBUILDING;
    if (report.headerlength == 0)
        return ERR_RTP_RTCPCOMPPACKBUILDER_REPORTNOTSTARTED;

    std::size_t totalothersize = byesize + appsize + sdes.NeededBytes();
    std::size_t reportsizewithextrablock = report.NeededBytesWithExtraReportBlock();

    if ((totalothersize + reportsizewithextrablock) > maximumpacketsize)
        return ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT;

    uint8_t *buf = new uint8_t[sizeof(RTCPReceiverReport)];

    RTCPReceiverReport *rr = (RTCPReceiverReport *) buf;
    uint32_t *packlost = (uint32_t *) &packetslost;
    uint32_t packlost2 = (*packlost);

    rr->ssrc = qToBigEndian(ssrc);
    rr->fractionlost = fractionlost;
    rr->packetslost[2] = (uint8_t) (packlost2 & 0xFF);
    rr->packetslost[1] = (uint8_t) ((packlost2 >> 8) & 0xFF);
    rr->packetslost[0] = (uint8_t) ((packlost2 >> 16) & 0xFF);
    rr->exthighseqnr = qToBigEndian(exthighestseq);
    rr->jitter = qToBigEndian(jitter);
    rr->lsr = qToBigEndian(lsr);
    rr->dlsr = qToBigEndian(dlsr);

    report.reportblocks.push_back(Buffer(buf, sizeof(RTCPReceiverReport)));
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

AddSDESNormalItem()

int qrtplib::RTCPCompoundPacketBuilder::AddSDESNormalItem	(	RTCPSDESPacket::ItemType	t,
		const void *	itemdata,
		uint8_t	itemlength
	)

Adds a normal (non-private) SDES item of type t to the current SDES chunk. Adds a normal (non-private) SDES item of type t to the current SDES chunk. The item's value will have length itemlength and will contain the data itemdata.

Definition at line 232 of file rtcpcompoundpacketbuilder.cpp.

References qrtplib::RTCPCompoundPacketBuilder::SDES::AddItem(), appsize, arebuilding, byesize, qrtplib::RTCPSDESPacket::CNAME, qrtplib::RTCPSDESPacket::EMAIL, ERR_RTP_RTCPCOMPPACKBUILDER_INVALIDITEMTYPE, ERR_RTP_RTCPCOMPPACKBUILDER_NOCURRENTSOURCE, ERR_RTP_RTCPCOMPPACKBUILDER_NOTBUILDING, ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT, qrtplib::RTCPSDESHeader::length, qrtplib::RTCPSDESPacket::LOC, maximumpacketsize, qrtplib::RTCPSDESPacket::NAME, qrtplib::RTCPCompoundPacketBuilder::Report::NeededBytes(), qrtplib::RTCPCompoundPacketBuilder::SDES::NeededBytesWithExtraItem(), qrtplib::RTCPSDESPacket::NOTE, qrtplib::RTCPSDESPacket::PHONE, report, RTCP_SDES_ID_CNAME, RTCP_SDES_ID_EMAIL, RTCP_SDES_ID_LOCATION, RTCP_SDES_ID_NAME, RTCP_SDES_ID_NOTE, RTCP_SDES_ID_PHONE, RTCP_SDES_ID_TOOL, sdes, qrtplib::RTCPSDESHeader::sdesid, qrtplib::RTCPCompoundPacketBuilder::SDES::sdessources, and qrtplib::RTCPSDESPacket::TOOL.

Referenced by qrtplib::RTCPPacketBuilder::BuildBYEPacket(), qrtplib::RTCPPacketBuilder::BuildNextPacket(), qrtplib::RTCPPacketBuilder::FillInSDES(), and qrtplib::RTPSession::SendRTCPAPPPacket().

{
    if (!arebuilding)
        return ERR_RTP_RTCPCOMPPACKBUILDER_NOTBUILDING;
    if (sdes.sdessources.empty())
        return ERR_RTP_RTCPCOMPPACKBUILDER_NOCURRENTSOURCE;

    uint8_t itemid;

    switch (t)
    {
    case RTCPSDESPacket::CNAME:
        itemid = RTCP_SDES_ID_CNAME;
        break;
    case RTCPSDESPacket::NAME:
        itemid = RTCP_SDES_ID_NAME;
        break;
    case RTCPSDESPacket::EMAIL:
        itemid = RTCP_SDES_ID_EMAIL;
        break;
    case RTCPSDESPacket::PHONE:
        itemid = RTCP_SDES_ID_PHONE;
        break;
    case RTCPSDESPacket::LOC:
        itemid = RTCP_SDES_ID_LOCATION;
        break;
    case RTCPSDESPacket::TOOL:
        itemid = RTCP_SDES_ID_TOOL;
        break;
    case RTCPSDESPacket::NOTE:
        itemid = RTCP_SDES_ID_NOTE;
        break;
    default:
        return ERR_RTP_RTCPCOMPPACKBUILDER_INVALIDITEMTYPE;
    }

    std::size_t totalotherbytes = byesize + appsize + report.NeededBytes();
    std::size_t sdessizewithextraitem = sdes.NeededBytesWithExtraItem(itemlength);

    if ((sdessizewithextraitem + totalotherbytes) > maximumpacketsize)
        return ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT;

    uint8_t *buf;
    std::size_t len;

    buf = new uint8_t[sizeof(RTCPSDESHeader) + (std::size_t) itemlength];
    len = sizeof(RTCPSDESHeader) + (std::size_t) itemlength;

    RTCPSDESHeader *sdeshdr = (RTCPSDESHeader *) (buf);

    sdeshdr->sdesid = itemid;
    sdeshdr->length = itemlength;
    if (itemlength != 0)
        memcpy((buf + sizeof(RTCPSDESHeader)), itemdata, (std::size_t) itemlength);

    sdes.AddItem(buf, len);
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

AddSDESPrivateItem()

int qrtplib::RTCPCompoundPacketBuilder::AddSDESPrivateItem	(	const void *	prefixdata,
		uint8_t	prefixlength,
		const void *	valuedata,
		uint8_t	valuelength
	)

Adds an SDES PRIV item described by the function's arguments to the current SDES chunk.

Definition at line 292 of file rtcpcompoundpacketbuilder.cpp.

References qrtplib::RTCPCompoundPacketBuilder::SDES::AddItem(), appsize, arebuilding, byesize, ERR_RTP_RTCPCOMPPACKBUILDER_NOCURRENTSOURCE, ERR_RTP_RTCPCOMPPACKBUILDER_NOTBUILDING, ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT, ERR_RTP_RTCPCOMPPACKBUILDER_TOTALITEMLENGTHTOOBIG, qrtplib::RTCPSDESHeader::length, maximumpacketsize, qrtplib::RTCPCompoundPacketBuilder::Report::NeededBytes(), qrtplib::RTCPCompoundPacketBuilder::SDES::NeededBytesWithExtraItem(), report, RTCP_SDES_ID_PRIVATE, sdes, qrtplib::RTCPSDESHeader::sdesid, and qrtplib::RTCPCompoundPacketBuilder::SDES::sdessources.

{
    if (!arebuilding)
        return ERR_RTP_RTCPCOMPPACKBUILDER_NOTBUILDING;
    if (sdes.sdessources.empty())
        return ERR_RTP_RTCPCOMPPACKBUILDER_NOCURRENTSOURCE;

    std::size_t itemlength = ((std::size_t) prefixlength) + 1 + ((std::size_t) valuelength);
    if (itemlength > 255)
        return ERR_RTP_RTCPCOMPPACKBUILDER_TOTALITEMLENGTHTOOBIG;

    std::size_t totalotherbytes = byesize + appsize + report.NeededBytes();
    std::size_t sdessizewithextraitem = sdes.NeededBytesWithExtraItem(itemlength);

    if ((sdessizewithextraitem + totalotherbytes) > maximumpacketsize)
        return ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT;

    uint8_t *buf;
    std::size_t len;

    buf = new uint8_t[sizeof(RTCPSDESHeader) + itemlength];
    len = sizeof(RTCPSDESHeader) + (std::size_t) itemlength;

    RTCPSDESHeader *sdeshdr = (RTCPSDESHeader *) (buf);

    sdeshdr->sdesid = RTCP_SDES_ID_PRIVATE;
    sdeshdr->length = itemlength;

    buf[sizeof(RTCPSDESHeader)] = prefixlength;
    if (prefixlength != 0)
        memcpy((buf + sizeof(RTCPSDESHeader) + 1), prefixdata, (std::size_t) prefixlength);
    if (valuelength != 0)
        memcpy((buf + sizeof(RTCPSDESHeader) + 1 + (std::size_t) prefixlength), valuedata, (std::size_t) valuelength);

    sdes.AddItem(buf, len);
    return 0;
}

Here is the call graph for this function:

AddSDESSource()

int qrtplib::RTCPCompoundPacketBuilder::AddSDESSource

(

uint32_t

ssrc

)

Starts an SDES chunk for participant ssrc.

Definition at line 214 of file rtcpcompoundpacketbuilder.cpp.

References qrtplib::RTCPCompoundPacketBuilder::SDES::AddSSRC(), appsize, arebuilding, byesize, ERR_RTP_RTCPCOMPPACKBUILDER_NOTBUILDING, ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT, maximumpacketsize, qrtplib::RTCPCompoundPacketBuilder::Report::NeededBytes(), qrtplib::RTCPCompoundPacketBuilder::SDES::NeededBytesWithExtraSource(), report, and sdes.

Referenced by qrtplib::RTCPPacketBuilder::BuildBYEPacket(), qrtplib::RTCPPacketBuilder::BuildNextPacket(), and qrtplib::RTPSession::SendRTCPAPPPacket().

{
    if (!arebuilding)
        return ERR_RTP_RTCPCOMPPACKBUILDER_NOTBUILDING;

    std::size_t totalotherbytes = byesize + appsize + report.NeededBytes();
    std::size_t sdessizewithextrasource = sdes.NeededBytesWithExtraSource();

    if ((totalotherbytes + sdessizewithextrasource) > maximumpacketsize)
        return ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT;

    int status;

    if ((status = sdes.AddSSRC(ssrc)) < 0)
        return status;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ClearBuildBuffers()

void qrtplib::RTCPCompoundPacketBuilder::ClearBuildBuffers ( )

private

Definition at line 61 of file rtcpcompoundpacketbuilder.cpp.

References apppackets, appsize, byepackets, byesize, qrtplib::RTCPCompoundPacketBuilder::Report::Clear(), qrtplib::RTCPCompoundPacketBuilder::SDES::Clear(), report, and sdes.

Referenced by EndBuild(), and ~RTCPCompoundPacketBuilder().

{
    report.Clear();
    sdes.Clear();

    std::list<Buffer>::const_iterator it;
    for (it = byepackets.begin(); it != byepackets.end(); it++)
    {
        if ((*it).packetdata)
            delete[] (*it).packetdata;
    }
    for (it = apppackets.begin(); it != apppackets.end(); it++)
    {
        if ((*it).packetdata)
            delete[] (*it).packetdata;
    }
    byepackets.clear();
    apppackets.clear();
    byesize = 0;
    appsize = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

EndBuild()

int qrtplib::RTCPCompoundPacketBuilder::EndBuild

(

)

Finishes building the compound packet. Finishes building the compound packet. If successful, the RTCPCompoundPacket member functions can be used to access the RTCP packet data.

Definition at line 447 of file rtcpcompoundpacketbuilder.cpp.

References apppackets, appsize, arebuilding, buffer, byepackets, byesize, ClearBuildBuffers(), qrtplib::RTCPCompoundPacket::compoundpacket, qrtplib::RTCPCompoundPacket::compoundpacketlength, qrtplib::RTCPCommonHeader::count, ERR_RTP_RTCPCOMPPACKBUILDER_NOREPORTPRESENT, ERR_RTP_RTCPCOMPPACKBUILDER_NOTBUILDING, external, qrtplib::RTCPCompoundPacketBuilder::Report::headerdata, qrtplib::RTCPCompoundPacketBuilder::Report::headerlength, i, qrtplib::RTCPCompoundPacketBuilder::Report::isSR, qrtplib::RTCPCommonHeader::length, qrtplib::RTCPCompoundPacketBuilder::Report::NeededBytes(), qrtplib::RTCPCompoundPacketBuilder::SDES::NeededBytes(), qrtplib::RTCPCommonHeader::packettype, qrtplib::RTCPCommonHeader::padding, report, qrtplib::RTCPCompoundPacketBuilder::Report::reportblocks, qrtplib::RTCPCompoundPacket::rtcppacklist, RTP_RTCPTYPE_RR, RTP_RTCPTYPE_SDES, RTP_RTCPTYPE_SR, sdes, qrtplib::RTCPCompoundPacketBuilder::SDES::sdessources, and qrtplib::RTCPCommonHeader::version.

Referenced by qrtplib::RTCPPacketBuilder::BuildBYEPacket(), qrtplib::RTCPPacketBuilder::BuildNextPacket(), and qrtplib::RTPSession::SendRTCPAPPPacket().

{
    if (!arebuilding)
        return ERR_RTP_RTCPCOMPPACKBUILDER_NOTBUILDING;
    if (report.headerlength == 0)
        return ERR_RTP_RTCPCOMPPACKBUILDER_NOREPORTPRESENT;

    uint8_t *buf;
    std::size_t len;

    len = appsize + byesize + report.NeededBytes() + sdes.NeededBytes();

    if (!external)
    {
        buf = new uint8_t[len];
    }
    else
        buf = buffer;

    uint8_t *curbuf = buf;
    RTCPPacket *p;

    // first, we'll add all report info

    {
        bool firstpacket = true;
        bool done = false;
        std::list<Buffer>::const_iterator it = report.reportblocks.begin();
        do
        {
            RTCPCommonHeader *hdr = (RTCPCommonHeader *) curbuf;
            std::size_t offset;

            hdr->version = 2;
            hdr->padding = 0;

            if (firstpacket && report.isSR)
            {
                hdr->packettype = RTP_RTCPTYPE_SR;
                memcpy((curbuf + sizeof(RTCPCommonHeader)), report.headerdata, report.headerlength);
                offset = sizeof(RTCPCommonHeader) + report.headerlength;
            }
            else
            {
                hdr->packettype = RTP_RTCPTYPE_RR;
                memcpy((curbuf + sizeof(RTCPCommonHeader)), report.headerdata, sizeof(uint32_t));
                offset = sizeof(RTCPCommonHeader) + sizeof(uint32_t);
            }
            firstpacket = false;

            uint8_t count = 0;

            while (it != report.reportblocks.end() && count < 31)
            {
                memcpy(curbuf + offset, (*it).packetdata, (*it).packetlength);
                offset += (*it).packetlength;
                count++;
                it++;
            }

            std::size_t numwords = offset / sizeof(uint32_t);

            hdr->length = qToBigEndian((uint16_t) (numwords - 1));
            hdr->count = count;

            // add entry in parent's list
            if (hdr->packettype == RTP_RTCPTYPE_SR)
                p = new RTCPSRPacket(curbuf, offset);
            else
                p = new RTCPRRPacket(curbuf, offset);
            rtcppacklist.push_back(p);

            curbuf += offset;
            if (it == report.reportblocks.end())
                done = true;
        } while (!done);
    }

    // then, we'll add the sdes info

    if (!sdes.sdessources.empty())
    {
        bool done = false;
        std::list<SDESSource *>::const_iterator sourceit = sdes.sdessources.begin();

        do
        {
            RTCPCommonHeader *hdr = (RTCPCommonHeader *) curbuf;
            std::size_t offset = sizeof(RTCPCommonHeader);

            hdr->version = 2;
            hdr->padding = 0;
            hdr->packettype = RTP_RTCPTYPE_SDES;

            uint8_t sourcecount = 0;

            while (sourceit != sdes.sdessources.end() && sourcecount < 31)
            {
                uint32_t *ssrc = (uint32_t *) (curbuf + offset);
                *ssrc = qToBigEndian((*sourceit)->ssrc);
                offset += sizeof(uint32_t);

                std::list<Buffer>::const_iterator itemit, itemend;

                itemit = (*sourceit)->items.begin();
                itemend = (*sourceit)->items.end();
                while (itemit != itemend)
                {
                    memcpy(curbuf + offset, (*itemit).packetdata, (*itemit).packetlength);
                    offset += (*itemit).packetlength;
                    itemit++;
                }

                curbuf[offset] = 0; // end of item list;
                offset++;

                std::size_t r = offset & 0x03;
                if (r != 0) // align to 32 bit boundary
                {
                    std::size_t num = 4 - r;
                    std::size_t i;

                    for (i = 0; i < num; i++)
                        curbuf[offset + i] = 0;
                    offset += num;
                }

                sourceit++;
                sourcecount++;
            }

            std::size_t numwords = offset / 4;

            hdr->count = sourcecount;
            hdr->length = qToBigEndian((uint16_t) (numwords - 1));

            p = new RTCPSDESPacket(curbuf, offset);
            rtcppacklist.push_back(p);

            curbuf += offset;
            if (sourceit == sdes.sdessources.end())
                done = true;
        } while (!done);
    }

    // adding the app data

    {
        std::list<Buffer>::const_iterator it;

        for (it = apppackets.begin(); it != apppackets.end(); it++)
        {
            memcpy(curbuf, (*it).packetdata, (*it).packetlength);

            p = new RTCPAPPPacket(curbuf, (*it).packetlength);
            rtcppacklist.push_back(p);

            curbuf += (*it).packetlength;
        }
    }

    // adding bye packets

    {
        std::list<Buffer>::const_iterator it;

        for (it = byepackets.begin(); it != byepackets.end(); it++)
        {
            memcpy(curbuf, (*it).packetdata, (*it).packetlength);

            p = new RTCPBYEPacket(curbuf, (*it).packetlength);
            rtcppacklist.push_back(p);

            curbuf += (*it).packetlength;
        }
    }

    compoundpacket = buf;
    compoundpacketlength = len;
    arebuilding = false;
    ClearBuildBuffers();
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

InitBuild() [1/2]

int qrtplib::RTCPCompoundPacketBuilder::InitBuild

(

std::size_t

maxpacketsize

)

Starts building an RTCP compound packet with maximum size maxpacketsize. Starts building an RTCP compound packet with maximum size maxpacketsize. New memory will be allocated to store the packet.

Definition at line 83 of file rtcpcompoundpacketbuilder.cpp.

References appsize, arebuilding, buffer, byesize, qrtplib::RTCPCompoundPacket::compoundpacket, ERR_RTP_RTCPCOMPPACKBUILDER_ALREADYBUILDING, ERR_RTP_RTCPCOMPPACKBUILDER_ALREADYBUILT, ERR_RTP_RTCPCOMPPACKBUILDER_MAXPACKETSIZETOOSMALL, external, maximumpacketsize, and RTP_MINPACKETSIZE.

Referenced by qrtplib::RTCPPacketBuilder::BuildBYEPacket(), qrtplib::RTCPPacketBuilder::BuildNextPacket(), and qrtplib::RTPSession::SendRTCPAPPPacket().

{
    if (arebuilding)
        return ERR_RTP_RTCPCOMPPACKBUILDER_ALREADYBUILDING;
    if (compoundpacket)
        return ERR_RTP_RTCPCOMPPACKBUILDER_ALREADYBUILT;

    if (maxpacketsize < RTP_MINPACKETSIZE)
        return ERR_RTP_RTCPCOMPPACKBUILDER_MAXPACKETSIZETOOSMALL;

    maximumpacketsize = maxpacketsize;
    buffer = 0;
    external = false;
    byesize = 0;
    appsize = 0;

    arebuilding = true;
    return 0;
}

Here is the caller graph for this function:

InitBuild() [2/2]

int qrtplib::RTCPCompoundPacketBuilder::InitBuild	(	void *	externalbuffer,
		std::size_t	buffersize
	)

Starts building a RTCP compound packet. Starts building a RTCP compound packet. Data will be stored in externalbuffer which can contain buffersize bytes.

Definition at line 103 of file rtcpcompoundpacketbuilder.cpp.

References appsize, arebuilding, buffer, byesize, qrtplib::RTCPCompoundPacket::compoundpacket, ERR_RTP_RTCPCOMPPACKBUILDER_ALREADYBUILDING, ERR_RTP_RTCPCOMPPACKBUILDER_ALREADYBUILT, ERR_RTP_RTCPCOMPPACKBUILDER_BUFFERSIZETOOSMALL, external, maximumpacketsize, and RTP_MINPACKETSIZE.

{
    if (arebuilding)
        return ERR_RTP_RTCPCOMPPACKBUILDER_ALREADYBUILDING;
    if (compoundpacket)
        return ERR_RTP_RTCPCOMPPACKBUILDER_ALREADYBUILT;

    if (buffersize < RTP_MINPACKETSIZE)
        return ERR_RTP_RTCPCOMPPACKBUILDER_BUFFERSIZETOOSMALL;

    maximumpacketsize = buffersize;
    buffer = (uint8_t *) externalbuffer;
    external = true;
    byesize = 0;
    appsize = 0;

    arebuilding = true;
    return 0;
}

StartReceiverReport()

int qrtplib::RTCPCompoundPacketBuilder::StartReceiverReport

(

uint32_t

senderssrc

)

Adds a receiver report to the compound packet. Tells the packet builder that the packet should start with a receiver report which will contain he sender SSRC senderssrc. Once the sender report is started, report blocks can be added using the AddReportBlock function.

Definition at line 156 of file rtcpcompoundpacketbuilder.cpp.

References appsize, arebuilding, byesize, ERR_RTP_RTCPCOMPPACKBUILDER_ALREADYGOTREPORT, ERR_RTP_RTCPCOMPPACKBUILDER_NOTBUILDING, ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT, qrtplib::RTCPCompoundPacketBuilder::Report::headerdata, qrtplib::RTCPCompoundPacketBuilder::Report::headerlength, qrtplib::RTCPCompoundPacketBuilder::Report::isSR, maximumpacketsize, qrtplib::RTCPCompoundPacketBuilder::SDES::NeededBytes(), report, and sdes.

Referenced by qrtplib::RTCPPacketBuilder::BuildBYEPacket(), qrtplib::RTCPPacketBuilder::BuildNextPacket(), and qrtplib::RTPSession::SendRTCPAPPPacket().

{
    if (!arebuilding)
        return ERR_RTP_RTCPCOMPPACKBUILDER_NOTBUILDING;
    if (report.headerlength != 0)
        return ERR_RTP_RTCPCOMPPACKBUILDER_ALREADYGOTREPORT;

    std::size_t totalsize = byesize + appsize + sdes.NeededBytes();
    std::size_t sizeleft = maximumpacketsize - totalsize;
    std::size_t neededsize = sizeof(RTCPCommonHeader) + sizeof(uint32_t);

    if (neededsize > sizeleft)
        return ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT;

    // fill in some things

    report.headerlength = sizeof(uint32_t);
    report.isSR = false;

    uint32_t *ssrc = (uint32_t *) report.headerdata;
    *ssrc = qToBigEndian(senderssrc);

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

StartSenderReport()

int qrtplib::RTCPCompoundPacketBuilder::StartSenderReport	(	uint32_t	senderssrc,
		const RTPNTPTime &	ntptimestamp,
		uint32_t	rtptimestamp,
		uint32_t	packetcount,
		uint32_t	octetcount
	)

Adds a sender report to the compound packet. Tells the packet builder that the packet should start with a sender report which will contain the sender information specified by this function's arguments. Once the sender report is started, report blocks can be added using the AddReportBlock function.

Definition at line 123 of file rtcpcompoundpacketbuilder.cpp.

References appsize, arebuilding, byesize, ERR_RTP_RTCPCOMPPACKBUILDER_ALREADYGOTREPORT, ERR_RTP_RTCPCOMPPACKBUILDER_NOTBUILDING, ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT, qrtplib::RTPNTPTime::GetLSW(), qrtplib::RTPNTPTime::GetMSW(), qrtplib::RTCPCompoundPacketBuilder::Report::headerdata, qrtplib::RTCPCompoundPacketBuilder::Report::headerlength, qrtplib::RTCPCompoundPacketBuilder::Report::isSR, maximumpacketsize, qrtplib::RTCPCompoundPacketBuilder::SDES::NeededBytes(), qrtplib::RTCPSenderReport::ntptime_lsw, qrtplib::RTCPSenderReport::ntptime_msw, qrtplib::RTCPSenderReport::octetcount, qrtplib::RTCPSenderReport::packetcount, report, qrtplib::RTCPSenderReport::rtptimestamp, and sdes.

Referenced by qrtplib::RTCPPacketBuilder::BuildBYEPacket(), and qrtplib::RTCPPacketBuilder::BuildNextPacket().

{
    if (!arebuilding)
        return ERR_RTP_RTCPCOMPPACKBUILDER_NOTBUILDING;

    if (report.headerlength != 0)
        return ERR_RTP_RTCPCOMPPACKBUILDER_ALREADYGOTREPORT;

    std::size_t totalsize = byesize + appsize + sdes.NeededBytes();
    std::size_t sizeleft = maximumpacketsize - totalsize;
    std::size_t neededsize = sizeof(RTCPCommonHeader) + sizeof(uint32_t) + sizeof(RTCPSenderReport);

    if (neededsize > sizeleft)
        return ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT;

    // fill in some things

    report.headerlength = sizeof(uint32_t) + sizeof(RTCPSenderReport);
    report.isSR = true;

    uint32_t *ssrc = (uint32_t *) report.headerdata;
    *ssrc = qToBigEndian(senderssrc);

    RTCPSenderReport *sr = (RTCPSenderReport *) (report.headerdata + sizeof(uint32_t));
    sr->ntptime_msw = qToBigEndian(ntptimestamp.GetMSW());
    sr->ntptime_lsw = qToBigEndian(ntptimestamp.GetLSW());
    sr->rtptimestamp = qToBigEndian(rtptimestamp);
    sr->packetcount = qToBigEndian(packetcount);
    sr->octetcount = qToBigEndian(octetcount);

    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

apppackets

std::list<Buffer> qrtplib::RTCPCompoundPacketBuilder::apppackets

private

Definition at line 398 of file rtcpcompoundpacketbuilder.h.

Referenced by AddAPPPacket(), ClearBuildBuffers(), and EndBuild().

appsize

std::size_t qrtplib::RTCPCompoundPacketBuilder::appsize

private

Definition at line 399 of file rtcpcompoundpacketbuilder.h.

Referenced by AddAPPPacket(), AddBYEPacket(), AddReportBlock(), AddSDESNormalItem(), AddSDESPrivateItem(), AddSDESSource(), ClearBuildBuffers(), EndBuild(), InitBuild(), RTCPCompoundPacketBuilder(), StartReceiverReport(), and StartSenderReport().

arebuilding

bool qrtplib::RTCPCompoundPacketBuilder::arebuilding

private

Definition at line 390 of file rtcpcompoundpacketbuilder.h.

Referenced by AddAPPPacket(), AddBYEPacket(), AddReportBlock(), AddSDESNormalItem(), AddSDESPrivateItem(), AddSDESSource(), EndBuild(), InitBuild(), RTCPCompoundPacketBuilder(), StartReceiverReport(), and StartSenderReport().

buffer

uint8_t* qrtplib::RTCPCompoundPacketBuilder::buffer

private

Definition at line 388 of file rtcpcompoundpacketbuilder.h.

Referenced by EndBuild(), InitBuild(), and RTCPCompoundPacketBuilder().

byepackets

std::list<Buffer> qrtplib::RTCPCompoundPacketBuilder::byepackets

private

Definition at line 395 of file rtcpcompoundpacketbuilder.h.

Referenced by AddBYEPacket(), ClearBuildBuffers(), and EndBuild().

byesize

std::size_t qrtplib::RTCPCompoundPacketBuilder::byesize

private

Definition at line 396 of file rtcpcompoundpacketbuilder.h.

Referenced by AddAPPPacket(), AddBYEPacket(), AddReportBlock(), AddSDESNormalItem(), AddSDESPrivateItem(), AddSDESSource(), ClearBuildBuffers(), EndBuild(), InitBuild(), RTCPCompoundPacketBuilder(), StartReceiverReport(), and StartSenderReport().

external

bool qrtplib::RTCPCompoundPacketBuilder::external

private

Definition at line 389 of file rtcpcompoundpacketbuilder.h.

Referenced by EndBuild(), InitBuild(), RTCPCompoundPacketBuilder(), and ~RTCPCompoundPacketBuilder().

m_endian

RTPEndian qrtplib::RTCPCompoundPacketBuilder::m_endian

private

Definition at line 386 of file rtcpcompoundpacketbuilder.h.

maximumpacketsize

std::size_t qrtplib::RTCPCompoundPacketBuilder::maximumpacketsize

private

Definition at line 387 of file rtcpcompoundpacketbuilder.h.

Referenced by AddAPPPacket(), AddBYEPacket(), AddReportBlock(), AddSDESNormalItem(), AddSDESPrivateItem(), AddSDESSource(), InitBuild(), RTCPCompoundPacketBuilder(), StartReceiverReport(), and StartSenderReport().

report

Report qrtplib::RTCPCompoundPacketBuilder::report

private

Definition at line 392 of file rtcpcompoundpacketbuilder.h.

Referenced by AddAPPPacket(), AddBYEPacket(), AddReportBlock(), AddSDESNormalItem(), AddSDESPrivateItem(), AddSDESSource(), ClearBuildBuffers(), EndBuild(), StartReceiverReport(), and StartSenderReport().

sdes

SDES qrtplib::RTCPCompoundPacketBuilder::sdes

private

Definition at line 393 of file rtcpcompoundpacketbuilder.h.

Referenced by AddAPPPacket(), AddBYEPacket(), AddReportBlock(), AddSDESNormalItem(), AddSDESPrivateItem(), AddSDESSource(), ClearBuildBuffers(), EndBuild(), StartReceiverReport(), and StartSenderReport().

---

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

• qrtplib/rtcpcompoundpacketbuilder.h
• qrtplib/rtcpcompoundpacketbuilder.cpp