zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Replace rtcp packet parsing in the RtcpReceiver.

Browse Source 
BUG=webrtc:5260

Review-Url: https://codereview.webrtc.org/2316093002
Cr-Commit-Position: refs/heads/master@{#14301}
This commit is contained in:
danilchap
2016-09-20 01:39:54 -07:00
committed by Commit bot
parent 61a208b1b8
commit 1b1863a11a
5 changed files with 341 additions and 405 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.h
View File

@ -50,9 +50,8 @@ class Tmmbr : public Rtpfb {
TmmbItem::kLength * items_.size(); TmmbItem::kLength * items_.size();
} }
// Media ssrc is unused, shadow base class setter and getter. // Media ssrc is unused, shadow base class setter.
void To(uint32_t ssrc); void To(uint32_t ssrc);
uint32_t media_ssrc() const;
std::vector<TmmbItem> items_; std::vector<TmmbItem> items_;

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

@ -18,6 +18,22 @@
#include "webrtc/base/checks.h" #include "webrtc/base/checks.h"
#include "webrtc/base/logging.h" #include "webrtc/base/logging.h"
#include "webrtc/base/trace_event.h" #include "webrtc/base/trace_event.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/common_header.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/compound_packet.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/fir.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/pli.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/rpsi.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sli.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h" #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
#include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h" #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
#include "webrtc/modules/rtp_rtcp/source/time_util.h" #include "webrtc/modules/rtp_rtcp/source/time_util.h"
@ -25,10 +41,13 @@
#include "webrtc/system_wrappers/include/ntp_time.h" #include "webrtc/system_wrappers/include/ntp_time.h"
namespace webrtc { namespace webrtc {
namespace {
using rtcp::CommonHeader;
using rtcp::ReportBlock;
using RTCPHelp::RTCPPacketInformation; using RTCPHelp::RTCPPacketInformation;
using RTCPHelp::RTCPReceiveInformation; using RTCPHelp::RTCPReceiveInformation;
using RTCPHelp::RTCPReportBlockInformation; using RTCPHelp::RTCPReportBlockInformation;
using RTCPUtility::kBtVoipMetric;
using RTCPUtility::RTCPCnameInformation; using RTCPUtility::RTCPCnameInformation;
using RTCPUtility::RTCPPacketReportBlockItem; using RTCPUtility::RTCPPacketReportBlockItem;
using RTCPUtility::RTCPPacketTypes; using RTCPUtility::RTCPPacketTypes;
@ -38,6 +57,8 @@ const int kRrTimeoutIntervals = 3;
const int64_t kMaxWarningLogIntervalMs = 10000; const int64_t kMaxWarningLogIntervalMs = 10000;
} // namespace
RTCPReceiver::RTCPReceiver( RTCPReceiver::RTCPReceiver(
Clock* clock, Clock* clock,
bool receiver_only, bool receiver_only,
@ -48,7 +69,6 @@ RTCPReceiver::RTCPReceiver(
ModuleRtpRtcp* owner) ModuleRtpRtcp* owner)
: _clock(clock), : _clock(clock),
receiver_only_(receiver_only), receiver_only_(receiver_only),
_lastReceived(0),
_rtpRtcp(*owner), _rtpRtcp(*owner),
_cbRtcpBandwidthObserver(rtcp_bandwidth_observer), _cbRtcpBandwidthObserver(rtcp_bandwidth_observer),
_cbRtcpIntraFrameObserver(rtcp_intra_frame_observer), _cbRtcpIntraFrameObserver(rtcp_intra_frame_observer),
@ -97,22 +117,16 @@ RTCPReceiver::~RTCPReceiver() {
} }
bool RTCPReceiver::IncomingPacket(const uint8_t* packet, size_t packet_size) { bool RTCPReceiver::IncomingPacket(const uint8_t* packet, size_t packet_size) {
// Allow receive of non-compound RTCP packets. if (packet_size == 0) {
RTCPUtility::RTCPParserV2 rtcp_parser(packet, packet_size, true); LOG(LS_WARNING) << "Incoming empty RTCP packet";
if (!rtcp_parser.IsValid()) {
LOG(LS_WARNING) << "Incoming invalid RTCP packet";
return false; return false;
} }
RTCPHelp::RTCPPacketInformation rtcp_packet_information;
IncomingRTCPPacket(rtcp_packet_information, &rtcp_parser);
TriggerCallbacksFromRTCPPacket(rtcp_packet_information);
return true;
}
int64_t RTCPReceiver::LastReceived() { RTCPHelp::RTCPPacketInformation packet_information;
rtc::CritScope lock(&_criticalSectionRTCPReceiver); if (!ParseCompoundPacket(packet, packet + packet_size, &packet_information))
return _lastReceived; return false;
TriggerCallbacksFromRTCPPacket(packet_information);
return true;
} }
int64_t RTCPReceiver::LastReceivedReceiverReport() const { int64_t RTCPReceiver::LastReceivedReceiverReport() const {
@ -282,78 +296,94 @@ int32_t RTCPReceiver::StatisticsReceived(
return 0; return 0;
} }
int32_t RTCPReceiver::IncomingRTCPPacket( bool RTCPReceiver::ParseCompoundPacket(
RTCPPacketInformation& rtcpPacketInformation, const uint8_t* packet_begin,
RTCPUtility::RTCPParserV2* rtcpParser) { const uint8_t* packet_end,
RTCPPacketInformation* packet_information) {
rtc::CritScope lock(&_criticalSectionRTCPReceiver); rtc::CritScope lock(&_criticalSectionRTCPReceiver);
_lastReceived = _clock->TimeInMilliseconds(); CommonHeader rtcp_block;
for (const uint8_t* next_block = packet_begin; next_block != packet_end;
next_block = rtcp_block.NextPacket()) {
ptrdiff_t remaining_blocks_size = packet_end - next_block;
RTC_DCHECK_GT(remaining_blocks_size, 0);
if (!rtcp_block.Parse(next_block, remaining_blocks_size)) {
if (next_block == packet_begin) {
// Failed to parse 1st header, nothing was extracted from this packet.
LOG(LS_WARNING) << "Incoming invalid RTCP packet";
return false;
}
++num_skipped_packets_;
break;
}
if (packet_type_counter_.first_packet_time_ms == -1) { if (packet_type_counter_.first_packet_time_ms == -1)
packet_type_counter_.first_packet_time_ms = _lastReceived; packet_type_counter_.first_packet_time_ms = _clock->TimeInMilliseconds();
}
RTCPUtility::RTCPPacketTypes pktType = rtcpParser->Begin(); switch (rtcp_block.type()) {
while (pktType != RTCPPacketTypes::kInvalid) { case rtcp::SenderReport::kPacketType:
// Each "case" is responsible for iterate the parser to the HandleSenderReport(rtcp_block, *packet_information);
// next top level packet.
switch (pktType) {
case RTCPPacketTypes::kSr:
HandleSenderReport(*rtcpParser, rtcpPacketInformation);
break; break;
case RTCPPacketTypes::kRr: case rtcp::ReceiverReport::kPacketType:
HandleReceiverReport(*rtcpParser, rtcpPacketInformation); HandleReceiverReport(rtcp_block, *packet_information);
break; break;
case RTCPPacketTypes::kSdes: case rtcp::Sdes::kPacketType:
HandleSDES(*rtcpParser, rtcpPacketInformation); HandleSDES(rtcp_block, *packet_information);
break; break;
case RTCPPacketTypes::kXrHeader: case rtcp::ExtendedReports::kPacketType:
HandleXrHeader(*rtcpParser, rtcpPacketInformation); HandleXr(rtcp_block, *packet_information);
break; break;
case RTCPPacketTypes::kXrReceiverReferenceTime: case rtcp::Bye::kPacketType:
HandleXrReceiveReferenceTime(*rtcpParser, rtcpPacketInformation); HandleBYE(rtcp_block);
break; break;
case RTCPPacketTypes::kXrDlrrReportBlock: case rtcp::Rtpfb::kPacketType:
HandleXrDlrrReportBlock(*rtcpParser, rtcpPacketInformation); switch (rtcp_block.fmt()) {
case rtcp::Nack::kFeedbackMessageType:
HandleNACK(rtcp_block, *packet_information);
break;
case rtcp::Tmmbr::kFeedbackMessageType:
HandleTMMBR(rtcp_block, *packet_information);
break;
case rtcp::Tmmbn::kFeedbackMessageType:
HandleTMMBN(rtcp_block, *packet_information);
break;
case rtcp::RapidResyncRequest::kFeedbackMessageType:
HandleSR_REQ(rtcp_block, *packet_information);
break;
case rtcp::TransportFeedback::kFeedbackMessageType:
HandleTransportFeedback(rtcp_block, packet_information);
break;
default:
++num_skipped_packets_;
break;
}
break; break;
case RTCPPacketTypes::kBye: case rtcp::Psfb::kPacketType:
HandleBYE(*rtcpParser); switch (rtcp_block.fmt()) {
break; case rtcp::Pli::kFeedbackMessageType:
case RTCPPacketTypes::kRtpfbNack: HandlePLI(rtcp_block, *packet_information);
HandleNACK(*rtcpParser, rtcpPacketInformation); break;
break; case rtcp::Sli::kFeedbackMessageType:
case RTCPPacketTypes::kRtpfbTmmbr: HandleSLI(rtcp_block, *packet_information);
HandleTMMBR(*rtcpParser, rtcpPacketInformation); break;
break; case rtcp::Rpsi::kFeedbackMessageType:
case RTCPPacketTypes::kRtpfbTmmbn: HandleRPSI(rtcp_block, *packet_information);
HandleTMMBN(*rtcpParser, rtcpPacketInformation); break;
break; case rtcp::Fir::kFeedbackMessageType:
case RTCPPacketTypes::kRtpfbSrReq: HandleFIR(rtcp_block, *packet_information);
HandleSR_REQ(*rtcpParser, rtcpPacketInformation); break;
break; case rtcp::Remb::kFeedbackMessageType:
case RTCPPacketTypes::kPsfbPli: HandlePsfbApp(rtcp_block, *packet_information);
HandlePLI(*rtcpParser, rtcpPacketInformation); break;
break; default:
case RTCPPacketTypes::kPsfbSli: ++num_skipped_packets_;
HandleSLI(*rtcpParser, rtcpPacketInformation); break;
break; }
case RTCPPacketTypes::kPsfbRpsi:
HandleRPSI(*rtcpParser, rtcpPacketInformation);
break;
case RTCPPacketTypes::kPsfbFir:
HandleFIR(*rtcpParser, rtcpPacketInformation);
break;
case RTCPPacketTypes::kPsfbApp:
HandlePsfbApp(*rtcpParser, rtcpPacketInformation);
break;
case RTCPPacketTypes::kTransportFeedback:
HandleTransportFeedback(rtcpParser, &rtcpPacketInformation);
break; break;
default: default:
rtcpParser->Iterate(); ++num_skipped_packets_;
break; break;
} }
pktType = rtcpParser->PacketType();
} }
if (packet_type_counter_observer_ != NULL) { if (packet_type_counter_observer_ != NULL) {
@ -361,8 +391,6 @@ int32_t RTCPReceiver::IncomingRTCPPacket(
main_ssrc_, packet_type_counter_); main_ssrc_, packet_type_counter_);
} }
num_skipped_packets_ += rtcpParser->NumSkippedBlocks();
int64_t now = _clock->TimeInMilliseconds(); int64_t now = _clock->TimeInMilliseconds();
if (now - last_skipped_packets_warning_ >= kMaxWarningLogIntervalMs && if (now - last_skipped_packets_warning_ >= kMaxWarningLogIntervalMs &&
num_skipped_packets_ > 0) { num_skipped_packets_ > 0) {
@ -373,29 +401,25 @@ int32_t RTCPReceiver::IncomingRTCPPacket(
<< (kMaxWarningLogIntervalMs / 1000) << " second period."; << (kMaxWarningLogIntervalMs / 1000) << " second period.";
} }
return 0; return true;
} }
void RTCPReceiver::HandleSenderReport( void RTCPReceiver::HandleSenderReport(
RTCPUtility::RTCPParserV2& rtcpParser, const CommonHeader& rtcp_block,
RTCPPacketInformation& rtcpPacketInformation) { RTCPPacketInformation& rtcpPacketInformation) {
RTCPUtility::RTCPPacketTypes rtcpPacketType = rtcpParser.PacketType(); rtcp::SenderReport sender_report;
const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet(); if (!sender_report.Parse(rtcp_block)) {
++num_skipped_packets_;
return;
}
RTC_DCHECK(rtcpPacketType == RTCPPacketTypes::kSr); const uint32_t remoteSSRC = sender_report.sender_ssrc();
// SR.SenderSSRC
// The synchronization source identifier for the originator of this SR packet
const uint32_t remoteSSRC = rtcpPacket.SR.SenderSSRC;
rtcpPacketInformation.remoteSSRC = remoteSSRC; rtcpPacketInformation.remoteSSRC = remoteSSRC;
RTCPReceiveInformation* ptrReceiveInfo = CreateReceiveInformation(remoteSSRC); RTCPReceiveInformation* ptrReceiveInfo = CreateReceiveInformation(remoteSSRC);
if (!ptrReceiveInfo) { if (!ptrReceiveInfo)
rtcpParser.Iterate();
return; return;
}
TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "SR", TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "SR",
"remote_ssrc", remoteSSRC, "ssrc", main_ssrc_); "remote_ssrc", remoteSSRC, "ssrc", main_ssrc_);
@ -405,16 +429,16 @@ void RTCPReceiver::HandleSenderReport(
// Only signal that we have received a SR when we accept one. // Only signal that we have received a SR when we accept one.
rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSr; rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSr;
rtcpPacketInformation.ntp_secs = rtcpPacket.SR.NTPMostSignificant; rtcpPacketInformation.ntp_secs = sender_report.ntp().seconds();
rtcpPacketInformation.ntp_frac = rtcpPacket.SR.NTPLeastSignificant; rtcpPacketInformation.ntp_frac = sender_report.ntp().fractions();
rtcpPacketInformation.rtp_timestamp = rtcpPacket.SR.RTPTimestamp; rtcpPacketInformation.rtp_timestamp = sender_report.rtp_timestamp();
// Save the NTP time of this report. // Save the NTP time of this report.
_remoteSenderInfo.NTPseconds = rtcpPacket.SR.NTPMostSignificant; _remoteSenderInfo.NTPseconds = sender_report.ntp().seconds();
_remoteSenderInfo.NTPfraction = rtcpPacket.SR.NTPLeastSignificant; _remoteSenderInfo.NTPfraction = sender_report.ntp().fractions();
_remoteSenderInfo.RTPtimeStamp = rtcpPacket.SR.RTPTimestamp; _remoteSenderInfo.RTPtimeStamp = sender_report.rtp_timestamp();
_remoteSenderInfo.sendPacketCount = rtcpPacket.SR.SenderPacketCount; _remoteSenderInfo.sendPacketCount = sender_report.sender_packet_count();
_remoteSenderInfo.sendOctetCount = rtcpPacket.SR.SenderOctetCount; _remoteSenderInfo.sendOctetCount = sender_report.sender_octet_count();
_clock->CurrentNtp(_lastReceivedSRNTPsecs, _lastReceivedSRNTPfrac); _clock->CurrentNtp(_lastReceivedSRNTPsecs, _lastReceivedSRNTPfrac);
} else { } else {
@ -425,33 +449,26 @@ void RTCPReceiver::HandleSenderReport(
// Update that this remote is alive. // Update that this remote is alive.
ptrReceiveInfo->last_time_received_ms = _clock->TimeInMilliseconds(); ptrReceiveInfo->last_time_received_ms = _clock->TimeInMilliseconds();
rtcpPacketType = rtcpParser.Iterate(); for (const rtcp::ReportBlock report_block : sender_report.report_blocks())
HandleReportBlock(report_block, rtcpPacketInformation, remoteSSRC);
while (rtcpPacketType == RTCPPacketTypes::kReportBlockItem) {
HandleReportBlock(rtcpPacket, rtcpPacketInformation, remoteSSRC);
rtcpPacketType = rtcpParser.Iterate();
}
} }
void RTCPReceiver::HandleReceiverReport( void RTCPReceiver::HandleReceiverReport(
RTCPUtility::RTCPParserV2& rtcpParser, const CommonHeader& rtcp_block,
RTCPPacketInformation& rtcpPacketInformation) { RTCPPacketInformation& rtcpPacketInformation) {
RTCPUtility::RTCPPacketTypes rtcpPacketType = rtcpParser.PacketType(); rtcp::ReceiverReport receiver_report;
const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet(); if (!receiver_report.Parse(rtcp_block)) {
++num_skipped_packets_;
return;
}
RTC_DCHECK(rtcpPacketType == RTCPPacketTypes::kRr); const uint32_t remoteSSRC = receiver_report.sender_ssrc();
// rtcpPacket.RR.SenderSSRC
// The source of the packet sender, same as of SR? or is this a CE?
const uint32_t remoteSSRC = rtcpPacket.RR.SenderSSRC;
rtcpPacketInformation.remoteSSRC = remoteSSRC; rtcpPacketInformation.remoteSSRC = remoteSSRC;
RTCPReceiveInformation* ptrReceiveInfo = CreateReceiveInformation(remoteSSRC); RTCPReceiveInformation* ptrReceiveInfo = CreateReceiveInformation(remoteSSRC);
if (!ptrReceiveInfo) { if (!ptrReceiveInfo)
rtcpParser.Iterate();
return; return;
}
TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RR", TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RR",
"remote_ssrc", remoteSSRC, "ssrc", main_ssrc_); "remote_ssrc", remoteSSRC, "ssrc", main_ssrc_);
@ -461,19 +478,14 @@ void RTCPReceiver::HandleReceiverReport(
// Update that this remote is alive. // Update that this remote is alive.
ptrReceiveInfo->last_time_received_ms = _clock->TimeInMilliseconds(); ptrReceiveInfo->last_time_received_ms = _clock->TimeInMilliseconds();
rtcpPacketType = rtcpParser.Iterate(); for (const ReportBlock& report_block : receiver_report.report_blocks())
HandleReportBlock(report_block, rtcpPacketInformation, remoteSSRC);
while (rtcpPacketType == RTCPPacketTypes::kReportBlockItem) {
HandleReportBlock(rtcpPacket, rtcpPacketInformation, remoteSSRC);
rtcpPacketType = rtcpParser.Iterate();
}
} }
void RTCPReceiver::HandleReportBlock( void RTCPReceiver::HandleReportBlock(
const RTCPUtility::RTCPPacket& rtcpPacket, const ReportBlock& report_block,
RTCPPacketInformation& rtcpPacketInformation, RTCPPacketInformation& rtcpPacketInformation,
uint32_t remoteSSRC) uint32_t remoteSSRC) {
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver) {
// This will be called once per report block in the RTCP packet. // This will be called once per report block in the RTCP packet.
// We filter out all report blocks that are not for us. // We filter out all report blocks that are not for us.
// Each packet has max 31 RR blocks. // Each packet has max 31 RR blocks.
@ -484,14 +496,11 @@ void RTCPReceiver::HandleReportBlock(
// which the information in this reception report block pertains. // which the information in this reception report block pertains.
// Filter out all report blocks that are not for us. // Filter out all report blocks that are not for us.
if (registered_ssrcs_.find(rtcpPacket.ReportBlockItem.SSRC) == if (registered_ssrcs_.count(report_block.source_ssrc()) == 0)
registered_ssrcs_.end()) {
// This block is not for us ignore it.
return; return;
}
RTCPReportBlockInformation* reportBlock = CreateOrGetReportBlockInformation( RTCPReportBlockInformation* reportBlock =
remoteSSRC, rtcpPacket.ReportBlockItem.SSRC); CreateOrGetReportBlockInformation(remoteSSRC, report_block.source_ssrc());
if (reportBlock == NULL) { if (reportBlock == NULL) {
LOG(LS_WARNING) << "Failed to CreateReportBlockInformation(" << remoteSSRC LOG(LS_WARNING) << "Failed to CreateReportBlockInformation(" << remoteSSRC
<< ")"; << ")";
@ -499,36 +508,35 @@ void RTCPReceiver::HandleReportBlock(
} }
_lastReceivedRrMs = _clock->TimeInMilliseconds(); _lastReceivedRrMs = _clock->TimeInMilliseconds();
const RTCPPacketReportBlockItem& rb = rtcpPacket.ReportBlockItem;
reportBlock->remoteReceiveBlock.remoteSSRC = remoteSSRC; reportBlock->remoteReceiveBlock.remoteSSRC = remoteSSRC;
reportBlock->remoteReceiveBlock.sourceSSRC = rb.SSRC; reportBlock->remoteReceiveBlock.sourceSSRC = report_block.source_ssrc();
reportBlock->remoteReceiveBlock.fractionLost = rb.FractionLost; reportBlock->remoteReceiveBlock.fractionLost = report_block.fraction_lost();
reportBlock->remoteReceiveBlock.cumulativeLost = reportBlock->remoteReceiveBlock.cumulativeLost =
rb.CumulativeNumOfPacketsLost; report_block.cumulative_lost();
if (rb.ExtendedHighestSequenceNumber > if (report_block.extended_high_seq_num() >
reportBlock->remoteReceiveBlock.extendedHighSeqNum) { reportBlock->remoteReceiveBlock.extendedHighSeqNum) {
// We have successfully delivered new RTP packets to the remote side after // We have successfully delivered new RTP packets to the remote side after
// the last RR was sent from the remote side. // the last RR was sent from the remote side.
_lastIncreasedSequenceNumberMs = _lastReceivedRrMs; _lastIncreasedSequenceNumberMs = _lastReceivedRrMs;
} }
reportBlock->remoteReceiveBlock.extendedHighSeqNum = reportBlock->remoteReceiveBlock.extendedHighSeqNum =
rb.ExtendedHighestSequenceNumber; report_block.extended_high_seq_num();
reportBlock->remoteReceiveBlock.jitter = rb.Jitter; reportBlock->remoteReceiveBlock.jitter = report_block.jitter();
reportBlock->remoteReceiveBlock.delaySinceLastSR = rb.DelayLastSR; reportBlock->remoteReceiveBlock.delaySinceLastSR =
reportBlock->remoteReceiveBlock.lastSR = rb.LastSR; report_block.delay_since_last_sr();
reportBlock->remoteReceiveBlock.lastSR = report_block.last_sr();
if (rtcpPacket.ReportBlockItem.Jitter > reportBlock->remoteMaxJitter) { if (report_block.jitter() > reportBlock->remoteMaxJitter)
reportBlock->remoteMaxJitter = rtcpPacket.ReportBlockItem.Jitter; reportBlock->remoteMaxJitter = report_block.jitter();
}
int64_t rtt = 0; int64_t rtt = 0;
uint32_t send_time = rtcpPacket.ReportBlockItem.LastSR; uint32_t send_time = report_block.last_sr();
// RFC3550, section 6.4.1, LSR field discription states: // RFC3550, section 6.4.1, LSR field discription states:
// If no SR has been received yet, the field is set to zero. // If no SR has been received yet, the field is set to zero.
// Receiver rtp_rtcp module is not expected to calculate rtt using // Receiver rtp_rtcp module is not expected to calculate rtt using
// Sender Reports even if it accidentally can. // Sender Reports even if it accidentally can.
if (!receiver_only_ && send_time != 0) { if (!receiver_only_ && send_time != 0) {
uint32_t delay = rtcpPacket.ReportBlockItem.DelayLastSR; uint32_t delay = report_block.delay_since_last_sr();
// Local NTP time. // Local NTP time.
uint32_t receive_time = CompactNtp(NtpTime(*_clock)); uint32_t receive_time = CompactNtp(NtpTime(*_clock));
@ -563,8 +571,8 @@ void RTCPReceiver::HandleReportBlock(
reportBlock->numAverageCalcs++; reportBlock->numAverageCalcs++;
} }
TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RR_RTT", rb.SSRC, TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RR_RTT",
rtt); report_block.source_ssrc(), rtt);
rtcpPacketInformation.AddReportInfo(*reportBlock); rtcpPacketInformation.AddReportInfo(*reportBlock);
} }
@ -741,76 +749,64 @@ std::vector<rtcp::TmmbItem> RTCPReceiver::BoundingSet(bool* tmmbr_owner) {
return receiveInfo->tmmbn; return receiveInfo->tmmbn;
} }
void RTCPReceiver::HandleSDES(RTCPUtility::RTCPParserV2& rtcpParser, void RTCPReceiver::HandleSDES(const CommonHeader& rtcp_block,
RTCPPacketInformation& rtcpPacketInformation) { RTCPPacketInformation& rtcpPacketInformation) {
RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate(); rtcp::Sdes sdes;
while (pktType == RTCPPacketTypes::kSdesChunk) { if (!sdes.Parse(rtcp_block)) {
const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet(); ++num_skipped_packets_;
RTCPCnameInformation* cnameInfo = return;
CreateCnameInformation(rtcpPacket.CName.SenderSSRC); }
for (const rtcp::Sdes::Chunk& chunk : sdes.chunks()) {
RTCPCnameInformation* cnameInfo = CreateCnameInformation(chunk.ssrc);
RTC_DCHECK(cnameInfo); RTC_DCHECK(cnameInfo);
cnameInfo->name[RTCP_CNAME_SIZE - 1] = 0; cnameInfo->name[RTCP_CNAME_SIZE - 1] = 0;
strncpy(cnameInfo->name, rtcpPacket.CName.CName, RTCP_CNAME_SIZE - 1); strncpy(cnameInfo->name, chunk.cname.c_str(), RTCP_CNAME_SIZE - 1);
{ {
rtc::CritScope lock(&_criticalSectionFeedbacks); rtc::CritScope lock(&_criticalSectionFeedbacks);
if (stats_callback_) { if (stats_callback_)
stats_callback_->CNameChanged(rtcpPacket.CName.CName, stats_callback_->CNameChanged(chunk.cname.c_str(), chunk.ssrc);
rtcpPacket.CName.SenderSSRC);
}
} }
pktType = rtcpParser.Iterate();
} }
rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSdes; rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSdes;
} }
void RTCPReceiver::HandleNACK(RTCPUtility::RTCPParserV2& rtcpParser, void RTCPReceiver::HandleNACK(const CommonHeader& rtcp_block,
RTCPPacketInformation& rtcpPacketInformation) { RTCPPacketInformation& rtcpPacketInformation) {
const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet(); rtcp::Nack nack;
if (receiver_only_ || main_ssrc_ != rtcpPacket.NACK.MediaSSRC) { if (!nack.Parse(rtcp_block)) {
// Not to us. ++num_skipped_packets_;
rtcpParser.Iterate();
return; return;
} }
rtcpPacketInformation.ResetNACKPacketIdArray();
RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate(); if (receiver_only_ || main_ssrc_ != nack.media_ssrc()) // Not to us.
while (pktType == RTCPPacketTypes::kRtpfbNackItem) { return;
rtcpPacketInformation.AddNACKPacket(rtcpPacket.NACKItem.PacketID);
nack_stats_.ReportRequest(rtcpPacket.NACKItem.PacketID);
uint16_t bitMask = rtcpPacket.NACKItem.BitMask; rtcpPacketInformation.nackSequenceNumbers = nack.packet_ids();
if (bitMask) { for (uint16_t packet_id : nack.packet_ids())
for (int i = 1; i <= 16; ++i) { nack_stats_.ReportRequest(packet_id);
if (bitMask & 0x01) {
rtcpPacketInformation.AddNACKPacket(rtcpPacket.NACKItem.PacketID + i); if (!nack.packet_ids().empty()) {
nack_stats_.ReportRequest(rtcpPacket.NACKItem.PacketID + i);
}
bitMask = bitMask >> 1;
}
}
rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpNack; rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpNack;
pktType = rtcpParser.Iterate();
}
if (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpNack) {
++packet_type_counter_.nack_packets; ++packet_type_counter_.nack_packets;
packet_type_counter_.nack_requests = nack_stats_.requests(); packet_type_counter_.nack_requests = nack_stats_.requests();
packet_type_counter_.unique_nack_requests = nack_stats_.unique_requests(); packet_type_counter_.unique_nack_requests = nack_stats_.unique_requests();
} }
} }
void RTCPReceiver::HandleBYE(RTCPUtility::RTCPParserV2& rtcpParser) { void RTCPReceiver::HandleBYE(const CommonHeader& rtcp_block) {
const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet(); rtcp::Bye bye;
if (!bye.Parse(rtcp_block)) {
++num_skipped_packets_;
return;
}
// clear our lists // clear our lists
ReportBlockMap::iterator it = _receivedReportBlockMap.begin(); ReportBlockMap::iterator it = _receivedReportBlockMap.begin();
for (; it != _receivedReportBlockMap.end(); ++it) { for (; it != _receivedReportBlockMap.end(); ++it) {
ReportBlockInfoMap* info_map = &(it->second); ReportBlockInfoMap* info_map = &(it->second);
ReportBlockInfoMap::iterator it_info = ReportBlockInfoMap::iterator it_info = info_map->find(bye.sender_ssrc());
info_map->find(rtcpPacket.BYE.SenderSSRC);
if (it_info != info_map->end()) { if (it_info != info_map->end()) {
delete it_info->second; delete it_info->second;
info_map->erase(it_info); info_map->erase(it_info);
@ -819,257 +815,212 @@ void RTCPReceiver::HandleBYE(RTCPUtility::RTCPParserV2& rtcpParser) {
// we can't delete it due to TMMBR // we can't delete it due to TMMBR
std::map<uint32_t, RTCPReceiveInformation*>::iterator receiveInfoIt = std::map<uint32_t, RTCPReceiveInformation*>::iterator receiveInfoIt =
_receivedInfoMap.find(rtcpPacket.BYE.SenderSSRC); _receivedInfoMap.find(bye.sender_ssrc());
if (receiveInfoIt != _receivedInfoMap.end()) { if (receiveInfoIt != _receivedInfoMap.end())
receiveInfoIt->second->ready_for_delete = true; receiveInfoIt->second->ready_for_delete = true;
}
std::map<uint32_t, RTCPCnameInformation*>::iterator cnameInfoIt = std::map<uint32_t, RTCPCnameInformation*>::iterator cnameInfoIt =
_receivedCnameMap.find(rtcpPacket.BYE.SenderSSRC); _receivedCnameMap.find(bye.sender_ssrc());
if (cnameInfoIt != _receivedCnameMap.end()) { if (cnameInfoIt != _receivedCnameMap.end()) {
delete cnameInfoIt->second; delete cnameInfoIt->second;
_receivedCnameMap.erase(cnameInfoIt); _receivedCnameMap.erase(cnameInfoIt);
} }
xr_rr_rtt_ms_ = 0; xr_rr_rtt_ms_ = 0;
rtcpParser.Iterate();
} }
void RTCPReceiver::HandleXrHeader( void RTCPReceiver::HandleXr(const CommonHeader& rtcp_block,
RTCPUtility::RTCPParserV2& parser, RTCPPacketInformation& rtcpPacketInformation) {
RTCPPacketInformation& rtcpPacketInformation) { rtcp::ExtendedReports xr;
const RTCPUtility::RTCPPacket& packet = parser.Packet(); if (!xr.Parse(rtcp_block)) {
++num_skipped_packets_;
return;
}
rtcpPacketInformation.xr_originator_ssrc = packet.XR.OriginatorSSRC; rtcpPacketInformation.xr_originator_ssrc = xr.sender_ssrc();
for (const rtcp::Rrtr& rrtr : xr.rrtrs())
HandleXrReceiveReferenceTime(rrtr, rtcpPacketInformation);
parser.Iterate(); for (const rtcp::Dlrr& dlrr : xr.dlrrs()) {
for (const rtcp::ReceiveTimeInfo& time_info : dlrr.sub_blocks())
HandleXrDlrrReportBlock(time_info, rtcpPacketInformation);
}
} }
void RTCPReceiver::HandleXrReceiveReferenceTime( void RTCPReceiver::HandleXrReceiveReferenceTime(
RTCPUtility::RTCPParserV2& parser, const rtcp::Rrtr& rrtr,
RTCPPacketInformation& rtcpPacketInformation) { RTCPPacketInformation& rtcpPacketInformation) {
const RTCPUtility::RTCPPacket& packet = parser.Packet();
_remoteXRReceiveTimeInfo.sourceSSRC = _remoteXRReceiveTimeInfo.sourceSSRC =
rtcpPacketInformation.xr_originator_ssrc; rtcpPacketInformation.xr_originator_ssrc;
_remoteXRReceiveTimeInfo.lastRR = RTCPUtility::MidNtp( _remoteXRReceiveTimeInfo.lastRR = CompactNtp(rrtr.ntp());
packet.XRReceiverReferenceTimeItem.NTPMostSignificant,
packet.XRReceiverReferenceTimeItem.NTPLeastSignificant);
_clock->CurrentNtp(_lastReceivedXRNTPsecs, _lastReceivedXRNTPfrac); _clock->CurrentNtp(_lastReceivedXRNTPsecs, _lastReceivedXRNTPfrac);
rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpXrReceiverReferenceTime; rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpXrReceiverReferenceTime;
parser.Iterate();
} }
void RTCPReceiver::HandleXrDlrrReportBlock( void RTCPReceiver::HandleXrDlrrReportBlock(
RTCPUtility::RTCPParserV2& parser, const rtcp::ReceiveTimeInfo& rti,
RTCPPacketInformation& rtcpPacketInformation) { RTCPPacketInformation& rtcpPacketInformation) {
const RTCPUtility::RTCPPacket& packet = parser.Packet(); if (registered_ssrcs_.count(rti.ssrc) == 0) // Not to us.
// Iterate through sub-block(s), if any. return;
RTCPUtility::RTCPPacketTypes packet_type = parser.Iterate();
while (packet_type == RTCPPacketTypes::kXrDlrrReportBlockItem) { rtcpPacketInformation.xr_dlrr_item = true;
if (registered_ssrcs_.find(packet.XRDLRRReportBlockItem.SSRC) ==
registered_ssrcs_.end()) {
// Not to us.
return;
}
rtcpPacketInformation.xr_dlrr_item = true; // Caller should explicitly enable rtt calculation using extended reports.
if (!xr_rrtr_status_)
return;
// Caller should explicitly enable rtt calculation using extended reports. // The send_time and delay_rr fields are in units of 1/2^16 sec.
if (!xr_rrtr_status_) uint32_t send_time = rti.last_rr;
return; // RFC3611, section 4.5, LRR field discription states:
// If no such block has been received, the field is set to zero.
if (send_time == 0)
return;
// The send_time and delay_rr fields are in units of 1/2^16 sec. uint32_t delay_rr = rti.delay_since_last_rr;
uint32_t send_time = packet.XRDLRRReportBlockItem.LastRR; uint32_t now = CompactNtp(NtpTime(*_clock));
// RFC3611, section 4.5, LRR field discription states:
// If no such block has been received, the field is set to zero.
if (send_time == 0)
return;
uint32_t delay_rr = packet.XRDLRRReportBlockItem.DelayLastRR; uint32_t rtt_ntp = now - delay_rr - send_time;
uint32_t now = CompactNtp(NtpTime(*_clock)); xr_rr_rtt_ms_ = CompactNtpRttToMs(rtt_ntp);
uint32_t rtt_ntp = now - delay_rr - send_time; rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpXrDlrrReportBlock;
xr_rr_rtt_ms_ = CompactNtpRttToMs(rtt_ntp);
rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpXrDlrrReportBlock;
packet_type = parser.Iterate();
}
} }
void RTCPReceiver::HandlePLI(RTCPUtility::RTCPParserV2& rtcpParser, void RTCPReceiver::HandlePLI(const CommonHeader& rtcp_block,
RTCPPacketInformation& rtcpPacketInformation) { RTCPPacketInformation& rtcpPacketInformation) {
const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet(); rtcp::Pli pli;
if (main_ssrc_ == rtcpPacket.PLI.MediaSSRC) { if (!pli.Parse(rtcp_block)) {
++num_skipped_packets_;
return;
}
if (main_ssrc_ == pli.media_ssrc()) {
TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "PLI"); TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "PLI");
++packet_type_counter_.pli_packets; ++packet_type_counter_.pli_packets;
// Received a signal that we need to send a new key frame. // Received a signal that we need to send a new key frame.
rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpPli; rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpPli;
} }
rtcpParser.Iterate();
} }
void RTCPReceiver::HandleTMMBR(RTCPUtility::RTCPParserV2& rtcpParser, void RTCPReceiver::HandleTMMBR(const CommonHeader& rtcp_block,
RTCPPacketInformation& rtcpPacketInformation) { RTCPPacketInformation& rtcpPacketInformation) {
const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet(); rtcp::Tmmbr tmmbr;
if (!tmmbr.Parse(rtcp_block)) {
++num_skipped_packets_;
return;
}
uint32_t senderSSRC = rtcpPacket.TMMBR.SenderSSRC; uint32_t senderSSRC = tmmbr.sender_ssrc();
RTCPReceiveInformation* ptrReceiveInfo = GetReceiveInformation(senderSSRC); RTCPReceiveInformation* ptrReceiveInfo = GetReceiveInformation(senderSSRC);
if (ptrReceiveInfo == NULL) { if (!ptrReceiveInfo) // This remote SSRC must be saved before.
// This remote SSRC must be saved before.
rtcpParser.Iterate();
return; return;
}
if (rtcpPacket.TMMBR.MediaSSRC) { if (tmmbr.media_ssrc()) {
// rtcpPacket.TMMBR.MediaSSRC SHOULD be 0 if same as SenderSSRC // media_ssrc() SHOULD be 0 if same as SenderSSRC.
// in relay mode this is a valid number // In relay mode this is a valid number.
senderSSRC = rtcpPacket.TMMBR.MediaSSRC; senderSSRC = tmmbr.media_ssrc();
} }
// Use packet length to calc max number of TMMBR blocks for (const rtcp::TmmbItem& request : tmmbr.requests()) {
// each TMMBR block is 8 bytes if (main_ssrc_ == request.ssrc() && request.bitrate_bps()) {
ptrdiff_t maxNumOfTMMBRBlocks = rtcpParser.LengthLeft() / 8; ptrReceiveInfo->InsertTmmbrItem(senderSSRC, request,
_clock->TimeInMilliseconds());
// sanity, we can't have more than what's in one packet
if (maxNumOfTMMBRBlocks > 200) {
assert(false);
rtcpParser.Iterate();
return;
}
RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
while (pktType == RTCPPacketTypes::kRtpfbTmmbrItem) {
if (main_ssrc_ == rtcpPacket.TMMBRItem.SSRC &&
rtcpPacket.TMMBRItem.MaxTotalMediaBitRate > 0) {
ptrReceiveInfo->InsertTmmbrItem(
senderSSRC,
rtcp::TmmbItem(rtcpPacket.TMMBRItem.SSRC,
rtcpPacket.TMMBRItem.MaxTotalMediaBitRate * 1000,
rtcpPacket.TMMBRItem.MeasuredOverhead),
_clock->TimeInMilliseconds());
rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpTmmbr; rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpTmmbr;
} }
pktType = rtcpParser.Iterate();
} }
} }
void RTCPReceiver::HandleTMMBN(RTCPUtility::RTCPParserV2& rtcpParser, void RTCPReceiver::HandleTMMBN(const CommonHeader& rtcp_block,
RTCPPacketInformation& rtcpPacketInformation) { RTCPPacketInformation& rtcpPacketInformation) {
const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet(); rtcp::Tmmbn tmmbn;
if (!tmmbn.Parse(rtcp_block)) {
++num_skipped_packets_;
return;
}
RTCPReceiveInformation* ptrReceiveInfo = RTCPReceiveInformation* ptrReceiveInfo =
GetReceiveInformation(rtcpPacket.TMMBN.SenderSSRC); GetReceiveInformation(tmmbn.sender_ssrc());
if (ptrReceiveInfo == NULL) { if (!ptrReceiveInfo) // This remote SSRC must be saved before.
// This remote SSRC must be saved before.
rtcpParser.Iterate();
return; return;
}
rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpTmmbn; rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpTmmbn;
// Use packet length to calc max number of TMMBN blocks
// each TMMBN block is 8 bytes
ptrdiff_t maxNumOfTMMBNBlocks = rtcpParser.LengthLeft() / 8;
// sanity, we cant have more than what's in one packet for (const auto& item : tmmbn.items())
if (maxNumOfTMMBNBlocks > 200) { ptrReceiveInfo->tmmbn.push_back(item);
assert(false); }
rtcpParser.Iterate();
void RTCPReceiver::HandleSR_REQ(const CommonHeader& rtcp_block,
RTCPPacketInformation& rtcpPacketInformation) {
rtcp::RapidResyncRequest sr_req;
if (!sr_req.Parse(rtcp_block)) {
++num_skipped_packets_;
return; return;
} }
RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
while (pktType == RTCPPacketTypes::kRtpfbTmmbnItem) {
ptrReceiveInfo->tmmbn.emplace_back(
rtcpPacket.TMMBNItem.SSRC,
rtcpPacket.TMMBNItem.MaxTotalMediaBitRate * 1000,
rtcpPacket.TMMBNItem.MeasuredOverhead);
pktType = rtcpParser.Iterate();
}
}
void RTCPReceiver::HandleSR_REQ(RTCPUtility::RTCPParserV2& rtcpParser,
RTCPPacketInformation& rtcpPacketInformation) {
rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSrReq; rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSrReq;
rtcpParser.Iterate();
} }
void RTCPReceiver::HandleSLI(RTCPUtility::RTCPParserV2& rtcpParser, void RTCPReceiver::HandleSLI(const CommonHeader& rtcp_block,
RTCPPacketInformation& rtcpPacketInformation) { RTCPPacketInformation& rtcpPacketInformation) {
const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet(); rtcp::Sli sli;
RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate(); if (!sli.Parse(rtcp_block)) {
while (pktType == RTCPPacketTypes::kPsfbSliItem) { ++num_skipped_packets_;
// in theory there could be multiple slices lost return;
rtcpPacketInformation.rtcpPacketTypeFlags |= }
kRtcpSli; // received signal that we need to refresh a slice
rtcpPacketInformation.sliPictureId = rtcpPacket.SLIItem.PictureId;
pktType = rtcpParser.Iterate(); for (const rtcp::Sli::Macroblocks& item : sli.macroblocks()) {
// In theory there could be multiple slices lost.
// Received signal that we need to refresh a slice.
rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSli;
rtcpPacketInformation.sliPictureId = item.picture_id();
} }
} }
void RTCPReceiver::HandleRPSI( void RTCPReceiver::HandleRPSI(
RTCPUtility::RTCPParserV2& rtcpParser, const CommonHeader& rtcp_block,
RTCPHelp::RTCPPacketInformation& rtcpPacketInformation) { RTCPHelp::RTCPPacketInformation& rtcpPacketInformation) {
const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet(); rtcp::Rpsi rpsi;
RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate(); if (!rpsi.Parse(rtcp_block)) {
if (pktType == RTCPPacketTypes::kPsfbRpsiItem) { ++num_skipped_packets_;
if (rtcpPacket.RPSI.NumberOfValidBits % 8 != 0) { return;
// to us unknown
// continue
rtcpParser.Iterate();
return;
}
// Received signal that we have a confirmed reference picture.
rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRpsi;
rtcpPacketInformation.rpsiPictureId = 0;
// convert NativeBitString to rpsiPictureId
uint8_t numberOfBytes = rtcpPacket.RPSI.NumberOfValidBits / 8;
for (uint8_t n = 0; n < (numberOfBytes - 1); n++) {
rtcpPacketInformation.rpsiPictureId +=
(rtcpPacket.RPSI.NativeBitString[n] & 0x7f);
rtcpPacketInformation.rpsiPictureId <<= 7; // prepare next
}
rtcpPacketInformation.rpsiPictureId +=
(rtcpPacket.RPSI.NativeBitString[numberOfBytes - 1] & 0x7f);
} }
// Received signal that we have a confirmed reference picture.
rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRpsi;
rtcpPacketInformation.rpsiPictureId = rpsi.picture_id();
} }
void RTCPReceiver::HandlePsfbApp(RTCPUtility::RTCPParserV2& rtcpParser, void RTCPReceiver::HandlePsfbApp(const CommonHeader& rtcp_block,
RTCPPacketInformation& rtcpPacketInformation) { RTCPPacketInformation& rtcpPacketInformation) {
RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate(); rtcp::Remb remb;
if (pktType == RTCPPacketTypes::kPsfbRemb) { if (remb.Parse(rtcp_block)) {
pktType = rtcpParser.Iterate(); rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRemb;
if (pktType == RTCPPacketTypes::kPsfbRembItem) { rtcpPacketInformation.receiverEstimatedMaxBitrate = remb.bitrate_bps();
const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet(); return;
rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRemb;
rtcpPacketInformation.receiverEstimatedMaxBitrate =
rtcpPacket.REMBItem.BitRate;
rtcpParser.Iterate();
}
} }
++num_skipped_packets_;
} }
void RTCPReceiver::HandleFIR(RTCPUtility::RTCPParserV2& rtcpParser, void RTCPReceiver::HandleFIR(const CommonHeader& rtcp_block,
RTCPPacketInformation& rtcpPacketInformation) { RTCPPacketInformation& rtcpPacketInformation) {
const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet(); rtcp::Fir fir;
RTCPReceiveInformation* ptrReceiveInfo = if (!fir.Parse(rtcp_block)) {
GetReceiveInformation(rtcpPacket.FIR.SenderSSRC); ++num_skipped_packets_;
return;
}
RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate(); RTCPReceiveInformation* ptrReceiveInfo =
while (pktType == RTCPPacketTypes::kPsfbFirItem) { GetReceiveInformation(fir.sender_ssrc());
for (const rtcp::Fir::Request& fir_request : fir.requests()) {
// Is it our sender that is requested to generate a new keyframe // Is it our sender that is requested to generate a new keyframe
if (main_ssrc_ != rtcpPacket.FIRItem.SSRC) { if (main_ssrc_ != fir_request.ssrc)
return; continue;
}
++packet_type_counter_.fir_packets; ++packet_type_counter_.fir_packets;
@ -1077,15 +1028,13 @@ void RTCPReceiver::HandleFIR(RTCPUtility::RTCPParserV2& rtcpParser,
// we don't know who this originate from // we don't know who this originate from
if (ptrReceiveInfo) { if (ptrReceiveInfo) {
// check if we have reported this FIRSequenceNumber before // check if we have reported this FIRSequenceNumber before
if (rtcpPacket.FIRItem.CommandSequenceNumber != if (fir_request.seq_nr != ptrReceiveInfo->last_fir_sequence_number) {
ptrReceiveInfo->last_fir_sequence_number) {
int64_t now = _clock->TimeInMilliseconds(); int64_t now = _clock->TimeInMilliseconds();
// sanity; don't go crazy with the callbacks // sanity; don't go crazy with the callbacks
if ((now - ptrReceiveInfo->last_fir_request_ms) > if ((now - ptrReceiveInfo->last_fir_request_ms) >
RTCP_MIN_FRAME_LENGTH_MS) { RTCP_MIN_FRAME_LENGTH_MS) {
ptrReceiveInfo->last_fir_request_ms = now; ptrReceiveInfo->last_fir_request_ms = now;
ptrReceiveInfo->last_fir_sequence_number = ptrReceiveInfo->last_fir_sequence_number = fir_request.seq_nr;
rtcpPacket.FIRItem.CommandSequenceNumber;
// received signal that we need to send a new key frame // received signal that we need to send a new key frame
rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpFir; rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpFir;
} }
@ -1094,21 +1043,21 @@ void RTCPReceiver::HandleFIR(RTCPUtility::RTCPParserV2& rtcpParser,
// received signal that we need to send a new key frame // received signal that we need to send a new key frame
rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpFir; rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpFir;
} }
pktType = rtcpParser.Iterate();
} }
} }
void RTCPReceiver::HandleTransportFeedback( void RTCPReceiver::HandleTransportFeedback(
RTCPUtility::RTCPParserV2* rtcp_parser, const CommonHeader& rtcp_block,
RTCPHelp::RTCPPacketInformation* rtcp_packet_information) { RTCPHelp::RTCPPacketInformation* rtcp_packet_information) {
rtcp::RtcpPacket* packet = rtcp_parser->ReleaseRtcpPacket(); std::unique_ptr<rtcp::TransportFeedback> transport_feedback(
RTC_DCHECK(packet != nullptr); new rtcp::TransportFeedback());
rtcp_packet_information->rtcpPacketTypeFlags |= kRtcpTransportFeedback; if (!transport_feedback->Parse(rtcp_block)) {
rtcp_packet_information->transport_feedback_.reset( ++num_skipped_packets_;
static_cast<rtcp::TransportFeedback*>(packet)); return;
}
rtcp_parser->Iterate(); rtcp_packet_information->rtcpPacketTypeFlags |= kRtcpTransportFeedback;
rtcp_packet_information->transport_feedback_ = std::move(transport_feedback);
} }
void RTCPReceiver::UpdateTmmbr() { void RTCPReceiver::UpdateTmmbr() {

50
webrtc/modules/rtp_rtcp/source/rtcp_receiver.h
View File

@ -24,6 +24,10 @@
namespace webrtc { namespace webrtc {
namespace rtcp { namespace rtcp {
class CommonHeader;
struct ReceiveTimeInfo;
class ReportBlock;
class Rrtr;
class TmmbItem; class TmmbItem;
} // namespace rtcp } // namespace rtcp
@ -53,7 +57,6 @@ class RTCPReceiver {
bool IncomingPacket(const uint8_t* packet, size_t packet_size); bool IncomingPacket(const uint8_t* packet, size_t packet_size);
int64_t LastReceived();
int64_t LastReceivedReceiverReport() const; int64_t LastReceivedReceiverReport() const;
void SetSsrcs(uint32_t main_ssrc, const std::set<uint32_t>& registered_ssrcs); void SetSsrcs(uint32_t main_ssrc, const std::set<uint32_t>& registered_ssrcs);
@ -116,9 +119,9 @@ class RTCPReceiver {
// RTCP report block information map mapped by source SSRC. // RTCP report block information map mapped by source SSRC.
using ReportBlockMap = std::map<uint32_t, ReportBlockInfoMap>; using ReportBlockMap = std::map<uint32_t, ReportBlockInfoMap>;
int32_t IncomingRTCPPacket( bool ParseCompoundPacket(const uint8_t* packet_begin,
RTCPHelp::RTCPPacketInformation& rtcpPacketInformation, const uint8_t* packet_end,
RTCPUtility::RTCPParserV2* rtcpParser); RTCPHelp::RTCPPacketInformation* packet_information);
void TriggerCallbacksFromRTCPPacket( void TriggerCallbacksFromRTCPPacket(
RTCPHelp::RTCPPacketInformation& rtcpPacketInformation); RTCPHelp::RTCPPacketInformation& rtcpPacketInformation);
@ -133,79 +136,79 @@ class RTCPReceiver {
RTCPHelp::RTCPReceiveInformation* GetReceiveInformation(uint32_t remoteSSRC); RTCPHelp::RTCPReceiveInformation* GetReceiveInformation(uint32_t remoteSSRC);
void HandleSenderReport( void HandleSenderReport(
RTCPUtility::RTCPParserV2& rtcpParser, const rtcp::CommonHeader& rtcp_block,
RTCPHelp::RTCPPacketInformation& rtcpPacketInformation) RTCPHelp::RTCPPacketInformation& rtcpPacketInformation)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver); EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
void HandleReceiverReport( void HandleReceiverReport(
RTCPUtility::RTCPParserV2& rtcpParser, const rtcp::CommonHeader& rtcp_block,
RTCPHelp::RTCPPacketInformation& rtcpPacketInformation) RTCPHelp::RTCPPacketInformation& rtcpPacketInformation)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver); EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
void HandleReportBlock(const RTCPUtility::RTCPPacket& rtcpPacket, void HandleReportBlock(const rtcp::ReportBlock& report_block,
RTCPHelp::RTCPPacketInformation& rtcpPacketInformation, RTCPHelp::RTCPPacketInformation& rtcpPacketInformation,
uint32_t remoteSSRC) uint32_t remoteSSRC)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver); EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
void HandleSDES(RTCPUtility::RTCPParserV2& rtcpParser, void HandleSDES(const rtcp::CommonHeader& rtcp_block,
RTCPHelp::RTCPPacketInformation& rtcpPacketInformation) RTCPHelp::RTCPPacketInformation& rtcpPacketInformation)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver); EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
void HandleXrHeader(RTCPUtility::RTCPParserV2& parser, void HandleXr(const rtcp::CommonHeader& rtcp_block,
RTCPHelp::RTCPPacketInformation& rtcpPacketInformation) RTCPHelp::RTCPPacketInformation& rtcpPacketInformation)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver); EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
void HandleXrReceiveReferenceTime( void HandleXrReceiveReferenceTime(
RTCPUtility::RTCPParserV2& parser, const rtcp::Rrtr& rrtr,
RTCPHelp::RTCPPacketInformation& rtcpPacketInformation) RTCPHelp::RTCPPacketInformation& rtcpPacketInformation)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver); EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
void HandleXrDlrrReportBlock( void HandleXrDlrrReportBlock(
RTCPUtility::RTCPParserV2& parser, const rtcp::ReceiveTimeInfo& rti,
RTCPHelp::RTCPPacketInformation& rtcpPacketInformation) RTCPHelp::RTCPPacketInformation& rtcpPacketInformation)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver); EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
void HandleNACK(RTCPUtility::RTCPParserV2& rtcpParser, void HandleNACK(const rtcp::CommonHeader& rtcp_block,
RTCPHelp::RTCPPacketInformation& rtcpPacketInformation) RTCPHelp::RTCPPacketInformation& rtcpPacketInformation)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver); EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
void HandleBYE(RTCPUtility::RTCPParserV2& rtcpParser) void HandleBYE(const rtcp::CommonHeader& rtcp_block)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver); EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
void HandlePLI(RTCPUtility::RTCPParserV2& rtcpParser, void HandlePLI(const rtcp::CommonHeader& rtcp_block,
RTCPHelp::RTCPPacketInformation& rtcpPacketInformation) RTCPHelp::RTCPPacketInformation& rtcpPacketInformation)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver); EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
void HandleSLI(RTCPUtility::RTCPParserV2& rtcpParser, void HandleSLI(const rtcp::CommonHeader& rtcp_block,
RTCPHelp::RTCPPacketInformation& rtcpPacketInformation) RTCPHelp::RTCPPacketInformation& rtcpPacketInformation)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver); EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
void HandleRPSI(RTCPUtility::RTCPParserV2& rtcpParser, void HandleRPSI(const rtcp::CommonHeader& rtcp_block,
RTCPHelp::RTCPPacketInformation& rtcpPacketInformation) RTCPHelp::RTCPPacketInformation& rtcpPacketInformation)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver); EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
void HandlePsfbApp(RTCPUtility::RTCPParserV2& rtcpParser, void HandlePsfbApp(const rtcp::CommonHeader& rtcp_block,
RTCPHelp::RTCPPacketInformation& rtcpPacketInformation) RTCPHelp::RTCPPacketInformation& rtcpPacketInformation)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver); EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
void HandleTMMBR(RTCPUtility::RTCPParserV2& rtcpParser, void HandleTMMBR(const rtcp::CommonHeader& rtcp_block,
RTCPHelp::RTCPPacketInformation& rtcpPacketInformation) RTCPHelp::RTCPPacketInformation& rtcpPacketInformation)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver); EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
void HandleTMMBN(RTCPUtility::RTCPParserV2& rtcpParser, void HandleTMMBN(const rtcp::CommonHeader& rtcp_block,
RTCPHelp::RTCPPacketInformation& rtcpPacketInformation) RTCPHelp::RTCPPacketInformation& rtcpPacketInformation)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver); EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
void HandleSR_REQ(RTCPUtility::RTCPParserV2& rtcpParser, void HandleSR_REQ(const rtcp::CommonHeader& rtcp_block,
RTCPHelp::RTCPPacketInformation& rtcpPacketInformation) RTCPHelp::RTCPPacketInformation& rtcpPacketInformation)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver); EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
void HandleFIR(RTCPUtility::RTCPParserV2& rtcpParser, void HandleFIR(const rtcp::CommonHeader& rtcp_block,
RTCPHelp::RTCPPacketInformation& rtcpPacketInformation) RTCPHelp::RTCPPacketInformation& rtcpPacketInformation)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver); EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
void HandleTransportFeedback( void HandleTransportFeedback(
RTCPUtility::RTCPParserV2* rtcp_parser, const rtcp::CommonHeader& rtcp_block,
RTCPHelp::RTCPPacketInformation* rtcp_packet_information) RTCPHelp::RTCPPacketInformation* rtcp_packet_information)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver); EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver);
@ -220,7 +223,6 @@ class RTCPReceiver {
Clock* const _clock; Clock* const _clock;
const bool receiver_only_; const bool receiver_only_;
int64_t _lastReceived;
ModuleRtpRtcp& _rtpRtcp; ModuleRtpRtcp& _rtpRtcp;
rtc::CriticalSection _criticalSectionFeedbacks; rtc::CriticalSection _criticalSectionFeedbacks;

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

@ -35,17 +35,6 @@ RTCPPacketInformation::RTCPPacketInformation()
RTCPPacketInformation::~RTCPPacketInformation() {} RTCPPacketInformation::~RTCPPacketInformation() {}
void RTCPPacketInformation::ResetNACKPacketIdArray() {
nackSequenceNumbers.clear();
}
void RTCPPacketInformation::AddNACKPacket(const uint16_t packetID) {
if (nackSequenceNumbers.size() >= kSendSideNackListSizeSanity) {
return;
}
nackSequenceNumbers.push_back(packetID);
}
void RTCPPacketInformation::AddReportInfo( void RTCPPacketInformation::AddReportInfo(
const RTCPReportBlockInformation& report_block_info) { const RTCPReportBlockInformation& report_block_info) {
this->rtt = report_block_info.RTT; this->rtt = report_block_info.RTT;

3
webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.h
View File

@ -48,9 +48,6 @@ class RTCPPacketInformation {
RTCPPacketInformation(); RTCPPacketInformation();
~RTCPPacketInformation(); ~RTCPPacketInformation();
void AddNACKPacket(const uint16_t packetID);
void ResetNACKPacketIdArray();
void AddReportInfo(const RTCPReportBlockInformation& report_block_info); void AddReportInfo(const RTCPReportBlockInformation& report_block_info);
uint32_t rtcpPacketTypeFlags; // RTCPPacketTypeFlags bit field uint32_t rtcpPacketTypeFlags; // RTCPPacketTypeFlags bit field