generic-library/webrtc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Refactor RTCP sender

Browse Source 
The main purpose of this CL is to clean up RTCPSender::PrepareRTCP, but
it has quite a few ramifications. Notable changes:

* Removed the rtcpPacketTypeFlags bit vector and don't assume
  RTCPPacketType values have a single unique bit set. This will allow
  making this an enum class once rtcp_receiver has been overhauled.

* Flags are now stored in a map that is a member of the class. This
  meant we could remove some bool flags (eg send_remb_) which was
  previously masked into rtcpPacketTypeFlags and then masked out again
  when testing if a remb packet should be sent.

* Make all build methods, eg. BuildREMB(), have the same signature.
  An RtcpContext struct was introduced for this purpose. This allowed
  the use of a map from RTCPPacketType to method pointer. Instead of
  18 consecutive if-statements, there is now a single loop.
  The context class also allowed some simplifications in the build
  methods themselves.

* A few minor simplifications and cleanups.

The next step is to gradually replace the builder methods with the
builders from the new RtcpPacket classes.

BUG=2450
R=asapersson@webrtc.org, pbos@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/48329004

Cr-Commit-Position: refs/heads/master@{#9166}
This commit is contained in:
Erik Språng
2015-05-11 10:17:43 +02:00
parent 1f629232d5
commit 242e22b055
15 changed files with 1508 additions and 1681 deletions
Download Patch File Download Diff File Expand all files Collapse all files

15
webrtc/modules/rtp_rtcp/interface/rtp_rtcp.h
View File

@@ -11,6 +11,7 @@
#ifndef WEBRTC_MODULES_RTP_RTCP_INTERFACE_RTP_RTCP_H_
#define WEBRTC_MODULES_RTP_RTCP_INTERFACE_RTP_RTCP_H_
#include <set>
#include <vector>
#include "webrtc/modules/interface/module.h"
@@ -390,12 +391,20 @@ class RtpRtcp : public Module {
/*
* Force a send of a RTCP packet
* normal SR and RR are triggered via the process function
* periodic SR and RR are triggered via the process function
*
* return -1 on failure else 0
*/
virtual int32_t SendRTCP(
uint32_t rtcpPacketType = kRtcpReport) = 0;
virtual int32_t SendRTCP(RTCPPacketType rtcpPacketType) = 0;
/*
* Force a send of a RTCP packet with more than one packet type.
* periodic SR and RR are triggered via the process function
*
* return -1 on failure else 0
*/
virtual int32_t SendCompoundRTCP(
const std::set<RTCPPacketType>& rtcpPacketTypes) = 0;
/*
* Good state of RTP receiver inform sender

51
webrtc/modules/rtp_rtcp/interface/rtp_rtcp_defines.h
View File

@@ -88,26 +88,27 @@ enum RTCPAppSubTypes
kAppSubtypeBwe = 0x00
};
enum RTCPPacketType
{
kRtcpReport = 0x0001,
kRtcpSr = 0x0002,
kRtcpRr = 0x0004,
kRtcpBye = 0x0008,
kRtcpPli = 0x0010,
kRtcpNack = 0x0020,
kRtcpFir = 0x0040,
kRtcpTmmbr = 0x0080,
kRtcpTmmbn = 0x0100,
kRtcpSrReq = 0x0200,
kRtcpXrVoipMetric = 0x0400,
kRtcpApp = 0x0800,
kRtcpSli = 0x4000,
kRtcpRpsi = 0x8000,
kRtcpRemb = 0x10000,
kRtcpTransmissionTimeOffset = 0x20000,
kRtcpXrReceiverReferenceTime = 0x40000,
kRtcpXrDlrrReportBlock = 0x80000
// TODO(sprang): Make this an enum class once rtcp_receiver has been cleaned up.
enum RTCPPacketType : uint32_t {
kRtcpReport = 0x0001,
kRtcpSr = 0x0002,
kRtcpRr = 0x0004,
kRtcpSdes = 0x0008,
kRtcpBye = 0x0010,
kRtcpPli = 0x0020,
kRtcpNack = 0x0040,
kRtcpFir = 0x0080,
kRtcpTmmbr = 0x0100,
kRtcpTmmbn = 0x0200,
kRtcpSrReq = 0x0400,
kRtcpXrVoipMetric = 0x0800,
kRtcpApp = 0x1000,
kRtcpSli = 0x4000,
kRtcpRpsi = 0x8000,
kRtcpRemb = 0x10000,
kRtcpTransmissionTimeOffset = 0x20000,
kRtcpXrReceiverReferenceTime = 0x40000,
kRtcpXrDlrrReportBlock = 0x80000
};
enum KeyFrameRequestMethod
@@ -129,12 +130,12 @@ enum NACKMethod
kNackRtcp = 2
};
enum RetransmissionMode {
kRetransmitOff = 0x0,
kRetransmitFECPackets = 0x1,
kRetransmitBaseLayer = 0x2,
enum RetransmissionMode : uint8_t {
kRetransmitOff = 0x0,
kRetransmitFECPackets = 0x1,
kRetransmitBaseLayer = 0x2,
kRetransmitHigherLayers = 0x4,
kRetransmitAllPackets = 0xFF
kRetransmitAllPackets = 0xFF
};
enum RtxMode {

5
webrtc/modules/rtp_rtcp/mocks/mock_rtp_rtcp.h
View File

@@ -156,8 +156,9 @@ class MockRtpRtcp : public RtpRtcp {
int64_t* avgRTT,
int64_t* minRTT,
int64_t* maxRTT));
MOCK_METHOD1(SendRTCP,
int32_t(uint32_t rtcpPacketType));
MOCK_METHOD1(SendRTCP, int32_t(RTCPPacketType packetType));
MOCK_METHOD1(SendCompoundRTCP,
int32_t(const std::set<RTCPPacketType>& packetTypes));
MOCK_METHOD1(SendRTCPReferencePictureSelection,
int32_t(const uint64_t pictureID));
MOCK_METHOD1(SendRTCPSliceLossIndication,

83
webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc
View File

@@ -285,69 +285,68 @@ RTCPReceiver::IncomingRTCPPacket(RTCPPacketInformation& rtcpPacketInformation,
}
RTCPUtility::RTCPPacketTypes pktType = rtcpParser->Begin();
while (pktType != RTCPUtility::kRtcpNotValidCode)
{
while (pktType != RTCPPacketTypes::kInvalid) {
// Each "case" is responsible for iterate the parser to the
// next top level packet.
switch (pktType)
{
case RTCPUtility::kRtcpSrCode:
case RTCPUtility::kRtcpRrCode:
case RTCPPacketTypes::kSr:
case RTCPPacketTypes::kRr:
HandleSenderReceiverReport(*rtcpParser, rtcpPacketInformation);
break;
case RTCPUtility::kRtcpSdesCode:
case RTCPPacketTypes::kSdes:
HandleSDES(*rtcpParser);
break;
case RTCPUtility::kRtcpXrHeaderCode:
case RTCPPacketTypes::kXrHeader:
HandleXrHeader(*rtcpParser, rtcpPacketInformation);
break;
case RTCPUtility::kRtcpXrReceiverReferenceTimeCode:
case RTCPPacketTypes::kXrReceiverReferenceTime:
HandleXrReceiveReferenceTime(*rtcpParser, rtcpPacketInformation);
break;
case RTCPUtility::kRtcpXrDlrrReportBlockCode:
case RTCPPacketTypes::kXrDlrrReportBlock:
HandleXrDlrrReportBlock(*rtcpParser, rtcpPacketInformation);
break;
case RTCPUtility::kRtcpXrVoipMetricCode:
case RTCPPacketTypes::kXrVoipMetric:
HandleXRVOIPMetric(*rtcpParser, rtcpPacketInformation);
break;
case RTCPUtility::kRtcpByeCode:
case RTCPPacketTypes::kBye:
HandleBYE(*rtcpParser);
break;
case RTCPUtility::kRtcpRtpfbNackCode:
case RTCPPacketTypes::kRtpfbNack:
HandleNACK(*rtcpParser, rtcpPacketInformation);
break;
case RTCPUtility::kRtcpRtpfbTmmbrCode:
case RTCPPacketTypes::kRtpfbTmmbr:
HandleTMMBR(*rtcpParser, rtcpPacketInformation);
break;
case RTCPUtility::kRtcpRtpfbTmmbnCode:
case RTCPPacketTypes::kRtpfbTmmbn:
HandleTMMBN(*rtcpParser, rtcpPacketInformation);
break;
case RTCPUtility::kRtcpRtpfbSrReqCode:
case RTCPPacketTypes::kRtpfbSrReq:
HandleSR_REQ(*rtcpParser, rtcpPacketInformation);
break;
case RTCPUtility::kRtcpPsfbPliCode:
case RTCPPacketTypes::kPsfbPli:
HandlePLI(*rtcpParser, rtcpPacketInformation);
break;
case RTCPUtility::kRtcpPsfbSliCode:
case RTCPPacketTypes::kPsfbSli:
HandleSLI(*rtcpParser, rtcpPacketInformation);
break;
case RTCPUtility::kRtcpPsfbRpsiCode:
case RTCPPacketTypes::kPsfbRpsi:
HandleRPSI(*rtcpParser, rtcpPacketInformation);
break;
case RTCPUtility::kRtcpExtendedIjCode:
case RTCPPacketTypes::kExtendedIj:
HandleIJ(*rtcpParser, rtcpPacketInformation);
break;
case RTCPUtility::kRtcpPsfbFirCode:
case RTCPPacketTypes::kPsfbFir:
HandleFIR(*rtcpParser, rtcpPacketInformation);
break;
case RTCPUtility::kRtcpPsfbAppCode:
case RTCPPacketTypes::kPsfbApp:
HandlePsfbApp(*rtcpParser, rtcpPacketInformation);
break;
case RTCPUtility::kRtcpAppCode:
case RTCPPacketTypes::kApp:
// generic application messages
HandleAPP(*rtcpParser, rtcpPacketInformation);
break;
case RTCPUtility::kRtcpAppItemCode:
case RTCPPacketTypes::kAppItem:
// generic application messages
HandleAPPItem(*rtcpParser, rtcpPacketInformation);
break;
@@ -374,7 +373,8 @@ RTCPReceiver::HandleSenderReceiverReport(RTCPUtility::RTCPParserV2& rtcpParser,
RTCPUtility::RTCPPacketTypes rtcpPacketType = rtcpParser.PacketType();
const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
assert((rtcpPacketType == RTCPUtility::kRtcpRrCode) || (rtcpPacketType == RTCPUtility::kRtcpSrCode));
assert((rtcpPacketType == RTCPPacketTypes::kRr) ||
(rtcpPacketType == RTCPPacketTypes::kSr));
// SR.SenderSSRC
// The synchronization source identifier for the originator of this SR packet
@@ -382,7 +382,9 @@ RTCPReceiver::HandleSenderReceiverReport(RTCPUtility::RTCPParserV2& rtcpParser,
// rtcpPacket.RR.SenderSSRC
// The source of the packet sender, same as of SR? or is this a CE?
const uint32_t remoteSSRC = (rtcpPacketType == RTCPUtility::kRtcpRrCode) ? rtcpPacket.RR.SenderSSRC:rtcpPacket.SR.SenderSSRC;
const uint32_t remoteSSRC = (rtcpPacketType == RTCPPacketTypes::kRr)
? rtcpPacket.RR.SenderSSRC
: rtcpPacket.SR.SenderSSRC;
rtcpPacketInformation.remoteSSRC = remoteSSRC;
@@ -393,8 +395,7 @@ RTCPReceiver::HandleSenderReceiverReport(RTCPUtility::RTCPParserV2& rtcpParser,
return;
}
if (rtcpPacketType == RTCPUtility::kRtcpSrCode)
{
if (rtcpPacketType == RTCPPacketTypes::kSr) {
TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "SR",
"remote_ssrc", remoteSSRC, "ssrc", main_ssrc_);
@@ -434,8 +435,7 @@ RTCPReceiver::HandleSenderReceiverReport(RTCPUtility::RTCPParserV2& rtcpParser,
rtcpPacketType = rtcpParser.Iterate();
while (rtcpPacketType == RTCPUtility::kRtcpReportBlockItemCode)
{
while (rtcpPacketType == RTCPPacketTypes::kReportBlockItem) {
HandleReportBlock(rtcpPacket, rtcpPacketInformation, remoteSSRC);
rtcpPacketType = rtcpParser.Iterate();
}
@@ -756,7 +756,7 @@ int32_t RTCPReceiver::BoundingSet(bool &tmmbrOwner, TMMBRSet* boundingSetRec) {
// no need for critsect we have _criticalSectionRTCPReceiver
void RTCPReceiver::HandleSDES(RTCPUtility::RTCPParserV2& rtcpParser) {
RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
while (pktType == RTCPUtility::kRtcpSdesChunkCode) {
while (pktType == RTCPPacketTypes::kSdesChunk) {
HandleSDESChunk(rtcpParser);
pktType = rtcpParser.Iterate();
}
@@ -792,7 +792,7 @@ void RTCPReceiver::HandleNACK(RTCPUtility::RTCPParserV2& rtcpParser,
rtcpPacketInformation.ResetNACKPacketIdArray();
RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
while (pktType == RTCPUtility::kRtcpRtpfbNackItemCode) {
while (pktType == RTCPPacketTypes::kRtpfbNackItem) {
HandleNACKItem(rtcpPacket, rtcpPacketInformation);
pktType = rtcpParser.Iterate();
}
@@ -896,7 +896,7 @@ void RTCPReceiver::HandleXrDlrrReportBlock(
// Iterate through sub-block(s), if any.
RTCPUtility::RTCPPacketTypes packet_type = parser.Iterate();
while (packet_type == RTCPUtility::kRtcpXrDlrrReportBlockItemCode) {
while (packet_type == RTCPPacketTypes::kXrDlrrReportBlockItem) {
HandleXrDlrrReportBlockItem(packet, rtcpPacketInformation);
packet_type = parser.Iterate();
}
@@ -1029,7 +1029,7 @@ void RTCPReceiver::HandleTMMBR(RTCPUtility::RTCPParserV2& rtcpParser,
ptrReceiveInfo->VerifyAndAllocateTMMBRSet((uint32_t)maxNumOfTMMBRBlocks);
RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
while (pktType == RTCPUtility::kRtcpRtpfbTmmbrItemCode) {
while (pktType == RTCPPacketTypes::kRtpfbTmmbrItem) {
HandleTMMBRItem(*ptrReceiveInfo, rtcpPacket, rtcpPacketInformation, senderSSRC);
pktType = rtcpParser.Iterate();
}
@@ -1074,7 +1074,7 @@ void RTCPReceiver::HandleTMMBN(RTCPUtility::RTCPParserV2& rtcpParser,
ptrReceiveInfo->VerifyAndAllocateBoundingSet((uint32_t)maxNumOfTMMBNBlocks);
RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
while (pktType == RTCPUtility::kRtcpRtpfbTmmbnItemCode) {
while (pktType == RTCPPacketTypes::kRtpfbTmmbnItem) {
HandleTMMBNItem(*ptrReceiveInfo, rtcpPacket);
pktType = rtcpParser.Iterate();
}
@@ -1101,7 +1101,7 @@ void RTCPReceiver::HandleSLI(RTCPUtility::RTCPParserV2& rtcpParser,
RTCPPacketInformation& rtcpPacketInformation) {
const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
while (pktType == RTCPUtility::kRtcpPsfbSliItemCode) {
while (pktType == RTCPPacketTypes::kPsfbSliItem) {
HandleSLIItem(rtcpPacket, rtcpPacketInformation);
pktType = rtcpParser.Iterate();
}
@@ -1121,8 +1121,7 @@ RTCPReceiver::HandleRPSI(RTCPUtility::RTCPParserV2& rtcpParser,
{
const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
if(pktType == RTCPUtility::kRtcpPsfbRpsiCode)
{
if (pktType == RTCPPacketTypes::kPsfbRpsi) {
rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRpsi; // received signal that we have a confirmed reference picture
if(rtcpPacket.RPSI.NumberOfValidBits%8 != 0)
{
@@ -1148,9 +1147,9 @@ RTCPReceiver::HandleRPSI(RTCPUtility::RTCPParserV2& rtcpParser,
void RTCPReceiver::HandlePsfbApp(RTCPUtility::RTCPParserV2& rtcpParser,
RTCPPacketInformation& rtcpPacketInformation) {
RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
if (pktType == RTCPUtility::kRtcpPsfbRembCode) {
if (pktType == RTCPPacketTypes::kPsfbRemb) {
pktType = rtcpParser.Iterate();
if (pktType == RTCPUtility::kRtcpPsfbRembItemCode) {
if (pktType == RTCPPacketTypes::kPsfbRembItem) {
HandleREMBItem(rtcpParser, rtcpPacketInformation);
rtcpParser.Iterate();
}
@@ -1163,7 +1162,7 @@ void RTCPReceiver::HandleIJ(RTCPUtility::RTCPParserV2& rtcpParser,
const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
while (pktType == RTCPUtility::kRtcpExtendedIjItemCode) {
while (pktType == RTCPPacketTypes::kExtendedIjItem) {
HandleIJItem(rtcpPacket, rtcpPacketInformation);
pktType = rtcpParser.Iterate();
}
@@ -1193,7 +1192,7 @@ void RTCPReceiver::HandleFIR(RTCPUtility::RTCPParserV2& rtcpParser,
GetReceiveInformation(rtcpPacket.FIR.SenderSSRC);
RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
while (pktType == RTCPUtility::kRtcpPsfbFirItemCode) {
while (pktType == RTCPPacketTypes::kPsfbFirItem) {
HandleFIRItem(ptrReceiveInfo, rtcpPacket, rtcpPacketInformation);
pktType = rtcpParser.Iterate();
}
@@ -1367,8 +1366,8 @@ void RTCPReceiver::TriggerCallbacksFromRTCPPacket(
_cbRtcpBandwidthObserver->OnReceivedEstimatedBitrate(
rtcpPacketInformation.receiverEstimatedMaxBitrate);
}
if (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpSr ||
rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpRr) {
if ((rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpSr) ||
(rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpRr)) {
int64_t now = _clock->TimeInMilliseconds();
_cbRtcpBandwidthObserver->OnReceivedRtcpReceiverReport(
rtcpPacketInformation.report_blocks,

1637
webrtc/modules/rtp_rtcp/source/rtcp_sender.cc
View File

File diff suppressed because it is too large Load Diff

270
webrtc/modules/rtp_rtcp/source/rtcp_sender.h
View File

@@ -12,6 +12,7 @@
#define WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_SENDER_H_
#include <map>
#include <set>
#include <sstream>
#include <string>
@@ -40,10 +41,10 @@ class NACKStringBuilder {
std::string GetResult();
private:
std::ostringstream _stream;
int _count;
uint16_t _prevNack;
bool _consecutive;
std::ostringstream stream_;
int count_;
uint16_t prevNack_;
bool consecutive_;
};
class RTCPSender {
@@ -107,12 +108,19 @@ public:
bool TimeToSendRTCPReport(bool sendKeyframeBeforeRTP = false) const;
int32_t SendRTCP(const FeedbackState& feedback_state,
uint32_t rtcpPacketTypeFlags,
RTCPPacketType packetType,
int32_t nackSize = 0,
const uint16_t* nackList = 0,
bool repeat = false,
uint64_t pictureID = 0);
int32_t SendCompoundRTCP(const FeedbackState& feedback_state,
const std::set<RTCPPacketType>& packetTypes,
int32_t nackSize = 0,
const uint16_t* nackList = 0,
bool repeat = false,
uint64_t pictureID = 0);
int32_t AddExternalReportBlock(uint32_t SSRC,
const RTCPReportBlock* receiveBlock);
@@ -150,18 +158,36 @@ public:
void SetTargetBitrate(unsigned int target_bitrate);
private:
struct RtcpContext;
// The BuildResult indicates the outcome of a call to a builder method,
// constructing a part of an RTCP packet:
//
// kError
// Building RTCP packet failed, propagate error out to caller.
// kAbort
// The (partial) block being build should not be included. Reset current
// buffer position to the state before the method call and proceed to the
// next packet type.
// kTruncated
// There is not enough room in the buffer to fit the data being constructed.
// (IP packet is full). Proceed to the next packet type, and call this
// method again when a new buffer has been allocated.
// TODO(sprang): Actually allocate multiple packets if needed.
// kSuccess
// Data has been successfully placed in the buffer.
enum class BuildResult { kError, kAborted, kTruncated, kSuccess };
int32_t SendToNetwork(const uint8_t* dataBuffer, size_t length);
int32_t WriteAllReportBlocksToBuffer(uint8_t* rtcpbuffer,
int pos,
uint8_t* numberOfReportBlocks,
uint32_t NTPsec,
uint32_t NTPfrac)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
RTCPSender::BuildResult WriteAllReportBlocksToBuffer(
RtcpContext* context,
uint8_t* numberOfReportBlocks)
EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
int32_t WriteReportBlocksToBuffer(
uint8_t* rtcpbuffer,
int32_t position,
void WriteReportBlocksToBuffer(
RtcpContext* context,
const std::map<uint32_t, RTCPReportBlock*>& report_blocks);
int32_t AddReportBlock(uint32_t SSRC,
@@ -174,21 +200,8 @@ private:
uint32_t* ntp_secs,
uint32_t* ntp_frac);
int32_t BuildSR(const FeedbackState& feedback_state,
uint8_t* rtcpbuffer,
int32_t pos,
uint32_t NTPsec,
uint32_t NTPfrac)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
int32_t BuildRR(uint8_t* rtcpbuffer,
int32_t pos,
uint32_t NTPsec,
uint32_t NTPfrac)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
int PrepareRTCP(const FeedbackState& feedback_state,
uint32_t packetTypeFlags,
const std::set<RTCPPacketType>& packetTypes,
int32_t nackSize,
const uint16_t* nackList,
bool repeat,
@@ -196,135 +209,142 @@ private:
uint8_t* rtcp_buffer,
int buffer_size);
bool ShouldSendReportBlocks(uint32_t rtcp_packet_type) const;
int32_t BuildExtendedJitterReport(uint8_t* rtcpbuffer,
int32_t pos,
uint32_t jitterTransmissionTimeOffset)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
int32_t BuildSDEC(uint8_t* rtcpbuffer, int32_t pos)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
int32_t BuildPLI(uint8_t* rtcpbuffer, int32_t pos)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
int32_t BuildREMB(uint8_t* rtcpbuffer, int32_t pos)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
int32_t BuildTMMBR(ModuleRtpRtcpImpl* module, uint8_t* rtcpbuffer, int32_t pos)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
int32_t BuildTMMBN(uint8_t* rtcpbuffer, int32_t pos)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
int32_t BuildAPP(uint8_t* rtcpbuffer, int32_t pos)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
int32_t BuildVoIPMetric(uint8_t* rtcpbuffer, int32_t pos)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
int32_t BuildBYE(uint8_t* rtcpbuffer, int32_t pos)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
int32_t BuildFIR(uint8_t* rtcpbuffer, int32_t pos, bool repeat)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
int32_t BuildSLI(uint8_t* rtcpbuffer, int32_t pos, uint8_t pictureID)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
int32_t BuildRPSI(uint8_t* rtcpbuffer,
int32_t pos,
uint64_t pictureID,
uint8_t payloadType)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
int32_t BuildNACK(uint8_t* rtcpbuffer,
int32_t pos,
int32_t nackSize,
const uint16_t* nackList,
std::string* nackString)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
int32_t BuildReceiverReferenceTime(uint8_t* buffer,
int32_t pos,
uint32_t ntp_sec,
uint32_t ntp_frac)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
int32_t BuildDlrr(uint8_t* buffer,
int32_t pos,
const RtcpReceiveTimeInfo& info)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPSender);
BuildResult BuildSR(RtcpContext* context)
EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
BuildResult BuildRR(RtcpContext* context)
EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
BuildResult BuildExtendedJitterReport(RtcpContext* context)
EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
BuildResult BuildSDEC(RtcpContext* context)
EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
BuildResult BuildPLI(RtcpContext* context)
EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
BuildResult BuildREMB(RtcpContext* context)
EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
BuildResult BuildTMMBR(RtcpContext* context)
EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
BuildResult BuildTMMBN(RtcpContext* context)
EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
BuildResult BuildAPP(RtcpContext* context)
EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
BuildResult BuildVoIPMetric(RtcpContext* context)
EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
BuildResult BuildBYE(RtcpContext* context)
EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
BuildResult BuildFIR(RtcpContext* context)
EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
BuildResult BuildSLI(RtcpContext* context)
EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
BuildResult BuildRPSI(RtcpContext* context)
EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
BuildResult BuildNACK(RtcpContext* context)
EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
BuildResult BuildReceiverReferenceTime(RtcpContext* context)
EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
BuildResult BuildDlrr(RtcpContext* context)
EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
private:
const int32_t _id;
const bool _audio;
Clock* const _clock;
RTCPMethod _method GUARDED_BY(_criticalSectionRTCPSender);
const int32_t id_;
const bool audio_;
Clock* const clock_;
RTCPMethod method_ GUARDED_BY(critical_section_rtcp_sender_);
rtc::scoped_ptr<CriticalSectionWrapper> _criticalSectionTransport;
Transport* _cbTransport GUARDED_BY(_criticalSectionTransport);
rtc::scoped_ptr<CriticalSectionWrapper> critical_section_transport_;
Transport* cbTransport_ GUARDED_BY(critical_section_transport_);
rtc::scoped_ptr<CriticalSectionWrapper> _criticalSectionRTCPSender;
bool _usingNack GUARDED_BY(_criticalSectionRTCPSender);
bool _sending GUARDED_BY(_criticalSectionRTCPSender);
bool _sendTMMBN GUARDED_BY(_criticalSectionRTCPSender);
bool _REMB GUARDED_BY(_criticalSectionRTCPSender);
bool _sendREMB GUARDED_BY(_criticalSectionRTCPSender);
bool _TMMBR GUARDED_BY(_criticalSectionRTCPSender);
bool _IJ GUARDED_BY(_criticalSectionRTCPSender);
rtc::scoped_ptr<CriticalSectionWrapper> critical_section_rtcp_sender_;
bool using_nack_ GUARDED_BY(critical_section_rtcp_sender_);
bool sending_ GUARDED_BY(critical_section_rtcp_sender_);
bool remb_enabled_ GUARDED_BY(critical_section_rtcp_sender_);
bool extended_jitter_report_enabled_ GUARDED_BY(critical_section_rtcp_sender_);
int64_t _nextTimeToSendRTCP GUARDED_BY(_criticalSectionRTCPSender);
int64_t next_time_to_send_rtcp_ GUARDED_BY(critical_section_rtcp_sender_);
uint32_t start_timestamp_ GUARDED_BY(_criticalSectionRTCPSender);
uint32_t last_rtp_timestamp_ GUARDED_BY(_criticalSectionRTCPSender);
int64_t last_frame_capture_time_ms_ GUARDED_BY(_criticalSectionRTCPSender);
uint32_t _SSRC GUARDED_BY(_criticalSectionRTCPSender);
uint32_t start_timestamp_ GUARDED_BY(critical_section_rtcp_sender_);
uint32_t last_rtp_timestamp_ GUARDED_BY(critical_section_rtcp_sender_);
int64_t last_frame_capture_time_ms_ GUARDED_BY(critical_section_rtcp_sender_);
uint32_t ssrc_ GUARDED_BY(critical_section_rtcp_sender_);
// SSRC that we receive on our RTP channel
uint32_t _remoteSSRC GUARDED_BY(_criticalSectionRTCPSender);
char _CNAME[RTCP_CNAME_SIZE] GUARDED_BY(_criticalSectionRTCPSender);
uint32_t remote_ssrc_ GUARDED_BY(critical_section_rtcp_sender_);
char cname_[RTCP_CNAME_SIZE] GUARDED_BY(critical_section_rtcp_sender_);
ReceiveStatistics* receive_statistics_ GUARDED_BY(_criticalSectionRTCPSender);
ReceiveStatistics* receive_statistics_
GUARDED_BY(critical_section_rtcp_sender_);
std::map<uint32_t, RTCPReportBlock*> internal_report_blocks_
GUARDED_BY(_criticalSectionRTCPSender);
GUARDED_BY(critical_section_rtcp_sender_);
std::map<uint32_t, RTCPReportBlock*> external_report_blocks_
GUARDED_BY(_criticalSectionRTCPSender);
std::map<uint32_t, RTCPUtility::RTCPCnameInformation*> _csrcCNAMEs
GUARDED_BY(_criticalSectionRTCPSender);
GUARDED_BY(critical_section_rtcp_sender_);
std::map<uint32_t, RTCPUtility::RTCPCnameInformation*> csrc_cnames_
GUARDED_BY(critical_section_rtcp_sender_);
// Sent
uint32_t _lastSendReport[RTCP_NUMBER_OF_SR] GUARDED_BY(
_criticalSectionRTCPSender); // allow packet loss and RTT above 1 sec
int64_t _lastRTCPTime[RTCP_NUMBER_OF_SR] GUARDED_BY(
_criticalSectionRTCPSender);
uint32_t last_send_report_[RTCP_NUMBER_OF_SR] GUARDED_BY(
critical_section_rtcp_sender_); // allow packet loss and RTT above 1 sec
int64_t last_rtcp_time_[RTCP_NUMBER_OF_SR] GUARDED_BY(
critical_section_rtcp_sender_);
// Sent XR receiver reference time report.
// <mid ntp (mid 32 bits of the 64 bits NTP timestamp), send time in ms>.
std::map<uint32_t, int64_t> last_xr_rr_ GUARDED_BY(_criticalSectionRTCPSender);
std::map<uint32_t, int64_t> last_xr_rr_
GUARDED_BY(critical_section_rtcp_sender_);
// send CSRCs
std::vector<uint32_t> csrcs_ GUARDED_BY(_criticalSectionRTCPSender);
std::vector<uint32_t> csrcs_ GUARDED_BY(critical_section_rtcp_sender_);
// Full intra request
uint8_t _sequenceNumberFIR GUARDED_BY(_criticalSectionRTCPSender);
uint8_t sequence_number_fir_ GUARDED_BY(critical_section_rtcp_sender_);
// REMB
uint32_t _rembBitrate GUARDED_BY(_criticalSectionRTCPSender);
std::vector<uint32_t> remb_ssrcs_ GUARDED_BY(_criticalSectionRTCPSender);
uint32_t remb_bitrate_ GUARDED_BY(critical_section_rtcp_sender_);
std::vector<uint32_t> remb_ssrcs_ GUARDED_BY(critical_section_rtcp_sender_);
TMMBRHelp _tmmbrHelp GUARDED_BY(_criticalSectionRTCPSender);
uint32_t _tmmbr_Send GUARDED_BY(_criticalSectionRTCPSender);
uint32_t _packetOH_Send GUARDED_BY(_criticalSectionRTCPSender);
TMMBRHelp tmmbr_help_ GUARDED_BY(critical_section_rtcp_sender_);
uint32_t tmmbr_send_ GUARDED_BY(critical_section_rtcp_sender_);
uint32_t packet_oh_send_ GUARDED_BY(critical_section_rtcp_sender_);
// APP
bool _appSend GUARDED_BY(_criticalSectionRTCPSender);
uint8_t _appSubType GUARDED_BY(_criticalSectionRTCPSender);
uint32_t _appName GUARDED_BY(_criticalSectionRTCPSender);
rtc::scoped_ptr<uint8_t[]> _appData GUARDED_BY(_criticalSectionRTCPSender);
uint16_t _appLength GUARDED_BY(_criticalSectionRTCPSender);
uint8_t app_sub_type_ GUARDED_BY(critical_section_rtcp_sender_);
uint32_t app_name_ GUARDED_BY(critical_section_rtcp_sender_);
rtc::scoped_ptr<uint8_t[]> app_data_ GUARDED_BY(critical_section_rtcp_sender_);
uint16_t app_length_ GUARDED_BY(critical_section_rtcp_sender_);
// True if sending of XR Receiver reference time report is enabled.
bool xrSendReceiverReferenceTimeEnabled_
GUARDED_BY(_criticalSectionRTCPSender);
bool xr_send_receiver_reference_time_enabled_
GUARDED_BY(critical_section_rtcp_sender_);
// XR VoIP metric
bool _xrSendVoIPMetric GUARDED_BY(_criticalSectionRTCPSender);
RTCPVoIPMetric _xrVoIPMetric GUARDED_BY(_criticalSectionRTCPSender);
RTCPVoIPMetric xr_voip_metric_ GUARDED_BY(critical_section_rtcp_sender_);
RtcpPacketTypeCounterObserver* const packet_type_counter_observer_;
RtcpPacketTypeCounter packet_type_counter_
GUARDED_BY(_criticalSectionRTCPSender);
GUARDED_BY(critical_section_rtcp_sender_);
RTCPUtility::NackStats nack_stats_ GUARDED_BY(_criticalSectionRTCPSender);
RTCPUtility::NackStats nack_stats_ GUARDED_BY(critical_section_rtcp_sender_);
void SetFlag(RTCPPacketType type, bool is_volatile)
EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
void SetFlags(const std::set<RTCPPacketType>& types, bool is_volatile)
EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
bool IsFlagPresent(RTCPPacketType type) const
EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
bool ConsumeFlag(RTCPPacketType type, bool forced = false)
EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
bool AllVolatileFlagsConsumed() const
EXCLUSIVE_LOCKS_REQUIRED(critical_section_rtcp_sender_);
struct ReportFlag {
ReportFlag(RTCPPacketType type, bool is_volatile)
: type(type), is_volatile(is_volatile) {}
bool operator<(const ReportFlag& flag) const { return type < flag.type; }
bool operator==(const ReportFlag& flag) const { return type == flag.type; }
const RTCPPacketType type;
const bool is_volatile;
};
std::set<ReportFlag> report_flags_ GUARDED_BY(critical_section_rtcp_sender_);
typedef BuildResult (RTCPSender::*Builder)(RtcpContext*);
std::map<RTCPPacketType, Builder> builders_;
};
} // namespace webrtc

208
webrtc/modules/rtp_rtcp/source/rtcp_utility.cc
View File

@@ -49,9 +49,9 @@ RTCPUtility::RTCPParserV2::RTCPParserV2(const uint8_t* rtcpData,
_validPacket(false),
_ptrRTCPData(rtcpData),
_ptrRTCPBlockEnd(NULL),
_state(State_TopLevel),
_state(ParseState::State_TopLevel),
_numberOfBlocks(0),
_packetType(kRtcpNotValidCode) {
_packetType(RTCPPacketTypes::kInvalid) {
Validate();
}
@@ -88,58 +88,58 @@ RTCPUtility::RTCPPacketTypes
RTCPUtility::RTCPParserV2::Iterate()
{
// Reset packet type
_packetType = kRtcpNotValidCode;
_packetType = RTCPPacketTypes::kInvalid;
if (IsValid())
{
switch (_state)
{
case State_TopLevel:
case ParseState::State_TopLevel:
IterateTopLevel();
break;
case State_ReportBlockItem:
case ParseState::State_ReportBlockItem:
IterateReportBlockItem();
break;
case State_SDESChunk:
case ParseState::State_SDESChunk:
IterateSDESChunk();
break;
case State_BYEItem:
case ParseState::State_BYEItem:
IterateBYEItem();
break;
case State_ExtendedJitterItem:
case ParseState::State_ExtendedJitterItem:
IterateExtendedJitterItem();
break;
case State_RTPFB_NACKItem:
case ParseState::State_RTPFB_NACKItem:
IterateNACKItem();
break;
case State_RTPFB_TMMBRItem:
case ParseState::State_RTPFB_TMMBRItem:
IterateTMMBRItem();
break;
case State_RTPFB_TMMBNItem:
case ParseState::State_RTPFB_TMMBNItem:
IterateTMMBNItem();
break;
case State_PSFB_SLIItem:
case ParseState::State_PSFB_SLIItem:
IterateSLIItem();
break;
case State_PSFB_RPSIItem:
case ParseState::State_PSFB_RPSIItem:
IterateRPSIItem();
break;
case State_PSFB_FIRItem:
case ParseState::State_PSFB_FIRItem:
IterateFIRItem();
break;
case State_PSFB_AppItem:
case ParseState::State_PSFB_AppItem:
IteratePsfbAppItem();
break;
case State_PSFB_REMBItem:
case ParseState::State_PSFB_REMBItem:
IteratePsfbREMBItem();
break;
case State_XRItem:
case ParseState::State_XRItem:
IterateXrItem();
break;
case State_XR_DLLRItem:
case ParseState::State_XR_DLLRItem:
IterateXrDlrrItem();
break;
case State_AppItem:
case ParseState::State_AppItem:
IterateAppItem();
break;
default:
@@ -515,7 +515,7 @@ RTCPUtility::RTCPParserV2::ParseRR()
_ptrRTCPData += 4; // Skip header
_packetType = kRtcpRrCode;
_packetType = RTCPPacketTypes::kRr;
_packet.RR.SenderSSRC = *_ptrRTCPData++ << 24;
_packet.RR.SenderSSRC += *_ptrRTCPData++ << 16;
@@ -525,7 +525,7 @@ RTCPUtility::RTCPParserV2::ParseRR()
_packet.RR.NumberOfReportBlocks = _numberOfBlocks;
// State transition
_state = State_ReportBlockItem;
_state = ParseState::State_ReportBlockItem;
return true;
}
@@ -543,7 +543,7 @@ RTCPUtility::RTCPParserV2::ParseSR()
_ptrRTCPData += 4; // Skip header
_packetType = kRtcpSrCode;
_packetType = RTCPPacketTypes::kSr;
_packet.SR.SenderSSRC = *_ptrRTCPData++ << 24;
_packet.SR.SenderSSRC += *_ptrRTCPData++ << 16;
@@ -580,11 +580,11 @@ RTCPUtility::RTCPParserV2::ParseSR()
// State transition
if(_numberOfBlocks != 0)
{
_state = State_ReportBlockItem;
_state = ParseState::State_ReportBlockItem;
}else
{
// don't go to state report block item if 0 report blocks
_state = State_TopLevel;
_state = ParseState::State_TopLevel;
EndCurrentBlock();
}
return true;
@@ -597,7 +597,7 @@ RTCPUtility::RTCPParserV2::ParseReportBlockItem()
if (length < 24 || _numberOfBlocks <= 0)
{
_state = State_TopLevel;
_state = ParseState::State_TopLevel;
EndCurrentBlock();
return false;
@@ -634,7 +634,7 @@ RTCPUtility::RTCPParserV2::ParseReportBlockItem()
_packet.ReportBlockItem.DelayLastSR += *_ptrRTCPData++;
_numberOfBlocks--;
_packetType = kRtcpReportBlockItemCode;
_packetType = RTCPPacketTypes::kReportBlockItem;
return true;
}
@@ -665,10 +665,10 @@ RTCPUtility::RTCPParserV2::ParseIJ()
_ptrRTCPData += 4; // Skip header
_packetType = kRtcpExtendedIjCode;
_packetType = RTCPPacketTypes::kExtendedIj;
// State transition
_state = State_ExtendedJitterItem;
_state = ParseState::State_ExtendedJitterItem;
return true;
}
@@ -679,7 +679,7 @@ RTCPUtility::RTCPParserV2::ParseIJItem()
if (length < 4 || _numberOfBlocks <= 0)
{
_state = State_TopLevel;
_state = ParseState::State_TopLevel;
EndCurrentBlock();
return false;
}
@@ -690,7 +690,7 @@ RTCPUtility::RTCPParserV2::ParseIJItem()
_packet.ExtendedJitterReportItem.Jitter += *_ptrRTCPData++;
_numberOfBlocks--;
_packetType = kRtcpExtendedIjItemCode;
_packetType = RTCPPacketTypes::kExtendedIjItem;
return true;
}
@@ -701,15 +701,15 @@ RTCPUtility::RTCPParserV2::ParseSDES()
if (length < 8)
{
_state = State_TopLevel;
_state = ParseState::State_TopLevel;
EndCurrentBlock();
return false;
}
_ptrRTCPData += 4; // Skip header
_state = State_SDESChunk;
_packetType = kRtcpSdesCode;
_state = ParseState::State_SDESChunk;
_packetType = RTCPPacketTypes::kSdes;
return true;
}
@@ -718,7 +718,7 @@ RTCPUtility::RTCPParserV2::ParseSDESChunk()
{
if(_numberOfBlocks <= 0)
{
_state = State_TopLevel;
_state = ParseState::State_TopLevel;
EndCurrentBlock();
return false;
@@ -731,7 +731,7 @@ RTCPUtility::RTCPParserV2::ParseSDESChunk()
const ptrdiff_t dataLen = _ptrRTCPBlockEnd - _ptrRTCPData;
if (dataLen < 4)
{
_state = State_TopLevel;
_state = ParseState::State_TopLevel;
EndCurrentBlock();
return false;
@@ -749,7 +749,7 @@ RTCPUtility::RTCPParserV2::ParseSDESChunk()
return true;
}
}
_state = State_TopLevel;
_state = ParseState::State_TopLevel;
EndCurrentBlock();
return false;
@@ -790,7 +790,7 @@ RTCPUtility::RTCPParserV2::ParseSDESItem()
// Sanity
if ((_ptrRTCPData + len) >= _ptrRTCPBlockEnd)
{
_state = State_TopLevel;
_state = ParseState::State_TopLevel;
EndCurrentBlock();
return false;
@@ -802,7 +802,7 @@ RTCPUtility::RTCPParserV2::ParseSDESItem()
if ((c < ' ') || (c > '{') || (c == '%') || (c == '\\'))
{
// Illegal char
_state = State_TopLevel;
_state = ParseState::State_TopLevel;
EndCurrentBlock();
return false;
@@ -811,7 +811,7 @@ RTCPUtility::RTCPParserV2::ParseSDESItem()
}
// Make sure we are null terminated.
_packet.CName.CName[i] = 0;
_packetType = kRtcpSdesChunkCode;
_packetType = RTCPPacketTypes::kSdesChunk;
foundCName = true;
}
@@ -821,7 +821,7 @@ RTCPUtility::RTCPParserV2::ParseSDESItem()
}
// No end tag found!
_state = State_TopLevel;
_state = ParseState::State_TopLevel;
EndCurrentBlock();
return false;
@@ -832,7 +832,7 @@ RTCPUtility::RTCPParserV2::ParseBYE()
{
_ptrRTCPData += 4; // Skip header
_state = State_BYEItem;
_state = ParseState::State_BYEItem;
return ParseBYEItem();
}
@@ -843,13 +843,13 @@ RTCPUtility::RTCPParserV2::ParseBYEItem()
const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData;
if (length < 4 || _numberOfBlocks == 0)
{
_state = State_TopLevel;
_state = ParseState::State_TopLevel;
EndCurrentBlock();
return false;
}
_packetType = kRtcpByeCode;
_packetType = RTCPPacketTypes::kBye;
_packet.BYE.SenderSSRC = *_ptrRTCPData++ << 24;
_packet.BYE.SenderSSRC += *_ptrRTCPData++ << 16;
@@ -894,8 +894,8 @@ bool RTCPUtility::RTCPParserV2::ParseXr()
_packet.XR.OriginatorSSRC += *_ptrRTCPData++ << 8;
_packet.XR.OriginatorSSRC += *_ptrRTCPData++;
_packetType = kRtcpXrHeaderCode;
_state = State_XRItem;
_packetType = RTCPPacketTypes::kXrHeader;
_state = ParseState::State_XRItem;
return true;
}
@@ -915,7 +915,7 @@ bool RTCPUtility::RTCPParserV2::ParseXrItem() {
const int kBlockHeaderLengthInBytes = 4;
const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData;
if (length < kBlockHeaderLengthInBytes) {
_state = State_TopLevel;
_state = ParseState::State_TopLevel;
EndCurrentBlock();
return false;
}
@@ -956,7 +956,7 @@ bool RTCPUtility::RTCPParserV2::ParseXrReceiverReferenceTimeItem(
const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData;
if (block_length_4bytes != kBlockLengthIn4Bytes ||
length < kBlockLengthInBytes) {
_state = State_TopLevel;
_state = ParseState::State_TopLevel;
EndCurrentBlock();
return false;
}
@@ -971,8 +971,8 @@ bool RTCPUtility::RTCPParserV2::ParseXrReceiverReferenceTimeItem(
_packet.XRReceiverReferenceTimeItem.NTPLeastSignificant+= *_ptrRTCPData++<<8;
_packet.XRReceiverReferenceTimeItem.NTPLeastSignificant+= *_ptrRTCPData++;
_packetType = kRtcpXrReceiverReferenceTimeCode;
_state = State_XRItem;
_packetType = RTCPPacketTypes::kXrReceiverReferenceTime;
_state = ParseState::State_XRItem;
return true;
}
@@ -997,25 +997,25 @@ bool RTCPUtility::RTCPParserV2::ParseXrDlrr(int block_length_4bytes) {
const int kSubBlockLengthIn4Bytes = 3;
if (block_length_4bytes < 0 ||
(block_length_4bytes % kSubBlockLengthIn4Bytes) != 0) {
_state = State_TopLevel;
_state = ParseState::State_TopLevel;
EndCurrentBlock();
return false;
}
_packetType = kRtcpXrDlrrReportBlockCode;
_state = State_XR_DLLRItem;
_packetType = RTCPPacketTypes::kXrDlrrReportBlock;
_state = ParseState::State_XR_DLLRItem;
_numberOfBlocks = block_length_4bytes / kSubBlockLengthIn4Bytes;
return true;
}
bool RTCPUtility::RTCPParserV2::ParseXrDlrrItem() {
if (_numberOfBlocks == 0) {
_state = State_XRItem;
_state = ParseState::State_XRItem;
return false;
}
const int kSubBlockLengthInBytes = 12;
const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData;
if (length < kSubBlockLengthInBytes) {
_state = State_TopLevel;
_state = ParseState::State_TopLevel;
EndCurrentBlock();
return false;
}
@@ -1035,9 +1035,9 @@ bool RTCPUtility::RTCPParserV2::ParseXrDlrrItem() {
_packet.XRDLRRReportBlockItem.DelayLastRR += *_ptrRTCPData++ << 8;
_packet.XRDLRRReportBlockItem.DelayLastRR += *_ptrRTCPData++;
_packetType = kRtcpXrDlrrReportBlockItemCode;
_packetType = RTCPPacketTypes::kXrDlrrReportBlockItem;
--_numberOfBlocks;
_state = State_XR_DLLRItem;
_state = ParseState::State_XR_DLLRItem;
return true;
}
/* VoIP Metrics Report Block.
@@ -1070,7 +1070,7 @@ bool RTCPUtility::RTCPParserV2::ParseXrVoipMetricItem(int block_length_4bytes) {
const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData;
if (block_length_4bytes != kBlockLengthIn4Bytes ||
length < kBlockLengthInBytes) {
_state = State_TopLevel;
_state = ParseState::State_TopLevel;
EndCurrentBlock();
return false;
}
@@ -1117,8 +1117,8 @@ bool RTCPUtility::RTCPParserV2::ParseXrVoipMetricItem(int block_length_4bytes) {
_packet.XRVOIPMetricItem.JBabsMax = *_ptrRTCPData++ << 8;
_packet.XRVOIPMetricItem.JBabsMax += *_ptrRTCPData++;
_packetType = kRtcpXrVoipMetricCode;
_state = State_XRItem;
_packetType = RTCPPacketTypes::kXrVoipMetric;
_state = ParseState::State_XRItem;
return true;
}
@@ -1127,13 +1127,13 @@ bool RTCPUtility::RTCPParserV2::ParseXrUnsupportedBlockType(
const int32_t kBlockLengthInBytes = block_length_4bytes * 4;
const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData;
if (length < kBlockLengthInBytes) {
_state = State_TopLevel;
_state = ParseState::State_TopLevel;
EndCurrentBlock();
return false;
}
// Skip block.
_ptrRTCPData += kBlockLengthInBytes;
_state = State_XRItem;
_state = ParseState::State_XRItem;
return false;
}
@@ -1171,11 +1171,11 @@ RTCPUtility::RTCPParserV2::ParseFBCommon(const RTCPCommonHeader& header)
case 1:
{
// NACK
_packetType = kRtcpRtpfbNackCode;
_packetType = RTCPPacketTypes::kRtpfbNack;
_packet.NACK.SenderSSRC = senderSSRC;
_packet.NACK.MediaSSRC = mediaSSRC;
_state = State_RTPFB_NACKItem;
_state = ParseState::State_RTPFB_NACKItem;
return true;
}
@@ -1188,22 +1188,22 @@ RTCPUtility::RTCPParserV2::ParseFBCommon(const RTCPCommonHeader& header)
case 3:
{
// TMMBR
_packetType = kRtcpRtpfbTmmbrCode;
_packetType = RTCPPacketTypes::kRtpfbTmmbr;
_packet.TMMBR.SenderSSRC = senderSSRC;
_packet.TMMBR.MediaSSRC = mediaSSRC;
_state = State_RTPFB_TMMBRItem;
_state = ParseState::State_RTPFB_TMMBRItem;
return true;
}
case 4:
{
// TMMBN
_packetType = kRtcpRtpfbTmmbnCode;
_packetType = RTCPPacketTypes::kRtpfbTmmbn;
_packet.TMMBN.SenderSSRC = senderSSRC;
_packet.TMMBN.MediaSSRC = mediaSSRC;
_state = State_RTPFB_TMMBNItem;
_state = ParseState::State_RTPFB_TMMBNItem;
return true;
}
@@ -1212,7 +1212,7 @@ RTCPUtility::RTCPParserV2::ParseFBCommon(const RTCPCommonHeader& header)
// RTCP-SR-REQ Rapid Synchronisation of RTP Flows
// draft-perkins-avt-rapid-rtp-sync-03.txt
// trigger a new RTCP SR
_packetType = kRtcpRtpfbSrReqCode;
_packetType = RTCPPacketTypes::kRtpfbSrReq;
// Note: No state transition, SR REQ is empty!
return true;
@@ -1230,7 +1230,7 @@ RTCPUtility::RTCPParserV2::ParseFBCommon(const RTCPCommonHeader& header)
{
case 1:
// PLI
_packetType = kRtcpPsfbPliCode;
_packetType = RTCPPacketTypes::kPsfbPli;
_packet.PLI.SenderSSRC = senderSSRC;
_packet.PLI.MediaSSRC = mediaSSRC;
@@ -1238,34 +1238,34 @@ RTCPUtility::RTCPParserV2::ParseFBCommon(const RTCPCommonHeader& header)
return true;
case 2:
// SLI
_packetType = kRtcpPsfbSliCode;
_packetType = RTCPPacketTypes::kPsfbSli;
_packet.SLI.SenderSSRC = senderSSRC;
_packet.SLI.MediaSSRC = mediaSSRC;
_state = State_PSFB_SLIItem;
_state = ParseState::State_PSFB_SLIItem;
return true;
case 3:
_packetType = kRtcpPsfbRpsiCode;
_packetType = RTCPPacketTypes::kPsfbRpsi;
_packet.RPSI.SenderSSRC = senderSSRC;
_packet.RPSI.MediaSSRC = mediaSSRC;
_state = State_PSFB_RPSIItem;
_state = ParseState::State_PSFB_RPSIItem;
return true;
case 4:
// FIR
_packetType = kRtcpPsfbFirCode;
_packetType = RTCPPacketTypes::kPsfbFir;
_packet.FIR.SenderSSRC = senderSSRC;
_packet.FIR.MediaSSRC = mediaSSRC;
_state = State_PSFB_FIRItem;
_state = ParseState::State_PSFB_FIRItem;
return true;
case 15:
_packetType = kRtcpPsfbAppCode;
_packetType = RTCPPacketTypes::kPsfbApp;
_packet.PSFBAPP.SenderSSRC = senderSSRC;
_packet.PSFBAPP.MediaSSRC = mediaSSRC;
_state = State_PSFB_AppItem;
_state = ParseState::State_PSFB_AppItem;
return true;
default:
break;
@@ -1298,19 +1298,19 @@ bool RTCPUtility::RTCPParserV2::ParseRPSIItem() {
const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData;
if (length < 4) {
_state = State_TopLevel;
_state = ParseState::State_TopLevel;
EndCurrentBlock();
return false;
}
if (length > 2 + RTCP_RPSI_DATA_SIZE) {
_state = State_TopLevel;
_state = ParseState::State_TopLevel;
EndCurrentBlock();
return false;
}
_packetType = kRtcpPsfbRpsiCode;
_packetType = RTCPPacketTypes::kPsfbRpsi;
uint8_t padding_bits = *_ptrRTCPData++;
_packet.RPSI.PayloadType = *_ptrRTCPData++;
@@ -1332,13 +1332,13 @@ RTCPUtility::RTCPParserV2::ParseNACKItem()
if (length < 4)
{
_state = State_TopLevel;
_state = ParseState::State_TopLevel;
EndCurrentBlock();
return false;
}
_packetType = kRtcpRtpfbNackItemCode;
_packetType = RTCPPacketTypes::kRtpfbNackItem;
_packet.NACKItem.PacketID = *_ptrRTCPData++ << 8;
_packet.NACKItem.PacketID += *_ptrRTCPData++;
@@ -1356,41 +1356,41 @@ RTCPUtility::RTCPParserV2::ParsePsfbAppItem()
if (length < 4)
{
_state = State_TopLevel;
_state = ParseState::State_TopLevel;
EndCurrentBlock();
return false;
}
if(*_ptrRTCPData++ != 'R')
{
_state = State_TopLevel;
_state = ParseState::State_TopLevel;
EndCurrentBlock();
return false;
}
if(*_ptrRTCPData++ != 'E')
{
_state = State_TopLevel;
_state = ParseState::State_TopLevel;
EndCurrentBlock();
return false;
}
if(*_ptrRTCPData++ != 'M')
{
_state = State_TopLevel;
_state = ParseState::State_TopLevel;
EndCurrentBlock();
return false;
}
if(*_ptrRTCPData++ != 'B')
{
_state = State_TopLevel;
_state = ParseState::State_TopLevel;
EndCurrentBlock();
return false;
}
_packetType = kRtcpPsfbRembCode;
_state = State_PSFB_REMBItem;
_packetType = RTCPPacketTypes::kPsfbRemb;
_state = ParseState::State_PSFB_REMBItem;
return true;
}
@@ -1401,7 +1401,7 @@ RTCPUtility::RTCPParserV2::ParsePsfbREMBItem()
if (length < 4)
{
_state = State_TopLevel;
_state = ParseState::State_TopLevel;
EndCurrentBlock();
return false;
@@ -1420,13 +1420,13 @@ RTCPUtility::RTCPParserV2::ParsePsfbREMBItem()
const ptrdiff_t length_ssrcs = _ptrRTCPBlockEnd - _ptrRTCPData;
if (length_ssrcs < 4 * _packet.REMBItem.NumberOfSSRCs)
{
_state = State_TopLevel;
_state = ParseState::State_TopLevel;
EndCurrentBlock();
return false;
}
_packetType = kRtcpPsfbRembItemCode;
_packetType = RTCPPacketTypes::kPsfbRembItem;
for (int i = 0; i < _packet.REMBItem.NumberOfSSRCs; i++)
{
@@ -1447,13 +1447,13 @@ RTCPUtility::RTCPParserV2::ParseTMMBRItem()
if (length < 8)
{
_state = State_TopLevel;
_state = ParseState::State_TopLevel;
EndCurrentBlock();
return false;
}
_packetType = kRtcpRtpfbTmmbrItemCode;
_packetType = RTCPPacketTypes::kRtpfbTmmbrItem;
_packet.TMMBRItem.SSRC = *_ptrRTCPData++ << 24;
_packet.TMMBRItem.SSRC += *_ptrRTCPData++ << 16;
@@ -1486,13 +1486,13 @@ RTCPUtility::RTCPParserV2::ParseTMMBNItem()
if (length < 8)
{
_state = State_TopLevel;
_state = ParseState::State_TopLevel;
EndCurrentBlock();
return false;
}
_packetType = kRtcpRtpfbTmmbnItemCode;
_packetType = RTCPPacketTypes::kRtpfbTmmbnItem;
_packet.TMMBNItem.SSRC = *_ptrRTCPData++ << 24;
_packet.TMMBNItem.SSRC += *_ptrRTCPData++ << 16;
@@ -1532,12 +1532,12 @@ RTCPUtility::RTCPParserV2::ParseSLIItem()
if (length < 4)
{
_state = State_TopLevel;
_state = ParseState::State_TopLevel;
EndCurrentBlock();
return false;
}
_packetType = kRtcpPsfbSliItemCode;
_packetType = RTCPPacketTypes::kPsfbSliItem;
uint32_t buffer;
buffer = *_ptrRTCPData++ << 24;
@@ -1561,13 +1561,13 @@ RTCPUtility::RTCPParserV2::ParseFIRItem()
if (length < 8)
{
_state = State_TopLevel;
_state = ParseState::State_TopLevel;
EndCurrentBlock();
return false;
}
_packetType = kRtcpPsfbFirItemCode;
_packetType = RTCPPacketTypes::kPsfbFirItem;
_packet.FIRItem.SSRC = *_ptrRTCPData++ << 24;
_packet.FIRItem.SSRC += *_ptrRTCPData++ << 16;
@@ -1604,12 +1604,12 @@ RTCPUtility::RTCPParserV2::ParseAPP( const RTCPCommonHeader& header)
length = _ptrRTCPBlockEnd - _ptrRTCPData;
_packetType = kRtcpAppCode;
_packetType = RTCPPacketTypes::kApp;
_packet.APP.SubType = header.IC;
_packet.APP.Name = name;
_state = State_AppItem;
_state = ParseState::State_AppItem;
return true;
}
@@ -1619,12 +1619,12 @@ RTCPUtility::RTCPParserV2::ParseAPPItem()
const ptrdiff_t length = _ptrRTCPBlockEnd - _ptrRTCPData;
if (length < 4)
{
_state = State_TopLevel;
_state = ParseState::State_TopLevel;
EndCurrentBlock();
return false;
}
_packetType = kRtcpAppItemCode;
_packetType = RTCPPacketTypes::kAppItem;
if(length > kRtcpAppCode_DATA_SIZE)
{

781
webrtc/modules/rtp_rtcp/source/rtcp_utility.h
View File

@@ -1,12 +1,12 @@
/*
* Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
* Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_UTILITY_H_
#define WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_UTILITY_H_
@@ -42,463 +42,428 @@ class NackStats {
uint32_t unique_requests_;
};
uint32_t MidNtp(uint32_t ntp_sec, uint32_t ntp_frac);
uint32_t MidNtp(uint32_t ntp_sec, uint32_t ntp_frac);
// CNAME
struct RTCPCnameInformation
{
char name[RTCP_CNAME_SIZE];
};
struct RTCPPacketRR
{
uint32_t SenderSSRC;
uint8_t NumberOfReportBlocks;
};
struct RTCPPacketSR
{
uint32_t SenderSSRC;
uint8_t NumberOfReportBlocks;
// CNAME
struct RTCPCnameInformation {
char name[RTCP_CNAME_SIZE];
};
struct RTCPPacketRR {
uint32_t SenderSSRC;
uint8_t NumberOfReportBlocks;
};
struct RTCPPacketSR {
uint32_t SenderSSRC;
uint8_t NumberOfReportBlocks;
// sender info
uint32_t NTPMostSignificant;
uint32_t NTPLeastSignificant;
uint32_t RTPTimestamp;
uint32_t SenderPacketCount;
uint32_t SenderOctetCount;
};
struct RTCPPacketReportBlockItem
{
// report block
uint32_t SSRC;
uint8_t FractionLost;
uint32_t CumulativeNumOfPacketsLost;
uint32_t ExtendedHighestSequenceNumber;
uint32_t Jitter;
uint32_t LastSR;
uint32_t DelayLastSR;
};
struct RTCPPacketSDESCName
{
// RFC3550
uint32_t SenderSSRC;
char CName[RTCP_CNAME_SIZE];
};
// sender info
uint32_t NTPMostSignificant;
uint32_t NTPLeastSignificant;
uint32_t RTPTimestamp;
uint32_t SenderPacketCount;
uint32_t SenderOctetCount;
};
struct RTCPPacketReportBlockItem {
// report block
uint32_t SSRC;
uint8_t FractionLost;
uint32_t CumulativeNumOfPacketsLost;
uint32_t ExtendedHighestSequenceNumber;
uint32_t Jitter;
uint32_t LastSR;
uint32_t DelayLastSR;
};
struct RTCPPacketSDESCName {
// RFC3550
uint32_t SenderSSRC;
char CName[RTCP_CNAME_SIZE];
};
struct RTCPPacketExtendedJitterReportItem
{
// RFC 5450
uint32_t Jitter;
};
struct RTCPPacketExtendedJitterReportItem {
// RFC 5450
uint32_t Jitter;
};
struct RTCPPacketBYE
{
uint32_t SenderSSRC;
};
struct RTCPPacketXR
{
// RFC 3611
uint32_t OriginatorSSRC;
};
struct RTCPPacketXRReceiverReferenceTimeItem
{
// RFC 3611 4.4
uint32_t NTPMostSignificant;
uint32_t NTPLeastSignificant;
};
struct RTCPPacketXRDLRRReportBlockItem
{
// RFC 3611 4.5
uint32_t SSRC;
uint32_t LastRR;
uint32_t DelayLastRR;
};
struct RTCPPacketXRVOIPMetricItem
{
// RFC 3611 4.7
uint32_t SSRC;
uint8_t lossRate;
uint8_t discardRate;
uint8_t burstDensity;
uint8_t gapDensity;
uint16_t burstDuration;
uint16_t gapDuration;
uint16_t roundTripDelay;
uint16_t endSystemDelay;
uint8_t signalLevel;
uint8_t noiseLevel;
uint8_t RERL;
uint8_t Gmin;
uint8_t Rfactor;
uint8_t extRfactor;
uint8_t MOSLQ;
uint8_t MOSCQ;
uint8_t RXconfig;
uint16_t JBnominal;
uint16_t JBmax;
uint16_t JBabsMax;
};
struct RTCPPacketBYE {
uint32_t SenderSSRC;
};
struct RTCPPacketXR {
// RFC 3611
uint32_t OriginatorSSRC;
};
struct RTCPPacketXRReceiverReferenceTimeItem {
// RFC 3611 4.4
uint32_t NTPMostSignificant;
uint32_t NTPLeastSignificant;
};
struct RTCPPacketXRDLRRReportBlockItem {
// RFC 3611 4.5
uint32_t SSRC;
uint32_t LastRR;
uint32_t DelayLastRR;
};
struct RTCPPacketXRVOIPMetricItem {
// RFC 3611 4.7
uint32_t SSRC;
uint8_t lossRate;
uint8_t discardRate;
uint8_t burstDensity;
uint8_t gapDensity;
uint16_t burstDuration;
uint16_t gapDuration;
uint16_t roundTripDelay;
uint16_t endSystemDelay;
uint8_t signalLevel;
uint8_t noiseLevel;
uint8_t RERL;
uint8_t Gmin;
uint8_t Rfactor;
uint8_t extRfactor;
uint8_t MOSLQ;
uint8_t MOSCQ;
uint8_t RXconfig;
uint16_t JBnominal;
uint16_t JBmax;
uint16_t JBabsMax;
};
struct RTCPPacketRTPFBNACK
{
uint32_t SenderSSRC;
uint32_t MediaSSRC;
};
struct RTCPPacketRTPFBNACKItem
{
// RFC4585
uint16_t PacketID;
uint16_t BitMask;
};
struct RTCPPacketRTPFBNACK {
uint32_t SenderSSRC;
uint32_t MediaSSRC;
};
struct RTCPPacketRTPFBNACKItem {
// RFC4585
uint16_t PacketID;
uint16_t BitMask;
};
struct RTCPPacketRTPFBTMMBR
{
uint32_t SenderSSRC;
uint32_t MediaSSRC; // zero!
};
struct RTCPPacketRTPFBTMMBRItem
{
// RFC5104
uint32_t SSRC;
uint32_t MaxTotalMediaBitRate; // In Kbit/s
uint32_t MeasuredOverhead;
};
struct RTCPPacketRTPFBTMMBR {
uint32_t SenderSSRC;
uint32_t MediaSSRC; // zero!
};
struct RTCPPacketRTPFBTMMBRItem {
// RFC5104
uint32_t SSRC;
uint32_t MaxTotalMediaBitRate; // In Kbit/s
uint32_t MeasuredOverhead;
};
struct RTCPPacketRTPFBTMMBN
{
uint32_t SenderSSRC;
uint32_t MediaSSRC; // zero!
};
struct RTCPPacketRTPFBTMMBNItem
{
// RFC5104
uint32_t SSRC; // "Owner"
uint32_t MaxTotalMediaBitRate;
uint32_t MeasuredOverhead;
};
struct RTCPPacketRTPFBTMMBN {
uint32_t SenderSSRC;
uint32_t MediaSSRC; // zero!
};
struct RTCPPacketRTPFBTMMBNItem {
// RFC5104
uint32_t SSRC; // "Owner"
uint32_t MaxTotalMediaBitRate;
uint32_t MeasuredOverhead;
};
struct RTCPPacketPSFBFIR
{
uint32_t SenderSSRC;
uint32_t MediaSSRC; // zero!
};
struct RTCPPacketPSFBFIRItem
{
// RFC5104
uint32_t SSRC;
uint8_t CommandSequenceNumber;
};
struct RTCPPacketPSFBFIR {
uint32_t SenderSSRC;
uint32_t MediaSSRC; // zero!
};
struct RTCPPacketPSFBFIRItem {
// RFC5104
uint32_t SSRC;
uint8_t CommandSequenceNumber;
};
struct RTCPPacketPSFBPLI
{
// RFC4585
uint32_t SenderSSRC;
uint32_t MediaSSRC;
};
struct RTCPPacketPSFBPLI {
// RFC4585
uint32_t SenderSSRC;
uint32_t MediaSSRC;
};
struct RTCPPacketPSFBSLI
{
// RFC4585
uint32_t SenderSSRC;
uint32_t MediaSSRC;
};
struct RTCPPacketPSFBSLIItem
{
// RFC4585
uint16_t FirstMB;
uint16_t NumberOfMB;
uint8_t PictureId;
};
struct RTCPPacketPSFBRPSI
{
// RFC4585
uint32_t SenderSSRC;
uint32_t MediaSSRC;
uint8_t PayloadType;
uint16_t NumberOfValidBits;
uint8_t NativeBitString[RTCP_RPSI_DATA_SIZE];
};
struct RTCPPacketPSFBAPP
{
uint32_t SenderSSRC;
uint32_t MediaSSRC;
};
struct RTCPPacketPSFBREMBItem
{
uint32_t BitRate;
uint8_t NumberOfSSRCs;
uint32_t SSRCs[MAX_NUMBER_OF_REMB_FEEDBACK_SSRCS];
};
// generic name APP
struct RTCPPacketAPP
{
uint8_t SubType;
uint32_t Name;
uint8_t Data[kRtcpAppCode_DATA_SIZE];
uint16_t Size;
};
struct RTCPPacketPSFBSLI {
// RFC4585
uint32_t SenderSSRC;
uint32_t MediaSSRC;
};
struct RTCPPacketPSFBSLIItem {
// RFC4585
uint16_t FirstMB;
uint16_t NumberOfMB;
uint8_t PictureId;
};
struct RTCPPacketPSFBRPSI {
// RFC4585
uint32_t SenderSSRC;
uint32_t MediaSSRC;
uint8_t PayloadType;
uint16_t NumberOfValidBits;
uint8_t NativeBitString[RTCP_RPSI_DATA_SIZE];
};
struct RTCPPacketPSFBAPP {
uint32_t SenderSSRC;
uint32_t MediaSSRC;
};
struct RTCPPacketPSFBREMBItem {
uint32_t BitRate;
uint8_t NumberOfSSRCs;
uint32_t SSRCs[MAX_NUMBER_OF_REMB_FEEDBACK_SSRCS];
};
// generic name APP
struct RTCPPacketAPP {
uint8_t SubType;
uint32_t Name;
uint8_t Data[kRtcpAppCode_DATA_SIZE];
uint16_t Size;
};
union RTCPPacket
{
RTCPPacketRR RR;
RTCPPacketSR SR;
RTCPPacketReportBlockItem ReportBlockItem;
union RTCPPacket {
RTCPPacketRR RR;
RTCPPacketSR SR;
RTCPPacketReportBlockItem ReportBlockItem;
RTCPPacketSDESCName CName;
RTCPPacketBYE BYE;
RTCPPacketSDESCName CName;
RTCPPacketBYE BYE;
RTCPPacketExtendedJitterReportItem ExtendedJitterReportItem;
RTCPPacketExtendedJitterReportItem ExtendedJitterReportItem;
RTCPPacketRTPFBNACK NACK;
RTCPPacketRTPFBNACKItem NACKItem;
RTCPPacketRTPFBNACK NACK;
RTCPPacketRTPFBNACKItem NACKItem;
RTCPPacketPSFBPLI PLI;
RTCPPacketPSFBSLI SLI;
RTCPPacketPSFBSLIItem SLIItem;
RTCPPacketPSFBRPSI RPSI;
RTCPPacketPSFBAPP PSFBAPP;
RTCPPacketPSFBREMBItem REMBItem;
RTCPPacketPSFBPLI PLI;
RTCPPacketPSFBSLI SLI;
RTCPPacketPSFBSLIItem SLIItem;
RTCPPacketPSFBRPSI RPSI;
RTCPPacketPSFBAPP PSFBAPP;
RTCPPacketPSFBREMBItem REMBItem;
RTCPPacketRTPFBTMMBR TMMBR;
RTCPPacketRTPFBTMMBRItem TMMBRItem;
RTCPPacketRTPFBTMMBN TMMBN;
RTCPPacketRTPFBTMMBNItem TMMBNItem;
RTCPPacketPSFBFIR FIR;
RTCPPacketPSFBFIRItem FIRItem;
RTCPPacketRTPFBTMMBR TMMBR;
RTCPPacketRTPFBTMMBRItem TMMBRItem;
RTCPPacketRTPFBTMMBN TMMBN;
RTCPPacketRTPFBTMMBNItem TMMBNItem;
RTCPPacketPSFBFIR FIR;
RTCPPacketPSFBFIRItem FIRItem;
RTCPPacketXR XR;
RTCPPacketXRReceiverReferenceTimeItem XRReceiverReferenceTimeItem;
RTCPPacketXRDLRRReportBlockItem XRDLRRReportBlockItem;
RTCPPacketXRVOIPMetricItem XRVOIPMetricItem;
RTCPPacketXR XR;
RTCPPacketXRReceiverReferenceTimeItem XRReceiverReferenceTimeItem;
RTCPPacketXRDLRRReportBlockItem XRDLRRReportBlockItem;
RTCPPacketXRVOIPMetricItem XRVOIPMetricItem;
RTCPPacketAPP APP;
};
RTCPPacketAPP APP;
};
enum RTCPPacketTypes
{
kRtcpNotValidCode,
enum class RTCPPacketTypes {
kInvalid,
// RFC3550
kRtcpRrCode,
kRtcpSrCode,
kRtcpReportBlockItemCode,
// RFC3550
kRr,
kSr,
kReportBlockItem,
kRtcpSdesCode,
kRtcpSdesChunkCode,
kRtcpByeCode,
kSdes,
kSdesChunk,
kBye,
// RFC5450
kRtcpExtendedIjCode,
kRtcpExtendedIjItemCode,
// RFC5450
kExtendedIj,
kExtendedIjItem,
// RFC4585
kRtcpRtpfbNackCode,
kRtcpRtpfbNackItemCode,
// RFC4585
kRtpfbNack,
kRtpfbNackItem,
kRtcpPsfbPliCode,
kRtcpPsfbRpsiCode,
kRtcpPsfbSliCode,
kRtcpPsfbSliItemCode,
kRtcpPsfbAppCode,
kRtcpPsfbRembCode,
kRtcpPsfbRembItemCode,
kPsfbPli,
kPsfbRpsi,
kPsfbSli,
kPsfbSliItem,
kPsfbApp,
kPsfbRemb,
kPsfbRembItem,
// RFC5104
kRtcpRtpfbTmmbrCode,
kRtcpRtpfbTmmbrItemCode,
kRtcpRtpfbTmmbnCode,
kRtcpRtpfbTmmbnItemCode,
kRtcpPsfbFirCode,
kRtcpPsfbFirItemCode,
// RFC5104
kRtpfbTmmbr,
kRtpfbTmmbrItem,
kRtpfbTmmbn,
kRtpfbTmmbnItem,
kPsfbFir,
kPsfbFirItem,
// draft-perkins-avt-rapid-rtp-sync
kRtcpRtpfbSrReqCode,
// draft-perkins-avt-rapid-rtp-sync
kRtpfbSrReq,
// RFC 3611
kRtcpXrHeaderCode,
kRtcpXrReceiverReferenceTimeCode,
kRtcpXrDlrrReportBlockCode,
kRtcpXrDlrrReportBlockItemCode,
kRtcpXrVoipMetricCode,
// RFC 3611
kXrHeader,
kXrReceiverReferenceTime,
kXrDlrrReportBlock,
kXrDlrrReportBlockItem,
kXrVoipMetric,
kRtcpAppCode,
kRtcpAppItemCode,
};
kApp,
kAppItem,
};
struct RTCPRawPacket
{
const uint8_t* _ptrPacketBegin;
const uint8_t* _ptrPacketEnd;
};
struct RTCPRawPacket {
const uint8_t* _ptrPacketBegin;
const uint8_t* _ptrPacketEnd;
};
struct RTCPModRawPacket
{
uint8_t* _ptrPacketBegin;
uint8_t* _ptrPacketEnd;
};
struct RTCPModRawPacket {
uint8_t* _ptrPacketBegin;
uint8_t* _ptrPacketEnd;
};
struct RTCPCommonHeader
{
uint8_t V; // Version
bool P; // Padding
uint8_t IC; // Item count/subtype
uint8_t PT; // Packet Type
uint16_t LengthInOctets;
};
struct RTCPCommonHeader {
uint8_t V; // Version
bool P; // Padding
uint8_t IC; // Item count/subtype
uint8_t PT; // Packet Type
uint16_t LengthInOctets;
};
enum RTCPPT
{
PT_IJ = 195,
PT_SR = 200,
PT_RR = 201,
PT_SDES = 202,
PT_BYE = 203,
PT_APP = 204,
PT_RTPFB = 205,
PT_PSFB = 206,
PT_XR = 207
};
enum RTCPPT : uint8_t {
PT_IJ = 195,
PT_SR = 200,
PT_RR = 201,
PT_SDES = 202,
PT_BYE = 203,
PT_APP = 204,
PT_RTPFB = 205,
PT_PSFB = 206,
PT_XR = 207
};
// Extended report blocks, RFC 3611.
enum RtcpXrBlockType {
kBtReceiverReferenceTime = 4,
kBtDlrr = 5,
kBtVoipMetric = 7
};
// Extended report blocks, RFC 3611.
enum RtcpXrBlockType : uint8_t {
kBtReceiverReferenceTime = 4,
kBtDlrr = 5,
kBtVoipMetric = 7
};
bool RTCPParseCommonHeader( const uint8_t* ptrDataBegin,
const uint8_t* ptrDataEnd,
RTCPCommonHeader& parsedHeader);
bool RTCPParseCommonHeader(const uint8_t* ptrDataBegin,
const uint8_t* ptrDataEnd,
RTCPCommonHeader& parsedHeader);
class RTCPParserV2
{
public:
RTCPParserV2(const uint8_t* rtcpData,
size_t rtcpDataLength,
bool rtcpReducedSizeEnable); // Set to true, to allow non-compound RTCP!
~RTCPParserV2();
class RTCPParserV2 {
public:
RTCPParserV2(
const uint8_t* rtcpData,
size_t rtcpDataLength,
bool rtcpReducedSizeEnable); // Set to true, to allow non-compound RTCP!
~RTCPParserV2();
RTCPPacketTypes PacketType() const;
const RTCPPacket& Packet() const;
const RTCPRawPacket& RawPacket() const;
ptrdiff_t LengthLeft() const;
RTCPPacketTypes PacketType() const;
const RTCPPacket& Packet() const;
const RTCPRawPacket& RawPacket() const;
ptrdiff_t LengthLeft() const;
bool IsValid() const;
bool IsValid() const;
RTCPPacketTypes Begin();
RTCPPacketTypes Iterate();
RTCPPacketTypes Begin();
RTCPPacketTypes Iterate();
private:
enum ParseState
{
State_TopLevel, // Top level packet
State_ReportBlockItem, // SR/RR report block
State_SDESChunk, // SDES chunk
State_BYEItem, // BYE item
State_ExtendedJitterItem, // Extended jitter report item
State_RTPFB_NACKItem, // NACK FCI item
State_RTPFB_TMMBRItem, // TMMBR FCI item
State_RTPFB_TMMBNItem, // TMMBN FCI item
State_PSFB_SLIItem, // SLI FCI item
State_PSFB_RPSIItem, // RPSI FCI item
State_PSFB_FIRItem, // FIR FCI item
State_PSFB_AppItem, // Application specific FCI item
State_PSFB_REMBItem, // Application specific REMB item
State_XRItem,
State_XR_DLLRItem,
State_AppItem
};
private:
enum class ParseState {
State_TopLevel, // Top level packet
State_ReportBlockItem, // SR/RR report block
State_SDESChunk, // SDES chunk
State_BYEItem, // BYE item
State_ExtendedJitterItem, // Extended jitter report item
State_RTPFB_NACKItem, // NACK FCI item
State_RTPFB_TMMBRItem, // TMMBR FCI item
State_RTPFB_TMMBNItem, // TMMBN FCI item
State_PSFB_SLIItem, // SLI FCI item
State_PSFB_RPSIItem, // RPSI FCI item
State_PSFB_FIRItem, // FIR FCI item
State_PSFB_AppItem, // Application specific FCI item
State_PSFB_REMBItem, // Application specific REMB item
State_XRItem,
State_XR_DLLRItem,
State_AppItem
};
private:
void IterateTopLevel();
void IterateReportBlockItem();
void IterateSDESChunk();
void IterateBYEItem();
void IterateExtendedJitterItem();
void IterateNACKItem();
void IterateTMMBRItem();
void IterateTMMBNItem();
void IterateSLIItem();
void IterateRPSIItem();
void IterateFIRItem();
void IteratePsfbAppItem();
void IteratePsfbREMBItem();
void IterateAppItem();
void IterateXrItem();
void IterateXrDlrrItem();
private:
void IterateTopLevel();
void IterateReportBlockItem();
void IterateSDESChunk();
void IterateBYEItem();
void IterateExtendedJitterItem();
void IterateNACKItem();
void IterateTMMBRItem();
void IterateTMMBNItem();
void IterateSLIItem();
void IterateRPSIItem();
void IterateFIRItem();
void IteratePsfbAppItem();
void IteratePsfbREMBItem();
void IterateAppItem();
void IterateXrItem();
void IterateXrDlrrItem();
void Validate();
void EndCurrentBlock();
void Validate();
void EndCurrentBlock();
bool ParseRR();
bool ParseSR();
bool ParseReportBlockItem();
bool ParseRR();
bool ParseSR();
bool ParseReportBlockItem();
bool ParseSDES();
bool ParseSDESChunk();
bool ParseSDESItem();
bool ParseSDES();
bool ParseSDESChunk();
bool ParseSDESItem();
bool ParseBYE();
bool ParseBYEItem();
bool ParseBYE();
bool ParseBYEItem();
bool ParseIJ();
bool ParseIJItem();
bool ParseIJ();
bool ParseIJItem();
bool ParseXr();
bool ParseXrItem();
bool ParseXrReceiverReferenceTimeItem(int block_length_4bytes);
bool ParseXrDlrr(int block_length_4bytes);
bool ParseXrDlrrItem();
bool ParseXrVoipMetricItem(int block_length_4bytes);
bool ParseXrUnsupportedBlockType(int block_length_4bytes);
bool ParseXr();
bool ParseXrItem();
bool ParseXrReceiverReferenceTimeItem(int block_length_4bytes);
bool ParseXrDlrr(int block_length_4bytes);
bool ParseXrDlrrItem();
bool ParseXrVoipMetricItem(int block_length_4bytes);
bool ParseXrUnsupportedBlockType(int block_length_4bytes);
bool ParseFBCommon(const RTCPCommonHeader& header);
bool ParseNACKItem();
bool ParseTMMBRItem();
bool ParseTMMBNItem();
bool ParseSLIItem();
bool ParseRPSIItem();
bool ParseFIRItem();
bool ParsePsfbAppItem();
bool ParsePsfbREMBItem();
bool ParseFBCommon(const RTCPCommonHeader& header);
bool ParseNACKItem();
bool ParseTMMBRItem();
bool ParseTMMBNItem();
bool ParseSLIItem();
bool ParseRPSIItem();
bool ParseFIRItem();
bool ParsePsfbAppItem();
bool ParsePsfbREMBItem();
bool ParseAPP(const RTCPCommonHeader& header);
bool ParseAPPItem();
bool ParseAPP(const RTCPCommonHeader& header);
bool ParseAPPItem();
private:
const uint8_t* const _ptrRTCPDataBegin;
const bool _RTCPReducedSizeEnable;
const uint8_t* const _ptrRTCPDataEnd;
private:
const uint8_t* const _ptrRTCPDataBegin;
const bool _RTCPReducedSizeEnable;
const uint8_t* const _ptrRTCPDataEnd;
bool _validPacket;
const uint8_t* _ptrRTCPData;
const uint8_t* _ptrRTCPBlockEnd;
bool _validPacket;
const uint8_t* _ptrRTCPData;
const uint8_t* _ptrRTCPBlockEnd;
ParseState _state;
uint8_t _numberOfBlocks;
ParseState _state;
uint8_t _numberOfBlocks;
RTCPPacketTypes _packetType;
RTCPPacket _packet;
};
RTCPPacketTypes _packetType;
RTCPPacket _packet;
};
class RTCPPacketIterator
{
public:
RTCPPacketIterator(uint8_t* rtcpData,
size_t rtcpDataLength);
~RTCPPacketIterator();
class RTCPPacketIterator {
public:
RTCPPacketIterator(uint8_t* rtcpData, size_t rtcpDataLength);
~RTCPPacketIterator();
const RTCPCommonHeader* Begin();
const RTCPCommonHeader* Iterate();
const RTCPCommonHeader* Current();
const RTCPCommonHeader* Begin();
const RTCPCommonHeader* Iterate();
const RTCPCommonHeader* Current();
private:
uint8_t* const _ptrBegin;
uint8_t* const _ptrEnd;
private:
uint8_t* const _ptrBegin;
uint8_t* const _ptrEnd;
uint8_t* _ptrBlock;
uint8_t* _ptrBlock;
RTCPCommonHeader _header;
};
RTCPCommonHeader _header;
};
} // RTCPUtility
} // namespace webrtc
#endif // WEBRTC_MODULES_RTP_RTCP_SOURCE_RTCP_UTILITY_H_

11
webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.cc
View File

@@ -556,8 +556,15 @@ int32_t ModuleRtpRtcpImpl::ResetSendDataCountersRTP() {
// Force a send of an RTCP packet.
// Normal SR and RR are triggered via the process function.
int32_t ModuleRtpRtcpImpl::SendRTCP(uint32_t rtcp_packet_type) {
return rtcp_sender_.SendRTCP(GetFeedbackState(), rtcp_packet_type);
int32_t ModuleRtpRtcpImpl::SendRTCP(RTCPPacketType packet_type) {
return rtcp_sender_.SendRTCP(GetFeedbackState(), packet_type);
}
// Force a send of an RTCP packet.
// Normal SR and RR are triggered via the process function.
int32_t ModuleRtpRtcpImpl::SendCompoundRTCP(
const std::set<RTCPPacketType>& packet_types) {
return rtcp_sender_.SendCompoundRTCP(GetFeedbackState(), packet_types);
}
int32_t ModuleRtpRtcpImpl::SetRTCPApplicationSpecificData(

5
webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h
View File

@@ -161,7 +161,10 @@ class ModuleRtpRtcpImpl : public RtpRtcp {
// Force a send of an RTCP packet.
// Normal SR and RR are triggered via the process function.
int32_t SendRTCP(uint32_t rtcp_packet_type = kRtcpReport) override;
int32_t SendRTCP(RTCPPacketType rtcpPacketType) override;
int32_t SendCompoundRTCP(
const std::set<RTCPPacketType>& rtcpPacketTypes) override;
int32_t ResetSendDataCountersRTP() override;

5
webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl_unittest.cc
View File

@@ -373,7 +373,10 @@ TEST_F(RtpRtcpImplTest, RtcpPacketTypeCounter_FirAndPli) {
EXPECT_EQ(1U, sender_.RtcpReceived().fir_packets);
// Receive module sends a FIR and PLI.
EXPECT_EQ(0, receiver_.impl_->SendRTCP(kRtcpFir | kRtcpPli));
std::set<RTCPPacketType> packet_types;
packet_types.insert(kRtcpFir);
packet_types.insert(kRtcpPli);
EXPECT_EQ(0, receiver_.impl_->SendCompoundRTCP(packet_types));
EXPECT_EQ(2U, receiver_.RtcpSent().fir_packets);
EXPECT_EQ(1U, receiver_.RtcpSent().pli_packets);
// Send module receives the FIR and PLI.

63
webrtc/test/rtcp_packet_parser.cc
View File

@@ -15,6 +15,8 @@
namespace webrtc {
namespace test {
using namespace RTCPUtility;
RtcpPacketParser::RtcpPacketParser() {}
RtcpPacketParser::~RtcpPacketParser() {}
@@ -24,98 +26,97 @@ void RtcpPacketParser::Parse(const void *data, size_t len) {
RTCPUtility::RTCPParserV2 parser(packet, len, true);
EXPECT_TRUE(parser.IsValid());
for (RTCPUtility::RTCPPacketTypes type = parser.Begin();
type != RTCPUtility::kRtcpNotValidCode;
type = parser.Iterate()) {
type != RTCPPacketTypes::kInvalid; type = parser.Iterate()) {
switch (type) {
case RTCPUtility::kRtcpSrCode:
case RTCPPacketTypes::kSr:
sender_report_.Set(parser.Packet().SR);
break;
case RTCPUtility::kRtcpRrCode:
case RTCPPacketTypes::kRr:
receiver_report_.Set(parser.Packet().RR);
break;
case RTCPUtility::kRtcpReportBlockItemCode:
case RTCPPacketTypes::kReportBlockItem:
report_block_.Set(parser.Packet().ReportBlockItem);
++report_blocks_per_ssrc_[parser.Packet().ReportBlockItem.SSRC];
break;
case RTCPUtility::kRtcpSdesCode:
case RTCPPacketTypes::kSdes:
sdes_.Set();
break;
case RTCPUtility::kRtcpSdesChunkCode:
case RTCPPacketTypes::kSdesChunk:
sdes_chunk_.Set(parser.Packet().CName);
break;
case RTCPUtility::kRtcpByeCode:
case RTCPPacketTypes::kBye:
bye_.Set(parser.Packet().BYE);
break;
case RTCPUtility::kRtcpAppCode:
case RTCPPacketTypes::kApp:
app_.Set(parser.Packet().APP);
break;
case RTCPUtility::kRtcpAppItemCode:
case RTCPPacketTypes::kAppItem:
app_item_.Set(parser.Packet().APP);
break;
case RTCPUtility::kRtcpExtendedIjCode:
case RTCPPacketTypes::kExtendedIj:
ij_.Set();
break;
case RTCPUtility::kRtcpExtendedIjItemCode:
case RTCPPacketTypes::kExtendedIjItem:
ij_item_.Set(parser.Packet().ExtendedJitterReportItem);
break;
case RTCPUtility::kRtcpPsfbPliCode:
case RTCPPacketTypes::kPsfbPli:
pli_.Set(parser.Packet().PLI);
break;
case RTCPUtility::kRtcpPsfbSliCode:
case RTCPPacketTypes::kPsfbSli:
sli_.Set(parser.Packet().SLI);
break;
case RTCPUtility::kRtcpPsfbSliItemCode:
case RTCPPacketTypes::kPsfbSliItem:
sli_item_.Set(parser.Packet().SLIItem);
break;
case RTCPUtility::kRtcpPsfbRpsiCode:
case RTCPPacketTypes::kPsfbRpsi:
rpsi_.Set(parser.Packet().RPSI);
break;
case RTCPUtility::kRtcpPsfbFirCode:
case RTCPPacketTypes::kPsfbFir:
fir_.Set(parser.Packet().FIR);
break;
case RTCPUtility::kRtcpPsfbFirItemCode:
case RTCPPacketTypes::kPsfbFirItem:
fir_item_.Set(parser.Packet().FIRItem);
break;
case RTCPUtility::kRtcpRtpfbNackCode:
case RTCPPacketTypes::kRtpfbNack:
nack_.Set(parser.Packet().NACK);
nack_item_.Clear();
break;
case RTCPUtility::kRtcpRtpfbNackItemCode:
case RTCPPacketTypes::kRtpfbNackItem:
nack_item_.Set(parser.Packet().NACKItem);
break;
case RTCPUtility::kRtcpPsfbAppCode:
case RTCPPacketTypes::kPsfbApp:
psfb_app_.Set(parser.Packet().PSFBAPP);
break;
case RTCPUtility::kRtcpPsfbRembItemCode:
case RTCPPacketTypes::kPsfbRembItem:
remb_item_.Set(parser.Packet().REMBItem);
break;
case RTCPUtility::kRtcpRtpfbTmmbrCode:
case RTCPPacketTypes::kRtpfbTmmbr:
tmmbr_.Set(parser.Packet().TMMBR);
break;
case RTCPUtility::kRtcpRtpfbTmmbrItemCode:
case RTCPPacketTypes::kRtpfbTmmbrItem:
tmmbr_item_.Set(parser.Packet().TMMBRItem);
break;
case RTCPUtility::kRtcpRtpfbTmmbnCode:
case RTCPPacketTypes::kRtpfbTmmbn:
tmmbn_.Set(parser.Packet().TMMBN);
tmmbn_items_.Clear();
break;
case RTCPUtility::kRtcpRtpfbTmmbnItemCode:
case RTCPPacketTypes::kRtpfbTmmbnItem:
tmmbn_items_.Set(parser.Packet().TMMBNItem);
break;
case RTCPUtility::kRtcpXrHeaderCode:
case RTCPPacketTypes::kXrHeader:
xr_header_.Set(parser.Packet().XR);
dlrr_items_.Clear();
break;
case RTCPUtility::kRtcpXrReceiverReferenceTimeCode:
case RTCPPacketTypes::kXrReceiverReferenceTime:
rrtr_.Set(parser.Packet().XRReceiverReferenceTimeItem);
break;
case RTCPUtility::kRtcpXrDlrrReportBlockCode:
case RTCPPacketTypes::kXrDlrrReportBlock:
dlrr_.Set();
break;
case RTCPUtility::kRtcpXrDlrrReportBlockItemCode:
case RTCPPacketTypes::kXrDlrrReportBlockItem:
dlrr_items_.Set(parser.Packet().XRDLRRReportBlockItem);
break;
case RTCPUtility::kRtcpXrVoipMetricCode:
case RTCPPacketTypes::kXrVoipMetric:
voip_metric_.Set(parser.Packet().XRVOIPMetricItem);
break;
default:

4
webrtc/video/call_perf_tests.cc
View File

@@ -66,9 +66,9 @@ class SyncRtcpObserver : public test::RtpRtcpObserver {
EXPECT_TRUE(parser.IsValid());
for (RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
packet_type != RTCPUtility::kRtcpNotValidCode;
packet_type != RTCPUtility::RTCPPacketTypes::kInvalid;
packet_type = parser.Iterate()) {
if (packet_type == RTCPUtility::kRtcpSrCode) {
if (packet_type == RTCPUtility::RTCPPacketTypes::kSr) {
const RTCPUtility::RTCPPacket& packet = parser.Packet();
RtcpMeasurement ntp_rtp_pair(
packet.SR.NTPMostSignificant,

43
webrtc/video/end_to_end_tests.cc
View File

@@ -418,8 +418,8 @@ TEST_F(EndToEndTest, ReceivesAndRetransmitsNack) {
EXPECT_TRUE(parser.IsValid());
RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
while (packet_type != RTCPUtility::kRtcpNotValidCode) {
if (packet_type == RTCPUtility::kRtcpRtpfbNackCode) {
while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
if (packet_type == RTCPUtility::RTCPPacketTypes::kRtpfbNack) {
--nacks_left_;
break;
}
@@ -929,12 +929,12 @@ void EndToEndTest::ReceivesPliAndRecovers(int rtp_history_ms) {
EXPECT_TRUE(parser.IsValid());
for (RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
packet_type != RTCPUtility::kRtcpNotValidCode;
packet_type != RTCPUtility::RTCPPacketTypes::kInvalid;
packet_type = parser.Iterate()) {
if (!nack_enabled_)
EXPECT_NE(packet_type, RTCPUtility::kRtcpRtpfbNackCode);
EXPECT_NE(packet_type, RTCPUtility::RTCPPacketTypes::kRtpfbNack);
if (packet_type == RTCPUtility::kRtcpPsfbPliCode) {
if (packet_type == RTCPUtility::RTCPPacketTypes::kPsfbPli) {
received_pli_ = true;
break;
}
@@ -1070,9 +1070,9 @@ void EndToEndTest::RespectsRtcpMode(newapi::RtcpMode rtcp_mode) {
RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
bool has_report_block = false;
while (packet_type != RTCPUtility::kRtcpNotValidCode) {
EXPECT_NE(RTCPUtility::kRtcpSrCode, packet_type);
if (packet_type == RTCPUtility::kRtcpRrCode) {
while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
EXPECT_NE(RTCPUtility::RTCPPacketTypes::kSr, packet_type);
if (packet_type == RTCPUtility::RTCPPacketTypes::kRr) {
has_report_block = true;
break;
}
@@ -1336,12 +1336,12 @@ TEST_F(EndToEndTest, ReceiveStreamSendsRemb) {
bool received_psfb = false;
bool received_remb = false;
RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
while (packet_type != RTCPUtility::kRtcpNotValidCode) {
if (packet_type == RTCPUtility::kRtcpPsfbRembCode) {
while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
if (packet_type == RTCPUtility::RTCPPacketTypes::kPsfbRemb) {
const RTCPUtility::RTCPPacket& packet = parser.Packet();
EXPECT_EQ(packet.PSFBAPP.SenderSSRC, kReceiverLocalSsrc);
received_psfb = true;
} else if (packet_type == RTCPUtility::kRtcpPsfbRembItemCode) {
} else if (packet_type == RTCPUtility::RTCPPacketTypes::kPsfbRembItem) {
const RTCPUtility::RTCPPacket& packet = parser.Packet();
EXPECT_GT(packet.REMBItem.BitRate, 0u);
EXPECT_EQ(packet.REMBItem.NumberOfSSRCs, 1u);
@@ -1700,15 +1700,16 @@ void EndToEndTest::TestXrReceiverReferenceTimeReport(bool enable_rrtr) {
EXPECT_TRUE(parser.IsValid());
RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
while (packet_type != RTCPUtility::kRtcpNotValidCode) {
if (packet_type == RTCPUtility::kRtcpRrCode) {
while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
if (packet_type == RTCPUtility::RTCPPacketTypes::kRr) {
++sent_rtcp_rr_;
} else if (packet_type ==
RTCPUtility::kRtcpXrReceiverReferenceTimeCode) {
RTCPUtility::RTCPPacketTypes::kXrReceiverReferenceTime) {
++sent_rtcp_rrtr_;
}
EXPECT_NE(packet_type, RTCPUtility::kRtcpSrCode);
EXPECT_NE(packet_type, RTCPUtility::kRtcpXrDlrrReportBlockItemCode);
EXPECT_NE(packet_type, RTCPUtility::RTCPPacketTypes::kSr);
EXPECT_NE(packet_type,
RTCPUtility::RTCPPacketTypes::kXrDlrrReportBlockItem);
packet_type = parser.Iterate();
}
return SEND_PACKET;
@@ -1719,13 +1720,15 @@ void EndToEndTest::TestXrReceiverReferenceTimeReport(bool enable_rrtr) {
EXPECT_TRUE(parser.IsValid());
RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
while (packet_type != RTCPUtility::kRtcpNotValidCode) {
if (packet_type == RTCPUtility::kRtcpSrCode) {
while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
if (packet_type == RTCPUtility::RTCPPacketTypes::kSr) {
++sent_rtcp_sr_;
} else if (packet_type == RTCPUtility::kRtcpXrDlrrReportBlockItemCode) {
} else if (packet_type ==
RTCPUtility::RTCPPacketTypes::kXrDlrrReportBlockItem) {
++sent_rtcp_dlrr_;
}
EXPECT_NE(packet_type, RTCPUtility::kRtcpXrReceiverReferenceTimeCode);
EXPECT_NE(packet_type,
RTCPUtility::RTCPPacketTypes::kXrReceiverReferenceTime);
packet_type = parser.Iterate();
}
if (sent_rtcp_sr_ > kNumRtcpReportPacketsToObserve &&

8
webrtc/video/video_send_stream_tests.cc
View File

@@ -104,8 +104,8 @@ TEST_F(VideoSendStreamTest, SupportsCName) {
EXPECT_TRUE(parser.IsValid());
RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
while (packet_type != RTCPUtility::kRtcpNotValidCode) {
if (packet_type == RTCPUtility::kRtcpSdesChunkCode) {
while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
if (packet_type == RTCPUtility::RTCPPacketTypes::kSdesChunk) {
EXPECT_EQ(parser.Packet().CName.CName, kCName);
observation_complete_->Set();
}
@@ -1514,8 +1514,8 @@ TEST_F(VideoSendStreamTest, RtcpSenderReportContainsMediaBytesSent) {
EXPECT_TRUE(parser.IsValid());
RTCPUtility::RTCPPacketTypes packet_type = parser.Begin();
while (packet_type != RTCPUtility::kRtcpNotValidCode) {
if (packet_type == RTCPUtility::kRtcpSrCode) {
while (packet_type != RTCPUtility::RTCPPacketTypes::kInvalid) {
if (packet_type == RTCPUtility::RTCPPacketTypes::kSr) {
// Only compare sent media bytes if SenderPacketCount matches the
// number of sent rtp packets (a new rtp packet could be sent before
// the rtcp packet).