VE7UWU/sdrangel
1
0
Fork 0
mirror of https://github.com/f4exb/sdrangel.git synced 2025-02-03 09:44:01 -05:00
Code Issues Projects Releases Wiki Activity

qrtplib: replaced size_t by std::size_t

Browse Source
This commit is contained in:
f4exb 2018-02-28 13:31:44 +01:00
parent 9bcabb708d
commit f678c049f9
47 changed files with 460 additions and 457 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
qrtplib/rtcpapppacket.cpp
View File

@ -35,13 +35,13 @@
namespace qrtplib
{
RTCPAPPPacket::RTCPAPPPacket(uint8_t *data, size_t datalength) :
RTCPAPPPacket::RTCPAPPPacket(uint8_t *data, std::size_t datalength) :
RTCPPacket(APP, data, datalength)
{
knownformat = false;
RTCPCommonHeader *hdr;
size_t len = datalength;
std::size_t len = datalength;
hdr = (RTCPCommonHeader *) data;
if (hdr->padding)
@ -49,9 +49,9 @@ RTCPAPPPacket::RTCPAPPPacket(uint8_t *data, size_t datalength) :
uint8_t padcount = data[datalength - 1];
if ((padcount & 0x03) != 0) // not a multiple of four! (see rfc 3550 p 37)
return;
if (((size_t) padcount) >= len)
if (((std::size_t) padcount) >= len)
return;
len -= (size_t) padcount;
len -= (std::size_t) padcount;
}
if (len < (sizeof(RTCPCommonHeader) + sizeof(uint32_t) * 2))

8
qrtplib/rtcpapppacket.h
View File

@ -57,7 +57,7 @@ public:
* is referenced inside the class (no copy of the data is made) one must make sure that the memory it
* points to is valid as long as the class instance exists.
*/
RTCPAPPPacket(uint8_t *data, size_t datalen);
RTCPAPPPacket(uint8_t *data, std::size_t datalen);
~RTCPAPPPacket()
{
}
@ -77,10 +77,10 @@ public:
uint8_t *GetAPPData();
/** Returns the length of the actual data. */
size_t GetAPPDataLength() const;
std::size_t GetAPPDataLength() const;
private:
RTPEndian m_endian;
size_t appdatalen;
std::size_t appdatalen;
};
inline uint8_t RTCPAPPPacket::GetSubType() const
@ -117,7 +117,7 @@ inline uint8_t *RTCPAPPPacket::GetAPPData()
return (data + sizeof(RTCPCommonHeader) + sizeof(uint32_t) * 2);
}
inline size_t RTCPAPPPacket::GetAPPDataLength() const
inline std::size_t RTCPAPPPacket::GetAPPDataLength() const
{
if (!knownformat)
return 0;

12
qrtplib/rtcpbyepacket.cpp
View File

@ -35,14 +35,14 @@
namespace qrtplib
{
RTCPBYEPacket::RTCPBYEPacket(uint8_t *data, size_t datalength) :
RTCPBYEPacket::RTCPBYEPacket(uint8_t *data, std::size_t datalength) :
RTCPPacket(BYE, data, datalength)
{
knownformat = false;
reasonoffset = 0;
RTCPCommonHeader *hdr;
size_t len = datalength;
std::size_t len = datalength;
hdr = (RTCPCommonHeader *) data;
if (hdr->padding)
@ -50,18 +50,18 @@ RTCPBYEPacket::RTCPBYEPacket(uint8_t *data, size_t datalength) :
uint8_t padcount = data[datalength - 1];
if ((padcount & 0x03) != 0) // not a multiple of four! (see rfc 3550 p 37)
return;
if (((size_t) padcount) >= len)
if (((std::size_t) padcount) >= len)
return;
len -= (size_t) padcount;
len -= (std::size_t) padcount;
}
size_t ssrclen = ((size_t)(hdr->count)) * sizeof(uint32_t) + sizeof(RTCPCommonHeader);
std::size_t ssrclen = ((std::size_t)(hdr->count)) * sizeof(uint32_t) + sizeof(RTCPCommonHeader);
if (ssrclen > len)
return;
if (ssrclen < len) // there's probably a reason for leaving
{
uint8_t *reasonlength = (data + ssrclen);
size_t reaslen = (size_t)(*reasonlength);
std::size_t reaslen = (std::size_t)(*reasonlength);
if (reaslen > (len - ssrclen - 1))
return;
reasonoffset = ssrclen;

10
qrtplib/rtcpbyepacket.h
View File

@ -57,7 +57,7 @@ public:
* is referenced inside the class (no copy of the data is made) one must make sure that the memory it
* points to is valid as long as the class instance exists.
*/
RTCPBYEPacket(uint8_t *data, size_t datalen);
RTCPBYEPacket(uint8_t *data, std::size_t datalen);
~RTCPBYEPacket()
{
}
@ -74,14 +74,14 @@ public:
bool HasReasonForLeaving() const;
/** Returns the length of the string which describes why the source(s) left. */
size_t GetReasonLength() const;
std::size_t GetReasonLength() const;
/** Returns the actual reason for leaving data. */
uint8_t *GetReasonData();
private:
RTPEndian m_endian;
size_t reasonoffset;
std::size_t reasonoffset;
};
inline int RTCPBYEPacket::GetSSRCCount() const
@ -110,14 +110,14 @@ inline bool RTCPBYEPacket::HasReasonForLeaving() const
return true;
}
inline size_t RTCPBYEPacket::GetReasonLength() const
inline std::size_t RTCPBYEPacket::GetReasonLength() const
{
if (!knownformat)
return 0;
if (reasonoffset == 0)
return 0;
uint8_t *reasonlen = (data + reasonoffset);
return (size_t)(*reasonlen);
return (std::size_t)(*reasonlen);
}
inline uint8_t *RTCPBYEPacket::GetReasonData()

12
qrtplib/rtcpcompoundpacket.cpp
View File

@ -58,7 +58,7 @@ RTCPCompoundPacket::RTCPCompoundPacket(RTPRawPacket &rawpack)
}
uint8_t *data = rawpack.GetData();
size_t datalen = rawpack.GetDataLength();
std::size_t datalen = rawpack.GetDataLength();
error = ParseData(data, datalen);
if (error < 0)
@ -73,7 +73,7 @@ RTCPCompoundPacket::RTCPCompoundPacket(RTPRawPacket &rawpack)
rtcppackit = rtcppacklist.begin();
}
RTCPCompoundPacket::RTCPCompoundPacket(uint8_t *packet, size_t packetlen, bool deletedata)
RTCPCompoundPacket::RTCPCompoundPacket(uint8_t *packet, std::size_t packetlen, bool deletedata)
{
compoundpacket = 0;
compoundpacketlength = 0;
@ -97,7 +97,7 @@ RTCPCompoundPacket::RTCPCompoundPacket()
deletepacket = true;
}
int RTCPCompoundPacket::ParseData(uint8_t *data, size_t datalen)
int RTCPCompoundPacket::ParseData(uint8_t *data, std::size_t datalen)
{
bool first;
@ -109,7 +109,7 @@ int RTCPCompoundPacket::ParseData(uint8_t *data, size_t datalen)
do
{
RTCPCommonHeader *rtcphdr;
size_t length;
std::size_t length;
rtcphdr = (RTCPCommonHeader *) data;
if (rtcphdr->version != RTP_VERSION) // check version
@ -129,7 +129,7 @@ int RTCPCompoundPacket::ParseData(uint8_t *data, size_t datalen)
}
}
length = (size_t) m_endian.qToHost(rtcphdr->length);
length = (std::size_t) m_endian.qToHost(rtcphdr->length);
length++;
length *= sizeof(uint32_t);
@ -182,7 +182,7 @@ int RTCPCompoundPacket::ParseData(uint8_t *data, size_t datalen)
datalen -= length;
data += length;
} while (datalen >= (size_t) sizeof(RTCPCommonHeader));
} while (datalen >= (std::size_t) sizeof(RTCPCommonHeader));
if (datalen != 0) // some remaining bytes
{

8
qrtplib/rtcpcompoundpacket.h
View File

@ -61,7 +61,7 @@ public:
* flag specifies if the data in \c packet should be deleted when the compound packet is destroyed. If
* specified, a memory manager will be installed.
*/
RTCPCompoundPacket(uint8_t *packet, size_t len, bool deletedata = true);
RTCPCompoundPacket(uint8_t *packet, std::size_t len, bool deletedata = true);
protected:
RTCPCompoundPacket(); // this is for the compoundpacket builder
public:
@ -83,7 +83,7 @@ public:
}
/** Returns the size of the entire RTCP compound packet. */
size_t GetCompoundPacketLength()
std::size_t GetCompoundPacketLength()
{
return compoundpacketlength;
}
@ -109,13 +109,13 @@ public:
protected:
void ClearPacketList();
int ParseData(uint8_t *packet, size_t len);
int ParseData(uint8_t *packet, std::size_t len);
RTPEndian m_endian;
int error;
uint8_t *compoundpacket;
size_t compoundpacketlength;
std::size_t compoundpacketlength;
bool deletepacket;
std::list<RTCPPacket *> rtcppacklist;

92
qrtplib/rtcpcompoundpacketbuilder.cpp
View File

@ -80,7 +80,7 @@ void RTCPCompoundPacketBuilder::ClearBuildBuffers()
appsize = 0;
}
int RTCPCompoundPacketBuilder::InitBuild(size_t maxpacketsize)
int RTCPCompoundPacketBuilder::InitBuild(std::size_t maxpacketsize)
{
if (arebuilding)
return ERR_RTP_RTCPCOMPPACKBUILDER_ALREADYBUILDING;
@ -100,7 +100,7 @@ int RTCPCompoundPacketBuilder::InitBuild(size_t maxpacketsize)
return 0;
}
int RTCPCompoundPacketBuilder::InitBuild(void *externalbuffer, size_t buffersize)
int RTCPCompoundPacketBuilder::InitBuild(void *externalbuffer, std::size_t buffersize)
{
if (arebuilding)
return ERR_RTP_RTCPCOMPPACKBUILDER_ALREADYBUILDING;
@ -128,9 +128,9 @@ int RTCPCompoundPacketBuilder::StartSenderReport(uint32_t senderssrc, const RTPN
if (report.headerlength != 0)
return ERR_RTP_RTCPCOMPPACKBUILDER_ALREADYGOTREPORT;
size_t totalsize = byesize + appsize + sdes.NeededBytes();
size_t sizeleft = maximumpacketsize - totalsize;
size_t neededsize = sizeof(RTCPCommonHeader) + sizeof(uint32_t) + sizeof(RTCPSenderReport);
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;
@ -160,9 +160,9 @@ int RTCPCompoundPacketBuilder::StartReceiverReport(uint32_t senderssrc)
if (report.headerlength != 0)
return ERR_RTP_RTCPCOMPPACKBUILDER_ALREADYGOTREPORT;
size_t totalsize = byesize + appsize + sdes.NeededBytes();
size_t sizeleft = maximumpacketsize - totalsize;
size_t neededsize = sizeof(RTCPCommonHeader) + sizeof(uint32_t);
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;
@ -185,8 +185,8 @@ int RTCPCompoundPacketBuilder::AddReportBlock(uint32_t ssrc, uint8_t fractionlos
if (report.headerlength == 0)
return ERR_RTP_RTCPCOMPPACKBUILDER_REPORTNOTSTARTED;
size_t totalothersize = byesize + appsize + sdes.NeededBytes();
size_t reportsizewithextrablock = report.NeededBytesWithExtraReportBlock();
std::size_t totalothersize = byesize + appsize + sdes.NeededBytes();
std::size_t reportsizewithextrablock = report.NeededBytesWithExtraReportBlock();
if ((totalothersize + reportsizewithextrablock) > maximumpacketsize)
return ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT;
@ -218,8 +218,8 @@ int RTCPCompoundPacketBuilder::AddSDESSource(uint32_t ssrc)
if (!arebuilding)
return ERR_RTP_RTCPCOMPPACKBUILDER_NOTBUILDING;
size_t totalotherbytes = byesize + appsize + report.NeededBytes();
size_t sdessizewithextrasource = sdes.NeededBytesWithExtraSource();
std::size_t totalotherbytes = byesize + appsize + report.NeededBytes();
std::size_t sdessizewithextrasource = sdes.NeededBytesWithExtraSource();
if ((totalotherbytes + sdessizewithextrasource) > maximumpacketsize)
return ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT;
@ -267,26 +267,26 @@ int RTCPCompoundPacketBuilder::AddSDESNormalItem(RTCPSDESPacket::ItemType t, con
return ERR_RTP_RTCPCOMPPACKBUILDER_INVALIDITEMTYPE;
}
size_t totalotherbytes = byesize + appsize + report.NeededBytes();
size_t sdessizewithextraitem = sdes.NeededBytesWithExtraItem(itemlength);
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;
size_t len;
std::size_t len;
buf = new uint8_t[sizeof(RTCPSDESHeader) + (size_t) itemlength];
buf = new uint8_t[sizeof(RTCPSDESHeader) + (std::size_t) itemlength];
if (buf == 0)
return ERR_RTP_OUTOFMEM;
len = sizeof(RTCPSDESHeader) + (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, (size_t) itemlength);
memcpy((buf + sizeof(RTCPSDESHeader)), itemdata, (std::size_t) itemlength);
sdes.AddItem(buf, len);
return 0;
@ -300,23 +300,23 @@ int RTCPCompoundPacketBuilder::AddSDESPrivateItem(const void *prefixdata, uint8_
if (sdes.sdessources.empty())
return ERR_RTP_RTCPCOMPPACKBUILDER_NOCURRENTSOURCE;
size_t itemlength = ((size_t) prefixlength) + 1 + ((size_t) valuelength);
std::size_t itemlength = ((std::size_t) prefixlength) + 1 + ((std::size_t) valuelength);
if (itemlength > 255)
return ERR_RTP_RTCPCOMPPACKBUILDER_TOTALITEMLENGTHTOOBIG;
size_t totalotherbytes = byesize + appsize + report.NeededBytes();
size_t sdessizewithextraitem = sdes.NeededBytesWithExtraItem(itemlength);
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;
size_t len;
std::size_t len;
buf = new uint8_t[sizeof(RTCPSDESHeader) + itemlength];
if (buf == 0)
return ERR_RTP_OUTOFMEM;
len = sizeof(RTCPSDESHeader) + (size_t) itemlength;
len = sizeof(RTCPSDESHeader) + (std::size_t) itemlength;
RTCPSDESHeader *sdeshdr = (RTCPSDESHeader *) (buf);
@ -325,9 +325,9 @@ int RTCPCompoundPacketBuilder::AddSDESPrivateItem(const void *prefixdata, uint8_
buf[sizeof(RTCPSDESHeader)] = prefixlength;
if (prefixlength != 0)
memcpy((buf + sizeof(RTCPSDESHeader) + 1), prefixdata, (size_t) prefixlength);
memcpy((buf + sizeof(RTCPSDESHeader) + 1), prefixdata, (std::size_t) prefixlength);
if (valuelength != 0)
memcpy((buf + sizeof(RTCPSDESHeader) + 1 + (size_t) prefixlength), valuedata, (size_t) valuelength);
memcpy((buf + sizeof(RTCPSDESHeader) + 1 + (std::size_t) prefixlength), valuedata, (std::size_t) valuelength);
sdes.AddItem(buf, len);
return 0;
@ -342,15 +342,15 @@ int RTCPCompoundPacketBuilder::AddBYEPacket(uint32_t *ssrcs, uint8_t numssrcs, c
if (numssrcs > 31)
return ERR_RTP_RTCPCOMPPACKBUILDER_TOOMANYSSRCS;
size_t packsize = sizeof(RTCPCommonHeader) + sizeof(uint32_t) * ((size_t) numssrcs);
size_t zerobytes = 0;
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 += (size_t) reasonlength;
packsize += (std::size_t) reasonlength;
size_t r = (packsize & 0x03);
std::size_t r = (packsize & 0x03);
if (r != 0)
{
zerobytes = 4 - r;
@ -358,13 +358,13 @@ int RTCPCompoundPacketBuilder::AddBYEPacket(uint32_t *ssrcs, uint8_t numssrcs, c
}
}
size_t totalotherbytes = appsize + byesize + sdes.NeededBytes() + report.NeededBytes();
std::size_t totalotherbytes = appsize + byesize + sdes.NeededBytes() + report.NeededBytes();
if ((totalotherbytes + packsize) > maximumpacketsize)
return ERR_RTP_RTCPCOMPPACKBUILDER_NOTENOUGHBYTESLEFT;
uint8_t *buf;
size_t numwords;
std::size_t numwords;
buf = new uint8_t[packsize];
if (buf == 0)
@ -388,11 +388,11 @@ int RTCPCompoundPacketBuilder::AddBYEPacket(uint32_t *ssrcs, uint8_t numssrcs, c
if (reasonlength != 0)
{
size_t offset = sizeof(RTCPCommonHeader) + ((size_t) numssrcs) * sizeof(uint32_t);
std::size_t offset = sizeof(RTCPCommonHeader) + ((std::size_t) numssrcs) * sizeof(uint32_t);
buf[offset] = reasonlength;
memcpy((buf + offset + 1), reasondata, (size_t) reasonlength);
for (size_t i = 0; i < zerobytes; i++)
memcpy((buf + offset + 1), reasondata, (std::size_t) reasonlength);
for (std::size_t i = 0; i < zerobytes; i++)
buf[packsize - 1 - i] = 0;
}
@ -402,7 +402,7 @@ int RTCPCompoundPacketBuilder::AddBYEPacket(uint32_t *ssrcs, uint8_t numssrcs, c
return 0;
}
int RTCPCompoundPacketBuilder::AddAPPPacket(uint8_t subtype, uint32_t ssrc, const uint8_t name[4], const void *appdata, size_t appdatalen)
int RTCPCompoundPacketBuilder::AddAPPPacket(uint8_t subtype, uint32_t ssrc, const uint8_t name[4], const void *appdata, std::size_t appdatalen)
{
if (!arebuilding)
return ERR_RTP_RTCPCOMPPACKBUILDER_NOTBUILDING;
@ -411,13 +411,13 @@ int RTCPCompoundPacketBuilder::AddAPPPacket(uint8_t subtype, uint32_t ssrc, cons
if ((appdatalen % 4) != 0)
return ERR_RTP_RTCPCOMPPACKBUILDER_ILLEGALAPPDATALENGTH;
size_t appdatawords = appdatalen / 4;
std::size_t appdatawords = appdatalen / 4;
if ((appdatawords + 2) > 65535)
return ERR_RTP_RTCPCOMPPACKBUILDER_APPDATALENTOOBIG;
size_t packsize = sizeof(RTCPCommonHeader) + sizeof(uint32_t) * 2 + appdatalen;
size_t totalotherbytes = appsize + byesize + sdes.NeededBytes() + report.NeededBytes();
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;
@ -462,7 +462,7 @@ int RTCPCompoundPacketBuilder::EndBuild()
return ERR_RTP_RTCPCOMPPACKBUILDER_NOREPORTPRESENT;
uint8_t *buf;
size_t len;
std::size_t len;
len = appsize + byesize + report.NeededBytes() + sdes.NeededBytes();
@ -487,7 +487,7 @@ int RTCPCompoundPacketBuilder::EndBuild()
do
{
RTCPCommonHeader *hdr = (RTCPCommonHeader *) curbuf;
size_t offset;
std::size_t offset;
hdr->version = 2;
hdr->padding = 0;
@ -516,7 +516,7 @@ int RTCPCompoundPacketBuilder::EndBuild()
it++;
}
size_t numwords = offset / sizeof(uint32_t);
std::size_t numwords = offset / sizeof(uint32_t);
hdr->length = qToBigEndian((uint16_t) (numwords - 1));
hdr->count = count;
@ -551,7 +551,7 @@ int RTCPCompoundPacketBuilder::EndBuild()
do
{
RTCPCommonHeader *hdr = (RTCPCommonHeader *) curbuf;
size_t offset = sizeof(RTCPCommonHeader);
std::size_t offset = sizeof(RTCPCommonHeader);
hdr->version = 2;
hdr->padding = 0;
@ -579,11 +579,11 @@ int RTCPCompoundPacketBuilder::EndBuild()
curbuf[offset] = 0; // end of item list;
offset++;
size_t r = offset & 0x03;
std::size_t r = offset & 0x03;
if (r != 0) // align to 32 bit boundary
{
size_t num = 4 - r;
size_t i;
std::size_t num = 4 - r;
std::size_t i;
for (i = 0; i < num; i++)
curbuf[offset + i] = 0;
@ -594,7 +594,7 @@ int RTCPCompoundPacketBuilder::EndBuild()
sourcecount++;
}
size_t numwords = offset / 4;
std::size_t numwords = offset / 4;
hdr->count = sourcecount;
hdr->length = qToBigEndian((uint16_t) (numwords - 1));

60
qrtplib/rtcpcompoundpacketbuilder.h
View File

@ -66,13 +66,13 @@ public:
* Starts building an RTCP compound packet with maximum size \c maxpacketsize. New memory will be allocated
* to store the packet.
*/
int InitBuild(size_t maxpacketsize);
int InitBuild(std::size_t maxpacketsize);
/** Starts building a RTCP compound packet.
* Starts building a RTCP compound packet. Data will be stored in \c externalbuffer which
* can contain \c buffersize bytes.
*/
int InitBuild(void *externalbuffer, size_t buffersize);
int InitBuild(void *externalbuffer, std::size_t buffersize);
/** Adds a sender report to the compound packet.
* Tells the packet builder that the packet should start with a sender report which will contain
@ -118,7 +118,7 @@ public:
* Adds the APP packet specified by the arguments to the compound packet. Note that \c appdatalen has to be
* a multiple of four.
*/
int AddAPPPacket(uint8_t subtype, uint32_t ssrc, const uint8_t name[4], const void *appdata, size_t appdatalen);
int AddAPPPacket(uint8_t subtype, uint32_t ssrc, const uint8_t name[4], const void *appdata, std::size_t appdatalen);
/** Finishes building the compound packet.
* Finishes building the compound packet. If successful, the RTCPCompoundPacket member functions
@ -134,13 +134,13 @@ private:
packetdata(0), packetlength(0)
{
}
Buffer(uint8_t *data, size_t len) :
Buffer(uint8_t *data, std::size_t len) :
packetdata(data), packetlength(len)
{
}
uint8_t *packetdata;
size_t packetlength;
std::size_t packetlength;
};
class Report
@ -170,9 +170,9 @@ private:
headerlength = 0;
}
size_t NeededBytes()
std::size_t NeededBytes()
{
size_t x, n, d, r;
std::size_t x, n, d, r;
n = reportblocks.size();
if (n == 0)
{
@ -194,9 +194,9 @@ private:
return x;
}
size_t NeededBytesWithExtraReportBlock()
std::size_t NeededBytesWithExtraReportBlock()
{
size_t x, n, d, r;
std::size_t x, n, d, r;
n = reportblocks.size() + 1; // +1 for the extra block
x = n * sizeof(RTCPReceiverReport);
d = n / 31; // max 31 reportblocks per report
@ -213,7 +213,7 @@ private:
uint8_t *headerdata;
uint32_t headerdata32[(sizeof(uint32_t) + sizeof(RTCPSenderReport)) / sizeof(uint32_t)]; // either for ssrc and sender info or just ssrc
size_t headerlength;
std::size_t headerlength;
std::list<Buffer> reportblocks;
};
@ -235,9 +235,9 @@ private:
items.clear();
}
size_t NeededBytes()
std::size_t NeededBytes()
{
size_t x, r;
std::size_t x, r;
x = totalitemsize + 1; // +1 for the 0 byte which terminates the item list
r = x % sizeof(uint32_t);
if (r != 0)
@ -246,10 +246,10 @@ private:
return x;
}
size_t NeededBytesWithExtraItem(uint8_t itemdatalength)
std::size_t NeededBytesWithExtraItem(uint8_t itemdatalength)
{
size_t x, r;
x = totalitemsize + sizeof(RTCPSDESHeader) + (size_t) itemdatalength + 1;
std::size_t x, r;
x = totalitemsize + sizeof(RTCPSDESHeader) + (std::size_t) itemdatalength + 1;
r = x % sizeof(uint32_t);
if (r != 0)
x += (sizeof(uint32_t) - r); // make sure it ends on a 32 bit boundary
@ -257,7 +257,7 @@ private:
return x;
}
void AddItem(uint8_t *buf, size_t len)
void AddItem(uint8_t *buf, std::size_t len)
{
Buffer b(buf, len);
totalitemsize += len;
@ -267,7 +267,7 @@ private:
uint32_t ssrc;
std::list<Buffer> items;
private:
size_t totalitemsize;
std::size_t totalitemsize;
};
class SDES
@ -302,7 +302,7 @@ private:
return 0;
}
int AddItem(uint8_t *buf, size_t len)
int AddItem(uint8_t *buf, std::size_t len)
{
if (sdessources.empty())
return ERR_RTP_RTCPCOMPPACKBUILDER_NOCURRENTSOURCE;
@ -310,11 +310,11 @@ private:
return 0;
}
size_t NeededBytes()
std::size_t NeededBytes()
{
std::list<SDESSource *>::const_iterator it;
size_t x = 0;
size_t n, d, r;
std::size_t x = 0;
std::size_t n, d, r;
if (sdessources.empty())
return 0;
@ -330,11 +330,11 @@ private:
return x;
}
size_t NeededBytesWithExtraItem(uint8_t itemdatalength)
std::size_t NeededBytesWithExtraItem(uint8_t itemdatalength)
{
std::list<SDESSource *>::const_iterator it;
size_t x = 0;
size_t n, d, r;
std::size_t x = 0;
std::size_t n, d, r;
if (sdessources.empty())
return 0;
@ -351,11 +351,11 @@ private:
return x;
}
size_t NeededBytesWithExtraSource()
std::size_t NeededBytesWithExtraSource()
{
std::list<SDESSource *>::const_iterator it;
size_t x = 0;
size_t n, d, r;
std::size_t x = 0;
std::size_t n, d, r;
if (sdessources.empty())
return 0;
@ -381,7 +381,7 @@ private:
};
RTPEndian m_endian;
size_t maximumpacketsize;
std::size_t maximumpacketsize;
uint8_t *buffer;
bool external;
bool arebuilding;
@ -390,10 +390,10 @@ private:
SDES sdes;
std::list<Buffer> byepackets;
size_t byesize;
std::size_t byesize;
std::list<Buffer> apppackets;
size_t appsize;
std::size_t appsize;
void ClearBuildBuffers();
};

7
qrtplib/rtcppacket.h
View File

@ -40,6 +40,7 @@
#include "rtpconfig.h"
#include "rtptypes.h"
#include <cstddef>
namespace qrtplib
{
@ -61,7 +62,7 @@ public:
Unknown /**< The type of RTCP packet was not recognized. */
};
protected:
RTCPPacket(PacketType t, uint8_t *d, size_t dlen) :
RTCPPacket(PacketType t, uint8_t *d, std::size_t dlen) :
data(d), datalen(dlen), packettype(t)
{
knownformat = false;
@ -90,14 +91,14 @@ public:
}
/** Returns the length of this RTCP packet. */
size_t GetPacketLength() const
std::size_t GetPacketLength() const
{
return datalen;
}
protected:
uint8_t *data;
size_t datalen;
std::size_t datalen;
bool knownformat;
private:
const PacketType packettype;

10
qrtplib/rtcppacketbuilder.cpp
View File

@ -52,7 +52,7 @@ RTCPPacketBuilder::~RTCPPacketBuilder()
Destroy();
}
int RTCPPacketBuilder::Init(size_t maxpacksize, double tsunit, const void *cname, size_t cnamelen)
int RTCPPacketBuilder::Init(std::size_t maxpacksize, double tsunit, const void *cname, std::size_t cnamelen)
{
if (init)
return ERR_RTP_RTCPPACKETBUILDER_ALREADYINIT;
@ -163,7 +163,7 @@ int RTCPPacketBuilder::BuildNextPacket(RTCPCompoundPacket **pack)
}
uint8_t *owncname;
size_t owncnamelen;
std::size_t owncnamelen;
owncname = ownsdesinfo.GetCNAME(&owncnamelen);
@ -506,7 +506,7 @@ int RTCPPacketBuilder::FillInSDES(RTCPCompoundPacketBuilder *rtcpcomppack, bool
{
int status;
uint8_t *data;
size_t datalen;
std::size_t datalen;
*full = false;
*processedall = false;
@ -626,7 +626,7 @@ void RTCPPacketBuilder::ClearAllSDESFlags()
ownsdesinfo.ClearFlags();
}
int RTCPPacketBuilder::BuildBYEPacket(RTCPCompoundPacket **pack, const void *reason, size_t reasonlength, bool useSRifpossible)
int RTCPPacketBuilder::BuildBYEPacket(RTCPCompoundPacket **pack, const void *reason, std::size_t reasonlength, bool useSRifpossible)
{
if (!init)
return ERR_RTP_RTCPPACKETBUILDER_NOTINIT;
@ -697,7 +697,7 @@ int RTCPPacketBuilder::BuildBYEPacket(RTCPCompoundPacket **pack, const void *rea
}
uint8_t *owncname;
size_t owncnamelen;
std::size_t owncnamelen;
owncname = ownsdesinfo.GetCNAME(&owncnamelen);

22
qrtplib/rtcppacketbuilder.h
View File

@ -76,7 +76,7 @@ public:
* The timestamp unit is defined as a time interval divided by the timestamp interval corresponding to
* that interval: for 8000 Hz audio this would be 1/8000.
*/
int Init(size_t maxpacksize, double timestampunit, const void *cname, size_t cnamelen);
int Init(std::size_t maxpacksize, double timestampunit, const void *cname, std::size_t cnamelen);
/** Cleans up the builder. */
void Destroy();
@ -97,7 +97,7 @@ public:
}
/** Sets the maximum size allowed size of an RTCP compound packet to \c maxpacksize. */
int SetMaximumPacketSize(size_t maxpacksize)
int SetMaximumPacketSize(std::size_t maxpacksize)
{
if (!init)
return ERR_RTP_RTCPPACKETBUILDER_NOTINIT;
@ -129,7 +129,7 @@ public:
* \c useSRifpossible is set to \c true, the RTCP compound packet will start with a sender report if
* allowed. Otherwise, a receiver report is used.
*/
int BuildBYEPacket(RTCPCompoundPacket **pack, const void *reason, size_t reasonlength, bool useSRifpossible = true);
int BuildBYEPacket(RTCPCompoundPacket **pack, const void *reason, std::size_t reasonlength, bool useSRifpossible = true);
/** Sets the RTCP interval for the SDES name item.
* After all possible sources in the source table have been processed, the class will check if other
@ -210,7 +210,7 @@ public:
}
/** Sets the SDES name item for the local participant to the value \c s with length \c len. */
int SetLocalName(const void *s, size_t len)
int SetLocalName(const void *s, std::size_t len)
{
if (!init)
return ERR_RTP_RTCPPACKETBUILDER_NOTINIT;
@ -218,7 +218,7 @@ public:
}
/** Sets the SDES e-mail item for the local participant to the value \c s with length \c len. */
int SetLocalEMail(const void *s, size_t len)
int SetLocalEMail(const void *s, std::size_t len)
{
if (!init)
return ERR_RTP_RTCPPACKETBUILDER_NOTINIT;
@ -226,7 +226,7 @@ public:
}
/** Sets the SDES location item for the local participant to the value \c s with length \c len. */
int SetLocalLocation(const void *s, size_t len)
int SetLocalLocation(const void *s, std::size_t len)
{
if (!init)
return ERR_RTP_RTCPPACKETBUILDER_NOTINIT;
@ -234,7 +234,7 @@ public:
}
/** Sets the SDES phone item for the local participant to the value \c s with length \c len. */
int SetLocalPhone(const void *s, size_t len)
int SetLocalPhone(const void *s, std::size_t len)
{
if (!init)
return ERR_RTP_RTCPPACKETBUILDER_NOTINIT;
@ -242,7 +242,7 @@ public:
}
/** Sets the SDES tool item for the local participant to the value \c s with length \c len. */
int SetLocalTool(const void *s, size_t len)
int SetLocalTool(const void *s, std::size_t len)
{
if (!init)
return ERR_RTP_RTCPPACKETBUILDER_NOTINIT;
@ -250,7 +250,7 @@ public:
}
/** Sets the SDES note item for the local participant to the value \c s with length \c len. */
int SetLocalNote(const void *s, size_t len)
int SetLocalNote(const void *s, std::size_t len)
{
if (!init)
return ERR_RTP_RTCPPACKETBUILDER_NOTINIT;
@ -258,7 +258,7 @@ public:
}
/** Returns the own CNAME item with length \c len */
uint8_t *GetLocalCNAME(size_t *len) const
uint8_t *GetLocalCNAME(std::size_t *len) const
{
if (!init)
return 0;
@ -274,7 +274,7 @@ private:
RTPPacketBuilder &rtppacketbuilder;
bool init;
size_t maxpacketsize;
std::size_t maxpacketsize;
double timestampunit;
bool firstpacket;
RTPTime prevbuildtime, transmissiondelay;

10
qrtplib/rtcprrpacket.cpp
View File

@ -35,14 +35,14 @@
namespace qrtplib
{
RTCPRRPacket::RTCPRRPacket(uint8_t *data, size_t datalength) :
RTCPRRPacket::RTCPRRPacket(uint8_t *data, std::size_t datalength) :
RTCPPacket(RR, data, datalength)
{
knownformat = false;
RTCPCommonHeader *hdr;
size_t len = datalength;
size_t expectedlength;
std::size_t len = datalength;
std::size_t expectedlength;
hdr = (RTCPCommonHeader *) data;
if (hdr->padding)
@ -50,9 +50,9 @@ RTCPRRPacket::RTCPRRPacket(uint8_t *data, size_t datalength) :
uint8_t padcount = data[datalength - 1];
if ((padcount & 0x03) != 0) // not a multiple of four! (see rfc 3550 p 37)
return;
if (((size_t) padcount) >= len)
if (((std::size_t) padcount) >= len)
return;
len -= (size_t) padcount;
len -= (std::size_t) padcount;
}
expectedlength = sizeof(RTCPCommonHeader) + sizeof(uint32_t);

2
qrtplib/rtcprrpacket.h
View File

@ -57,7 +57,7 @@ public:
* is referenced inside the class (no copy of the data is made) one must make sure that the memory it points
* to is valid as long as the class instance exists.
*/
RTCPRRPacket(uint8_t *data, size_t datalen);
RTCPRRPacket(uint8_t *data, std::size_t datalen);
~RTCPRRPacket()
{
}

14
qrtplib/rtcpscheduler.cpp
View File

@ -120,15 +120,15 @@ void RTCPScheduler::AnalyseIncoming(RTCPCompoundPacket &rtcpcomppack)
if (!isbye)
{
size_t packsize = headeroverhead + rtcpcomppack.GetCompoundPacketLength();
avgrtcppacksize = (size_t)((1.0 / 16.0) * ((double) packsize) + (15.0 / 16.0) * ((double) avgrtcppacksize));
std::size_t packsize = headeroverhead + rtcpcomppack.GetCompoundPacketLength();
avgrtcppacksize = (std::size_t)((1.0 / 16.0) * ((double) packsize) + (15.0 / 16.0) * ((double) avgrtcppacksize));
}
else
{
if (byescheduled)
{
size_t packsize = headeroverhead + rtcpcomppack.GetCompoundPacketLength();
avgbyepacketsize = (size_t)((1.0 / 16.0) * ((double) packsize) + (15.0 / 16.0) * ((double) avgbyepacketsize));
std::size_t packsize = headeroverhead + rtcpcomppack.GetCompoundPacketLength();
avgbyepacketsize = (std::size_t)((1.0 / 16.0) * ((double) packsize) + (15.0 / 16.0) * ((double) avgbyepacketsize));
byemembers++;
}
}
@ -148,8 +148,8 @@ void RTCPScheduler::AnalyseOutgoing(RTCPCompoundPacket &rtcpcomppack)
if (!isbye)
{
size_t packsize = headeroverhead + rtcpcomppack.GetCompoundPacketLength();
avgrtcppacksize = (size_t)((1.0 / 16.0) * ((double) packsize) + (15.0 / 16.0) * ((double) avgrtcppacksize));
std::size_t packsize = headeroverhead + rtcpcomppack.GetCompoundPacketLength();
avgrtcppacksize = (std::size_t)((1.0 / 16.0) * ((double) packsize) + (15.0 / 16.0) * ((double) avgrtcppacksize));
}
hassentrtcp = true;
@ -354,7 +354,7 @@ void RTCPScheduler::PerformReverseReconsideration()
pmembers = members;
}
void RTCPScheduler::ScheduleBYEPacket(size_t packetsize)
void RTCPScheduler::ScheduleBYEPacket(std::size_t packetsize)
{
if (byescheduled)
return;

13
qrtplib/rtcpscheduler.h
View File

@ -41,6 +41,7 @@
#include "rtpconfig.h"
#include "rtptimeutilities.h"
#include "rtprandom.h"
#include <cstddef>
namespace qrtplib
{
@ -148,13 +149,13 @@ public:
}
/** Sets the header overhead from underlying protocols (for example UDP and IP) to \c numbytes. */
void SetHeaderOverhead(size_t numbytes)
void SetHeaderOverhead(std::size_t numbytes)
{
headeroverhead = numbytes;
}
/** Returns the currently used header overhead. */
size_t GetHeaderOverhead() const
std::size_t GetHeaderOverhead() const
{
return headeroverhead;
}
@ -171,7 +172,7 @@ public:
/** Asks the scheduler to schedule an RTCP compound packet containing a BYE packetl; the compound packet
* has size \c packetsize.
*/
void ScheduleBYEPacket(size_t packetsize);
void ScheduleBYEPacket(std::size_t packetsize);
/** Returns the delay after which an RTCP compound will possibly have to be sent.
* Returns the delay after which an RTCP compound will possibly have to be sent. The IsTime member function
@ -199,8 +200,8 @@ private:
RTPSources &sources;
RTCPSchedulerParams schedparams;
size_t headeroverhead;
size_t avgrtcppacksize;
std::size_t headeroverhead;
std::size_t avgrtcppacksize;
bool hassentrtcp;
bool firstcall;
RTPTime nextrtcptime;
@ -210,7 +211,7 @@ private:
// for BYE packet scheduling
bool byescheduled;
int byemembers, pbyemembers;
size_t avgbyepacketsize;
std::size_t avgbyepacketsize;
bool sendbyenow;
RTPRandom &rtprand;

14
qrtplib/rtcpsdesinfo.cpp
View File

@ -47,7 +47,7 @@ void RTCPSDESInfo::Clear()
}
#ifdef RTP_SUPPORT_SDESPRIV
int RTCPSDESInfo::SetPrivateValue(const uint8_t *prefix, size_t prefixlen, const uint8_t *value, size_t valuelen)
int RTCPSDESInfo::SetPrivateValue(const uint8_t *prefix, std::size_t prefixlen, const uint8_t *value, std::size_t valuelen)
{
std::list<SDESPrivateItem *>::const_iterator it;
bool found;
@ -57,7 +57,7 @@ int RTCPSDESInfo::SetPrivateValue(const uint8_t *prefix, size_t prefixlen, const
while (!found && it != privitems.end())
{
uint8_t *p;
size_t l;
std::size_t l;
p = (*it)->GetPrefix(&l);
if (l == prefixlen)
@ -97,7 +97,7 @@ int RTCPSDESInfo::SetPrivateValue(const uint8_t *prefix, size_t prefixlen, const
return item->SetInfo(value, valuelen);
}
int RTCPSDESInfo::DeletePrivatePrefix(const uint8_t *prefix, size_t prefixlen)
int RTCPSDESInfo::DeletePrivatePrefix(const uint8_t *prefix, std::size_t prefixlen)
{
std::list<SDESPrivateItem *>::iterator it;
bool found;
@ -107,7 +107,7 @@ int RTCPSDESInfo::DeletePrivatePrefix(const uint8_t *prefix, size_t prefixlen)
while (!found && it != privitems.end())
{
uint8_t *p;
size_t l;
std::size_t l;
p = (*it)->GetPrefix(&l);
if (l == prefixlen)
@ -135,7 +135,7 @@ void RTCPSDESInfo::GotoFirstPrivateValue()
curitem = privitems.begin();
}
bool RTCPSDESInfo::GetNextPrivateValue(uint8_t **prefix, size_t *prefixlen, uint8_t **value, size_t *valuelen)
bool RTCPSDESInfo::GetNextPrivateValue(uint8_t **prefix, std::size_t *prefixlen, uint8_t **value, std::size_t *valuelen)
{
if (curitem == privitems.end())
return false;
@ -145,7 +145,7 @@ bool RTCPSDESInfo::GetNextPrivateValue(uint8_t **prefix, size_t *prefixlen, uint
return true;
}
bool RTCPSDESInfo::GetPrivateValue(const uint8_t *prefix, size_t prefixlen, uint8_t **value, size_t *valuelen) const
bool RTCPSDESInfo::GetPrivateValue(const uint8_t *prefix, std::size_t prefixlen, uint8_t **value, std::size_t *valuelen) const
{
std::list<SDESPrivateItem *>::const_iterator it;
bool found;
@ -155,7 +155,7 @@ bool RTCPSDESInfo::GetPrivateValue(const uint8_t *prefix, size_t prefixlen, uint
while (!found && it != privitems.end())
{
uint8_t *p;
size_t l;
std::size_t l;
p = (*it)->GetPrefix(&l);
if (l == prefixlen)

54
qrtplib/rtcpsdesinfo.h
View File

@ -65,43 +65,43 @@ public:
void Clear();
/** Sets the SDES CNAME item to \c s with length \c l. */
int SetCNAME(const uint8_t *s, size_t l)
int SetCNAME(const uint8_t *s, std::size_t l)
{
return SetNonPrivateItem(RTCP_SDES_ID_CNAME - 1, s, l);
}
/** Sets the SDES name item to \c s with length \c l. */
int SetName(const uint8_t *s, size_t l)
int SetName(const uint8_t *s, std::size_t l)
{
return SetNonPrivateItem(RTCP_SDES_ID_NAME - 1, s, l);
}
/** Sets the SDES e-mail item to \c s with length \c l. */
int SetEMail(const uint8_t *s, size_t l)
int SetEMail(const uint8_t *s, std::size_t l)
{
return SetNonPrivateItem(RTCP_SDES_ID_EMAIL - 1, s, l);
}
/** Sets the SDES phone item to \c s with length \c l. */
int SetPhone(const uint8_t *s, size_t l)
int SetPhone(const uint8_t *s, std::size_t l)
{
return SetNonPrivateItem(RTCP_SDES_ID_PHONE - 1, s, l);
}
/** Sets the SDES location item to \c s with length \c l. */
int SetLocation(const uint8_t *s, size_t l)
int SetLocation(const uint8_t *s, std::size_t l)
{
return SetNonPrivateItem(RTCP_SDES_ID_LOCATION - 1, s, l);
}
/** Sets the SDES tool item to \c s with length \c l. */
int SetTool(const uint8_t *s, size_t l)
int SetTool(const uint8_t *s, std::size_t l)
{
return SetNonPrivateItem(RTCP_SDES_ID_TOOL - 1, s, l);
}
/** Sets the SDES note item to \c s with length \c l. */
int SetNote(const uint8_t *s, size_t l)
int SetNote(const uint8_t *s, std::size_t l)
{
return SetNonPrivateItem(RTCP_SDES_ID_NOTE - 1, s, l);
}
@ -111,50 +111,50 @@ public:
* the value string specified by \c value with length \c valuelen (if the maximum allowed
* number of prefixes was reached, the error code \c ERR_RTP_SDES_MAXPRIVITEMS is returned.
*/
int SetPrivateValue(const uint8_t *prefix, size_t prefixlen, const uint8_t *value, size_t valuelen);
int SetPrivateValue(const uint8_t *prefix, std::size_t prefixlen, const uint8_t *value, std::size_t valuelen);
/** Deletes the entry for the prefix specified by \c s with length \c len. */
int DeletePrivatePrefix(const uint8_t *s, size_t len);
int DeletePrivatePrefix(const uint8_t *s, std::size_t len);
#endif // RTP_SUPPORT_SDESPRIV
/** Returns the SDES CNAME item and stores its length in \c len. */
uint8_t *GetCNAME(size_t *len) const
uint8_t *GetCNAME(std::size_t *len) const
{
return GetNonPrivateItem(RTCP_SDES_ID_CNAME - 1, len);
}
/** Returns the SDES name item and stores its length in \c len. */
uint8_t *GetName(size_t *len) const
uint8_t *GetName(std::size_t *len) const
{
return GetNonPrivateItem(RTCP_SDES_ID_NAME - 1, len);
}
/** Returns the SDES e-mail item and stores its length in \c len. */
uint8_t *GetEMail(size_t *len) const
uint8_t *GetEMail(std::size_t *len) const
{
return GetNonPrivateItem(RTCP_SDES_ID_EMAIL - 1, len);
}
/** Returns the SDES phone item and stores its length in \c len. */
uint8_t *GetPhone(size_t *len) const
uint8_t *GetPhone(std::size_t *len) const
{
return GetNonPrivateItem(RTCP_SDES_ID_PHONE - 1, len);
}
/** Returns the SDES location item and stores its length in \c len. */
uint8_t *GetLocation(size_t *len) const
uint8_t *GetLocation(std::size_t *len) const
{
return GetNonPrivateItem(RTCP_SDES_ID_LOCATION - 1, len);
}
/** Returns the SDES tool item and stores its length in \c len. */
uint8_t *GetTool(size_t *len) const
uint8_t *GetTool(std::size_t *len) const
{
return GetNonPrivateItem(RTCP_SDES_ID_TOOL - 1, len);
}
/** Returns the SDES note item and stores its length in \c len. */
uint8_t *GetNote(size_t *len) const
uint8_t *GetNote(std::size_t *len) const
{
return GetNonPrivateItem(RTCP_SDES_ID_NOTE - 1, len);
}
@ -169,7 +169,7 @@ public:
* then stored in \c value and \c valuelen. Otherwise,
* it returns \c false.
*/
bool GetNextPrivateValue(uint8_t **prefix, size_t *prefixlen, uint8_t **value, size_t *valuelen);
bool GetNextPrivateValue(uint8_t **prefix, std::size_t *prefixlen, uint8_t **value, std::size_t *valuelen);
/** Returns SDES priv item information.
* Looks for the entry which corresponds to the SDES private
@ -178,16 +178,16 @@ public:
* value and its length in \c value and \c valuelen
* respectively.
*/
bool GetPrivateValue(const uint8_t *prefix, size_t prefixlen, uint8_t **value, size_t *valuelen) const;
bool GetPrivateValue(const uint8_t *prefix, std::size_t prefixlen, uint8_t **value, std::size_t *valuelen) const;
#endif // RTP_SUPPORT_SDESPRIV
private:
int SetNonPrivateItem(int itemno, const uint8_t *s, size_t l)
int SetNonPrivateItem(int itemno, const uint8_t *s, std::size_t l)
{
if (l > RTCP_SDES_MAXITEMLENGTH)
return ERR_RTP_SDES_LENGTHTOOBIG;
return nonprivateitems[itemno].SetInfo(s, l);
}
uint8_t *GetNonPrivateItem(int itemno, size_t *len) const
uint8_t *GetNonPrivateItem(int itemno, std::size_t *len) const
{
return nonprivateitems[itemno].GetInfo(len);
}
@ -205,17 +205,17 @@ private:
if (str)
delete[] str;
}
uint8_t *GetInfo(size_t *len) const
uint8_t *GetInfo(std::size_t *len) const
{
*len = length;
return str;
}
int SetInfo(const uint8_t *s, size_t len)
int SetInfo(const uint8_t *s, std::size_t len)
{
return SetString(&str, &length, s, len);
}
protected:
int SetString(uint8_t **dest, size_t *destlen, const uint8_t *s, size_t len)
int SetString(uint8_t **dest, std::size_t *destlen, const uint8_t *s, std::size_t len)
{
if (len <= 0)
{
@ -240,7 +240,7 @@ private:
}
private:
uint8_t *str;
size_t length;
std::size_t length;
};
SDESItem nonprivateitems[RTCP_SDES_NUMITEMS_NONPRIVATE];
@ -259,18 +259,18 @@ private:
if (prefix)
delete[] prefix;
}
uint8_t *GetPrefix(size_t *len) const
uint8_t *GetPrefix(std::size_t *len) const
{
*len = prefixlen;
return prefix;
}
int SetPrefix(const uint8_t *s, size_t len)
int SetPrefix(const uint8_t *s, std::size_t len)
{
return SetString(&prefix, &prefixlen, s, len);
}
private:
uint8_t *prefix;
size_t prefixlen;
std::size_t prefixlen;
};
std::list<SDESPrivateItem *> privitems;

14
qrtplib/rtcpsdespacket.cpp
View File

@ -35,7 +35,7 @@
namespace qrtplib
{
RTCPSDESPacket::RTCPSDESPacket(uint8_t *data, size_t datalength) :
RTCPSDESPacket::RTCPSDESPacket(uint8_t *data, std::size_t datalength) :
RTCPPacket(SDES, data, datalength)
{
knownformat = false;
@ -44,16 +44,16 @@ RTCPSDESPacket::RTCPSDESPacket(uint8_t *data, size_t datalength) :
curchunknum = 0;
RTCPCommonHeader *hdr = (RTCPCommonHeader *) data;
size_t len = datalength;
std::size_t len = datalength;
if (hdr->padding)
{
uint8_t padcount = data[datalength - 1];
if ((padcount & 0x03) != 0) // not a multiple of four! (see rfc 3550 p 37)
return;
if (((size_t) padcount) >= len)
if (((std::size_t) padcount) >= len)
return;
len -= (size_t) padcount;
len -= (std::size_t) padcount;
}
if (hdr->count == 0)
@ -93,10 +93,10 @@ RTCPSDESPacket::RTCPSDESPacket(uint8_t *data, size_t datalength) :
len--;
chunkoffset++;
size_t r = (chunkoffset & 0x03);
std::size_t r = (chunkoffset & 0x03);
if (r != 0)
{
size_t addoffset = 4 - r;
std::size_t addoffset = 4 - r;
if (addoffset > len)
return;
@ -113,7 +113,7 @@ RTCPSDESPacket::RTCPSDESPacket(uint8_t *data, size_t datalength) :
len -= sizeof(RTCPSDESHeader);
chunkoffset += sizeof(RTCPSDESHeader);
size_t itemlen = (size_t)(sdeshdr->length);
std::size_t itemlen = (std::size_t)(sdeshdr->length);
if (itemlen > len)
return;

46
qrtplib/rtcpsdespacket.h
View File

@ -73,7 +73,7 @@ public:
* is referenced inside the class (no copy of the data is made) one must make sure that the memory it
* points to is valid as long as the class instance exists.
*/
RTCPSDESPacket(uint8_t *data, size_t datalen);
RTCPSDESPacket(uint8_t *data, std::size_t datalen);
~RTCPSDESPacket()
{
}
@ -115,7 +115,7 @@ public:
ItemType GetItemType() const;
/** Returns the item length of the current item in the current chunk. */
size_t GetItemLength() const;
std::size_t GetItemLength() const;
/** Returns the item data of the current item in the current chunk. */
uint8_t *GetItemData();
@ -124,7 +124,7 @@ public:
/** If the current item is an SDES PRIV item, this function returns the length of the
* prefix string of the private item.
*/
size_t GetPRIVPrefixLength() const;
std::size_t GetPRIVPrefixLength() const;
/** If the current item is an SDES PRIV item, this function returns actual data of the
* prefix string.
@ -134,7 +134,7 @@ public:
/** If the current item is an SDES PRIV item, this function returns the length of the
* value string of the private item.
*/
size_t GetPRIVValueLength() const;
std::size_t GetPRIVValueLength() const;
/** If the current item is an SDES PRIV item, this function returns actual value data of the
* private item.
@ -146,7 +146,7 @@ private:
RTPEndian m_endian;
uint8_t *currentchunk;
int curchunknum;
size_t itemoffset;
std::size_t itemoffset;
};
inline int RTCPSDESPacket::GetChunkCount() const
@ -179,13 +179,13 @@ inline bool RTCPSDESPacket::GotoNextChunk()
if (curchunknum == GetChunkCount())
return false;
size_t offset = sizeof(uint32_t);
std::size_t offset = sizeof(uint32_t);
RTCPSDESHeader *sdeshdr = (RTCPSDESHeader *) (currentchunk + sizeof(uint32_t));
while (sdeshdr->sdesid != 0)
{
offset += sizeof(RTCPSDESHeader);
offset += (size_t)(sdeshdr->length);
offset += (std::size_t)(sdeshdr->length);
sdeshdr = (RTCPSDESHeader *) (currentchunk + offset);
}
offset++; // for the zero byte
@ -231,9 +231,9 @@ inline bool RTCPSDESPacket::GotoNextItem()
if (sdeshdr->sdesid == 0)
return false;
size_t offset = itemoffset;
std::size_t offset = itemoffset;
offset += sizeof(RTCPSDESHeader);
offset += (size_t)(sdeshdr->length);
offset += (std::size_t)(sdeshdr->length);
sdeshdr = (RTCPSDESHeader *) (currentchunk + offset);
if (sdeshdr->sdesid == 0)
return false;
@ -274,7 +274,7 @@ inline RTCPSDESPacket::ItemType RTCPSDESPacket::GetItemType() const
return Unknown;
}
inline size_t RTCPSDESPacket::GetItemLength() const
inline std::size_t RTCPSDESPacket::GetItemLength() const
{
if (!knownformat)
return None;
@ -283,7 +283,7 @@ inline size_t RTCPSDESPacket::GetItemLength() const
RTCPSDESHeader *sdeshdr = (RTCPSDESHeader *) (currentchunk + itemoffset);
if (sdeshdr->sdesid == 0)
return 0;
return (size_t)(sdeshdr->length);
return (std::size_t)(sdeshdr->length);
}
inline uint8_t *RTCPSDESPacket::GetItemData()
@ -299,7 +299,7 @@ inline uint8_t *RTCPSDESPacket::GetItemData()
}
#ifdef RTP_SUPPORT_SDESPRIV
inline size_t RTCPSDESPacket::GetPRIVPrefixLength() const
inline std::size_t RTCPSDESPacket::GetPRIVPrefixLength() const
{
if (!knownformat)
return 0;
@ -311,8 +311,8 @@ inline size_t RTCPSDESPacket::GetPRIVPrefixLength() const
if (sdeshdr->length == 0)
return 0;
uint8_t *preflen = currentchunk + itemoffset + sizeof(RTCPSDESHeader);
size_t prefixlength = (size_t)(*preflen);
if (prefixlength > (size_t)((sdeshdr->length) - 1))
std::size_t prefixlength = (std::size_t)(*preflen);
if (prefixlength > (std::size_t)((sdeshdr->length) - 1))
return 0;
return prefixlength;
}
@ -329,15 +329,15 @@ inline uint8_t *RTCPSDESPacket::GetPRIVPrefixData()
if (sdeshdr->length == 0)
return 0;
uint8_t *preflen = currentchunk + itemoffset + sizeof(RTCPSDESHeader);
size_t prefixlength = (size_t)(*preflen);
if (prefixlength > (size_t)((sdeshdr->length) - 1))
std::size_t prefixlength = (std::size_t)(*preflen);
if (prefixlength > (std::size_t)((sdeshdr->length) - 1))
return 0;
if (prefixlength == 0)
return 0;
return (currentchunk + itemoffset + sizeof(RTCPSDESHeader) + 1);
}
inline size_t RTCPSDESPacket::GetPRIVValueLength() const
inline std::size_t RTCPSDESPacket::GetPRIVValueLength() const
{
if (!knownformat)
return 0;
@ -349,10 +349,10 @@ inline size_t RTCPSDESPacket::GetPRIVValueLength() const
if (sdeshdr->length == 0)
return 0;
uint8_t *preflen = currentchunk + itemoffset + sizeof(RTCPSDESHeader);
size_t prefixlength = (size_t)(*preflen);
if (prefixlength > (size_t)((sdeshdr->length) - 1))
std::size_t prefixlength = (std::size_t)(*preflen);
if (prefixlength > (std::size_t)((sdeshdr->length) - 1))
return 0;
return ((size_t)(sdeshdr->length)) - prefixlength - 1;
return ((std::size_t)(sdeshdr->length)) - prefixlength - 1;
}
inline uint8_t *RTCPSDESPacket::GetPRIVValueData()
@ -367,10 +367,10 @@ inline uint8_t *RTCPSDESPacket::GetPRIVValueData()
if (sdeshdr->length == 0)
return 0;
uint8_t *preflen = currentchunk + itemoffset + sizeof(RTCPSDESHeader);
size_t prefixlength = (size_t)(*preflen);
if (prefixlength > (size_t)((sdeshdr->length) - 1))
std::size_t prefixlength = (std::size_t)(*preflen);
if (prefixlength > (std::size_t)((sdeshdr->length) - 1))
return 0;
size_t valuelen = ((size_t)(sdeshdr->length)) - prefixlength - 1;
std::size_t valuelen = ((std::size_t)(sdeshdr->length)) - prefixlength - 1;
if (valuelen == 0)
return 0;
return (currentchunk + itemoffset + sizeof(RTCPSDESHeader) + 1 + prefixlength);

10
qrtplib/rtcpsrpacket.cpp
View File

@ -35,14 +35,14 @@
namespace qrtplib
{
RTCPSRPacket::RTCPSRPacket(uint8_t *data, size_t datalength) :
RTCPSRPacket::RTCPSRPacket(uint8_t *data, std::size_t datalength) :
RTCPPacket(SR, data, datalength)
{
knownformat = false;
RTCPCommonHeader *hdr;
size_t len = datalength;
size_t expectedlength;
std::size_t len = datalength;
std::size_t expectedlength;
hdr = (RTCPCommonHeader *) data;
if (hdr->padding)
@ -50,9 +50,9 @@ RTCPSRPacket::RTCPSRPacket(uint8_t *data, size_t datalength) :
uint8_t padcount = data[datalength - 1];
if ((padcount & 0x03) != 0) // not a multiple of four! (see rfc 3550 p 37)
return;
if (((size_t) padcount) >= len)
if (((std::size_t) padcount) >= len)
return;
len -= (size_t) padcount;
len -= (std::size_t) padcount;
}
expectedlength = sizeof(RTCPCommonHeader) + sizeof(uint32_t) + sizeof(RTCPSenderReport);

2
qrtplib/rtcpsrpacket.h
View File

@ -58,7 +58,7 @@ public:
* is referenced inside the class (no copy of the data is made) one must make sure that the memory it
* points to is valid as long as the class instance exists.
*/
RTCPSRPacket(uint8_t *data, size_t datalength);
RTCPSRPacket(uint8_t *data, std::size_t datalength);
~RTCPSRPacket()
{
}

2
qrtplib/rtcpunknownpacket.h
View File

@ -59,7 +59,7 @@ public:
* is referenced inside the class (no copy of the data is made) one must make sure that the memory it
* points to is valid as long as the class instance exists.
*/
RTCPUnknownPacket(uint8_t *data, size_t datalen) :
RTCPUnknownPacket(uint8_t *data, std::size_t datalen) :
RTCPPacket(Unknown, data, datalen)
{
// Since we don't expect a format, we'll trivially put knownformat = true

16
qrtplib/rtpexternaltransmitter.cpp
View File

@ -69,7 +69,7 @@ int RTPExternalTransmitter::Init(bool tsafe)
return 0;
}
int RTPExternalTransmitter::Create(size_t maximumpacketsize, const RTPTransmissionParams *transparams)
int RTPExternalTransmitter::Create(std::size_t maximumpacketsize, const RTPTransmissionParams *transparams)
{
const RTPExternalTransmissionParams *params;
int status;
@ -163,7 +163,7 @@ void RTPExternalTransmitter::DeleteTransmissionInfo(RTPTransmissionInfo *i)
delete i;
}
int RTPExternalTransmitter::GetLocalHostName(uint8_t *buffer, size_t *bufferlength)
int RTPExternalTransmitter::GetLocalHostName(uint8_t *buffer, std::size_t *bufferlength)
{
if (!init)
return ERR_RTP_EXTERNALTRANS_NOTINIT;
@ -297,7 +297,7 @@ int RTPExternalTransmitter::AbortWait()
return 0;
}
int RTPExternalTransmitter::SendRTPData(const void *data, size_t len)
int RTPExternalTransmitter::SendRTPData(const void *data, std::size_t len)
{
if (!init)
return ERR_RTP_EXTERNALTRANS_NOTINIT;
@ -322,7 +322,7 @@ int RTPExternalTransmitter::SendRTPData(const void *data, size_t len)
return 0;
}
int RTPExternalTransmitter::SendRTCPData(const void *data, size_t len)
int RTPExternalTransmitter::SendRTCPData(const void *data, std::size_t len)
{
if (!init)
return ERR_RTP_EXTERNALTRANS_NOTINIT;
@ -424,7 +424,7 @@ void RTPExternalTransmitter::ClearAcceptList()
{
}
int RTPExternalTransmitter::SetMaximumPacketSize(size_t s)
int RTPExternalTransmitter::SetMaximumPacketSize(std::size_t s)
{
if (!init)
return ERR_RTP_EXTERNALTRANS_NOTINIT;
@ -490,7 +490,7 @@ void RTPExternalTransmitter::FlushPackets()
rawpacketlist.clear();
}
void RTPExternalTransmitter::InjectRTP(const void *data, size_t len, const RTPAddress &a)
void RTPExternalTransmitter::InjectRTP(const void *data, std::size_t len, const RTPAddress &a)
{
if (!init)
return;
@ -534,7 +534,7 @@ void RTPExternalTransmitter::InjectRTP(const void *data, size_t len, const RTPAd
}
void RTPExternalTransmitter::InjectRTCP(const void *data, size_t len, const RTPAddress &a)
void RTPExternalTransmitter::InjectRTCP(const void *data, std::size_t len, const RTPAddress &a)
{
if (!init)
return;
@ -578,7 +578,7 @@ void RTPExternalTransmitter::InjectRTCP(const void *data, size_t len, const RTPA
}
void RTPExternalTransmitter::InjectRTPorRTCP(const void *data, size_t len, const RTPAddress &a)
void RTPExternalTransmitter::InjectRTPorRTCP(const void *data, std::size_t len, const RTPAddress &a)
{
if (!init)
return;

38
qrtplib/rtpexternaltransmitter.h
View File

@ -67,10 +67,10 @@ public:
}
/** This member function will be called when RTP data needs to be transmitted. */
virtual bool SendRTP(const void *data, size_t len) = 0;
virtual bool SendRTP(const void *data, std::size_t len) = 0;
/** This member function will be called when an RTCP packet needs to be transmitted. */
virtual bool SendRTCP(const void *data, size_t len) = 0;
virtual bool SendRTCP(const void *data, std::size_t len) = 0;
/** Used to identify if an RTPAddress instance originated from this sender (to be able to detect own packets). */
virtual bool ComesFromThisSender(const RTPAddress *a) = 0;
@ -95,13 +95,13 @@ public:
}
/** This function can be called to insert an RTP packet into the transmission component. */
void InjectRTP(const void *data, size_t len, const RTPAddress &a);
void InjectRTP(const void *data, std::size_t len, const RTPAddress &a);
/** This function can be called to insert an RTCP packet into the transmission component. */
void InjectRTCP(const void *data, size_t len, const RTPAddress &a);
void InjectRTCP(const void *data, std::size_t len, const RTPAddress &a);
/** Use this function to inject an RTP or RTCP packet and the transmitter will try to figure out which type of packet it is. */
void InjectRTPorRTCP(const void *data, size_t len, const RTPAddress &a);
void InjectRTPorRTCP(const void *data, std::size_t len, const RTPAddress &a);
private:
RTPExternalTransmitter *transmitter;
};
@ -167,14 +167,14 @@ public:
~RTPExternalTransmitter();
int Init(bool treadsafe);
int Create(size_t maxpacksize, const RTPTransmissionParams *transparams);
int Create(std::size_t maxpacksize, const RTPTransmissionParams *transparams);
void Destroy();
RTPTransmissionInfo *GetTransmissionInfo();
void DeleteTransmissionInfo(RTPTransmissionInfo *inf);
int GetLocalHostName(uint8_t *buffer, size_t *bufferlength);
int GetLocalHostName(uint8_t *buffer, std::size_t *bufferlength);
bool ComesFromThisTransmitter(const RTPAddress *addr);
size_t GetHeaderOverhead()
std::size_t GetHeaderOverhead()
{
return headersize;
}
@ -183,8 +183,8 @@ public:
int WaitForIncomingData(const RTPTime &delay, bool *dataavailable = 0);
int AbortWait();
int SendRTPData(const void *data, size_t len);
int SendRTCPData(const void *data, size_t len);
int SendRTPData(const void *data, std::size_t len);
int SendRTCPData(const void *data, std::size_t len);
int AddDestination(const RTPAddress &addr);
int DeleteDestination(const RTPAddress &addr);
@ -202,14 +202,14 @@ public:
int AddToAcceptList(const RTPAddress &addr);
int DeleteFromAcceptList(const RTPAddress &addr);
void ClearAcceptList();
int SetMaximumPacketSize(size_t s);
int SetMaximumPacketSize(std::size_t s);
bool NewDataAvailable();
RTPRawPacket *GetNextPacket();
void InjectRTP(const void *data, size_t len, const RTPAddress &a);
void InjectRTCP(const void *data, size_t len, const RTPAddress &a);
void InjectRTPorRTCP(const void *data, size_t len, const RTPAddress &a);
void InjectRTP(const void *data, std::size_t len, const RTPAddress &a);
void InjectRTCP(const void *data, std::size_t len, const RTPAddress &a);
void InjectRTPorRTCP(const void *data, std::size_t len, const RTPAddress &a);
private:
void FlushPackets();
@ -222,26 +222,26 @@ private:
std::list<RTPRawPacket*> rawpacketlist;
uint8_t *localhostname;
size_t localhostnamelength;
std::size_t localhostnamelength;
size_t maxpacksize;
std::size_t maxpacksize;
int headersize;
RTPAbortDescriptors m_abortDesc;
int m_abortCount;
};
inline void RTPExternalPacketInjecter::InjectRTP(const void *data, size_t len, const RTPAddress &a)
inline void RTPExternalPacketInjecter::InjectRTP(const void *data, std::size_t len, const RTPAddress &a)
{
transmitter->InjectRTP(data, len, a);
}
inline void RTPExternalPacketInjecter::InjectRTCP(const void *data, size_t len, const RTPAddress &a)
inline void RTPExternalPacketInjecter::InjectRTCP(const void *data, std::size_t len, const RTPAddress &a)
{
transmitter->InjectRTCP(data, len, a);
}
inline void RTPExternalPacketInjecter::InjectRTPorRTCP(const void *data, size_t len, const RTPAddress &a)
inline void RTPExternalPacketInjecter::InjectRTPorRTCP(const void *data, std::size_t len, const RTPAddress &a)
{
transmitter->InjectRTPorRTCP(data, len, a);
}

14
qrtplib/rtpinternalsourcedata.cpp
View File

@ -147,7 +147,7 @@ int RTPInternalSourceData::ProcessRTPPacket(RTPPacket *rtppack, const RTPTime &r
return 0;
}
int RTPInternalSourceData::ProcessSDESItem(uint8_t sdesid, const uint8_t *data, size_t itemlen, const RTPTime &receivetime, bool *cnamecollis)
int RTPInternalSourceData::ProcessSDESItem(uint8_t sdesid, const uint8_t *data, std::size_t itemlen, const RTPTime &receivetime, bool *cnamecollis)
{
*cnamecollis = false;
@ -157,7 +157,7 @@ int RTPInternalSourceData::ProcessSDESItem(uint8_t sdesid, const uint8_t *data,
{
case RTCP_SDES_ID_CNAME:
{
size_t curlen;
std::size_t curlen;
uint8_t *oldcname;
// NOTE: we're going to make sure that the CNAME is only set once.
@ -182,7 +182,7 @@ int RTPInternalSourceData::ProcessSDESItem(uint8_t sdesid, const uint8_t *data,
break;
case RTCP_SDES_ID_NAME:
{
size_t oldlen;
std::size_t oldlen;
SDESinf.GetName(&oldlen);
if (oldlen == 0) // Name not set
@ -191,7 +191,7 @@ int RTPInternalSourceData::ProcessSDESItem(uint8_t sdesid, const uint8_t *data,
break;
case RTCP_SDES_ID_EMAIL:
{
size_t oldlen;
std::size_t oldlen;
SDESinf.GetEMail(&oldlen);
if (oldlen == 0)
@ -204,7 +204,7 @@ int RTPInternalSourceData::ProcessSDESItem(uint8_t sdesid, const uint8_t *data,
return SDESinf.SetLocation(data, itemlen);
case RTCP_SDES_ID_TOOL:
{
size_t oldlen;
std::size_t oldlen;
SDESinf.GetTool(&oldlen);
if (oldlen == 0)
@ -220,7 +220,7 @@ int RTPInternalSourceData::ProcessSDESItem(uint8_t sdesid, const uint8_t *data,
#ifdef RTP_SUPPORT_SDESPRIV
int RTPInternalSourceData::ProcessPrivateSDESItem(const uint8_t *prefix, size_t prefixlen, const uint8_t *value, size_t valuelen, const RTPTime &receivetime)
int RTPInternalSourceData::ProcessPrivateSDESItem(const uint8_t *prefix, std::size_t prefixlen, const uint8_t *value, std::size_t valuelen, const RTPTime &receivetime)
{
int status;
@ -233,7 +233,7 @@ int RTPInternalSourceData::ProcessPrivateSDESItem(const uint8_t *prefix, size_t
#endif // RTP_SUPPORT_SDESPRIV
int RTPInternalSourceData::ProcessBYEPacket(const uint8_t *reason, size_t reasonlen, const RTPTime &receivetime)
int RTPInternalSourceData::ProcessBYEPacket(const uint8_t *reason, std::size_t reasonlen, const RTPTime &receivetime)
{
if (byereason)
{

6
qrtplib/rtpinternalsourcedata.h
View File

@ -70,11 +70,11 @@ public:
{
stats.SetLastMessageTime(receivetime);
}
int ProcessSDESItem(uint8_t sdesid, const uint8_t *data, size_t itemlen, const RTPTime &receivetime, bool *cnamecollis);
int ProcessSDESItem(uint8_t sdesid, const uint8_t *data, std::size_t itemlen, const RTPTime &receivetime, bool *cnamecollis);
#ifdef RTP_SUPPORT_SDESPRIV
int ProcessPrivateSDESItem(const uint8_t *prefix, size_t prefixlen, const uint8_t *value, size_t valuelen, const RTPTime &receivetime);
int ProcessPrivateSDESItem(const uint8_t *prefix, std::size_t prefixlen, const uint8_t *value, std::size_t valuelen, const RTPTime &receivetime);
#endif // RTP_SUPPORT_SDESPRIV
int ProcessBYEPacket(const uint8_t *reason, size_t reasonlen, const RTPTime &receivetime);
int ProcessBYEPacket(const uint8_t *reason, std::size_t reasonlen, const RTPTime &receivetime);
int SetRTPDataAddress(const RTPAddress *a);
int SetRTCPDataAddress(const RTPAddress *a);

22
qrtplib/rtppacket.cpp
View File

@ -67,8 +67,8 @@ RTPPacket::RTPPacket(RTPRawPacket &rawpack) :
error = ParseRawPacket(rawpack);
}
RTPPacket::RTPPacket(uint8_t payloadtype, const void *payloaddata, size_t payloadlen, uint16_t seqnr, uint32_t timestamp, uint32_t ssrc, bool gotmarker, uint8_t numcsrcs,
const uint32_t *csrcs, bool gotextension, uint16_t extensionid, uint16_t extensionlen_numwords, const void *extensiondata, size_t maxpacksize) :
RTPPacket::RTPPacket(uint8_t payloadtype, const void *payloaddata, std::size_t payloadlen, uint16_t seqnr, uint32_t timestamp, uint32_t ssrc, bool gotmarker, uint8_t numcsrcs,
const uint32_t *csrcs, bool gotextension, uint16_t extensionid, uint16_t extensionlen_numwords, const void *extensiondata, std::size_t maxpacksize) :
receivetime(0, 0)
{
Clear();
@ -76,8 +76,8 @@ RTPPacket::RTPPacket(uint8_t payloadtype, const void *payloaddata, size_t payloa
0, maxpacksize);
}
RTPPacket::RTPPacket(uint8_t payloadtype, const void *payloaddata, size_t payloadlen, uint16_t seqnr, uint32_t timestamp, uint32_t ssrc, bool gotmarker, uint8_t numcsrcs,
const uint32_t *csrcs, bool gotextension, uint16_t extensionid, uint16_t extensionlen_numwords, const void *extensiondata, void *buffer, size_t buffersize) :
RTPPacket::RTPPacket(uint8_t payloadtype, const void *payloaddata, std::size_t payloadlen, uint16_t seqnr, uint32_t timestamp, uint32_t ssrc, bool gotmarker, uint8_t numcsrcs,
const uint32_t *csrcs, bool gotextension, uint16_t extensionid, uint16_t extensionlen_numwords, const void *extensiondata, void *buffer, std::size_t buffersize) :
receivetime(0, 0)
{
Clear();
@ -93,7 +93,7 @@ RTPPacket::RTPPacket(uint8_t payloadtype, const void *payloaddata, size_t payloa
int RTPPacket::ParseRawPacket(RTPRawPacket &rawpack)
{
uint8_t *packetbytes;
size_t packetlen;
std::size_t packetlen;
uint8_t payloadtype;
RTPHeader *rtpheader;
bool marker;
@ -209,8 +209,8 @@ uint32_t RTPPacket::GetCSRC(int num) const
return csrcval_hbo;
}
int RTPPacket::BuildPacket(uint8_t payloadtype, const void *payloaddata, size_t payloadlen, uint16_t seqnr, uint32_t timestamp, uint32_t ssrc, bool gotmarker, uint8_t numcsrcs,
const uint32_t *csrcs, bool gotextension, uint16_t extensionid, uint16_t extensionlen_numwords, const void *extensiondata, void *buffer, size_t maxsize)
int RTPPacket::BuildPacket(uint8_t payloadtype, const void *payloaddata, std::size_t payloadlen, uint16_t seqnr, uint32_t timestamp, uint32_t ssrc, bool gotmarker, uint8_t numcsrcs,
const uint32_t *csrcs, bool gotextension, uint16_t extensionid, uint16_t extensionlen_numwords, const void *extensiondata, void *buffer, std::size_t maxsize)
{
if (numcsrcs > RTP_MAXCSRCS)
return ERR_RTP_PACKET_TOOMANYCSRCS;
@ -221,11 +221,11 @@ int RTPPacket::BuildPacket(uint8_t payloadtype, const void *payloaddata, size_t
return ERR_RTP_PACKET_BADPAYLOADTYPE;
packetlength = sizeof(RTPHeader);
packetlength += sizeof(uint32_t) * ((size_t) numcsrcs);
packetlength += sizeof(uint32_t) * ((std::size_t) numcsrcs);
if (gotextension)
{
packetlength += sizeof(RTPExtensionHeader);
packetlength += sizeof(uint32_t) * ((size_t) extensionlen_numwords);
packetlength += sizeof(uint32_t) * ((std::size_t) extensionlen_numwords);
}
packetlength += payloadlen;
@ -264,7 +264,7 @@ int RTPPacket::BuildPacket(uint8_t payloadtype, const void *payloaddata, size_t
RTPPacket::ssrc = ssrc;
RTPPacket::payloadlength = payloadlen;
RTPPacket::extid = extensionid;
RTPPacket::extensionlength = ((size_t) extensionlen_numwords) * sizeof(uint32_t);
RTPPacket::extensionlength = ((std::size_t) extensionlen_numwords) * sizeof(uint32_t);
rtphdr = (RTPHeader *) packet;
rtphdr->version = RTP_VERSION;
@ -290,7 +290,7 @@ int RTPPacket::BuildPacket(uint8_t payloadtype, const void *payloaddata, size_t
for (i = 0; i < numcsrcs; i++, curcsrc++)
*curcsrc = qToBigEndian(csrcs[i]);
payload = packet + sizeof(RTPHeader) + ((size_t) numcsrcs) * sizeof(uint32_t);
payload = packet + sizeof(RTPHeader) + ((std::size_t) numcsrcs) * sizeof(uint32_t);
if (gotextension)
{
RTPExtensionHeader *rtpexthdr = (RTPExtensionHeader *) payload;

22
qrtplib/rtppacket.h
View File

@ -68,13 +68,13 @@ public:
* \c maxpacksize. The arguments of the constructor are self-explanatory. Note that the size of a header
* extension is specified in a number of 32-bit words. A memory manager can be installed.
*/
RTPPacket(uint8_t payloadtype, const void *payloaddata, size_t payloadlen, uint16_t seqnr, uint32_t timestamp, uint32_t ssrc, bool gotmarker, uint8_t numcsrcs,
const uint32_t *csrcs, bool gotextension, uint16_t extensionid, uint16_t extensionlen_numwords, const void *extensiondata, size_t maxpacksize);
RTPPacket(uint8_t payloadtype, const void *payloaddata, std::size_t payloadlen, uint16_t seqnr, uint32_t timestamp, uint32_t ssrc, bool gotmarker, uint8_t numcsrcs,
const uint32_t *csrcs, bool gotextension, uint16_t extensionid, uint16_t extensionlen_numwords, const void *extensiondata, std::size_t maxpacksize);
/** This constructor is similar to the other constructor, but here data is stored in an external buffer
* \c buffer with size \c buffersize. */
RTPPacket(uint8_t payloadtype, const void *payloaddata, size_t payloadlen, uint16_t seqnr, uint32_t timestamp, uint32_t ssrc, bool gotmarker, uint8_t numcsrcs,
const uint32_t *csrcs, bool gotextension, uint16_t extensionid, uint16_t extensionlen_numwords, const void *extensiondata, void *buffer, size_t buffersize);
RTPPacket(uint8_t payloadtype, const void *payloaddata, std::size_t payloadlen, uint16_t seqnr, uint32_t timestamp, uint32_t ssrc, bool gotmarker, uint8_t numcsrcs,
const uint32_t *csrcs, bool gotextension, uint16_t extensionid, uint16_t extensionlen_numwords, const void *extensiondata, void *buffer, std::size_t buffersize);
virtual ~RTPPacket()
{
@ -163,13 +163,13 @@ public:
}
/** Returns the length of the entire packet. */
size_t GetPacketLength() const
std::size_t GetPacketLength() const
{
return packetlength;
}
/** Returns the payload length. */
size_t GetPayloadLength() const
std::size_t GetPayloadLength() const
{
return payloadlength;
}
@ -187,7 +187,7 @@ public:
}
/** Returns the length of the header extension data. */
size_t GetExtensionLength() const
std::size_t GetExtensionLength() const
{
return extensionlength;
}
@ -204,8 +204,8 @@ public:
private:
void Clear();
int ParseRawPacket(RTPRawPacket &rawpack);
int BuildPacket(uint8_t payloadtype, const void *payloaddata, size_t payloadlen, uint16_t seqnr, uint32_t timestamp, uint32_t ssrc, bool gotmarker, uint8_t numcsrcs,
const uint32_t *csrcs, bool gotextension, uint16_t extensionid, uint16_t extensionlen_numwords, const void *extensiondata, void *buffer, size_t maxsize);
int BuildPacket(uint8_t payloadtype, const void *payloaddata, std::size_t payloadlen, uint16_t seqnr, uint32_t timestamp, uint32_t ssrc, bool gotmarker, uint8_t numcsrcs,
const uint32_t *csrcs, bool gotextension, uint16_t extensionid, uint16_t extensionlen_numwords, const void *extensiondata, void *buffer, std::size_t maxsize);
RTPEndian m_endian;
int error;
@ -216,11 +216,11 @@ private:
uint8_t payloadtype;
uint32_t extseqnr, timestamp, ssrc;
uint8_t *packet, *payload;
size_t packetlength, payloadlength;
std::size_t packetlength, payloadlength;
uint16_t extid;
uint8_t *extension;
size_t extensionlength;
std::size_t extensionlength;
bool externalbuffer;

16
qrtplib/rtppacketbuilder.cpp
View File

@ -54,7 +54,7 @@ RTPPacketBuilder::~RTPPacketBuilder()
Destroy();
}
int RTPPacketBuilder::Init(size_t max)
int RTPPacketBuilder::Init(std::size_t max)
{
if (init)
return ERR_RTP_PACKBUILD_ALREADYINIT;
@ -87,7 +87,7 @@ void RTPPacketBuilder::Destroy()
init = false;
}
int RTPPacketBuilder::SetMaximumPacketSize(size_t max)
int RTPPacketBuilder::SetMaximumPacketSize(std::size_t max)
{
uint8_t *newbuf;
@ -186,7 +186,7 @@ uint32_t RTPPacketBuilder::CreateNewSSRC(RTPSources &sources)
return ssrc;
}
int RTPPacketBuilder::BuildPacket(const void *data, size_t len)
int RTPPacketBuilder::BuildPacket(const void *data, std::size_t len)
{
if (!init)
return ERR_RTP_PACKBUILD_NOTINIT;
@ -199,14 +199,14 @@ int RTPPacketBuilder::BuildPacket(const void *data, size_t len)
return PrivateBuildPacket(data, len, defaultpayloadtype, defaultmark, defaulttimestampinc, false);
}
int RTPPacketBuilder::BuildPacket(const void *data, size_t len, uint8_t pt, bool mark, uint32_t timestampinc)
int RTPPacketBuilder::BuildPacket(const void *data, std::size_t len, uint8_t pt, bool mark, uint32_t timestampinc)
{
if (!init)
return ERR_RTP_PACKBUILD_NOTINIT;
return PrivateBuildPacket(data, len, pt, mark, timestampinc, false);
}
int RTPPacketBuilder::BuildPacketEx(const void *data, size_t len, uint16_t hdrextID, const void *hdrextdata, size_t numhdrextwords)
int RTPPacketBuilder::BuildPacketEx(const void *data, std::size_t len, uint16_t hdrextID, const void *hdrextdata, std::size_t numhdrextwords)
{
if (!init)
return ERR_RTP_PACKBUILD_NOTINIT;
@ -219,7 +219,7 @@ int RTPPacketBuilder::BuildPacketEx(const void *data, size_t len, uint16_t hdrex
return PrivateBuildPacket(data, len, defaultpayloadtype, defaultmark, defaulttimestampinc, true, hdrextID, hdrextdata, numhdrextwords);
}
int RTPPacketBuilder::BuildPacketEx(const void *data, size_t len, uint8_t pt, bool mark, uint32_t timestampinc, uint16_t hdrextID, const void *hdrextdata, size_t numhdrextwords)
int RTPPacketBuilder::BuildPacketEx(const void *data, std::size_t len, uint8_t pt, bool mark, uint32_t timestampinc, uint16_t hdrextID, const void *hdrextdata, std::size_t numhdrextwords)
{
if (!init)
return ERR_RTP_PACKBUILD_NOTINIT;
@ -227,8 +227,8 @@ int RTPPacketBuilder::BuildPacketEx(const void *data, size_t len, uint8_t pt, bo
}
int RTPPacketBuilder::PrivateBuildPacket(const void *data, size_t len, uint8_t pt, bool mark, uint32_t timestampinc, bool gotextension, uint16_t hdrextID, const void *hdrextdata,
size_t numhdrextwords)
int RTPPacketBuilder::PrivateBuildPacket(const void *data, std::size_t len, uint8_t pt, bool mark, uint32_t timestampinc, bool gotextension, uint16_t hdrextID, const void *hdrextdata,
std::size_t numhdrextwords)
{
RTPPacket p(pt, data, len, seqnr, timestamp, ssrc, mark, numcsrcs, csrcs, gotextension, hdrextID, (uint16_t) numhdrextwords, hdrextdata, buffer, maxpacksize);
int status = p.GetCreationError();

22
qrtplib/rtppacketbuilder.h
View File

@ -63,7 +63,7 @@ public:
~RTPPacketBuilder();
/** Initializes the builder to only allow packets with a size below \c maxpacksize. */
int Init(size_t maxpacksize);
int Init(std::size_t maxpacksize);
/** Cleans up the builder. */
void Destroy();
@ -85,7 +85,7 @@ public:
}
/** Sets the maximum allowed packet size to \c maxpacksize. */
int SetMaximumPacketSize(size_t maxpacksize);
int SetMaximumPacketSize(std::size_t maxpacksize);
/** Adds a CSRC to the CSRC list which will be stored in the RTP packets. */
int AddCSRC(uint32_t csrc);
@ -101,14 +101,14 @@ public:
* and timestamp increment used will be those that have been set using the \c SetDefault
* functions below.
*/
int BuildPacket(const void *data, size_t len);
int BuildPacket(const void *data, std::size_t len);
/** Builds a packet with payload \c data and payload length \c len.
* Builds a packet with payload \c data and payload length \c len. The payload type will be
* set to \c pt, the marker bit to \c mark and after building this packet, the timestamp will
* be incremented with \c timestamp.
*/
int BuildPacket(const void *data, size_t len, uint8_t pt, bool mark, uint32_t timestampinc);
int BuildPacket(const void *data, std::size_t len, uint8_t pt, bool mark, uint32_t timestampinc);
/** Builds a packet with payload \c data and payload length \c len.
* Builds a packet with payload \c data and payload length \c len. The payload type, marker
@ -117,7 +117,7 @@ public:
* \c hdrextID and data \c hdrextdata. The length of the header extension data is given by
* \c numhdrextwords which expresses the length in a number of 32-bit words.
*/
int BuildPacketEx(const void *data, size_t len, uint16_t hdrextID, const void *hdrextdata, size_t numhdrextwords);
int BuildPacketEx(const void *data, std::size_t len, uint16_t hdrextID, const void *hdrextdata, std::size_t numhdrextwords);
/** Builds a packet with payload \c data and payload length \c len.
* Builds a packet with payload \c data and payload length \c len. The payload type will be set
@ -126,7 +126,7 @@ public:
* with identifier \c hdrextID and data \c hdrextdata. The length of the header extension
* data is given by \c numhdrextwords which expresses the length in a number of 32-bit words.
*/
int BuildPacketEx(const void *data, size_t len, uint8_t pt, bool mark, uint32_t timestampinc, uint16_t hdrextID, const void *hdrextdata, size_t numhdrextwords);
int BuildPacketEx(const void *data, std::size_t len, uint8_t pt, bool mark, uint32_t timestampinc, uint16_t hdrextID, const void *hdrextdata, std::size_t numhdrextwords);
/** Returns a pointer to the last built RTP packet data. */
uint8_t *GetPacket()
@ -137,7 +137,7 @@ public:
}
/** Returns the size of the last built RTP packet. */
size_t GetPacketLength()
std::size_t GetPacketLength()
{
if (!init)
return 0;
@ -235,13 +235,13 @@ public:
ssrc = s;
}
private:
int PrivateBuildPacket(const void *data, size_t len, uint8_t pt, bool mark, uint32_t timestampinc, bool gotextension, uint16_t hdrextID = 0, const void *hdrextdata = 0,
size_t numhdrextwords = 0);
int PrivateBuildPacket(const void *data, std::size_t len, uint8_t pt, bool mark, uint32_t timestampinc, bool gotextension, uint16_t hdrextID = 0, const void *hdrextdata = 0,
std::size_t numhdrextwords = 0);
RTPRandom &rtprnd;
size_t maxpacksize;
std::size_t maxpacksize;
uint8_t *buffer;
size_t packetlength;
std::size_t packetlength;
uint32_t numpayloadbytes;
uint32_t numpackets;

12
qrtplib/rtprawpacket.h
View File

@ -57,7 +57,7 @@ public:
* The flag which indicates whether this data is RTP or RTCP data is set to \c rtp. A memory
* manager can be installed as well.
*/
RTPRawPacket(uint8_t *data, size_t datalen, RTPAddress *address, RTPTime &recvtime, bool rtp);
RTPRawPacket(uint8_t *data, std::size_t datalen, RTPAddress *address, RTPTime &recvtime, bool rtp);
~RTPRawPacket();
/** Returns the pointer to the data which is contained in this packet. */
@ -67,7 +67,7 @@ public:
}
/** Returns the length of the packet described by this instance. */
size_t GetDataLength() const
std::size_t GetDataLength() const
{
return packetdatalength;
}
@ -110,7 +110,7 @@ public:
/** Deallocates the previously stored data and replaces it with the data that's
* specified, can be useful when e.g. decrypting data in RTPSession::OnChangeIncomingData */
void SetData(uint8_t *data, size_t datalen);
void SetData(uint8_t *data, std::size_t datalen);
/** Deallocates the currently stored RTPAddress instance and replaces it
* with the one that's specified (you probably don't need this function). */
@ -119,13 +119,13 @@ private:
void DeleteData();
uint8_t *packetdata;
size_t packetdatalength;
std::size_t packetdatalength;
RTPTime receivetime;
RTPAddress *senderaddress;
bool isrtp;
};
inline RTPRawPacket::RTPRawPacket(uint8_t *data, size_t datalen, RTPAddress *address, RTPTime &recvtime, bool rtp) :
inline RTPRawPacket::RTPRawPacket(uint8_t *data, std::size_t datalen, RTPAddress *address, RTPTime &recvtime, bool rtp) :
receivetime(recvtime)
{
packetdata = data;
@ -155,7 +155,7 @@ inline uint8_t *RTPRawPacket::AllocateBytes(int recvlen) const
return new uint8_t[recvlen];
}
inline void RTPRawPacket::SetData(uint8_t *data, size_t datalen)
inline void RTPRawPacket::SetData(uint8_t *data, std::size_t datalen)
{
if (packetdata)
delete[] packetdata;

12
qrtplib/rtpselect.h
View File

@ -57,13 +57,13 @@
namespace qrtplib
{
inline int RTPSelect(const SocketType *sockets, int8_t *readflags, size_t numsocks, RTPTime timeout)
inline int RTPSelect(const SocketType *sockets, int8_t *readflags, std::size_t numsocks, RTPTime timeout)
{
using namespace std;
vector<struct pollfd> fds(numsocks);
for (size_t i = 0; i < numsocks; i++)
for (std::size_t i = 0; i < numsocks; i++)
{
fds[i].fd = sockets[i];
fds[i].events = POLLIN;
@ -98,7 +98,7 @@ inline int RTPSelect(const SocketType *sockets, int8_t *readflags, size_t numsoc
if (status > 0)
{
for (size_t i = 0; i < numsocks; i++)
for (std::size_t i = 0; i < numsocks; i++)
{
if (fds[i].revents)
readflags[i] = 1;
@ -131,7 +131,7 @@ namespace qrtplib
* indefinitely if set to a negative value. The function returns the number
* of sockets that have data incoming.
*/
inline int RTPSelect(const SocketType *sockets, int8_t *readflags, size_t numsocks, RTPTime timeout)
inline int RTPSelect(const SocketType *sockets, int8_t *readflags, std::size_t numsocks, RTPTime timeout)
{
struct timeval tv;
struct timeval *pTv = 0;
@ -145,7 +145,7 @@ namespace qrtplib
fd_set fdset;
FD_ZERO(&fdset);
for (size_t i = 0; i < numsocks; i++)
for (std::size_t i = 0; i < numsocks; i++)
{
#ifndef RTP_SOCKETTYPE_WINSOCK
const int setsize = FD_SETSIZE;
@ -174,7 +174,7 @@ namespace qrtplib
if (status > 0) // some descriptors were set, check them
{
for (size_t i = 0; i < numsocks; i++)
for (std::size_t i = 0; i < numsocks; i++)
{
if (FD_ISSET(sockets[i], &fdset))
readflags[i] = 1;

46
qrtplib/rtpsession.cpp
View File

@ -220,7 +220,7 @@ int RTPSession::InternalCreate(const RTPSessionParams &sessparams)
double timestampunit = sessparams.GetOwnTimestampUnit();
uint8_t buf[1024];
size_t buflen = 1024;
std::size_t buflen = 1024;
std::string forcedcname = sessparams.GetCNAME();
if (forcedcname.length() == 0)
@ -329,7 +329,7 @@ void RTPSession::Destroy()
created = false;
}
void RTPSession::BYEDestroy(const RTPTime &maxwaittime, const void *reason, size_t reasonlength)
void RTPSession::BYEDestroy(const RTPTime &maxwaittime, const void *reason, std::size_t reasonlength)
{
if (!created)
return;
@ -474,7 +474,7 @@ void RTPSession::LeaveAllMulticastGroups()
rtptrans->LeaveAllMulticastGroups();
}
int RTPSession::SendPacket(const void *data, size_t len)
int RTPSession::SendPacket(const void *data, std::size_t len)
{
int status;
@ -503,7 +503,7 @@ int RTPSession::SendPacket(const void *data, size_t len)
return 0;
}
int RTPSession::SendPacket(const void *data, size_t len, uint8_t pt, bool mark, uint32_t timestampinc)
int RTPSession::SendPacket(const void *data, std::size_t len, uint8_t pt, bool mark, uint32_t timestampinc)
{
int status;
@ -532,7 +532,7 @@ int RTPSession::SendPacket(const void *data, size_t len, uint8_t pt, bool mark,
return 0;
}
int RTPSession::SendPacketEx(const void *data, size_t len, uint16_t hdrextID, const void *hdrextdata, size_t numhdrextwords)
int RTPSession::SendPacketEx(const void *data, std::size_t len, uint16_t hdrextID, const void *hdrextdata, std::size_t numhdrextwords)
{
int status;
@ -561,7 +561,7 @@ int RTPSession::SendPacketEx(const void *data, size_t len, uint16_t hdrextID, co
return 0;
}
int RTPSession::SendPacketEx(const void *data, size_t len, uint8_t pt, bool mark, uint32_t timestampinc, uint16_t hdrextID, const void *hdrextdata, size_t numhdrextwords)
int RTPSession::SendPacketEx(const void *data, std::size_t len, uint8_t pt, bool mark, uint32_t timestampinc, uint16_t hdrextID, const void *hdrextdata, std::size_t numhdrextwords)
{
int status;
@ -592,7 +592,7 @@ int RTPSession::SendPacketEx(const void *data, size_t len, uint8_t pt, bool mark
#ifdef RTP_SUPPORT_SENDAPP
int RTPSession::SendRTCPAPPPacket(uint8_t subtype, const uint8_t name[4], const void *appdata, size_t appdatalen)
int RTPSession::SendRTCPAPPPacket(uint8_t subtype, const uint8_t name[4], const void *appdata, std::size_t appdatalen)
{
int status;
@ -619,7 +619,7 @@ int RTPSession::SendRTCPAPPPacket(uint8_t subtype, const uint8_t name[4], const
return status;
BUILDER_LOCK
size_t owncnamelen = 0;
std::size_t owncnamelen = 0;
uint8_t *owncname = rtcpbuilder.GetLocalCNAME(&owncnamelen);
if ((status = pb.AddSDESNormalItem(RTCPSDESPacket::CNAME, owncname, owncnamelen)) < 0)
@ -650,7 +650,7 @@ int RTPSession::SendRTCPAPPPacket(uint8_t subtype, const uint8_t name[4], const
#endif // RTP_SUPPORT_SENDAPP
int RTPSession::SendRawData(const void *data, size_t len, bool usertpchannel)
int RTPSession::SendRawData(const void *data, std::size_t len, bool usertpchannel)
{
if (!created)
return ERR_RTP_SESSION_NOTCREATED;
@ -940,7 +940,7 @@ void RTPSession::ClearAcceptList()
rtptrans->ClearAcceptList();
}
int RTPSession::SetMaximumPacketSize(size_t s)
int RTPSession::SetMaximumPacketSize(std::size_t s)
{
if (!created)
return ERR_RTP_SESSION_NOTCREATED;
@ -1059,7 +1059,7 @@ rtcpbuilder.SetNoteInterval(count);
BUILDER_UNLOCK
}
int RTPSession::SetLocalName(const void *s, size_t len)
int RTPSession::SetLocalName(const void *s, std::size_t len)
{
if (!created)
return ERR_RTP_SESSION_NOTCREATED;
@ -1071,7 +1071,7 @@ BUILDER_UNLOCK
return status;
}
int RTPSession::SetLocalEMail(const void *s, size_t len)
int RTPSession::SetLocalEMail(const void *s, std::size_t len)
{
if (!created)
return ERR_RTP_SESSION_NOTCREATED;
@ -1083,7 +1083,7 @@ BUILDER_UNLOCK
return status;
}
int RTPSession::SetLocalLocation(const void *s, size_t len)
int RTPSession::SetLocalLocation(const void *s, std::size_t len)
{
if (!created)
return ERR_RTP_SESSION_NOTCREATED;
@ -1095,7 +1095,7 @@ BUILDER_UNLOCK
return status;
}
int RTPSession::SetLocalPhone(const void *s, size_t len)
int RTPSession::SetLocalPhone(const void *s, std::size_t len)
{
if (!created)
return ERR_RTP_SESSION_NOTCREATED;
@ -1107,7 +1107,7 @@ BUILDER_UNLOCK
return status;
}
int RTPSession::SetLocalTool(const void *s, size_t len)
int RTPSession::SetLocalTool(const void *s, std::size_t len)
{
if (!created)
return ERR_RTP_SESSION_NOTCREATED;
@ -1119,7 +1119,7 @@ BUILDER_UNLOCK
return status;
}
int RTPSession::SetLocalNote(const void *s, size_t len)
int RTPSession::SetLocalNote(const void *s, std::size_t len)
{
if (!created)
return ERR_RTP_SESSION_NOTCREATED;
@ -1321,7 +1321,7 @@ SOURCES_UNLOCK
return 0;
}
int RTPSession::CreateCNAME(uint8_t *buffer, size_t *bufferlength, bool resolve)
int RTPSession::CreateCNAME(uint8_t *buffer, std::size_t *bufferlength, bool resolve)
{
#ifndef WIN32
bool gotlogin = true;
@ -1370,12 +1370,12 @@ RTP_STRNCPY((char *)buffer,"unknown",*bufferlength);
#endif // WIN32
buffer[*bufferlength - 1] = 0;
size_t offset = strlen((const char *) buffer);
std::size_t offset = strlen((const char *) buffer);
if (offset < (*bufferlength - 1))
buffer[offset] = (uint8_t) '@';
offset++;
size_t buflen2 = *bufferlength - offset;
std::size_t buflen2 = *bufferlength - offset;
int status;
if (resolve)
@ -1418,13 +1418,13 @@ deletertprnd = false;
return rnew;
}
int RTPSession::SendRTPData(const void *data, size_t len)
int RTPSession::SendRTPData(const void *data, std::size_t len)
{
if (!m_changeOutgoingData)
return rtptrans->SendRTPData(data, len);
void *pSendData = 0;
size_t sendLen = 0;
std::size_t sendLen = 0;
int status = 0;
status = OnChangeRTPOrRTCPData(data, len, true, &pSendData, &sendLen);
@ -1440,13 +1440,13 @@ OnSentRTPOrRTCPData(pSendData, sendLen, true);
return status;
}
int RTPSession::SendRTCPData(const void *data, size_t len)
int RTPSession::SendRTCPData(const void *data, std::size_t len)
{
if (!m_changeOutgoingData)
return rtptrans->SendRTCPData(data, len);
void *pSendData = 0;
size_t sendLen = 0;
std::size_t sendLen = 0;
int status = 0;
status = OnChangeRTPOrRTCPData(data, len, false, &pSendData, &sendLen);

56
qrtplib/rtpsession.h
View File

@ -112,7 +112,7 @@ public:
* send the BYE packet. If this time expires, the session will be left without sending a BYE packet.
* The BYE packet will contain as reason for leaving \c reason with length \c reasonlength.
*/
void BYEDestroy(const RTPTime &maxwaittime, const void *reason, size_t reasonlength);
void BYEDestroy(const RTPTime &maxwaittime, const void *reason, std::size_t reasonlength);
/** Returns whether the session has been created or not. */
bool IsActive();
@ -146,13 +146,13 @@ public:
* The used payload type, marker and timestamp increment will be those that have been set
* using the \c SetDefault member functions.
*/
int SendPacket(const void *data, size_t len);
int SendPacket(const void *data, std::size_t len);
/** Sends the RTP packet with payload \c data which has length \c len.
* It will use payload type \c pt, marker \c mark and after the packet has been built, the
* timestamp will be incremented by \c timestampinc.
*/
int SendPacket(const void *data, size_t len, uint8_t pt, bool mark, uint32_t timestampinc);
int SendPacket(const void *data, std::size_t len, uint8_t pt, bool mark, uint32_t timestampinc);
/** Sends the RTP packet with payload \c data which has length \c len.
* The packet will contain a header extension with identifier \c hdrextID and containing data
@ -160,7 +160,7 @@ public:
* number of 32-bit words. The used payload type, marker and timestamp increment will be those that
* have been set using the \c SetDefault member functions.
*/
int SendPacketEx(const void *data, size_t len, uint16_t hdrextID, const void *hdrextdata, size_t numhdrextwords);
int SendPacketEx(const void *data, std::size_t len, uint16_t hdrextID, const void *hdrextdata, std::size_t numhdrextwords);
/** Sends the RTP packet with payload \c data which has length \c len.
* It will use payload type \c pt, marker \c mark and after the packet has been built, the
@ -168,7 +168,7 @@ public:
* extension with identifier \c hdrextID and containing data \c hdrextdata. The length
* of this data is given by \c numhdrextwords and is specified in a number of 32-bit words.
*/
int SendPacketEx(const void *data, size_t len, uint8_t pt, bool mark, uint32_t timestampinc, uint16_t hdrextID, const void *hdrextdata, size_t numhdrextwords);
int SendPacketEx(const void *data, std::size_t len, uint8_t pt, bool mark, uint32_t timestampinc, uint16_t hdrextID, const void *hdrextdata, std::size_t numhdrextwords);
#ifdef RTP_SUPPORT_SENDAPP
/** If sending of RTCP APP packets was enabled at compile time, this function creates a compound packet
* containing an RTCP APP packet and sends it immediately.
@ -177,13 +177,13 @@ public:
* of bytes in the RTCP compound packet. Note that this immediate sending is not compliant with the RTP
* specification, so use with care.
*/
int SendRTCPAPPPacket(uint8_t subtype, const uint8_t name[4], const void *appdata, size_t appdatalen);
int SendRTCPAPPPacket(uint8_t subtype, const uint8_t name[4], const void *appdata, std::size_t appdatalen);
#endif // RTP_SUPPORT_SENDAPP
/** With this function raw data can be sent directly over the RTP or
* RTCP channel (if they are different); the data is **not** passed through the
* RTPSession::OnChangeRTPOrRTCPData function. */
int SendRawData(const void *data, size_t len, bool usertpchannel);
int SendRawData(const void *data, std::size_t len, bool usertpchannel);
/** Sets the default payload type for RTP packets to \c pt. */
int SetDefaultPayloadType(uint8_t pt);
@ -353,7 +353,7 @@ public:
void ClearAcceptList();
/** Sets the maximum allowed packet size to \c s. */
int SetMaximumPacketSize(size_t s);
int SetMaximumPacketSize(std::size_t s);
/** Sets the session bandwidth to \c bw, which is specified in bytes per second. */
int SetSessionBandwidth(double bw);
@ -415,22 +415,22 @@ public:
void SetNoteInterval(int count);
/** Sets the SDES name item for the local participant to the value \c s with length \c len. */
int SetLocalName(const void *s, size_t len);
int SetLocalName(const void *s, std::size_t len);
/** Sets the SDES e-mail item for the local participant to the value \c s with length \c len. */
int SetLocalEMail(const void *s, size_t len);
int SetLocalEMail(const void *s, std::size_t len);
/** Sets the SDES location item for the local participant to the value \c s with length \c len. */
int SetLocalLocation(const void *s, size_t len);
int SetLocalLocation(const void *s, std::size_t len);
/** Sets the SDES phone item for the local participant to the value \c s with length \c len. */
int SetLocalPhone(const void *s, size_t len);
int SetLocalPhone(const void *s, std::size_t len);
/** Sets the SDES tool item for the local participant to the value \c s with length \c len. */
int SetLocalTool(const void *s, size_t len);
int SetLocalTool(const void *s, std::size_t len);
/** Sets the SDES note item for the local participant to the value \c s with length \c len. */
int SetLocalNote(const void *s, size_t len);
int SetLocalNote(const void *s, std::size_t len);
protected:
/** Allocate a user defined transmitter.
@ -461,7 +461,7 @@ protected:
virtual void OnSSRCCollision(RTPSourceData *srcdat, const RTPAddress *senderaddress, bool isrtp);
/** Is called when another CNAME was received than the one already present for source \c srcdat. */
virtual void OnCNAMECollision(RTPSourceData *srcdat, const RTPAddress *senderaddress, const uint8_t *cname, size_t cnamelength);
virtual void OnCNAMECollision(RTPSourceData *srcdat, const RTPAddress *senderaddress, const uint8_t *cname, std::size_t cnamelength);
/** Is called when a new entry \c srcdat is added to the source table. */
virtual void OnNewSource(RTPSourceData *srcdat);
@ -496,10 +496,10 @@ protected:
virtual void OnRTCPReceiverReport(RTPSourceData *srcdat);
/** Is called when a specific SDES item was received for this source. */
virtual void OnRTCPSDESItem(RTPSourceData *srcdat, RTCPSDESPacket::ItemType t, const void *itemdata, size_t itemlength);
virtual void OnRTCPSDESItem(RTPSourceData *srcdat, RTCPSDESPacket::ItemType t, const void *itemdata, std::size_t itemlength);
#ifdef RTP_SUPPORT_SDESPRIV
/** Is called when a specific SDES item of 'private' type was received for this source. */
virtual void OnRTCPSDESPrivateItem(RTPSourceData *srcdat, const void *prefixdata, size_t prefixlen, const void *valuedata, size_t valuelen);
virtual void OnRTCPSDESPrivateItem(RTPSourceData *srcdat, const void *prefixdata, std::size_t prefixlen, const void *valuedata, std::size_t valuelen);
#endif // RTP_SUPPORT_SDESPRIV
/** Is called when a BYE packet has been processed for source \c srcdat. */
@ -531,12 +531,12 @@ protected:
* yourself, a good way may be to do this in RTPSession::OnSentRTPOrRTCPData. If `senddata` is
* set to 0, no packet will be sent out. This also provides a way to turn off sending RTCP
* packets if desired. */
virtual int OnChangeRTPOrRTCPData(const void *origdata, size_t origlen, bool isrtp, void **senddata, size_t *sendlen);
virtual int OnChangeRTPOrRTCPData(const void *origdata, std::size_t origlen, bool isrtp, void **senddata, std::size_t *sendlen);
/** This function is called when an RTP or RTCP packet was sent, it can be helpful
* when data was allocated in RTPSession::OnChangeRTPOrRTCPData to deallocate it
* here. */
virtual void OnSentRTPOrRTCPData(void *senddata, size_t sendlen, bool isrtp);
virtual void OnSentRTPOrRTCPData(void *senddata, std::size_t sendlen, bool isrtp);
/** By overriding this function, the raw incoming data can be inspected
* and modified (e.g. for encryption).
@ -559,12 +559,12 @@ protected:
virtual void OnValidatedRTPPacket(RTPSourceData *srcdat, RTPPacket *rtppack, bool isonprobation, bool *ispackethandled);
private:
int InternalCreate(const RTPSessionParams &sessparams);
int CreateCNAME(uint8_t *buffer, size_t *bufferlength, bool resolve);
int CreateCNAME(uint8_t *buffer, std::size_t *bufferlength, bool resolve);
int ProcessPolledData();
int ProcessRTCPCompoundPacket(RTCPCompoundPacket &rtcpcomppack, RTPRawPacket *pack);
RTPRandom *GetRandomNumberGenerator(RTPRandom *r);
int SendRTPData(const void *data, size_t len);
int SendRTCPData(const void *data, size_t len);
int SendRTPData(const void *data, std::size_t len);
int SendRTCPData(const void *data, std::size_t len);
RTPRandom *rtprnd;
bool deletertprnd;
@ -575,7 +575,7 @@ private:
bool usingpollthread, needthreadsafety;
bool acceptownpackets;
bool useSR_BYEifpossible;
size_t maxpacksize;
std::size_t maxpacksize;
double sessionbandwidth;
double controlfragment;
double sendermultiplier;
@ -612,7 +612,7 @@ inline void RTPSession::OnRTCPCompoundPacket(RTCPCompoundPacket *, const RTPTime
inline void RTPSession::OnSSRCCollision(RTPSourceData *, const RTPAddress *, bool)
{
}
inline void RTPSession::OnCNAMECollision(RTPSourceData *, const RTPAddress *, const uint8_t *, size_t)
inline void RTPSession::OnCNAMECollision(RTPSourceData *, const RTPAddress *, const uint8_t *, std::size_t)
{
}
inline void RTPSession::OnNewSource(RTPSourceData *)
@ -645,12 +645,12 @@ inline void RTPSession::OnRTCPSenderReport(RTPSourceData *)
inline void RTPSession::OnRTCPReceiverReport(RTPSourceData *)
{
}
inline void RTPSession::OnRTCPSDESItem(RTPSourceData *, RTCPSDESPacket::ItemType, const void *, size_t)
inline void RTPSession::OnRTCPSDESItem(RTPSourceData *, RTCPSDESPacket::ItemType, const void *, std::size_t)
{
}
#ifdef RTP_SUPPORT_SDESPRIV
inline void RTPSession::OnRTCPSDESPrivateItem(RTPSourceData *, const void *, size_t, const void *, size_t)
inline void RTPSession::OnRTCPSDESPrivateItem(RTPSourceData *, const void *, std::size_t, const void *, std::size_t)
{
}
#endif // RTP_SUPPORT_SDESPRIV
@ -662,11 +662,11 @@ inline void RTPSession::OnSendRTCPCompoundPacket(RTCPCompoundPacket *)
{
}
inline int RTPSession::OnChangeRTPOrRTCPData(const void *, size_t, bool, void **, size_t *)
inline int RTPSession::OnChangeRTPOrRTCPData(const void *, std::size_t, bool, void **, std::size_t *)
{
return ERR_RTP_RTPSESSION_CHANGEREQUESTEDBUTNOTIMPLEMENTED;
}
inline void RTPSession::OnSentRTPOrRTCPData(void *, size_t, bool)
inline void RTPSession::OnSentRTPOrRTCPData(void *, std::size_t, bool)
{
}
inline bool RTPSession::OnChangeIncomingData(RTPRawPacket *)

6
qrtplib/rtpsessionparams.h
View File

@ -72,13 +72,13 @@ public:
}
/** Sets the maximum allowed packet size for the session. */
void SetMaximumPacketSize(size_t max)
void SetMaximumPacketSize(std::size_t max)
{
maxpacksize = max;
}
/** Returns the maximum allowed packet size (default is 1400 bytes). */
size_t GetMaximumPacketSize() const
std::size_t GetMaximumPacketSize() const
{
return maxpacksize;
}
@ -340,7 +340,7 @@ public:
private:
bool acceptown;
bool usepollthread;
size_t maxpacksize;
std::size_t maxpacksize;
double owntsunit;
RTPTransmitter::ReceiveMode receivemode;
bool resolvehostname;

6
qrtplib/rtpsessionsources.cpp
View File

@ -56,7 +56,7 @@ void RTPSessionSources::OnSSRCCollision(RTPSourceData *srcdat, const RTPAddress
rtpsession.OnSSRCCollision(srcdat, senderaddress, isrtp);
}
void RTPSessionSources::OnCNAMECollision(RTPSourceData *srcdat, const RTPAddress *senderaddress, const uint8_t *cname, size_t cnamelength)
void RTPSessionSources::OnCNAMECollision(RTPSourceData *srcdat, const RTPAddress *senderaddress, const uint8_t *cname, std::size_t cnamelength)
{
rtpsession.OnCNAMECollision(srcdat, senderaddress, cname, cnamelength);
}
@ -123,13 +123,13 @@ void RTPSessionSources::OnRTCPReceiverReport(RTPSourceData *srcdat)
rtpsession.OnRTCPReceiverReport(srcdat);
}
void RTPSessionSources::OnRTCPSDESItem(RTPSourceData *srcdat, RTCPSDESPacket::ItemType t, const void *itemdata, size_t itemlength)
void RTPSessionSources::OnRTCPSDESItem(RTPSourceData *srcdat, RTCPSDESPacket::ItemType t, const void *itemdata, std::size_t itemlength)
{
rtpsession.OnRTCPSDESItem(srcdat, t, itemdata, itemlength);
}
#ifdef RTP_SUPPORT_SDESPRIV
void RTPSessionSources::OnRTCPSDESPrivateItem(RTPSourceData *srcdat, const void *prefixdata, size_t prefixlen, const void *valuedata, size_t valuelen)
void RTPSessionSources::OnRTCPSDESPrivateItem(RTPSourceData *srcdat, const void *prefixdata, std::size_t prefixlen, const void *valuedata, std::size_t valuelen)
{
rtpsession.OnRTCPSDESPrivateItem(srcdat, prefixdata, prefixlen, valuedata, valuelen);
}

6
qrtplib/rtpsessionsources.h
View File

@ -69,7 +69,7 @@ private:
void OnRTPPacket(RTPPacket *pack, const RTPTime &receivetime, const RTPAddress *senderaddress);
void OnRTCPCompoundPacket(RTCPCompoundPacket *pack, const RTPTime &receivetime, const RTPAddress *senderaddress);
void OnSSRCCollision(RTPSourceData *srcdat, const RTPAddress *senderaddress, bool isrtp);
void OnCNAMECollision(RTPSourceData *srcdat, const RTPAddress *senderaddress, const uint8_t *cname, size_t cnamelength);
void OnCNAMECollision(RTPSourceData *srcdat, const RTPAddress *senderaddress, const uint8_t *cname, std::size_t cnamelength);
void OnNewSource(RTPSourceData *srcdat);
void OnRemoveSource(RTPSourceData *srcdat);
void OnTimeout(RTPSourceData *srcdat);
@ -82,9 +82,9 @@ private:
void OnValidatedRTPPacket(RTPSourceData *srcdat, RTPPacket *rtppack, bool isonprobation, bool *ispackethandled);
void OnRTCPSenderReport(RTPSourceData *srcdat);
void OnRTCPReceiverReport(RTPSourceData *srcdat);
void OnRTCPSDESItem(RTPSourceData *srcdat, RTCPSDESPacket::ItemType t, const void *itemdata, size_t itemlength);
void OnRTCPSDESItem(RTPSourceData *srcdat, RTCPSDESPacket::ItemType t, const void *itemdata, std::size_t itemlength);
#ifdef RTP_SUPPORT_SDESPRIV
void OnRTCPSDESPrivateItem(RTPSourceData *srcdat, const void *prefixdata, size_t prefixlen, const void *valuedata, size_t valuelen);
void OnRTCPSDESPrivateItem(RTPSourceData *srcdat, const void *prefixdata, std::size_t prefixlen, const void *valuedata, std::size_t valuelen);
#endif // RTP_SUPPORT_SDESPRIV
RTPSession &rtpsession;

22
qrtplib/rtpsourcedata.h
View File

@ -405,7 +405,7 @@ public:
* Returns the reason for leaving contained in the BYE packet of this participant. The length of
* the reason is stored in \c len.
*/
uint8_t *GetBYEReason(size_t *len) const
uint8_t *GetBYEReason(std::size_t *len) const
{
*len = byereasonlen;
return byereason;
@ -679,43 +679,43 @@ public:
}
/** Returns a pointer to the SDES CNAME item of this participant and stores its length in \c len. */
uint8_t *SDES_GetCNAME(size_t *len) const
uint8_t *SDES_GetCNAME(std::size_t *len) const
{
return SDESinf.GetCNAME(len);
}
/** Returns a pointer to the SDES name item of this participant and stores its length in \c len. */
uint8_t *SDES_GetName(size_t *len) const
uint8_t *SDES_GetName(std::size_t *len) const
{
return SDESinf.GetName(len);
}
/** Returns a pointer to the SDES e-mail item of this participant and stores its length in \c len. */
uint8_t *SDES_GetEMail(size_t *len) const
uint8_t *SDES_GetEMail(std::size_t *len) const
{
return SDESinf.GetEMail(len);
}
/** Returns a pointer to the SDES phone item of this participant and stores its length in \c len. */
uint8_t *SDES_GetPhone(size_t *len) const
uint8_t *SDES_GetPhone(std::size_t *len) const
{
return SDESinf.GetPhone(len);
}
/** Returns a pointer to the SDES location item of this participant and stores its length in \c len. */
uint8_t *SDES_GetLocation(size_t *len) const
uint8_t *SDES_GetLocation(std::size_t *len) const
{
return SDESinf.GetLocation(len);
}
/** Returns a pointer to the SDES tool item of this participant and stores its length in \c len. */
uint8_t *SDES_GetTool(size_t *len) const
uint8_t *SDES_GetTool(std::size_t *len) const
{
return SDESinf.GetTool(len);
}
/** Returns a pointer to the SDES note item of this participant and stores its length in \c len. */
uint8_t *SDES_GetNote(size_t *len) const
uint8_t *SDES_GetNote(std::size_t *len) const
{
return SDESinf.GetNote(len);
}
@ -730,7 +730,7 @@ public:
/** If available, returns \c true and stores the next SDES private item prefix in \c prefix and its length in
* \c prefixlen; the associated value and its length are then stored in \c value and \c valuelen.
*/
bool SDES_GetNextPrivateValue(uint8_t **prefix, size_t *prefixlen, uint8_t **value, size_t *valuelen)
bool SDES_GetNextPrivateValue(uint8_t **prefix, std::size_t *prefixlen, uint8_t **value, std::size_t *valuelen)
{
return SDESinf.GetNextPrivateValue(prefix, prefixlen, value, valuelen);
}
@ -739,7 +739,7 @@ public:
* \c prefixlen; if found, the function returns \c true and stores the associated value and
* its length in \c value and \c valuelen respectively.
*/
bool SDES_GetPrivateValue(uint8_t *prefix, size_t prefixlen, uint8_t **value, size_t *valuelen) const
bool SDES_GetPrivateValue(uint8_t *prefix, std::size_t prefixlen, uint8_t **value, std::size_t *valuelen) const
{
return SDESinf.GetPrivateValue(prefix, prefixlen, value, valuelen);
}
@ -767,7 +767,7 @@ protected:
RTPTime byetime;
uint8_t *byereason;
size_t byereasonlen;
std::size_t byereasonlen;
};
inline RTPPacket *RTPSourceData::GetNextPacket()

10
qrtplib/rtpsources.cpp
View File

@ -686,7 +686,7 @@ int RTPSources::ProcessRTCPReportBlock(uint32_t ssrc, uint8_t fractionlost, int3
return 0;
}
int RTPSources::ProcessSDESNormalItem(uint32_t ssrc, RTCPSDESPacket::ItemType t, size_t itemlength, const void *itemdata, const RTPTime &receivetime,
int RTPSources::ProcessSDESNormalItem(uint32_t ssrc, RTCPSDESPacket::ItemType t, std::size_t itemlength, const void *itemdata, const RTPTime &receivetime,
const RTPAddress *senderaddress)
{
RTPInternalSourceData *srcdat;
@ -746,7 +746,7 @@ int RTPSources::ProcessSDESNormalItem(uint32_t ssrc, RTCPSDESPacket::ItemType t,
}
#ifdef RTP_SUPPORT_SDESPRIV
int RTPSources::ProcessSDESPrivateItem(uint32_t ssrc, size_t prefixlen, const void *prefixdata, size_t valuelen, const void *valuedata, const RTPTime &receivetime,
int RTPSources::ProcessSDESPrivateItem(uint32_t ssrc, std::size_t prefixlen, const void *prefixdata, std::size_t valuelen, const void *valuedata, const RTPTime &receivetime,
const RTPAddress *senderaddress)
{
RTPInternalSourceData *srcdat;
@ -771,7 +771,7 @@ int RTPSources::ProcessSDESPrivateItem(uint32_t ssrc, size_t prefixlen, const vo
}
#endif //RTP_SUPPORT_SDESPRIV
int RTPSources::ProcessBYE(uint32_t ssrc, size_t reasonlength, const void *reasondata, const RTPTime &receivetime, const RTPAddress *senderaddress)
int RTPSources::ProcessBYE(uint32_t ssrc, std::size_t reasonlength, const void *reasondata, const RTPTime &receivetime, const RTPAddress *senderaddress)
{
RTPInternalSourceData *srcdat;
bool created;
@ -1027,7 +1027,7 @@ void RTPSources::NoteTimeout(const RTPTime &curtime, const RTPTime &timeoutdelay
while (sourcelist.HasCurrentElement())
{
RTPInternalSourceData *srcdat = sourcelist.GetCurrentElement();
size_t notelen;
std::size_t notelen;
srcdat->SDES_GetNote(&notelen);
if (notelen != 0) // Note has been set
@ -1076,7 +1076,7 @@ void RTPSources::MultipleTimeouts(const RTPTime &curtime, const RTPTime &sendert
bool deleted, issender, isactive;
bool byetimeout, normaltimeout, notetimeout;
size_t notelen;
std::size_t notelen;
issender = srcdat->IsSender();
isactive = srcdat->IsActive();

18
qrtplib/rtpsources.h
View File

@ -153,14 +153,14 @@ public:
* received at time \c receivetime from address \c senderaddress. The \c senderaddress parameter must
* be NULL if the packet was sent by the local participant.
*/
int ProcessSDESNormalItem(uint32_t ssrc, RTCPSDESPacket::ItemType t, size_t itemlength, const void *itemdata, const RTPTime &receivetime, const RTPAddress *senderaddress);
int ProcessSDESNormalItem(uint32_t ssrc, RTCPSDESPacket::ItemType t, std::size_t itemlength, const void *itemdata, const RTPTime &receivetime, const RTPAddress *senderaddress);
#ifdef RTP_SUPPORT_SDESPRIV
/** Processes the SDES private item from source \c ssrc into the source table.
* Processes the SDES private item from source \c ssrc into the source table. The information was
* received at time \c receivetime from address \c senderaddress. The \c senderaddress
* parameter must be NULL if the packet was sent by the local participant.
*/
int ProcessSDESPrivateItem(uint32_t ssrc, size_t prefixlen, const void *prefixdata, size_t valuelen, const void *valuedata, const RTPTime &receivetime,
int ProcessSDESPrivateItem(uint32_t ssrc, std::size_t prefixlen, const void *prefixdata, std::size_t valuelen, const void *valuedata, const RTPTime &receivetime,
const RTPAddress *senderaddress);
#endif //RTP_SUPPORT_SDESPRIV
/** Processes the BYE message for SSRC \c ssrc.
@ -168,7 +168,7 @@ public:
* address \c senderaddress. The \c senderaddress parameter must be NULL if the packet was sent by the
* local participant.
*/
int ProcessBYE(uint32_t ssrc, size_t reasonlength, const void *reasondata, const RTPTime &receivetime, const RTPAddress *senderaddress);
int ProcessBYE(uint32_t ssrc, std::size_t reasonlength, const void *reasondata, const RTPTime &receivetime, const RTPAddress *senderaddress);
/** If we heard from source \c ssrc, but no actual data was added to the source table (for example, if
* no report block was meant for us), this function can e used to indicate that something was received from
@ -302,7 +302,7 @@ protected:
virtual void OnSSRCCollision(RTPSourceData *srcdat, const RTPAddress *senderaddress, bool isrtp);
/** Is called when another CNAME was received than the one already present for source \c srcdat. */
virtual void OnCNAMECollision(RTPSourceData *srcdat, const RTPAddress *senderaddress, const uint8_t *cname, size_t cnamelength);
virtual void OnCNAMECollision(RTPSourceData *srcdat, const RTPAddress *senderaddress, const uint8_t *cname, std::size_t cnamelength);
/** Is called when a new entry \c srcdat is added to the source table. */
virtual void OnNewSource(RTPSourceData *srcdat);
@ -326,10 +326,10 @@ protected:
virtual void OnRTCPReceiverReport(RTPSourceData *srcdat);
/** Is called when a specific SDES item was received for this source. */
virtual void OnRTCPSDESItem(RTPSourceData *srcdat, RTCPSDESPacket::ItemType t, const void *itemdata, size_t itemlength);
virtual void OnRTCPSDESItem(RTPSourceData *srcdat, RTCPSDESPacket::ItemType t, const void *itemdata, std::size_t itemlength);
#ifdef RTP_SUPPORT_SDESPRIV
/** Is called when a specific SDES item of 'private' type was received for this source. */
virtual void OnRTCPSDESPrivateItem(RTPSourceData *srcdat, const void *prefixdata, size_t prefixlen, const void *valuedata, size_t valuelen);
virtual void OnRTCPSDESPrivateItem(RTPSourceData *srcdat, const void *prefixdata, std::size_t prefixlen, const void *valuedata, std::size_t valuelen);
#endif // RTP_SUPPORT_SDESPRIV
/** Is called when an RTCP APP packet \c apppacket has been received at time \c receivetime
@ -378,7 +378,7 @@ inline void RTPSources::OnRTCPCompoundPacket(RTCPCompoundPacket *, const RTPTime
inline void RTPSources::OnSSRCCollision(RTPSourceData *, const RTPAddress *, bool)
{
}
inline void RTPSources::OnCNAMECollision(RTPSourceData *, const RTPAddress *, const uint8_t *, size_t)
inline void RTPSources::OnCNAMECollision(RTPSourceData *, const RTPAddress *, const uint8_t *, std::size_t)
{
}
inline void RTPSources::OnNewSource(RTPSourceData *)
@ -402,11 +402,11 @@ inline void RTPSources::OnRTCPSenderReport(RTPSourceData *)
inline void RTPSources::OnRTCPReceiverReport(RTPSourceData *)
{
}
inline void RTPSources::OnRTCPSDESItem(RTPSourceData *, RTCPSDESPacket::ItemType, const void *, size_t)
inline void RTPSources::OnRTCPSDESItem(RTPSourceData *, RTCPSDESPacket::ItemType, const void *, std::size_t)
{
}
#ifdef RTP_SUPPORT_SDESPRIV
inline void RTPSources::OnRTCPSDESPrivateItem(RTPSourceData *, const void *, size_t, const void *, size_t)
inline void RTPSources::OnRTCPSDESPrivateItem(RTPSourceData *, const void *, std::size_t, const void *, std::size_t)
{
}
#endif // RTP_SUPPORT_SDESPRIV

20
qrtplib/rtptcptransmitter.cpp
View File

@ -76,7 +76,7 @@ int RTPTCPTransmitter::Init(bool tsafe)
return 0;
}
int RTPTCPTransmitter::Create(size_t maximumpacketsize __attribute__((unused)), const RTPTransmissionParams *transparams)
int RTPTCPTransmitter::Create(std::size_t maximumpacketsize __attribute__((unused)), const RTPTransmissionParams *transparams)
{
const RTPTCPTransmissionParams *params, defaultparams;
int status;
@ -167,7 +167,7 @@ void RTPTCPTransmitter::DeleteTransmissionInfo(RTPTransmissionInfo *i)
delete i;
}
int RTPTCPTransmitter::GetLocalHostName(uint8_t *buffer, size_t *bufferlength)
int RTPTCPTransmitter::GetLocalHostName(uint8_t *buffer, std::size_t *bufferlength)
{
if (!m_init)
return ERR_RTP_TCPTRANS_NOTINIT;
@ -259,7 +259,7 @@ int RTPTCPTransmitter::Poll()
++it;
}
for (size_t i = 0; i < errSockets.size(); i++)
for (std::size_t i = 0; i < errSockets.size(); i++)
OnReceiveError(errSockets[i]);
return status;
@ -324,7 +324,7 @@ int RTPTCPTransmitter::WaitForIncomingData(const RTPTime &delay, bool *dataavail
{
bool avail = false;
for (size_t i = 0; i < m_tmpFlags.size(); i++)
for (std::size_t i = 0; i < m_tmpFlags.size(); i++)
{
if (m_tmpFlags[i])
{
@ -362,12 +362,12 @@ int RTPTCPTransmitter::AbortWait()
return 0;
}
int RTPTCPTransmitter::SendRTPData(const void *data, size_t len)
int RTPTCPTransmitter::SendRTPData(const void *data, std::size_t len)
{
return SendRTPRTCPData(data, len);
}
int RTPTCPTransmitter::SendRTCPData(const void *data, size_t len)
int RTPTCPTransmitter::SendRTCPData(const void *data, std::size_t len)
{
return SendRTPRTCPData(data, len);
}
@ -523,7 +523,7 @@ void RTPTCPTransmitter::ClearAcceptList()
{
}
int RTPTCPTransmitter::SetMaximumPacketSize(size_t s)
int RTPTCPTransmitter::SetMaximumPacketSize(std::size_t s)
{
if (!m_init)
return ERR_RTP_TCPTRANS_NOTINIT;
@ -603,7 +603,7 @@ int RTPTCPTransmitter::PollSocket(SocketType sock, SocketData &sdata)
#ifdef RTP_SOCKETTYPE_WINSOCK
unsigned long len;
#else
size_t len;
std::size_t len;
#endif // RTP_SOCKETTYPE_WINSOCK
bool dataavailable;
@ -668,7 +668,7 @@ int RTPTCPTransmitter::PollSocket(SocketType sock, SocketData &sdata)
return 0;
}
int RTPTCPTransmitter::SendRTPRTCPData(const void *data, size_t len)
int RTPTCPTransmitter::SendRTPRTCPData(const void *data, std::size_t len)
{
if (!m_init)
return ERR_RTP_TCPTRANS_NOTINIT;
@ -706,7 +706,7 @@ int RTPTCPTransmitter::SendRTPRTCPData(const void *data, size_t len)
if (errSockets.size() != 0)
{
for (size_t i = 0; i < errSockets.size(); i++)
for (std::size_t i = 0; i < errSockets.size(); i++)
OnSendError(errSockets[i]);
}

16
qrtplib/rtptcptransmitter.h
View File

@ -124,14 +124,14 @@ public:
~RTPTCPTransmitter();
int Init(bool treadsafe);
int Create(size_t maxpacksize, const RTPTransmissionParams *transparams);
int Create(std::size_t maxpacksize, const RTPTransmissionParams *transparams);
void Destroy();
RTPTransmissionInfo *GetTransmissionInfo();
void DeleteTransmissionInfo(RTPTransmissionInfo *inf);
int GetLocalHostName(uint8_t *buffer, size_t *bufferlength);
int GetLocalHostName(uint8_t *buffer, std::size_t *bufferlength);
bool ComesFromThisTransmitter(const RTPAddress *addr);
size_t GetHeaderOverhead()
std::size_t GetHeaderOverhead()
{
return RTPTCPTRANS_HEADERSIZE;
}
@ -140,8 +140,8 @@ public:
int WaitForIncomingData(const RTPTime &delay, bool *dataavailable = 0);
int AbortWait();
int SendRTPData(const void *data, size_t len);
int SendRTCPData(const void *data, size_t len);
int SendRTPData(const void *data, std::size_t len);
int SendRTCPData(const void *data, std::size_t len);
int AddDestination(const RTPAddress &addr);
int DeleteDestination(const RTPAddress &addr);
@ -159,7 +159,7 @@ public:
int AddToAcceptList(const RTPAddress &addr);
int DeleteFromAcceptList(const RTPAddress &addr);
void ClearAcceptList();
int SetMaximumPacketSize(size_t s);
int SetMaximumPacketSize(std::size_t s);
bool NewDataAvailable();
RTPRawPacket *GetNextPacket();
@ -191,7 +191,7 @@ private:
int ProcessAvailableBytes(SocketType sock, int availLen, bool &complete);
};
int SendRTPRTCPData(const void *data, size_t len);
int SendRTPRTCPData(const void *data, std::size_t len);
void FlushPackets();
int PollSocket(SocketType sock, SocketData &sdata);
void ClearDestSockets();
@ -205,7 +205,7 @@ private:
std::vector<SocketType> m_tmpSocks;
std::vector<int8_t> m_tmpFlags;
std::vector<uint8_t> m_localHostname;
size_t m_maxPackSize;
std::size_t m_maxPackSize;
std::list<RTPRawPacket*> m_rawpacketlist;

13
qrtplib/rtptransmitter.h
View File

@ -41,6 +41,7 @@
#include "rtpconfig.h"
#include "rtptypes.h"
#include "rtptimeutilities.h"
#include <cstddef>
namespace qrtplib
{
@ -107,7 +108,7 @@ public:
* from RTPTransmissionParams. If \c transparams is NULL, the default transmission parameters
* for the component will be used.
*/
virtual int Create(size_t maxpacksize, const RTPTransmissionParams *transparams) = 0;
virtual int Create(std::size_t maxpacksize, const RTPTransmissionParams *transparams) = 0;
/** By calling this function, buffers are cleared and the component cannot be used anymore.
* By calling this function, buffers are cleared and the component cannot be used anymore.
@ -137,14 +138,14 @@ public:
* it returns \c ERR_RTP_TRANS_BUFFERLENGTHTOOSMALL and stores the number of bytes needed in
* \c bufferlength.
*/
virtual int GetLocalHostName(uint8_t *buffer, size_t *bufferlength) = 0;
virtual int GetLocalHostName(uint8_t *buffer, std::size_t *bufferlength) = 0;
/** Returns \c true if the address specified by \c addr is one of the addresses of the transmitter. */
virtual bool ComesFromThisTransmitter(const RTPAddress *addr) = 0;
/** Returns the amount of bytes that will be added to the RTP packet by the underlying layers (excluding
* the link layer). */
virtual size_t GetHeaderOverhead() = 0;
virtual std::size_t GetHeaderOverhead() = 0;
/** Checks for incoming data and stores it. */
virtual int Poll() = 0;
@ -159,10 +160,10 @@ public:
virtual int AbortWait() = 0;
/** Send a packet with length \c len containing \c data to all RTP addresses of the current destination list. */
virtual int SendRTPData(const void *data, size_t len) = 0;
virtual int SendRTPData(const void *data, std::size_t len) = 0;
/** Send a packet with length \c len containing \c data to all RTCP addresses of the current destination list. */
virtual int SendRTCPData(const void *data, size_t len) = 0;
virtual int SendRTCPData(const void *data, std::size_t len) = 0;
/** Adds the address specified by \c addr to the list of destinations. */
virtual int AddDestination(const RTPAddress &addr) = 0;
@ -211,7 +212,7 @@ public:
virtual void ClearAcceptList() = 0;
/** Sets the maximum packet size which the transmitter should allow to \c s. */
virtual int SetMaximumPacketSize(size_t s) = 0;
virtual int SetMaximumPacketSize(std::size_t s) = 0;
/** Returns \c true if packets can be obtained using the GetNextPacket member function. */
virtual bool NewDataAvailable() = 0;

28
qrtplib/rtpudpv4transmitter.cpp
View File

@ -137,7 +137,7 @@ int RTPUDPv4Transmitter::GetAutoSockets(uint32_t bindIP, bool allowOdd, bool rtc
SocketType sock = socket(PF_INET, SOCK_DGRAM, 0);
if (sock == RTPSOCKERR)
{
for (size_t i = 0; i < toClose.size(); i++)
for (std::size_t i = 0; i < toClose.size(); i++)
RTPCLOSE(toClose[i]);
return ERR_RTP_UDPV4TRANS_CANTCREATESOCKET;
}
@ -153,7 +153,7 @@ int RTPUDPv4Transmitter::GetAutoSockets(uint32_t bindIP, bool allowOdd, bool rtc
if (bind(sock, (struct sockaddr *) &addr, sizeof(struct sockaddr_in)) != 0)
{
RTPCLOSE(sock);
for (size_t i = 0; i < toClose.size(); i++)
for (std::size_t i = 0; i < toClose.size(); i++)
RTPCLOSE(toClose[i]);
return ERR_RTP_UDPV4TRANS_CANTGETVALIDSOCKET;
}
@ -163,7 +163,7 @@ int RTPUDPv4Transmitter::GetAutoSockets(uint32_t bindIP, bool allowOdd, bool rtc
if (status < 0)
{
RTPCLOSE(sock);
for (size_t i = 0; i < toClose.size(); i++)
for (std::size_t i = 0; i < toClose.size(); i++)
RTPCLOSE(toClose[i]);
return status;
}
@ -176,7 +176,7 @@ int RTPUDPv4Transmitter::GetAutoSockets(uint32_t bindIP, bool allowOdd, bool rtc
*pRtcpSock = sock;
*pRtpPort = basePort;
*pRtcpPort = basePort;
for (size_t i = 0; i < toClose.size(); i++)
for (std::size_t i = 0; i < toClose.size(); i++)
RTPCLOSE(toClose[i]);
return 0;
@ -190,7 +190,7 @@ int RTPUDPv4Transmitter::GetAutoSockets(uint32_t bindIP, bool allowOdd, bool rtc
if (sock2 == RTPSOCKERR)
{
RTPCLOSE(sock);
for (size_t i = 0; i < toClose.size(); i++)
for (std::size_t i = 0; i < toClose.size(); i++)
RTPCLOSE(toClose[i]);
return ERR_RTP_UDPV4TRANS_CANTCREATESOCKET;
}
@ -237,7 +237,7 @@ int RTPUDPv4Transmitter::GetAutoSockets(uint32_t bindIP, bool allowOdd, bool rtc
*pRtcpPort = basePort;
}
for (size_t i = 0; i < toClose.size(); i++)
for (std::size_t i = 0; i < toClose.size(); i++)
RTPCLOSE(toClose[i]);
return 0;
@ -249,13 +249,13 @@ int RTPUDPv4Transmitter::GetAutoSockets(uint32_t bindIP, bool allowOdd, bool rtc
}
}
for (size_t i = 0; i < toClose.size(); i++)
for (std::size_t i = 0; i < toClose.size(); i++)
RTPCLOSE(toClose[i]);
return ERR_RTP_UDPV4TRANS_TOOMANYATTEMPTSCHOOSINGSOCKET;
}
int RTPUDPv4Transmitter::Create(size_t maximumpacketsize, const RTPTransmissionParams *transparams)
int RTPUDPv4Transmitter::Create(std::size_t maximumpacketsize, const RTPTransmissionParams *transparams)
{
const RTPUDPv4TransmissionParams *params, defaultparams;
struct sockaddr_in addr;
@ -555,7 +555,7 @@ void RTPUDPv4Transmitter::DeleteTransmissionInfo(RTPTransmissionInfo *i)
delete i;
}
int RTPUDPv4Transmitter::GetLocalHostName(uint8_t *buffer, size_t *bufferlength)
int RTPUDPv4Transmitter::GetLocalHostName(uint8_t *buffer, std::size_t *bufferlength)
{
if (!init)
return ERR_RTP_UDPV4TRANS_NOTINIT;
@ -831,7 +831,7 @@ int RTPUDPv4Transmitter::AbortWait()
return 0;
}
int RTPUDPv4Transmitter::SendRTPData(const void *data, size_t len)
int RTPUDPv4Transmitter::SendRTPData(const void *data, std::size_t len)
{
if (!init)
return ERR_RTP_UDPV4TRANS_NOTINIT;
@ -857,7 +857,7 @@ int RTPUDPv4Transmitter::SendRTPData(const void *data, size_t len)
return 0;
}
int RTPUDPv4Transmitter::SendRTCPData(const void *data, size_t len)
int RTPUDPv4Transmitter::SendRTCPData(const void *data, std::size_t len)
{
if (!init)
return ERR_RTP_UDPV4TRANS_NOTINIT;
@ -1248,7 +1248,7 @@ void RTPUDPv4Transmitter::ClearAcceptList()
}
int RTPUDPv4Transmitter::SetMaximumPacketSize(size_t s)
int RTPUDPv4Transmitter::SetMaximumPacketSize(std::size_t s)
{
if (!init)
return ERR_RTP_UDPV4TRANS_NOTINIT;
@ -1352,7 +1352,7 @@ int RTPUDPv4Transmitter::PollSocket(bool rtp)
SOCKET sock;
unsigned long len;
#else
size_t len;
std::size_t len;
int sock;
#endif // RTP_SOCKETTYPE_WINSOCK
struct sockaddr_in srcaddr;
@ -1425,7 +1425,7 @@ int RTPUDPv4Transmitter::PollSocket(bool rtp)
{
isrtp = true;
if ((size_t) recvlen > sizeof(RTCPCommonHeader))
if ((std::size_t) recvlen > sizeof(RTCPCommonHeader))
{
RTCPCommonHeader *rtcpheader = (RTCPCommonHeader *) datacopy;
uint8_t packettype = rtcpheader->packettype;

16
qrtplib/rtpudpv4transmitter.h
View File

@ -380,14 +380,14 @@ public:
~RTPUDPv4Transmitter();
int Init(bool treadsafe);
int Create(size_t maxpacksize, const RTPTransmissionParams *transparams);
int Create(std::size_t maxpacksize, const RTPTransmissionParams *transparams);
void Destroy();
RTPTransmissionInfo *GetTransmissionInfo();
void DeleteTransmissionInfo(RTPTransmissionInfo *inf);
int GetLocalHostName(uint8_t *buffer, size_t *bufferlength);
int GetLocalHostName(uint8_t *buffer, std::size_t *bufferlength);
bool ComesFromThisTransmitter(const RTPAddress *addr);
size_t GetHeaderOverhead()
std::size_t GetHeaderOverhead()
{
return RTPUDPV4TRANS_HEADERSIZE;
}
@ -396,8 +396,8 @@ public:
int WaitForIncomingData(const RTPTime &delay, bool *dataavailable = 0);
int AbortWait();
int SendRTPData(const void *data, size_t len);
int SendRTCPData(const void *data, size_t len);
int SendRTPData(const void *data, std::size_t len);
int SendRTCPData(const void *data, std::size_t len);
int AddDestination(const RTPAddress &addr);
int DeleteDestination(const RTPAddress &addr);
@ -415,7 +415,7 @@ public:
int AddToAcceptList(const RTPAddress &addr);
int DeleteFromAcceptList(const RTPAddress &addr);
void ClearAcceptList();
int SetMaximumPacketSize(size_t s);
int SetMaximumPacketSize(std::size_t s);
bool NewDataAvailable();
RTPRawPacket *GetNextPacket();
@ -449,7 +449,7 @@ private:
RTPTransmitter::ReceiveMode receivemode;
uint8_t *localhostname;
size_t localhostnamelength;
std::size_t localhostnamelength;
RTPHashTable<const RTPIPv4Destination, RTPUDPv4Trans_GetHashIndex_IPv4Dest, RTPUDPV4TRANS_HASHSIZE> destinations;
#ifdef RTP_SUPPORT_IPV4MULTICAST
@ -458,7 +458,7 @@ private:
std::list<RTPRawPacket*> rawpacketlist;
bool supportsmulticasting;
size_t maxpacksize;
std::size_t maxpacksize;
class PortInfo
{

28
qrtplib/rtpudpv4transmitternobind.cpp
View File

@ -137,7 +137,7 @@ int RTPUDPv4TransmitterNoBind::GetAutoSockets(uint32_t bindIP, bool allowOdd, bo
SocketType sock = socket(PF_INET, SOCK_DGRAM, 0);
if (sock == RTPSOCKERR)
{
for (size_t i = 0; i < toClose.size(); i++)
for (std::size_t i = 0; i < toClose.size(); i++)
RTPCLOSE(toClose[i]);
return ERR_RTP_UDPV4TRANS_CANTCREATESOCKET;
}
@ -153,7 +153,7 @@ int RTPUDPv4TransmitterNoBind::GetAutoSockets(uint32_t bindIP, bool allowOdd, bo
if (bind(sock, (struct sockaddr *) &addr, sizeof(struct sockaddr_in)) != 0)
{
RTPCLOSE(sock);
for (size_t i = 0; i < toClose.size(); i++)
for (std::size_t i = 0; i < toClose.size(); i++)
RTPCLOSE(toClose[i]);
return ERR_RTP_UDPV4TRANS_CANTGETVALIDSOCKET;
}
@ -163,7 +163,7 @@ int RTPUDPv4TransmitterNoBind::GetAutoSockets(uint32_t bindIP, bool allowOdd, bo
if (status < 0)
{
RTPCLOSE(sock);
for (size_t i = 0; i < toClose.size(); i++)
for (std::size_t i = 0; i < toClose.size(); i++)
RTPCLOSE(toClose[i]);
return status;
}
@ -176,7 +176,7 @@ int RTPUDPv4TransmitterNoBind::GetAutoSockets(uint32_t bindIP, bool allowOdd, bo
*pRtcpSock = sock;
*pRtpPort = basePort;
*pRtcpPort = basePort;
for (size_t i = 0; i < toClose.size(); i++)
for (std::size_t i = 0; i < toClose.size(); i++)
RTPCLOSE(toClose[i]);
return 0;
@ -190,7 +190,7 @@ int RTPUDPv4TransmitterNoBind::GetAutoSockets(uint32_t bindIP, bool allowOdd, bo
if (sock2 == RTPSOCKERR)
{
RTPCLOSE(sock);
for (size_t i = 0; i < toClose.size(); i++)
for (std::size_t i = 0; i < toClose.size(); i++)
RTPCLOSE(toClose[i]);
return ERR_RTP_UDPV4TRANS_CANTCREATESOCKET;
}
@ -237,7 +237,7 @@ int RTPUDPv4TransmitterNoBind::GetAutoSockets(uint32_t bindIP, bool allowOdd, bo
*pRtcpPort = basePort;
}
for (size_t i = 0; i < toClose.size(); i++)
for (std::size_t i = 0; i < toClose.size(); i++)
RTPCLOSE(toClose[i]);
return 0;
@ -249,13 +249,13 @@ int RTPUDPv4TransmitterNoBind::GetAutoSockets(uint32_t bindIP, bool allowOdd, bo
}
}
for (size_t i = 0; i < toClose.size(); i++)
for (std::size_t i = 0; i < toClose.size(); i++)
RTPCLOSE(toClose[i]);
return ERR_RTP_UDPV4TRANS_TOOMANYATTEMPTSCHOOSINGSOCKET;
}
int RTPUDPv4TransmitterNoBind::Create(size_t maximumpacketsize, const RTPTransmissionParams *transparams)
int RTPUDPv4TransmitterNoBind::Create(std::size_t maximumpacketsize, const RTPTransmissionParams *transparams)
{
const RTPUDPv4TransmissionNoBindParams *params, defaultparams;
// struct sockaddr_in addr;
@ -557,7 +557,7 @@ void RTPUDPv4TransmitterNoBind::DeleteTransmissionInfo(RTPTransmissionInfo *i)
delete i;
}
int RTPUDPv4TransmitterNoBind::GetLocalHostName(uint8_t *buffer, size_t *bufferlength)
int RTPUDPv4TransmitterNoBind::GetLocalHostName(uint8_t *buffer, std::size_t *bufferlength)
{
if (!init)
return ERR_RTP_UDPV4TRANS_NOTINIT;
@ -833,7 +833,7 @@ int RTPUDPv4TransmitterNoBind::AbortWait()
return 0;
}
int RTPUDPv4TransmitterNoBind::SendRTPData(const void *data, size_t len)
int RTPUDPv4TransmitterNoBind::SendRTPData(const void *data, std::size_t len)
{
if (!init)
return ERR_RTP_UDPV4TRANS_NOTINIT;
@ -859,7 +859,7 @@ int RTPUDPv4TransmitterNoBind::SendRTPData(const void *data, size_t len)
return 0;
}
int RTPUDPv4TransmitterNoBind::SendRTCPData(const void *data, size_t len)
int RTPUDPv4TransmitterNoBind::SendRTCPData(const void *data, std::size_t len)
{
if (!init)
return ERR_RTP_UDPV4TRANS_NOTINIT;
@ -1250,7 +1250,7 @@ void RTPUDPv4TransmitterNoBind::ClearAcceptList()
}
int RTPUDPv4TransmitterNoBind::SetMaximumPacketSize(size_t s)
int RTPUDPv4TransmitterNoBind::SetMaximumPacketSize(std::size_t s)
{
if (!init)
return ERR_RTP_UDPV4TRANS_NOTINIT;
@ -1354,7 +1354,7 @@ int RTPUDPv4TransmitterNoBind::PollSocket(bool rtp)
SOCKET sock;
unsigned long len;
#else
size_t len;
std::size_t len;
int sock;
#endif // RTP_SOCKETTYPE_WINSOCK
struct sockaddr_in srcaddr;
@ -1427,7 +1427,7 @@ int RTPUDPv4TransmitterNoBind::PollSocket(bool rtp)
{
isrtp = true;
if ((size_t) recvlen > sizeof(RTCPCommonHeader))
if ((std::size_t) recvlen > sizeof(RTCPCommonHeader))
{
RTCPCommonHeader *rtcpheader = (RTCPCommonHeader *) datacopy;
uint8_t packettype = rtcpheader->packettype;

16
qrtplib/rtpudpv4transmitternobind.h
View File

@ -382,16 +382,16 @@ public:
~RTPUDPv4TransmitterNoBind();
int Init(bool treadsafe);
int Create(size_t maxpacksize, const RTPTransmissionParams *transparams);
int Create(std::size_t maxpacksize, const RTPTransmissionParams *transparams);
/** Bind the RTP and RTCP sockets to ports defined in the transmission parameters */
int BindSockets(const RTPTransmissionParams *transparams);
void Destroy();
RTPTransmissionInfo *GetTransmissionInfo();
void DeleteTransmissionInfo(RTPTransmissionInfo *inf);
int GetLocalHostName(uint8_t *buffer, size_t *bufferlength);
int GetLocalHostName(uint8_t *buffer, std::size_t *bufferlength);
bool ComesFromThisTransmitter(const RTPAddress *addr);
size_t GetHeaderOverhead()
std::size_t GetHeaderOverhead()
{
return RTPUDPV4TRANSNOBIND_HEADERSIZE;
}
@ -400,8 +400,8 @@ public:
int WaitForIncomingData(const RTPTime &delay, bool *dataavailable = 0);
int AbortWait();
int SendRTPData(const void *data, size_t len);
int SendRTCPData(const void *data, size_t len);
int SendRTPData(const void *data, std::size_t len);
int SendRTCPData(const void *data, std::size_t len);
int AddDestination(const RTPAddress &addr);
int DeleteDestination(const RTPAddress &addr);
@ -419,7 +419,7 @@ public:
int AddToAcceptList(const RTPAddress &addr);
int DeleteFromAcceptList(const RTPAddress &addr);
void ClearAcceptList();
int SetMaximumPacketSize(size_t s);
int SetMaximumPacketSize(std::size_t s);
bool NewDataAvailable();
RTPRawPacket *GetNextPacket();
@ -453,7 +453,7 @@ private:
RTPTransmitter::ReceiveMode receivemode;
uint8_t *localhostname;
size_t localhostnamelength;
std::size_t localhostnamelength;
RTPHashTable<const RTPIPv4Destination, RTPUDPv4TransNoBind_GetHashIndex_IPv4Dest, RTPUDPV4TRANSNOBIND_HASHSIZE> destinations;
#ifdef RTP_SUPPORT_IPV4MULTICAST
@ -462,7 +462,7 @@ private:
std::list<RTPRawPacket*> rawpacketlist;
bool supportsmulticasting;
size_t maxpacksize;
std::size_t maxpacksize;
class PortInfo
{