void RTCPCompoundPacketBuilder::ClearBuildBuffers()
{
report.Clear();
sdes.Clear();
std::list<Buffer>::const_iterator it;
for (it = byepackets.begin() ; it != byepackets.end() ; it++)
{
if ((*it).packetdata)
RTPDeleteByteArray((*it).packetdata,GetMemoryManager());
}
for (it = apppackets.begin() ; it != apppackets.end() ; it++)
{
if ((*it).packetdata)
RTPDeleteByteArray((*it).packetdata,GetMemoryManager());
}
#ifdef RTP_SUPPORT_RTCPUNKNOWN
for (it = unknownpackets.begin() ; it != unknownpackets.end() ; it++)
{
if ((*it).packetdata)
RTPDeleteByteArray((*it).packetdata,GetMemoryManager());
}
#endif // RTP_SUPPORT_RTCPUNKNOWN
byepackets.clear();
apppackets.clear();
#ifdef RTP_SUPPORT_RTCPUNKNOWN
unknownpackets.clear();
#endif // RTP_SUPPORT_RTCPUNKNOWN
byesize = 0;
appsize = 0;
#ifdef RTP_SUPPORT_RTCPUNKNOWN
unknownsize = 0;
#endif // RTP_SUPPORT_RTCPUNKNOWN
}
void RTPPacketBuilder::Destroy()
{
if (!init)
return;
RTPDeleteByteArray(buffer,GetMemoryManager());
init = false;
}
void RTCPCompoundPacketBuilder::ClearBuildBuffers()
{
report.Clear();
sdes.Clear();
std::list<Buffer>::const_iterator it;
for (it = byepackets.begin() ; it != byepackets.end() ; it++)
{
if ((*it).packetdata)
RTPDeleteByteArray((*it).packetdata,GetMemoryManager());
}
for (it = apppackets.begin() ; it != apppackets.end() ; it++)
{
if ((*it).packetdata)
RTPDeleteByteArray((*it).packetdata,GetMemoryManager());
}
byepackets.clear();
apppackets.clear();
byesize = 0;
appsize = 0;
}
int RTPPacketBuilder::SetMaximumPacketSize(size_t max)
{
uint8_t *newbuf;
if (max <= 0)
return ERR_RTP_PACKBUILD_INVALIDMAXPACKETSIZE;
newbuf = RTPNew(GetMemoryManager(),RTPMEM_TYPE_BUFFER_RTPPACKETBUILDERBUFFER) uint8_t[max];
if (newbuf == 0)
return ERR_RTP_OUTOFMEM;
RTPDeleteByteArray(buffer,GetMemoryManager());
buffer = newbuf;
maxpacksize = max;
return 0;
}
int RTPInternalSourceData::ProcessBYEPacket(const uint8_t *reason,size_t reasonlen,const RTPTime &receivetime)
{
if (byereason)
{
RTPDeleteByteArray(byereason,GetMemoryManager());
byereason = 0;
byereasonlen = 0;
}
byetime = receivetime;
byereason = RTPNew(GetMemoryManager(),RTPMEM_TYPE_BUFFER_RTCPBYEREASON) uint8_t[reasonlen];
if (byereason == 0)
return ERR_RTP_OUTOFMEM;
memcpy(byereason,reason,reasonlen);
byereasonlen = reasonlen;
receivedbye = true;
stats.SetLastMessageTime(receivetime);
return 0;
}
int RTCPCompoundPacketBuilder::EndBuild()
{
if (!arebuilding)
return ERR_RTP_RTCPCOMPPACKBUILDER_NOTBUILDING;
if (report.headerlength == 0)
return ERR_RTP_RTCPCOMPPACKBUILDER_NOREPORTPRESENT;
uint8_t *buf;
size_t len;
len = appsize+byesize+report.NeededBytes()+sdes.NeededBytes();
if (!external)
{
buf = RTPNew(GetMemoryManager(),RTPMEM_TYPE_BUFFER_RTCPCOMPOUNDPACKET) uint8_t[len];
if (buf == 0)
return ERR_RTP_OUTOFMEM;
}
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;
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++;
}
size_t numwords = offset/sizeof(uint32_t);
hdr->length = htons((uint16_t)(numwords-1));
hdr->count = count;
// add entry in parent's list
if (hdr->packettype == RTP_RTCPTYPE_SR)
p = RTPNew(GetMemoryManager(),RTPMEM_TYPE_CLASS_RTCPSRPACKET) RTCPSRPacket(curbuf,offset);
else
p = RTPNew(GetMemoryManager(),RTPMEM_TYPE_CLASS_RTCPRRPACKET) RTCPRRPacket(curbuf,offset);
if (p == 0)
{
if (!external)
RTPDeleteByteArray(buf,GetMemoryManager());
ClearPacketList();
return ERR_RTP_OUTOFMEM;
}
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;
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 = htonl((*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++;
size_t r = offset&0x03;
if (r != 0) // align to 32 bit boundary
{
size_t num = 4-r;
size_t i;
for (i = 0 ; i < num ; i++)
curbuf[offset+i] = 0;
offset += num;
}
sourceit++;
sourcecount++;
}
size_t numwords = offset/4;
hdr->count = sourcecount;
hdr->length = htons((uint16_t)(numwords-1));
p = RTPNew(GetMemoryManager(),RTPMEM_TYPE_CLASS_RTCPSDESPACKET) RTCPSDESPacket(curbuf,offset);
if (p == 0)
{
if (!external)
RTPDeleteByteArray(buf,GetMemoryManager());
ClearPacketList();
return ERR_RTP_OUTOFMEM;
}
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 = RTPNew(GetMemoryManager(),RTPMEM_TYPE_CLASS_RTCPAPPPACKET) RTCPAPPPacket(curbuf,(*it).packetlength);
if (p == 0)
{
if (!external)
RTPDeleteByteArray(buf,GetMemoryManager());
ClearPacketList();
return ERR_RTP_OUTOFMEM;
}
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 = RTPNew(GetMemoryManager(),RTPMEM_TYPE_CLASS_RTCPBYEPACKET) RTCPBYEPacket(curbuf,(*it).packetlength);
if (p == 0)
{
if (!external)
RTPDeleteByteArray(buf,GetMemoryManager());
ClearPacketList();
return ERR_RTP_OUTOFMEM;
}
rtcppacklist.push_back(p);
curbuf += (*it).packetlength;
}
}
compoundpacket = buf;
compoundpacketlength = len;
arebuilding = false;
ClearBuildBuffers();
return 0;
}
RTCPCompoundPacket::~RTCPCompoundPacket()
{
ClearPacketList();
if (compoundpacket && deletepacket)
RTPDeleteByteArray(compoundpacket,GetMemoryManager());
}
