You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
800 lines
22 KiB
800 lines
22 KiB
/* |
|
|
|
This file is a part of JRTPLIB |
|
Copyright (c) 1999-2017 Jori Liesenborgs |
|
|
|
Contact: jori.liesenborgs@gmail.com |
|
|
|
This library was developed at the Expertise Centre for Digital Media |
|
(http://www.edm.uhasselt.be), a research center of the Hasselt University |
|
(http://www.uhasselt.be). The library is based upon work done for |
|
my thesis at the School for Knowledge Technology (Belgium/The Netherlands). |
|
|
|
Permission is hereby granted, free of charge, to any person obtaining a |
|
copy of this software and associated documentation files (the "Software"), |
|
to deal in the Software without restriction, including without limitation |
|
the rights to use, copy, modify, merge, publish, distribute, sublicense, |
|
and/or sell copies of the Software, and to permit persons to whom the |
|
Software is furnished to do so, subject to the following conditions: |
|
|
|
The above copyright notice and this permission notice shall be included |
|
in all copies or substantial portions of the Software. |
|
|
|
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS |
|
OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
|
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
|
THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
|
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
|
FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
|
IN THE SOFTWARE. |
|
|
|
*/ |
|
|
|
/** |
|
* \file rtpsourcedata.h |
|
*/ |
|
|
|
#ifndef RTPSOURCEDATA_H |
|
|
|
#define RTPSOURCEDATA_H |
|
|
|
#include "rtpconfig.h" |
|
#include "rtptimeutilities.h" |
|
#include "rtppacket.h" |
|
#include "rtcpsdesinfo.h" |
|
#include "rtptypes.h" |
|
#include <list> |
|
|
|
#include "export.h" |
|
|
|
namespace qrtplib |
|
{ |
|
|
|
class RTPAddress; |
|
|
|
class QRTPLIB_API RTCPSenderReportInfo |
|
{ |
|
public: |
|
RTCPSenderReportInfo() : |
|
ntptimestamp(0, 0), receivetime(0, 0) |
|
{ |
|
hasinfo = false; |
|
rtptimestamp = 0; |
|
packetcount = 0; |
|
bytecount = 0; |
|
} |
|
void Set(const RTPNTPTime &ntptime, uint32_t rtptime, uint32_t pcount, uint32_t bcount, const RTPTime &rcvtime) |
|
{ |
|
ntptimestamp = ntptime; |
|
rtptimestamp = rtptime; |
|
packetcount = pcount; |
|
bytecount = bcount; |
|
receivetime = rcvtime; |
|
hasinfo = true; |
|
} |
|
|
|
bool HasInfo() const |
|
{ |
|
return hasinfo; |
|
} |
|
RTPNTPTime GetNTPTimestamp() const |
|
{ |
|
return ntptimestamp; |
|
} |
|
uint32_t GetRTPTimestamp() const |
|
{ |
|
return rtptimestamp; |
|
} |
|
uint32_t GetPacketCount() const |
|
{ |
|
return packetcount; |
|
} |
|
uint32_t GetByteCount() const |
|
{ |
|
return bytecount; |
|
} |
|
RTPTime GetReceiveTime() const |
|
{ |
|
return receivetime; |
|
} |
|
private: |
|
bool hasinfo; |
|
RTPNTPTime ntptimestamp; |
|
uint32_t rtptimestamp; |
|
uint32_t packetcount; |
|
uint32_t bytecount; |
|
RTPTime receivetime; |
|
}; |
|
|
|
class RTCPReceiverReportInfo |
|
{ |
|
public: |
|
RTCPReceiverReportInfo() : |
|
receivetime(0, 0) |
|
{ |
|
hasinfo = false; |
|
fractionlost = 0; |
|
packetslost = 0; |
|
exthighseqnr = 0; |
|
jitter = 0; |
|
lsr = 0; |
|
dlsr = 0; |
|
} |
|
void Set(uint8_t fraclost, int32_t plost, uint32_t exthigh, uint32_t jit, uint32_t l, uint32_t dl, const RTPTime &rcvtime) |
|
{ |
|
fractionlost = ((double) fraclost) / 256.0; |
|
packetslost = plost; |
|
exthighseqnr = exthigh; |
|
jitter = jit; |
|
lsr = l; |
|
dlsr = dl; |
|
receivetime = rcvtime; |
|
hasinfo = true; |
|
} |
|
|
|
bool HasInfo() const |
|
{ |
|
return hasinfo; |
|
} |
|
double GetFractionLost() const |
|
{ |
|
return fractionlost; |
|
} |
|
int32_t GetPacketsLost() const |
|
{ |
|
return packetslost; |
|
} |
|
uint32_t GetExtendedHighestSequenceNumber() const |
|
{ |
|
return exthighseqnr; |
|
} |
|
uint32_t GetJitter() const |
|
{ |
|
return jitter; |
|
} |
|
uint32_t GetLastSRTimestamp() const |
|
{ |
|
return lsr; |
|
} |
|
uint32_t GetDelaySinceLastSR() const |
|
{ |
|
return dlsr; |
|
} |
|
RTPTime GetReceiveTime() const |
|
{ |
|
return receivetime; |
|
} |
|
private: |
|
bool hasinfo; |
|
double fractionlost; |
|
int32_t packetslost; |
|
uint32_t exthighseqnr; |
|
uint32_t jitter; |
|
uint32_t lsr; |
|
uint32_t dlsr; |
|
RTPTime receivetime; |
|
}; |
|
|
|
class RTPSourceStats |
|
{ |
|
public: |
|
RTPSourceStats(); |
|
void ProcessPacket( |
|
RTPPacket *pack, |
|
const RTPTime &receivetime, |
|
double tsunit, |
|
bool ownpacket, |
|
bool *accept); |
|
|
|
bool HasSentData() const |
|
{ |
|
return sentdata; |
|
} |
|
uint32_t GetNumPacketsReceived() const |
|
{ |
|
return packetsreceived; |
|
} |
|
uint32_t GetBaseSequenceNumber() const |
|
{ |
|
return baseseqnr; |
|
} |
|
uint32_t GetExtendedHighestSequenceNumber() const |
|
{ |
|
return exthighseqnr; |
|
} |
|
uint32_t GetJitter() const |
|
{ |
|
return jitter; |
|
} |
|
|
|
int32_t GetNumPacketsReceivedInInterval() const |
|
{ |
|
return numnewpackets; |
|
} |
|
uint32_t GetSavedExtendedSequenceNumber() const |
|
{ |
|
return savedextseqnr; |
|
} |
|
void StartNewInterval() |
|
{ |
|
numnewpackets = 0; |
|
savedextseqnr = exthighseqnr; |
|
} |
|
|
|
void SetLastMessageTime(const RTPTime &t) |
|
{ |
|
lastmsgtime = t; |
|
} |
|
RTPTime GetLastMessageTime() const |
|
{ |
|
return lastmsgtime; |
|
} |
|
void SetLastRTPPacketTime(const RTPTime &t) |
|
{ |
|
lastrtptime = t; |
|
} |
|
RTPTime GetLastRTPPacketTime() const |
|
{ |
|
return lastrtptime; |
|
} |
|
|
|
void SetLastNoteTime(const RTPTime &t) |
|
{ |
|
lastnotetime = t; |
|
} |
|
RTPTime GetLastNoteTime() const |
|
{ |
|
return lastnotetime; |
|
} |
|
private: |
|
bool sentdata; |
|
uint32_t packetsreceived; |
|
uint32_t numcycles; // shifted left 16 bits |
|
uint32_t baseseqnr; |
|
uint32_t exthighseqnr, prevexthighseqnr; |
|
uint32_t jitter, prevtimestamp; |
|
double djitter; |
|
RTPTime prevpacktime; |
|
RTPTime lastmsgtime; |
|
RTPTime lastrtptime; |
|
RTPTime lastnotetime; |
|
uint32_t numnewpackets; |
|
uint32_t savedextseqnr; |
|
}; |
|
|
|
inline RTPSourceStats::RTPSourceStats() : |
|
prevpacktime(0, 0), lastmsgtime(0, 0), lastrtptime(0, 0), lastnotetime(0, 0) |
|
{ |
|
sentdata = false; |
|
packetsreceived = 0; |
|
baseseqnr = 0; |
|
exthighseqnr = 0; |
|
prevexthighseqnr = 0; |
|
jitter = 0; |
|
numcycles = 0; |
|
numnewpackets = 0; |
|
prevtimestamp = 0; |
|
djitter = 0; |
|
savedextseqnr = 0; |
|
} |
|
|
|
/** Describes an entry in the RTPSources source table. */ |
|
class RTPSourceData |
|
{ |
|
protected: |
|
RTPSourceData(uint32_t ssrc); |
|
virtual ~RTPSourceData(); |
|
public: |
|
/** Extracts the first packet of this participants RTP packet queue. */ |
|
RTPPacket *GetNextPacket(); |
|
|
|
/** Clears the participant's RTP packet list. */ |
|
void FlushPackets(); |
|
|
|
/** Returns \c true if there are RTP packets which can be extracted. */ |
|
bool HasData() const |
|
{ |
|
if (!validated) |
|
return false; |
|
return packetlist.empty() ? false : true; |
|
} |
|
|
|
/** Returns the SSRC identifier for this member. */ |
|
uint32_t GetSSRC() const |
|
{ |
|
return ssrc; |
|
} |
|
|
|
/** Returns \c true if the participant was added using the RTPSources member function CreateOwnSSRC and |
|
* returns \c false otherwise. |
|
*/ |
|
bool IsOwnSSRC() const |
|
{ |
|
return ownssrc; |
|
} |
|
|
|
/** Returns \c true if the source identifier is actually a CSRC from an RTP packet. */ |
|
bool IsCSRC() const |
|
{ |
|
return iscsrc; |
|
} |
|
|
|
/** Returns \c true if this member is marked as a sender and \c false if not. */ |
|
bool IsSender() const |
|
{ |
|
return issender; |
|
} |
|
|
|
/** Returns \c true if the participant is validated, which is the case if a number of |
|
* consecutive RTP packets have been received or if a CNAME item has been received for |
|
* this participant. |
|
*/ |
|
bool IsValidated() const |
|
{ |
|
return validated; |
|
} |
|
|
|
/** Returns \c true if the source was validated and had not yet sent a BYE packet. */ |
|
bool IsActive() const |
|
{ |
|
if (!validated) |
|
return false; |
|
if (receivedbye) |
|
return false; |
|
return true; |
|
} |
|
|
|
/** This function is used by the RTCPPacketBuilder class to mark whether this participant's |
|
* information has been processed in a report block or not. |
|
*/ |
|
void SetProcessedInRTCP(bool v) |
|
{ |
|
processedinrtcp = v; |
|
} |
|
|
|
/** This function is used by the RTCPPacketBuilder class and returns whether this participant |
|
* has been processed in a report block or not. |
|
*/ |
|
bool IsProcessedInRTCP() const |
|
{ |
|
return processedinrtcp; |
|
} |
|
|
|
/** Returns \c true if the address from which this participant's RTP packets originate has |
|
* already been set. |
|
*/ |
|
bool IsRTPAddressSet() const |
|
{ |
|
return isrtpaddrset; |
|
} |
|
|
|
/** Returns \c true if the address from which this participant's RTCP packets originate has |
|
* already been set. |
|
*/ |
|
bool IsRTCPAddressSet() const |
|
{ |
|
return isrtcpaddrset; |
|
} |
|
|
|
/** Returns the address from which this participant's RTP packets originate. |
|
* Returns the address from which this participant's RTP packets originate. If the address has |
|
* been set and the returned value is NULL, this indicates that it originated from the local |
|
* participant. |
|
*/ |
|
const RTPAddress *GetRTPDataAddress() const |
|
{ |
|
return rtpaddr; |
|
} |
|
|
|
/** Returns the address from which this participant's RTCP packets originate. |
|
* Returns the address from which this participant's RTCP packets originate. If the address has |
|
* been set and the returned value is NULL, this indicates that it originated from the local |
|
* participant. |
|
*/ |
|
const RTPAddress *GetRTCPDataAddress() const |
|
{ |
|
return rtcpaddr; |
|
} |
|
|
|
/** Returns \c true if we received a BYE message for this participant and \c false otherwise. */ |
|
bool ReceivedBYE() const |
|
{ |
|
return receivedbye; |
|
} |
|
|
|
/** Returns the reason for leaving contained in the BYE packet of this participant. |
|
* 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(std::size_t *len) const |
|
{ |
|
*len = byereasonlen; |
|
return byereason; |
|
} |
|
|
|
/** Returns the time at which the BYE packet was received. */ |
|
RTPTime GetBYETime() const |
|
{ |
|
return byetime; |
|
} |
|
|
|
/** Sets the value for the timestamp unit to be used in jitter calculations for data received from this participant. |
|
* Sets the value for the timestamp unit to be used in jitter calculations for data received from this participant. |
|
* If not set, the library uses an approximation for the timestamp unit which is calculated from two consecutive |
|
* RTCP sender reports. The timestamp unit is defined as a time interval divided by the corresponding timestamp |
|
* interval. For 8000 Hz audio this would be 1/8000. For video, often a timestamp unit of 1/90000 is used. |
|
*/ |
|
void SetTimestampUnit(double tsu) |
|
{ |
|
timestampunit = tsu; |
|
} |
|
|
|
/** Returns the timestamp unit used for this participant. */ |
|
double GetTimestampUnit() const |
|
{ |
|
return timestampunit; |
|
} |
|
|
|
/** Returns \c true if an RTCP sender report has been received from this participant. */ |
|
bool SR_HasInfo() const |
|
{ |
|
return SRinf.HasInfo(); |
|
} |
|
|
|
/** Returns the NTP timestamp contained in the last sender report. */ |
|
RTPNTPTime SR_GetNTPTimestamp() const |
|
{ |
|
return SRinf.GetNTPTimestamp(); |
|
} |
|
|
|
/** Returns the RTP timestamp contained in the last sender report. */ |
|
uint32_t SR_GetRTPTimestamp() const |
|
{ |
|
return SRinf.GetRTPTimestamp(); |
|
} |
|
|
|
/** Returns the packet count contained in the last sender report. */ |
|
uint32_t SR_GetPacketCount() const |
|
{ |
|
return SRinf.GetPacketCount(); |
|
} |
|
|
|
/** Returns the octet count contained in the last sender report. */ |
|
uint32_t SR_GetByteCount() const |
|
{ |
|
return SRinf.GetByteCount(); |
|
} |
|
|
|
/** Returns the time at which the last sender report was received. */ |
|
RTPTime SR_GetReceiveTime() const |
|
{ |
|
return SRinf.GetReceiveTime(); |
|
} |
|
|
|
/** Returns \c true if more than one RTCP sender report has been received. */ |
|
bool SR_Prev_HasInfo() const |
|
{ |
|
return SRprevinf.HasInfo(); |
|
} |
|
|
|
/** Returns the NTP timestamp contained in the second to last sender report. */ |
|
RTPNTPTime SR_Prev_GetNTPTimestamp() const |
|
{ |
|
return SRprevinf.GetNTPTimestamp(); |
|
} |
|
|
|
/** Returns the RTP timestamp contained in the second to last sender report. */ |
|
uint32_t SR_Prev_GetRTPTimestamp() const |
|
{ |
|
return SRprevinf.GetRTPTimestamp(); |
|
} |
|
|
|
/** Returns the packet count contained in the second to last sender report. */ |
|
uint32_t SR_Prev_GetPacketCount() const |
|
{ |
|
return SRprevinf.GetPacketCount(); |
|
} |
|
|
|
/** Returns the octet count contained in the second to last sender report. */ |
|
uint32_t SR_Prev_GetByteCount() const |
|
{ |
|
return SRprevinf.GetByteCount(); |
|
} |
|
|
|
/** Returns the time at which the second to last sender report was received. */ |
|
RTPTime SR_Prev_GetReceiveTime() const |
|
{ |
|
return SRprevinf.GetReceiveTime(); |
|
} |
|
|
|
/** Returns \c true if this participant sent a receiver report with information about the reception of our data. */ |
|
bool RR_HasInfo() const |
|
{ |
|
return RRinf.HasInfo(); |
|
} |
|
|
|
/** Returns the fraction lost value from the last report. */ |
|
double RR_GetFractionLost() const |
|
{ |
|
return RRinf.GetFractionLost(); |
|
} |
|
|
|
/** Returns the number of lost packets contained in the last report. */ |
|
int32_t RR_GetPacketsLost() const |
|
{ |
|
return RRinf.GetPacketsLost(); |
|
} |
|
|
|
/** Returns the extended highest sequence number contained in the last report. */ |
|
uint32_t RR_GetExtendedHighestSequenceNumber() const |
|
{ |
|
return RRinf.GetExtendedHighestSequenceNumber(); |
|
} |
|
|
|
/** Returns the jitter value from the last report. */ |
|
uint32_t RR_GetJitter() const |
|
{ |
|
return RRinf.GetJitter(); |
|
} |
|
|
|
/** Returns the LSR value from the last report. */ |
|
uint32_t RR_GetLastSRTimestamp() const |
|
{ |
|
return RRinf.GetLastSRTimestamp(); |
|
} |
|
|
|
/** Returns the DLSR value from the last report. */ |
|
uint32_t RR_GetDelaySinceLastSR() const |
|
{ |
|
return RRinf.GetDelaySinceLastSR(); |
|
} |
|
|
|
/** Returns the time at which the last report was received. */ |
|
RTPTime RR_GetReceiveTime() const |
|
{ |
|
return RRinf.GetReceiveTime(); |
|
} |
|
|
|
/** Returns \c true if this participant sent more than one receiver report with information |
|
* about the reception of our data. |
|
*/ |
|
bool RR_Prev_HasInfo() const |
|
{ |
|
return RRprevinf.HasInfo(); |
|
} |
|
|
|
/** Returns the fraction lost value from the second to last report. */ |
|
double RR_Prev_GetFractionLost() const |
|
{ |
|
return RRprevinf.GetFractionLost(); |
|
} |
|
|
|
/** Returns the number of lost packets contained in the second to last report. */ |
|
int32_t RR_Prev_GetPacketsLost() const |
|
{ |
|
return RRprevinf.GetPacketsLost(); |
|
} |
|
|
|
/** Returns the extended highest sequence number contained in the second to last report. */ |
|
uint32_t RR_Prev_GetExtendedHighestSequenceNumber() const |
|
{ |
|
return RRprevinf.GetExtendedHighestSequenceNumber(); |
|
} |
|
|
|
/** Returns the jitter value from the second to last report. */ |
|
uint32_t RR_Prev_GetJitter() const |
|
{ |
|
return RRprevinf.GetJitter(); |
|
} |
|
|
|
/** Returns the LSR value from the second to last report. */ |
|
uint32_t RR_Prev_GetLastSRTimestamp() const |
|
{ |
|
return RRprevinf.GetLastSRTimestamp(); |
|
} |
|
|
|
/** Returns the DLSR value from the second to last report. */ |
|
uint32_t RR_Prev_GetDelaySinceLastSR() const |
|
{ |
|
return RRprevinf.GetDelaySinceLastSR(); |
|
} |
|
|
|
/** Returns the time at which the second to last report was received. */ |
|
RTPTime RR_Prev_GetReceiveTime() const |
|
{ |
|
return RRprevinf.GetReceiveTime(); |
|
} |
|
|
|
/** Returns \c true if validated RTP packets have been received from this participant. */ |
|
bool INF_HasSentData() const |
|
{ |
|
return stats.HasSentData(); |
|
} |
|
|
|
/** Returns the total number of received packets from this participant. */ |
|
int32_t INF_GetNumPacketsReceived() const |
|
{ |
|
return stats.GetNumPacketsReceived(); |
|
} |
|
|
|
/** Returns the base sequence number of this participant. */ |
|
uint32_t INF_GetBaseSequenceNumber() const |
|
{ |
|
return stats.GetBaseSequenceNumber(); |
|
} |
|
|
|
/** Returns the extended highest sequence number received from this participant. */ |
|
uint32_t INF_GetExtendedHighestSequenceNumber() const |
|
{ |
|
return stats.GetExtendedHighestSequenceNumber(); |
|
} |
|
|
|
/** Returns the current jitter value for this participant. */ |
|
uint32_t INF_GetJitter() const |
|
{ |
|
return stats.GetJitter(); |
|
} |
|
|
|
/** Returns the time at which something was last heard from this member. */ |
|
RTPTime INF_GetLastMessageTime() const |
|
{ |
|
return stats.GetLastMessageTime(); |
|
} |
|
|
|
/** Returns the time at which the last RTP packet was received. */ |
|
RTPTime INF_GetLastRTPPacketTime() const |
|
{ |
|
return stats.GetLastRTPPacketTime(); |
|
} |
|
|
|
/** Returns the estimated timestamp unit, calculated from two consecutive sender reports. */ |
|
double INF_GetEstimatedTimestampUnit() const; |
|
|
|
/** Returns the number of packets received since a new interval was started with INF_StartNewInterval. */ |
|
uint32_t INF_GetNumPacketsReceivedInInterval() const |
|
{ |
|
return stats.GetNumPacketsReceivedInInterval(); |
|
} |
|
|
|
/** Returns the extended sequence number which was stored by the INF_StartNewInterval call. */ |
|
uint32_t INF_GetSavedExtendedSequenceNumber() const |
|
{ |
|
return stats.GetSavedExtendedSequenceNumber(); |
|
} |
|
|
|
/** Starts a new interval to count received packets in; this also stores the current extended highest sequence |
|
* number to be able to calculate the packet loss during the interval. |
|
*/ |
|
void INF_StartNewInterval() |
|
{ |
|
stats.StartNewInterval(); |
|
} |
|
|
|
/** Estimates the round trip time by using the LSR and DLSR info from the last receiver report. */ |
|
RTPTime INF_GetRoundtripTime() const; |
|
|
|
/** Returns the time at which the last SDES NOTE item was received. */ |
|
RTPTime INF_GetLastSDESNoteTime() const |
|
{ |
|
return stats.GetLastNoteTime(); |
|
} |
|
|
|
/** Returns a pointer to the SDES CNAME item of this participant and stores its length in \c len. */ |
|
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(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(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(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(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(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(std::size_t *len) const |
|
{ |
|
return SDESinf.GetNote(len); |
|
} |
|
|
|
#ifdef RTP_SUPPORT_SDESPRIV |
|
/** Starts the iteration over the stored SDES private item prefixes and their associated values. */ |
|
void SDES_GotoFirstPrivateValue() |
|
{ |
|
SDESinf.GotoFirstPrivateValue(); |
|
} |
|
|
|
/** 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, std::size_t *prefixlen, uint8_t **value, std::size_t *valuelen) |
|
{ |
|
return SDESinf.GetNextPrivateValue(prefix, prefixlen, value, valuelen); |
|
} |
|
|
|
/** Looks for the entry which corresponds to the SDES private item prefix \c prefix with length |
|
* \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, std::size_t prefixlen, uint8_t **value, std::size_t *valuelen) const |
|
{ |
|
return SDESinf.GetPrivateValue(prefix, prefixlen, value, valuelen); |
|
} |
|
#endif // RTP_SUPPORT_SDESPRIV |
|
|
|
protected: |
|
std::list<RTPPacket *> packetlist; |
|
|
|
uint32_t ssrc; |
|
bool ownssrc; |
|
bool iscsrc; |
|
double timestampunit; |
|
bool receivedbye; |
|
bool validated; |
|
bool processedinrtcp; |
|
bool issender; |
|
|
|
RTCPSenderReportInfo SRinf, SRprevinf; |
|
RTCPReceiverReportInfo RRinf, RRprevinf; |
|
RTPSourceStats stats; |
|
RTCPSDESInfo SDESinf; |
|
|
|
bool isrtpaddrset, isrtcpaddrset; |
|
RTPAddress *rtpaddr, *rtcpaddr; |
|
|
|
RTPTime byetime; |
|
uint8_t *byereason; |
|
std::size_t byereasonlen; |
|
}; |
|
|
|
inline RTPPacket *RTPSourceData::GetNextPacket() |
|
{ |
|
if (!validated) |
|
return 0; |
|
|
|
RTPPacket *p; |
|
|
|
if (packetlist.empty()) |
|
return 0; |
|
p = *(packetlist.begin()); |
|
packetlist.pop_front(); |
|
return p; |
|
} |
|
|
|
inline void RTPSourceData::FlushPackets() |
|
{ |
|
std::list<RTPPacket *>::const_iterator it; |
|
|
|
for (it = packetlist.begin(); it != packetlist.end(); ++it) |
|
delete *it; |
|
packetlist.clear(); |
|
} |
|
|
|
} // end namespace |
|
|
|
#endif // RTPSOURCEDATA_H |
|
|
|
|