Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(26)

Unified Diff: webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc

Issue 2316093002: Replace rtcp packet parsing in the RtcpReceiver. (Closed)
Patch Set: More nits Created 4 years, 3 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « webrtc/modules/rtp_rtcp/source/rtcp_receiver.h ('k') | webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.h » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc
diff --git a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc
index da25d0a116570e62cff331eb34e3fc6ee9684b6f..50ad69bd0f8ef0b8ad948fc7555cf59f61c79d41 100644
--- a/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc
+++ b/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc
@@ -18,6 +18,22 @@
#include "webrtc/base/checks.h"
#include "webrtc/base/logging.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_utility.h"
#include "webrtc/modules/rtp_rtcp/source/time_util.h"
@@ -25,19 +41,24 @@
#include "webrtc/system_wrappers/include/ntp_time.h"
namespace webrtc {
-using RTCPHelp::RTCPPacketInformation;
-using RTCPHelp::RTCPReceiveInformation;
-using RTCPHelp::RTCPReportBlockInformation;
-using RTCPUtility::kBtVoipMetric;
-using RTCPUtility::RTCPCnameInformation;
-using RTCPUtility::RTCPPacketReportBlockItem;
-using RTCPUtility::RTCPPacketTypes;
+namespace {
+
+using ::webrtc::rtcp::CommonHeader;
philipel 2016/09/19 11:01:38 remove ::webrtc::
danilchap 2016/09/19 13:35:26 Done. Planned to ack, reread guide more carefully,
+using ::webrtc::rtcp::ReportBlock;
+using ::webrtc::RTCPHelp::RTCPPacketInformation;
+using ::webrtc::RTCPHelp::RTCPReceiveInformation;
+using ::webrtc::RTCPHelp::RTCPReportBlockInformation;
+using ::webrtc::RTCPUtility::RTCPCnameInformation;
+using ::webrtc::RTCPUtility::RTCPPacketReportBlockItem;
+using ::webrtc::RTCPUtility::RTCPPacketTypes;
// The number of RTCP time intervals needed to trigger a timeout.
const int kRrTimeoutIntervals = 3;
const int64_t kMaxWarningLogIntervalMs = 10000;
+} // namespace
+
RTCPReceiver::RTCPReceiver(
Clock* clock,
bool receiver_only,
@@ -48,7 +69,6 @@ RTCPReceiver::RTCPReceiver(
ModuleRtpRtcp* owner)
: _clock(clock),
receiver_only_(receiver_only),
- _lastReceived(0),
_rtpRtcp(*owner),
_cbRtcpBandwidthObserver(rtcp_bandwidth_observer),
_cbRtcpIntraFrameObserver(rtcp_intra_frame_observer),
@@ -97,22 +117,16 @@ RTCPReceiver::~RTCPReceiver() {
}
bool RTCPReceiver::IncomingPacket(const uint8_t* packet, size_t packet_size) {
- // Allow receive of non-compound RTCP packets.
- RTCPUtility::RTCPParserV2 rtcp_parser(packet, packet_size, true);
-
- if (!rtcp_parser.IsValid()) {
- LOG(LS_WARNING) << "Incoming invalid RTCP packet";
+ if (packet_size == 0) {
+ LOG(LS_WARNING) << "Incoming empty RTCP packet";
return false;
}
- RTCPHelp::RTCPPacketInformation rtcp_packet_information;
- IncomingRTCPPacket(rtcp_packet_information, &rtcp_parser);
- TriggerCallbacksFromRTCPPacket(rtcp_packet_information);
- return true;
-}
-int64_t RTCPReceiver::LastReceived() {
- rtc::CritScope lock(&_criticalSectionRTCPReceiver);
- return _lastReceived;
+ RTCPHelp::RTCPPacketInformation packet_information;
+ if (!ParseCompoundPacket(packet, packet + packet_size, &packet_information))
+ return false;
+ TriggerCallbacksFromRTCPPacket(packet_information);
+ return true;
}
int64_t RTCPReceiver::LastReceivedReceiverReport() const {
@@ -282,78 +296,94 @@ int32_t RTCPReceiver::StatisticsReceived(
return 0;
}
-int32_t RTCPReceiver::IncomingRTCPPacket(
- RTCPPacketInformation& rtcpPacketInformation,
- RTCPUtility::RTCPParserV2* rtcpParser) {
+bool RTCPReceiver::ParseCompoundPacket(
+ const uint8_t* packet_begin,
+ const uint8_t* packet_end,
+ RTCPPacketInformation* packet_information) {
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 tail_size = packet_end - next_block;
philipel 2016/09/19 11:01:38 block_size
danilchap 2016/09/19 13:35:26 s/tail/remaining_blocks/ It is more than one block
+ RTC_DCHECK_GT(tail_size, 0);
+ if (!rtcp_block.Parse(next_block, tail_size)) {
+ bool first = next_block == packet_begin;
+ if (first) {
+ LOG(LS_WARNING) << "Incoming invalid RTCP packet";
+ return false;
+ }
+ ++num_skipped_packets_;
+ break;
+ }
- if (packet_type_counter_.first_packet_time_ms == -1) {
- packet_type_counter_.first_packet_time_ms = _lastReceived;
- }
+ if (packet_type_counter_.first_packet_time_ms == -1)
+ packet_type_counter_.first_packet_time_ms = _clock->TimeInMilliseconds();
- RTCPUtility::RTCPPacketTypes pktType = rtcpParser->Begin();
- while (pktType != RTCPPacketTypes::kInvalid) {
- // Each "case" is responsible for iterate the parser to the
- // next top level packet.
- switch (pktType) {
- case RTCPPacketTypes::kSr:
- HandleSenderReport(*rtcpParser, rtcpPacketInformation);
- break;
- case RTCPPacketTypes::kRr:
- HandleReceiverReport(*rtcpParser, rtcpPacketInformation);
- break;
- case RTCPPacketTypes::kSdes:
- HandleSDES(*rtcpParser, rtcpPacketInformation);
+ switch (rtcp_block.type()) {
+ case rtcp::SenderReport::kPacketType:
+ HandleSenderReport(rtcp_block, *packet_information);
break;
- case RTCPPacketTypes::kXrHeader:
- HandleXrHeader(*rtcpParser, rtcpPacketInformation);
+ case rtcp::ReceiverReport::kPacketType:
+ HandleReceiverReport(rtcp_block, *packet_information);
break;
- case RTCPPacketTypes::kXrReceiverReferenceTime:
- HandleXrReceiveReferenceTime(*rtcpParser, rtcpPacketInformation);
+ case rtcp::Sdes::kPacketType:
+ HandleSDES(rtcp_block, *packet_information);
break;
- case RTCPPacketTypes::kXrDlrrReportBlock:
- HandleXrDlrrReportBlock(*rtcpParser, rtcpPacketInformation);
+ case rtcp::ExtendedReports::kPacketType:
+ HandleXr(rtcp_block, *packet_information);
break;
- case RTCPPacketTypes::kBye:
- HandleBYE(*rtcpParser);
+ case rtcp::Bye::kPacketType:
+ HandleBYE(rtcp_block);
break;
- case RTCPPacketTypes::kRtpfbNack:
- HandleNACK(*rtcpParser, rtcpPacketInformation);
- break;
- case RTCPPacketTypes::kRtpfbTmmbr:
- HandleTMMBR(*rtcpParser, rtcpPacketInformation);
- break;
- case RTCPPacketTypes::kRtpfbTmmbn:
- HandleTMMBN(*rtcpParser, rtcpPacketInformation);
- break;
- case RTCPPacketTypes::kRtpfbSrReq:
- HandleSR_REQ(*rtcpParser, rtcpPacketInformation);
- break;
- case RTCPPacketTypes::kPsfbPli:
- HandlePLI(*rtcpParser, rtcpPacketInformation);
- break;
- case RTCPPacketTypes::kPsfbSli:
- HandleSLI(*rtcpParser, rtcpPacketInformation);
- break;
- case RTCPPacketTypes::kPsfbRpsi:
- HandleRPSI(*rtcpParser, rtcpPacketInformation);
- break;
- case RTCPPacketTypes::kPsfbFir:
- HandleFIR(*rtcpParser, rtcpPacketInformation);
- break;
- case RTCPPacketTypes::kPsfbApp:
- HandlePsfbApp(*rtcpParser, rtcpPacketInformation);
+ case rtcp::Rtpfb::kPacketType:
+ 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;
- case RTCPPacketTypes::kTransportFeedback:
- HandleTransportFeedback(rtcpParser, &rtcpPacketInformation);
+ case rtcp::Psfb::kPacketType:
+ switch (rtcp_block.fmt()) {
+ case rtcp::Pli::kFeedbackMessageType:
+ HandlePLI(rtcp_block, *packet_information);
+ break;
+ case rtcp::Sli::kFeedbackMessageType:
+ HandleSLI(rtcp_block, *packet_information);
+ break;
+ case rtcp::Rpsi::kFeedbackMessageType:
+ HandleRPSI(rtcp_block, *packet_information);
+ break;
+ case rtcp::Fir::kFeedbackMessageType:
+ HandleFIR(rtcp_block, *packet_information);
+ break;
+ case rtcp::Remb::kFeedbackMessageType:
+ HandlePsfbApp(rtcp_block, *packet_information);
+ break;
+ default:
+ ++num_skipped_packets_;
+ break;
+ }
break;
default:
- rtcpParser->Iterate();
+ ++num_skipped_packets_;
break;
}
- pktType = rtcpParser->PacketType();
}
if (packet_type_counter_observer_ != NULL) {
@@ -361,8 +391,6 @@ int32_t RTCPReceiver::IncomingRTCPPacket(
main_ssrc_, packet_type_counter_);
}
- num_skipped_packets_ += rtcpParser->NumSkippedBlocks();
-
int64_t now = _clock->TimeInMilliseconds();
if (now - last_skipped_packets_warning_ >= kMaxWarningLogIntervalMs &&
num_skipped_packets_ > 0) {
@@ -373,29 +401,25 @@ int32_t RTCPReceiver::IncomingRTCPPacket(
<< (kMaxWarningLogIntervalMs / 1000) << " second period.";
}
- return 0;
+ return true;
}
void RTCPReceiver::HandleSenderReport(
- RTCPUtility::RTCPParserV2& rtcpParser,
+ const CommonHeader& rtcp_block,
RTCPPacketInformation& rtcpPacketInformation) {
- RTCPUtility::RTCPPacketTypes rtcpPacketType = rtcpParser.PacketType();
- const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
-
- RTC_DCHECK(rtcpPacketType == RTCPPacketTypes::kSr);
-
- // SR.SenderSSRC
- // The synchronization source identifier for the originator of this SR packet
+ rtcp::SenderReport sender_report;
+ if (!sender_report.Parse(rtcp_block)) {
+ ++num_skipped_packets_;
philipel 2016/09/19 11:01:38 Maybe change all RTCPReceiver::Handle* functions t
danilchap 2016/09/19 13:35:26 Interesting idea, but it seems wrong for Handle<>
+ return;
+ }
- const uint32_t remoteSSRC = rtcpPacket.SR.SenderSSRC;
+ const uint32_t remoteSSRC = sender_report.sender_ssrc();
rtcpPacketInformation.remoteSSRC = remoteSSRC;
RTCPReceiveInformation* ptrReceiveInfo = CreateReceiveInformation(remoteSSRC);
- if (!ptrReceiveInfo) {
- rtcpParser.Iterate();
+ if (!ptrReceiveInfo)
return;
- }
TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "SR",
"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.
rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSr;
- rtcpPacketInformation.ntp_secs = rtcpPacket.SR.NTPMostSignificant;
- rtcpPacketInformation.ntp_frac = rtcpPacket.SR.NTPLeastSignificant;
- rtcpPacketInformation.rtp_timestamp = rtcpPacket.SR.RTPTimestamp;
+ rtcpPacketInformation.ntp_secs = sender_report.ntp().seconds();
+ rtcpPacketInformation.ntp_frac = sender_report.ntp().fractions();
+ rtcpPacketInformation.rtp_timestamp = sender_report.rtp_timestamp();
// Save the NTP time of this report.
- _remoteSenderInfo.NTPseconds = rtcpPacket.SR.NTPMostSignificant;
- _remoteSenderInfo.NTPfraction = rtcpPacket.SR.NTPLeastSignificant;
- _remoteSenderInfo.RTPtimeStamp = rtcpPacket.SR.RTPTimestamp;
- _remoteSenderInfo.sendPacketCount = rtcpPacket.SR.SenderPacketCount;
- _remoteSenderInfo.sendOctetCount = rtcpPacket.SR.SenderOctetCount;
+ _remoteSenderInfo.NTPseconds = sender_report.ntp().seconds();
+ _remoteSenderInfo.NTPfraction = sender_report.ntp().fractions();
+ _remoteSenderInfo.RTPtimeStamp = sender_report.rtp_timestamp();
+ _remoteSenderInfo.sendPacketCount = sender_report.sender_packet_count();
+ _remoteSenderInfo.sendOctetCount = sender_report.sender_octet_count();
_clock->CurrentNtp(_lastReceivedSRNTPsecs, _lastReceivedSRNTPfrac);
} else {
@@ -425,33 +449,27 @@ void RTCPReceiver::HandleSenderReport(
// Update that this remote is alive.
ptrReceiveInfo->last_time_received_ms = _clock->TimeInMilliseconds();
- rtcpPacketType = rtcpParser.Iterate();
-
- while (rtcpPacketType == RTCPPacketTypes::kReportBlockItem) {
- HandleReportBlock(rtcpPacket, rtcpPacketInformation, remoteSSRC);
- rtcpPacketType = rtcpParser.Iterate();
+ for (const rtcp::ReportBlock report_block : sender_report.report_blocks()) {
philipel 2016/09/19 11:01:38 remove {}
danilchap 2016/09/19 13:35:26 Done.
+ HandleReportBlock(report_block, rtcpPacketInformation, remoteSSRC);
}
}
void RTCPReceiver::HandleReceiverReport(
- RTCPUtility::RTCPParserV2& rtcpParser,
+ const CommonHeader& rtcp_block,
RTCPPacketInformation& rtcpPacketInformation) {
- RTCPUtility::RTCPPacketTypes rtcpPacketType = rtcpParser.PacketType();
- const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
-
- RTC_DCHECK(rtcpPacketType == RTCPPacketTypes::kRr);
+ rtcp::ReceiverReport receiver_report;
+ if (!receiver_report.Parse(rtcp_block)) {
+ ++num_skipped_packets_;
+ return;
+ }
- // 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;
+ const uint32_t remoteSSRC = receiver_report.sender_ssrc();
rtcpPacketInformation.remoteSSRC = remoteSSRC;
RTCPReceiveInformation* ptrReceiveInfo = CreateReceiveInformation(remoteSSRC);
- if (!ptrReceiveInfo) {
- rtcpParser.Iterate();
+ if (!ptrReceiveInfo)
return;
- }
TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RR",
"remote_ssrc", remoteSSRC, "ssrc", main_ssrc_);
@@ -461,16 +479,13 @@ void RTCPReceiver::HandleReceiverReport(
// Update that this remote is alive.
ptrReceiveInfo->last_time_received_ms = _clock->TimeInMilliseconds();
- rtcpPacketType = rtcpParser.Iterate();
-
- while (rtcpPacketType == RTCPPacketTypes::kReportBlockItem) {
- HandleReportBlock(rtcpPacket, rtcpPacketInformation, remoteSSRC);
- rtcpPacketType = rtcpParser.Iterate();
+ for (const ReportBlock& report_block : receiver_report.report_blocks()) {
philipel 2016/09/19 11:01:38 remove {}
danilchap 2016/09/19 13:35:26 Done.
+ HandleReportBlock(report_block, rtcpPacketInformation, remoteSSRC);
}
}
void RTCPReceiver::HandleReportBlock(
- const RTCPUtility::RTCPPacket& rtcpPacket,
+ const ReportBlock& report_block,
RTCPPacketInformation& rtcpPacketInformation,
uint32_t remoteSSRC)
EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver) {
philipel 2016/09/19 11:01:38 remove thread annotation from .cc file
danilchap 2016/09/19 13:35:26 oops, Removed.
@@ -484,14 +499,14 @@ void RTCPReceiver::HandleReportBlock(
// which the information in this reception report block pertains.
// Filter out all report blocks that are not for us.
- if (registered_ssrcs_.find(rtcpPacket.ReportBlockItem.SSRC) ==
+ if (registered_ssrcs_.find(report_block.source_ssrc()) ==
registered_ssrcs_.end()) {
// This block is not for us ignore it.
return;
}
- RTCPReportBlockInformation* reportBlock = CreateOrGetReportBlockInformation(
- remoteSSRC, rtcpPacket.ReportBlockItem.SSRC);
+ RTCPReportBlockInformation* reportBlock =
+ CreateOrGetReportBlockInformation(remoteSSRC, report_block.source_ssrc());
if (reportBlock == NULL) {
LOG(LS_WARNING) << "Failed to CreateReportBlockInformation(" << remoteSSRC
<< ")";
@@ -499,36 +514,36 @@ void RTCPReceiver::HandleReportBlock(
}
_lastReceivedRrMs = _clock->TimeInMilliseconds();
- const RTCPPacketReportBlockItem& rb = rtcpPacket.ReportBlockItem;
reportBlock->remoteReceiveBlock.remoteSSRC = remoteSSRC;
- reportBlock->remoteReceiveBlock.sourceSSRC = rb.SSRC;
- reportBlock->remoteReceiveBlock.fractionLost = rb.FractionLost;
+ reportBlock->remoteReceiveBlock.sourceSSRC = report_block.source_ssrc();
+ reportBlock->remoteReceiveBlock.fractionLost = report_block.fraction_lost();
reportBlock->remoteReceiveBlock.cumulativeLost =
- rb.CumulativeNumOfPacketsLost;
- if (rb.ExtendedHighestSequenceNumber >
+ report_block.cumulative_lost();
+ if (report_block.extended_high_seq_num() >
reportBlock->remoteReceiveBlock.extendedHighSeqNum) {
// We have successfully delivered new RTP packets to the remote side after
// the last RR was sent from the remote side.
_lastIncreasedSequenceNumberMs = _lastReceivedRrMs;
}
reportBlock->remoteReceiveBlock.extendedHighSeqNum =
- rb.ExtendedHighestSequenceNumber;
- reportBlock->remoteReceiveBlock.jitter = rb.Jitter;
- reportBlock->remoteReceiveBlock.delaySinceLastSR = rb.DelayLastSR;
- reportBlock->remoteReceiveBlock.lastSR = rb.LastSR;
+ report_block.extended_high_seq_num();
+ reportBlock->remoteReceiveBlock.jitter = report_block.jitter();
+ reportBlock->remoteReceiveBlock.delaySinceLastSR =
+ report_block.delay_since_last_sr();
+ reportBlock->remoteReceiveBlock.lastSR = report_block.last_sr();
- if (rtcpPacket.ReportBlockItem.Jitter > reportBlock->remoteMaxJitter) {
- reportBlock->remoteMaxJitter = rtcpPacket.ReportBlockItem.Jitter;
+ if (report_block.jitter() > reportBlock->remoteMaxJitter) {
+ reportBlock->remoteMaxJitter = report_block.jitter();
}
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:
// If no SR has been received yet, the field is set to zero.
// Receiver rtp_rtcp module is not expected to calculate rtt using
// Sender Reports even if it accidentally can.
if (!receiver_only_ && send_time != 0) {
- uint32_t delay = rtcpPacket.ReportBlockItem.DelayLastSR;
+ uint32_t delay = report_block.delay_since_last_sr();
// Local NTP time.
uint32_t receive_time = CompactNtp(NtpTime(*_clock));
@@ -563,8 +578,8 @@ void RTCPReceiver::HandleReportBlock(
reportBlock->numAverageCalcs++;
}
- TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RR_RTT", rb.SSRC,
- rtt);
+ TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RR_RTT",
+ report_block.source_ssrc(), rtt);
rtcpPacketInformation.AddReportInfo(*reportBlock);
}
@@ -741,76 +756,67 @@ std::vector<rtcp::TmmbItem> RTCPReceiver::BoundingSet(bool* tmmbr_owner) {
return receiveInfo->tmmbn;
}
-void RTCPReceiver::HandleSDES(RTCPUtility::RTCPParserV2& rtcpParser,
+void RTCPReceiver::HandleSDES(const CommonHeader& rtcp_block,
RTCPPacketInformation& rtcpPacketInformation) {
- RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
- while (pktType == RTCPPacketTypes::kSdesChunk) {
- const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
- RTCPCnameInformation* cnameInfo =
- CreateCnameInformation(rtcpPacket.CName.SenderSSRC);
+ rtcp::Sdes sdes;
+ if (!sdes.Parse(rtcp_block)) {
+ ++num_skipped_packets_;
+ return;
+ }
+
+ for (const auto& chunk : sdes.chunks()) {
+ RTCPCnameInformation* cnameInfo = CreateCnameInformation(chunk.ssrc);
RTC_DCHECK(cnameInfo);
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);
if (stats_callback_) {
- stats_callback_->CNameChanged(rtcpPacket.CName.CName,
- rtcpPacket.CName.SenderSSRC);
+ stats_callback_->CNameChanged(chunk.cname.c_str(), chunk.ssrc);
}
}
-
- pktType = rtcpParser.Iterate();
}
rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSdes;
}
-void RTCPReceiver::HandleNACK(RTCPUtility::RTCPParserV2& rtcpParser,
+void RTCPReceiver::HandleNACK(const CommonHeader& rtcp_block,
RTCPPacketInformation& rtcpPacketInformation) {
- const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
- if (receiver_only_ || main_ssrc_ != rtcpPacket.NACK.MediaSSRC) {
- // Not to us.
- rtcpParser.Iterate();
+ rtcp::Nack nack;
+ if (!nack.Parse(rtcp_block)) {
+ ++num_skipped_packets_;
return;
}
- rtcpPacketInformation.ResetNACKPacketIdArray();
- RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
- while (pktType == RTCPPacketTypes::kRtpfbNackItem) {
- rtcpPacketInformation.AddNACKPacket(rtcpPacket.NACKItem.PacketID);
- nack_stats_.ReportRequest(rtcpPacket.NACKItem.PacketID);
-
- uint16_t bitMask = rtcpPacket.NACKItem.BitMask;
- if (bitMask) {
- for (int i = 1; i <= 16; ++i) {
- if (bitMask & 0x01) {
- rtcpPacketInformation.AddNACKPacket(rtcpPacket.NACKItem.PacketID + i);
- nack_stats_.ReportRequest(rtcpPacket.NACKItem.PacketID + i);
- }
- bitMask = bitMask >> 1;
- }
- }
- rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpNack;
-
- pktType = rtcpParser.Iterate();
+ if (receiver_only_ || main_ssrc_ != nack.media_ssrc()) {
philipel 2016/09/19 11:01:38 remove {}
danilchap 2016/09/19 13:35:26 Done.
+ // Not to us.
+ return;
+ }
+ rtcpPacketInformation.nackSequenceNumbers = nack.packet_ids();
+ for (uint16_t packet_id : nack.packet_ids()) {
philipel 2016/09/19 11:01:38 remove {}
danilchap 2016/09/19 13:35:26 Done.
+ nack_stats_.ReportRequest(packet_id);
}
- if (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpNack) {
+ if (!nack.packet_ids().empty()) {
+ rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpNack;
++packet_type_counter_.nack_packets;
packet_type_counter_.nack_requests = nack_stats_.requests();
packet_type_counter_.unique_nack_requests = nack_stats_.unique_requests();
}
}
-void RTCPReceiver::HandleBYE(RTCPUtility::RTCPParserV2& rtcpParser) {
- const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
+void RTCPReceiver::HandleBYE(const CommonHeader& rtcp_block) {
+ rtcp::Bye bye;
+ if (!bye.Parse(rtcp_block)) {
+ ++num_skipped_packets_;
+ return;
+ }
// clear our lists
ReportBlockMap::iterator it = _receivedReportBlockMap.begin();
for (; it != _receivedReportBlockMap.end(); ++it) {
ReportBlockInfoMap* info_map = &(it->second);
- ReportBlockInfoMap::iterator it_info =
- info_map->find(rtcpPacket.BYE.SenderSSRC);
+ ReportBlockInfoMap::iterator it_info = info_map->find(bye.sender_ssrc());
if (it_info != info_map->end()) {
delete it_info->second;
info_map->erase(it_info);
@@ -819,257 +825,218 @@ void RTCPReceiver::HandleBYE(RTCPUtility::RTCPParserV2& rtcpParser) {
// we can't delete it due to TMMBR
std::map<uint32_t, RTCPReceiveInformation*>::iterator receiveInfoIt =
- _receivedInfoMap.find(rtcpPacket.BYE.SenderSSRC);
+ _receivedInfoMap.find(bye.sender_ssrc());
if (receiveInfoIt != _receivedInfoMap.end()) {
receiveInfoIt->second->ready_for_delete = true;
}
std::map<uint32_t, RTCPCnameInformation*>::iterator cnameInfoIt =
- _receivedCnameMap.find(rtcpPacket.BYE.SenderSSRC);
+ _receivedCnameMap.find(bye.sender_ssrc());
if (cnameInfoIt != _receivedCnameMap.end()) {
delete cnameInfoIt->second;
_receivedCnameMap.erase(cnameInfoIt);
}
xr_rr_rtt_ms_ = 0;
- rtcpParser.Iterate();
}
-void RTCPReceiver::HandleXrHeader(
- RTCPUtility::RTCPParserV2& parser,
- RTCPPacketInformation& rtcpPacketInformation) {
- const RTCPUtility::RTCPPacket& packet = parser.Packet();
+void RTCPReceiver::HandleXr(const CommonHeader& rtcp_block,
+ RTCPPacketInformation& rtcpPacketInformation) {
+ rtcp::ExtendedReports xr;
+ 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(
- RTCPUtility::RTCPParserV2& parser,
+ const rtcp::Rrtr& rrtr,
RTCPPacketInformation& rtcpPacketInformation) {
- const RTCPUtility::RTCPPacket& packet = parser.Packet();
-
_remoteXRReceiveTimeInfo.sourceSSRC =
rtcpPacketInformation.xr_originator_ssrc;
- _remoteXRReceiveTimeInfo.lastRR = RTCPUtility::MidNtp(
- packet.XRReceiverReferenceTimeItem.NTPMostSignificant,
- packet.XRReceiverReferenceTimeItem.NTPLeastSignificant);
+ _remoteXRReceiveTimeInfo.lastRR = CompactNtp(rrtr.ntp());
_clock->CurrentNtp(_lastReceivedXRNTPsecs, _lastReceivedXRNTPfrac);
rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpXrReceiverReferenceTime;
-
- parser.Iterate();
}
void RTCPReceiver::HandleXrDlrrReportBlock(
- RTCPUtility::RTCPParserV2& parser,
+ const rtcp::ReceiveTimeInfo& rti,
RTCPPacketInformation& rtcpPacketInformation) {
- const RTCPUtility::RTCPPacket& packet = parser.Packet();
- // Iterate through sub-block(s), if any.
- RTCPUtility::RTCPPacketTypes packet_type = parser.Iterate();
-
- while (packet_type == RTCPPacketTypes::kXrDlrrReportBlockItem) {
- if (registered_ssrcs_.find(packet.XRDLRRReportBlockItem.SSRC) ==
- registered_ssrcs_.end()) {
- // Not to us.
- return;
- }
-
- rtcpPacketInformation.xr_dlrr_item = true;
+ if (registered_ssrcs_.find(rti.ssrc) == registered_ssrcs_.end()) {
philipel 2016/09/19 11:01:38 remove {}
danilchap 2016/09/19 13:35:26 Done.
+ // Not to us.
+ return;
+ }
- // Caller should explicitly enable rtt calculation using extended reports.
- if (!xr_rrtr_status_)
- return;
+ rtcpPacketInformation.xr_dlrr_item = true;
- // The send_time and delay_rr fields are in units of 1/2^16 sec.
- uint32_t send_time = packet.XRDLRRReportBlockItem.LastRR;
- // 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;
+ // Caller should explicitly enable rtt calculation using extended reports.
+ if (!xr_rrtr_status_)
+ return;
- uint32_t delay_rr = packet.XRDLRRReportBlockItem.DelayLastRR;
- uint32_t now = CompactNtp(NtpTime(*_clock));
+ // The send_time and delay_rr fields are in units of 1/2^16 sec.
+ uint32_t send_time = rti.last_rr;
+ // 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 rtt_ntp = now - delay_rr - send_time;
- xr_rr_rtt_ms_ = CompactNtpRttToMs(rtt_ntp);
+ uint32_t delay_rr = rti.delay_since_last_rr;
+ uint32_t now = CompactNtp(NtpTime(*_clock));
- rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpXrDlrrReportBlock;
+ uint32_t rtt_ntp = now - delay_rr - send_time;
+ xr_rr_rtt_ms_ = CompactNtpRttToMs(rtt_ntp);
- packet_type = parser.Iterate();
- }
+ rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpXrDlrrReportBlock;
}
-void RTCPReceiver::HandlePLI(RTCPUtility::RTCPParserV2& rtcpParser,
+void RTCPReceiver::HandlePLI(const CommonHeader& rtcp_block,
RTCPPacketInformation& rtcpPacketInformation) {
- const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
- if (main_ssrc_ == rtcpPacket.PLI.MediaSSRC) {
+ rtcp::Pli pli;
+ 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");
++packet_type_counter_.pli_packets;
// Received a signal that we need to send a new key frame.
rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpPli;
}
- rtcpParser.Iterate();
}
-void RTCPReceiver::HandleTMMBR(RTCPUtility::RTCPParserV2& rtcpParser,
+void RTCPReceiver::HandleTMMBR(const CommonHeader& rtcp_block,
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);
if (ptrReceiveInfo == NULL) {
// This remote SSRC must be saved before.
- rtcpParser.Iterate();
return;
}
- if (rtcpPacket.TMMBR.MediaSSRC) {
+ if (tmmbr.media_ssrc()) {
// rtcpPacket.TMMBR.MediaSSRC SHOULD be 0 if same as SenderSSRC
// in relay mode this is a valid number
- senderSSRC = rtcpPacket.TMMBR.MediaSSRC;
- }
-
- // Use packet length to calc max number of TMMBR blocks
- // each TMMBR block is 8 bytes
- ptrdiff_t maxNumOfTMMBRBlocks = rtcpParser.LengthLeft() / 8;
-
- // sanity, we can't have more than what's in one packet
- if (maxNumOfTMMBRBlocks > 200) {
- assert(false);
- rtcpParser.Iterate();
- return;
+ senderSSRC = tmmbr.media_ssrc();
}
- 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());
+ for (const rtcp::TmmbItem& request : tmmbr.requests()) {
+ if (main_ssrc_ == request.ssrc() && request.bitrate_bps()) {
+ ptrReceiveInfo->InsertTmmbrItem(senderSSRC, request,
+ _clock->TimeInMilliseconds());
rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpTmmbr;
}
-
- pktType = rtcpParser.Iterate();
}
}
-void RTCPReceiver::HandleTMMBN(RTCPUtility::RTCPParserV2& rtcpParser,
+void RTCPReceiver::HandleTMMBN(const CommonHeader& rtcp_block,
RTCPPacketInformation& rtcpPacketInformation) {
- const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
+ rtcp::Tmmbn tmmbn;
+ if (!tmmbn.Parse(rtcp_block)) {
+ ++num_skipped_packets_;
+ return;
+ }
+
RTCPReceiveInformation* ptrReceiveInfo =
- GetReceiveInformation(rtcpPacket.TMMBN.SenderSSRC);
+ GetReceiveInformation(tmmbn.sender_ssrc());
if (ptrReceiveInfo == NULL) {
// This remote SSRC must be saved before.
- rtcpParser.Iterate();
return;
}
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
- if (maxNumOfTMMBNBlocks > 200) {
- assert(false);
- rtcpParser.Iterate();
- 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();
+ for (const auto& item : tmmbn.items()) {
philipel 2016/09/19 11:01:38 remove {}
danilchap 2016/09/19 13:35:26 Done.
+ ptrReceiveInfo->tmmbn.push_back(item);
}
}
-void RTCPReceiver::HandleSR_REQ(RTCPUtility::RTCPParserV2& rtcpParser,
+void RTCPReceiver::HandleSR_REQ(const CommonHeader& rtcp_block,
RTCPPacketInformation& rtcpPacketInformation) {
+ rtcp::RapidResyncRequest sr_req;
+ if (!sr_req.Parse(rtcp_block)) {
+ ++num_skipped_packets_;
+ return;
+ }
+
rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSrReq;
- rtcpParser.Iterate();
}
-void RTCPReceiver::HandleSLI(RTCPUtility::RTCPParserV2& rtcpParser,
+void RTCPReceiver::HandleSLI(const CommonHeader& rtcp_block,
RTCPPacketInformation& rtcpPacketInformation) {
- const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
- RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
- while (pktType == RTCPPacketTypes::kPsfbSliItem) {
- // in theory there could be multiple slices lost
- rtcpPacketInformation.rtcpPacketTypeFlags |=
- kRtcpSli; // received signal that we need to refresh a slice
- rtcpPacketInformation.sliPictureId = rtcpPacket.SLIItem.PictureId;
+ rtcp::Sli sli;
+ if (!sli.Parse(rtcp_block)) {
+ ++num_skipped_packets_;
+ return;
+ }
- 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(
- RTCPUtility::RTCPParserV2& rtcpParser,
+ const CommonHeader& rtcp_block,
RTCPHelp::RTCPPacketInformation& rtcpPacketInformation) {
- const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
- RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
- if (pktType == RTCPPacketTypes::kPsfbRpsiItem) {
- if (rtcpPacket.RPSI.NumberOfValidBits % 8 != 0) {
- // 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);
+ rtcp::Rpsi rpsi;
+ if (!rpsi.Parse(rtcp_block)) {
+ ++num_skipped_packets_;
+ return;
}
+
+ // 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) {
- RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
- if (pktType == RTCPPacketTypes::kPsfbRemb) {
- pktType = rtcpParser.Iterate();
- if (pktType == RTCPPacketTypes::kPsfbRembItem) {
- const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
- rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRemb;
- rtcpPacketInformation.receiverEstimatedMaxBitrate =
- rtcpPacket.REMBItem.BitRate;
-
- rtcpParser.Iterate();
- }
+ rtcp::Remb remb;
+ if (remb.Parse(rtcp_block)) {
+ rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRemb;
+ rtcpPacketInformation.receiverEstimatedMaxBitrate = remb.bitrate_bps();
+ return;
}
+
+ ++num_skipped_packets_;
}
-void RTCPReceiver::HandleFIR(RTCPUtility::RTCPParserV2& rtcpParser,
+void RTCPReceiver::HandleFIR(const CommonHeader& rtcp_block,
RTCPPacketInformation& rtcpPacketInformation) {
- const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
+ rtcp::Fir fir;
+ if (!fir.Parse(rtcp_block)) {
+ ++num_skipped_packets_;
+ return;
+ }
+
RTCPReceiveInformation* ptrReceiveInfo =
- GetReceiveInformation(rtcpPacket.FIR.SenderSSRC);
+ GetReceiveInformation(fir.sender_ssrc());
- RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
- while (pktType == RTCPPacketTypes::kPsfbFirItem) {
+ for (const rtcp::Fir::Request& fir_request : fir.requests()) {
// Is it our sender that is requested to generate a new keyframe
- if (main_ssrc_ != rtcpPacket.FIRItem.SSRC) {
- return;
- }
+ if (main_ssrc_ != fir_request.ssrc)
+ continue;
++packet_type_counter_.fir_packets;
@@ -1077,15 +1044,13 @@ void RTCPReceiver::HandleFIR(RTCPUtility::RTCPParserV2& rtcpParser,
// we don't know who this originate from
if (ptrReceiveInfo) {
// check if we have reported this FIRSequenceNumber before
- if (rtcpPacket.FIRItem.CommandSequenceNumber !=
- ptrReceiveInfo->last_fir_sequence_number) {
+ if (fir_request.seq_nr != ptrReceiveInfo->last_fir_sequence_number) {
int64_t now = _clock->TimeInMilliseconds();
// sanity; don't go crazy with the callbacks
if ((now - ptrReceiveInfo->last_fir_request_ms) >
RTCP_MIN_FRAME_LENGTH_MS) {
ptrReceiveInfo->last_fir_request_ms = now;
- ptrReceiveInfo->last_fir_sequence_number =
- rtcpPacket.FIRItem.CommandSequenceNumber;
+ ptrReceiveInfo->last_fir_sequence_number = fir_request.seq_nr;
// received signal that we need to send a new key frame
rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpFir;
}
@@ -1094,21 +1059,21 @@ void RTCPReceiver::HandleFIR(RTCPUtility::RTCPParserV2& rtcpParser,
// received signal that we need to send a new key frame
rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpFir;
}
-
- pktType = rtcpParser.Iterate();
}
}
void RTCPReceiver::HandleTransportFeedback(
- RTCPUtility::RTCPParserV2* rtcp_parser,
+ const CommonHeader& rtcp_block,
RTCPHelp::RTCPPacketInformation* rtcp_packet_information) {
- rtcp::RtcpPacket* packet = rtcp_parser->ReleaseRtcpPacket();
- RTC_DCHECK(packet != nullptr);
- rtcp_packet_information->rtcpPacketTypeFlags |= kRtcpTransportFeedback;
- rtcp_packet_information->transport_feedback_.reset(
- static_cast<rtcp::TransportFeedback*>(packet));
+ std::unique_ptr<rtcp::TransportFeedback> transport_feedback(
+ new rtcp::TransportFeedback());
+ if (!transport_feedback->Parse(rtcp_block)) {
+ ++num_skipped_packets_;
+ return;
+ }
- rtcp_parser->Iterate();
+ rtcp_packet_information->rtcpPacketTypeFlags |= kRtcpTransportFeedback;
+ rtcp_packet_information->transport_feedback_ = std::move(transport_feedback);
}
void RTCPReceiver::UpdateTmmbr() {
« no previous file with comments | « webrtc/modules/rtp_rtcp/source/rtcp_receiver.h ('k') | webrtc/modules/rtp_rtcp/source/rtcp_receiver_help.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698