OLD | NEW |
---|---|
1 /* | 1 /* |
2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. | 2 * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved. |
3 * | 3 * |
4 * Use of this source code is governed by a BSD-style license | 4 * Use of this source code is governed by a BSD-style license |
5 * that can be found in the LICENSE file in the root of the source | 5 * that can be found in the LICENSE file in the root of the source |
6 * tree. An additional intellectual property rights grant can be found | 6 * tree. An additional intellectual property rights grant can be found |
7 * in the file PATENTS. All contributing project authors may | 7 * in the file PATENTS. All contributing project authors may |
8 * be found in the AUTHORS file in the root of the source tree. | 8 * be found in the AUTHORS file in the root of the source tree. |
9 */ | 9 */ |
10 | 10 |
11 #include "webrtc/modules/rtp_rtcp/source/rtcp_receiver.h" | 11 #include "webrtc/modules/rtp_rtcp/source/rtcp_receiver.h" |
12 | 12 |
13 #include <assert.h> | 13 #include <assert.h> |
14 #include <string.h> | 14 #include <string.h> |
15 | 15 |
16 #include <limits> | 16 #include <limits> |
17 | 17 |
18 #include "webrtc/base/checks.h" | 18 #include "webrtc/base/checks.h" |
19 #include "webrtc/base/logging.h" | 19 #include "webrtc/base/logging.h" |
20 #include "webrtc/base/trace_event.h" | 20 #include "webrtc/base/trace_event.h" |
21 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/bye.h" | |
22 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/common_header.h" | |
23 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/compound_packet.h" | |
24 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/extended_reports.h" | |
25 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/fir.h" | |
26 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/nack.h" | |
27 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/pli.h" | |
28 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/rapid_resync_request.h" | |
29 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/receiver_report.h" | |
30 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/remb.h" | |
31 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/rpsi.h" | |
32 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sdes.h" | |
33 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sender_report.h" | |
34 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/sli.h" | |
35 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbn.h" | |
36 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/tmmbr.h" | |
21 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h" | 37 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h" |
22 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h" | 38 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h" |
23 #include "webrtc/modules/rtp_rtcp/source/time_util.h" | 39 #include "webrtc/modules/rtp_rtcp/source/time_util.h" |
24 #include "webrtc/modules/rtp_rtcp/source/tmmbr_help.h" | 40 #include "webrtc/modules/rtp_rtcp/source/tmmbr_help.h" |
25 #include "webrtc/system_wrappers/include/ntp_time.h" | 41 #include "webrtc/system_wrappers/include/ntp_time.h" |
26 | 42 |
27 namespace webrtc { | 43 namespace webrtc { |
28 using RTCPHelp::RTCPPacketInformation; | 44 namespace { |
29 using RTCPHelp::RTCPReceiveInformation; | 45 |
30 using RTCPHelp::RTCPReportBlockInformation; | 46 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,
| |
31 using RTCPUtility::kBtVoipMetric; | 47 using ::webrtc::rtcp::ReportBlock; |
32 using RTCPUtility::RTCPCnameInformation; | 48 using ::webrtc::RTCPHelp::RTCPPacketInformation; |
33 using RTCPUtility::RTCPPacketReportBlockItem; | 49 using ::webrtc::RTCPHelp::RTCPReceiveInformation; |
34 using RTCPUtility::RTCPPacketTypes; | 50 using ::webrtc::RTCPHelp::RTCPReportBlockInformation; |
51 using ::webrtc::RTCPUtility::RTCPCnameInformation; | |
52 using ::webrtc::RTCPUtility::RTCPPacketReportBlockItem; | |
53 using ::webrtc::RTCPUtility::RTCPPacketTypes; | |
35 | 54 |
36 // The number of RTCP time intervals needed to trigger a timeout. | 55 // The number of RTCP time intervals needed to trigger a timeout. |
37 const int kRrTimeoutIntervals = 3; | 56 const int kRrTimeoutIntervals = 3; |
38 | 57 |
39 const int64_t kMaxWarningLogIntervalMs = 10000; | 58 const int64_t kMaxWarningLogIntervalMs = 10000; |
40 | 59 |
60 } // namespace | |
61 | |
41 RTCPReceiver::RTCPReceiver( | 62 RTCPReceiver::RTCPReceiver( |
42 Clock* clock, | 63 Clock* clock, |
43 bool receiver_only, | 64 bool receiver_only, |
44 RtcpPacketTypeCounterObserver* packet_type_counter_observer, | 65 RtcpPacketTypeCounterObserver* packet_type_counter_observer, |
45 RtcpBandwidthObserver* rtcp_bandwidth_observer, | 66 RtcpBandwidthObserver* rtcp_bandwidth_observer, |
46 RtcpIntraFrameObserver* rtcp_intra_frame_observer, | 67 RtcpIntraFrameObserver* rtcp_intra_frame_observer, |
47 TransportFeedbackObserver* transport_feedback_observer, | 68 TransportFeedbackObserver* transport_feedback_observer, |
48 ModuleRtpRtcp* owner) | 69 ModuleRtpRtcp* owner) |
49 : _clock(clock), | 70 : _clock(clock), |
50 receiver_only_(receiver_only), | 71 receiver_only_(receiver_only), |
51 _lastReceived(0), | |
52 _rtpRtcp(*owner), | 72 _rtpRtcp(*owner), |
53 _cbRtcpBandwidthObserver(rtcp_bandwidth_observer), | 73 _cbRtcpBandwidthObserver(rtcp_bandwidth_observer), |
54 _cbRtcpIntraFrameObserver(rtcp_intra_frame_observer), | 74 _cbRtcpIntraFrameObserver(rtcp_intra_frame_observer), |
55 _cbTransportFeedbackObserver(transport_feedback_observer), | 75 _cbTransportFeedbackObserver(transport_feedback_observer), |
56 main_ssrc_(0), | 76 main_ssrc_(0), |
57 _remoteSSRC(0), | 77 _remoteSSRC(0), |
58 _remoteSenderInfo(), | 78 _remoteSenderInfo(), |
59 _lastReceivedSRNTPsecs(0), | 79 _lastReceivedSRNTPsecs(0), |
60 _lastReceivedSRNTPfrac(0), | 80 _lastReceivedSRNTPfrac(0), |
61 _lastReceivedXRNTPsecs(0), | 81 _lastReceivedXRNTPsecs(0), |
(...skipping 28 matching lines...) Expand all Loading... | |
90 } | 110 } |
91 while (!_receivedCnameMap.empty()) { | 111 while (!_receivedCnameMap.empty()) { |
92 std::map<uint32_t, RTCPCnameInformation*>::iterator first = | 112 std::map<uint32_t, RTCPCnameInformation*>::iterator first = |
93 _receivedCnameMap.begin(); | 113 _receivedCnameMap.begin(); |
94 delete first->second; | 114 delete first->second; |
95 _receivedCnameMap.erase(first); | 115 _receivedCnameMap.erase(first); |
96 } | 116 } |
97 } | 117 } |
98 | 118 |
99 bool RTCPReceiver::IncomingPacket(const uint8_t* packet, size_t packet_size) { | 119 bool RTCPReceiver::IncomingPacket(const uint8_t* packet, size_t packet_size) { |
100 // Allow receive of non-compound RTCP packets. | 120 if (packet_size == 0) { |
101 RTCPUtility::RTCPParserV2 rtcp_parser(packet, packet_size, true); | 121 LOG(LS_WARNING) << "Incoming empty RTCP packet"; |
102 | |
103 if (!rtcp_parser.IsValid()) { | |
104 LOG(LS_WARNING) << "Incoming invalid RTCP packet"; | |
105 return false; | 122 return false; |
106 } | 123 } |
107 RTCPHelp::RTCPPacketInformation rtcp_packet_information; | 124 |
108 IncomingRTCPPacket(rtcp_packet_information, &rtcp_parser); | 125 RTCPHelp::RTCPPacketInformation packet_information; |
109 TriggerCallbacksFromRTCPPacket(rtcp_packet_information); | 126 if (!ParseCompoundPacket(packet, packet + packet_size, &packet_information)) |
127 return false; | |
128 TriggerCallbacksFromRTCPPacket(packet_information); | |
110 return true; | 129 return true; |
111 } | 130 } |
112 | 131 |
113 int64_t RTCPReceiver::LastReceived() { | |
114 rtc::CritScope lock(&_criticalSectionRTCPReceiver); | |
115 return _lastReceived; | |
116 } | |
117 | |
118 int64_t RTCPReceiver::LastReceivedReceiverReport() const { | 132 int64_t RTCPReceiver::LastReceivedReceiverReport() const { |
119 rtc::CritScope lock(&_criticalSectionRTCPReceiver); | 133 rtc::CritScope lock(&_criticalSectionRTCPReceiver); |
120 int64_t last_received_rr = -1; | 134 int64_t last_received_rr = -1; |
121 for (ReceivedInfoMap::const_iterator it = _receivedInfoMap.begin(); | 135 for (ReceivedInfoMap::const_iterator it = _receivedInfoMap.begin(); |
122 it != _receivedInfoMap.end(); ++it) { | 136 it != _receivedInfoMap.end(); ++it) { |
123 if (it->second->last_time_received_ms > last_received_rr) { | 137 if (it->second->last_time_received_ms > last_received_rr) { |
124 last_received_rr = it->second->last_time_received_ms; | 138 last_received_rr = it->second->last_time_received_ms; |
125 } | 139 } |
126 } | 140 } |
127 return last_received_rr; | 141 return last_received_rr; |
(...skipping 147 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
275 for (; it != _receivedReportBlockMap.end(); ++it) { | 289 for (; it != _receivedReportBlockMap.end(); ++it) { |
276 const ReportBlockInfoMap* info_map = &(it->second); | 290 const ReportBlockInfoMap* info_map = &(it->second); |
277 ReportBlockInfoMap::const_iterator it_info = info_map->begin(); | 291 ReportBlockInfoMap::const_iterator it_info = info_map->begin(); |
278 for (; it_info != info_map->end(); ++it_info) { | 292 for (; it_info != info_map->end(); ++it_info) { |
279 receiveBlocks->push_back(it_info->second->remoteReceiveBlock); | 293 receiveBlocks->push_back(it_info->second->remoteReceiveBlock); |
280 } | 294 } |
281 } | 295 } |
282 return 0; | 296 return 0; |
283 } | 297 } |
284 | 298 |
285 int32_t RTCPReceiver::IncomingRTCPPacket( | 299 bool RTCPReceiver::ParseCompoundPacket( |
286 RTCPPacketInformation& rtcpPacketInformation, | 300 const uint8_t* packet_begin, |
287 RTCPUtility::RTCPParserV2* rtcpParser) { | 301 const uint8_t* packet_end, |
302 RTCPPacketInformation* packet_information) { | |
288 rtc::CritScope lock(&_criticalSectionRTCPReceiver); | 303 rtc::CritScope lock(&_criticalSectionRTCPReceiver); |
289 | 304 |
290 _lastReceived = _clock->TimeInMilliseconds(); | 305 CommonHeader rtcp_block; |
306 for (const uint8_t* next_block = packet_begin; next_block != packet_end; | |
307 next_block = rtcp_block.NextPacket()) { | |
308 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
| |
309 RTC_DCHECK_GT(tail_size, 0); | |
310 if (!rtcp_block.Parse(next_block, tail_size)) { | |
311 bool first = next_block == packet_begin; | |
312 if (first) { | |
313 LOG(LS_WARNING) << "Incoming invalid RTCP packet"; | |
314 return false; | |
315 } | |
316 ++num_skipped_packets_; | |
317 break; | |
318 } | |
291 | 319 |
292 if (packet_type_counter_.first_packet_time_ms == -1) { | 320 if (packet_type_counter_.first_packet_time_ms == -1) |
293 packet_type_counter_.first_packet_time_ms = _lastReceived; | 321 packet_type_counter_.first_packet_time_ms = _clock->TimeInMilliseconds(); |
294 } | |
295 | 322 |
296 RTCPUtility::RTCPPacketTypes pktType = rtcpParser->Begin(); | 323 switch (rtcp_block.type()) { |
297 while (pktType != RTCPPacketTypes::kInvalid) { | 324 case rtcp::SenderReport::kPacketType: |
298 // Each "case" is responsible for iterate the parser to the | 325 HandleSenderReport(rtcp_block, *packet_information); |
299 // next top level packet. | |
300 switch (pktType) { | |
301 case RTCPPacketTypes::kSr: | |
302 HandleSenderReport(*rtcpParser, rtcpPacketInformation); | |
303 break; | 326 break; |
304 case RTCPPacketTypes::kRr: | 327 case rtcp::ReceiverReport::kPacketType: |
305 HandleReceiverReport(*rtcpParser, rtcpPacketInformation); | 328 HandleReceiverReport(rtcp_block, *packet_information); |
306 break; | 329 break; |
307 case RTCPPacketTypes::kSdes: | 330 case rtcp::Sdes::kPacketType: |
308 HandleSDES(*rtcpParser, rtcpPacketInformation); | 331 HandleSDES(rtcp_block, *packet_information); |
309 break; | 332 break; |
310 case RTCPPacketTypes::kXrHeader: | 333 case rtcp::ExtendedReports::kPacketType: |
311 HandleXrHeader(*rtcpParser, rtcpPacketInformation); | 334 HandleXr(rtcp_block, *packet_information); |
312 break; | 335 break; |
313 case RTCPPacketTypes::kXrReceiverReferenceTime: | 336 case rtcp::Bye::kPacketType: |
314 HandleXrReceiveReferenceTime(*rtcpParser, rtcpPacketInformation); | 337 HandleBYE(rtcp_block); |
315 break; | 338 break; |
316 case RTCPPacketTypes::kXrDlrrReportBlock: | 339 case rtcp::Rtpfb::kPacketType: |
317 HandleXrDlrrReportBlock(*rtcpParser, rtcpPacketInformation); | 340 switch (rtcp_block.fmt()) { |
341 case rtcp::Nack::kFeedbackMessageType: | |
342 HandleNACK(rtcp_block, *packet_information); | |
343 break; | |
344 case rtcp::Tmmbr::kFeedbackMessageType: | |
345 HandleTMMBR(rtcp_block, *packet_information); | |
346 break; | |
347 case rtcp::Tmmbn::kFeedbackMessageType: | |
348 HandleTMMBN(rtcp_block, *packet_information); | |
349 break; | |
350 case rtcp::RapidResyncRequest::kFeedbackMessageType: | |
351 HandleSR_REQ(rtcp_block, *packet_information); | |
352 break; | |
353 case rtcp::TransportFeedback::kFeedbackMessageType: | |
354 HandleTransportFeedback(rtcp_block, packet_information); | |
355 break; | |
356 default: | |
357 ++num_skipped_packets_; | |
358 break; | |
359 } | |
318 break; | 360 break; |
319 case RTCPPacketTypes::kBye: | 361 case rtcp::Psfb::kPacketType: |
320 HandleBYE(*rtcpParser); | 362 switch (rtcp_block.fmt()) { |
321 break; | 363 case rtcp::Pli::kFeedbackMessageType: |
322 case RTCPPacketTypes::kRtpfbNack: | 364 HandlePLI(rtcp_block, *packet_information); |
323 HandleNACK(*rtcpParser, rtcpPacketInformation); | 365 break; |
324 break; | 366 case rtcp::Sli::kFeedbackMessageType: |
325 case RTCPPacketTypes::kRtpfbTmmbr: | 367 HandleSLI(rtcp_block, *packet_information); |
326 HandleTMMBR(*rtcpParser, rtcpPacketInformation); | 368 break; |
327 break; | 369 case rtcp::Rpsi::kFeedbackMessageType: |
328 case RTCPPacketTypes::kRtpfbTmmbn: | 370 HandleRPSI(rtcp_block, *packet_information); |
329 HandleTMMBN(*rtcpParser, rtcpPacketInformation); | 371 break; |
330 break; | 372 case rtcp::Fir::kFeedbackMessageType: |
331 case RTCPPacketTypes::kRtpfbSrReq: | 373 HandleFIR(rtcp_block, *packet_information); |
332 HandleSR_REQ(*rtcpParser, rtcpPacketInformation); | 374 break; |
333 break; | 375 case rtcp::Remb::kFeedbackMessageType: |
334 case RTCPPacketTypes::kPsfbPli: | 376 HandlePsfbApp(rtcp_block, *packet_information); |
335 HandlePLI(*rtcpParser, rtcpPacketInformation); | 377 break; |
336 break; | 378 default: |
337 case RTCPPacketTypes::kPsfbSli: | 379 ++num_skipped_packets_; |
338 HandleSLI(*rtcpParser, rtcpPacketInformation); | 380 break; |
339 break; | 381 } |
340 case RTCPPacketTypes::kPsfbRpsi: | |
341 HandleRPSI(*rtcpParser, rtcpPacketInformation); | |
342 break; | |
343 case RTCPPacketTypes::kPsfbFir: | |
344 HandleFIR(*rtcpParser, rtcpPacketInformation); | |
345 break; | |
346 case RTCPPacketTypes::kPsfbApp: | |
347 HandlePsfbApp(*rtcpParser, rtcpPacketInformation); | |
348 break; | |
349 case RTCPPacketTypes::kTransportFeedback: | |
350 HandleTransportFeedback(rtcpParser, &rtcpPacketInformation); | |
351 break; | 382 break; |
352 default: | 383 default: |
353 rtcpParser->Iterate(); | 384 ++num_skipped_packets_; |
354 break; | 385 break; |
355 } | 386 } |
356 pktType = rtcpParser->PacketType(); | |
357 } | 387 } |
358 | 388 |
359 if (packet_type_counter_observer_ != NULL) { | 389 if (packet_type_counter_observer_ != NULL) { |
360 packet_type_counter_observer_->RtcpPacketTypesCounterUpdated( | 390 packet_type_counter_observer_->RtcpPacketTypesCounterUpdated( |
361 main_ssrc_, packet_type_counter_); | 391 main_ssrc_, packet_type_counter_); |
362 } | 392 } |
363 | 393 |
364 num_skipped_packets_ += rtcpParser->NumSkippedBlocks(); | |
365 | |
366 int64_t now = _clock->TimeInMilliseconds(); | 394 int64_t now = _clock->TimeInMilliseconds(); |
367 if (now - last_skipped_packets_warning_ >= kMaxWarningLogIntervalMs && | 395 if (now - last_skipped_packets_warning_ >= kMaxWarningLogIntervalMs && |
368 num_skipped_packets_ > 0) { | 396 num_skipped_packets_ > 0) { |
369 last_skipped_packets_warning_ = now; | 397 last_skipped_packets_warning_ = now; |
370 LOG(LS_WARNING) << num_skipped_packets_ | 398 LOG(LS_WARNING) << num_skipped_packets_ |
371 << " RTCP blocks were skipped due to being malformed or of " | 399 << " RTCP blocks were skipped due to being malformed or of " |
372 "unrecognized/unsupported type, during the past " | 400 "unrecognized/unsupported type, during the past " |
373 << (kMaxWarningLogIntervalMs / 1000) << " second period."; | 401 << (kMaxWarningLogIntervalMs / 1000) << " second period."; |
374 } | 402 } |
375 | 403 |
376 return 0; | 404 return true; |
377 } | 405 } |
378 | 406 |
379 void RTCPReceiver::HandleSenderReport( | 407 void RTCPReceiver::HandleSenderReport( |
380 RTCPUtility::RTCPParserV2& rtcpParser, | 408 const CommonHeader& rtcp_block, |
381 RTCPPacketInformation& rtcpPacketInformation) { | 409 RTCPPacketInformation& rtcpPacketInformation) { |
382 RTCPUtility::RTCPPacketTypes rtcpPacketType = rtcpParser.PacketType(); | 410 rtcp::SenderReport sender_report; |
383 const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet(); | 411 if (!sender_report.Parse(rtcp_block)) { |
412 ++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<>
| |
413 return; | |
414 } | |
384 | 415 |
385 RTC_DCHECK(rtcpPacketType == RTCPPacketTypes::kSr); | 416 const uint32_t remoteSSRC = sender_report.sender_ssrc(); |
386 | |
387 // SR.SenderSSRC | |
388 // The synchronization source identifier for the originator of this SR packet | |
389 | |
390 const uint32_t remoteSSRC = rtcpPacket.SR.SenderSSRC; | |
391 | 417 |
392 rtcpPacketInformation.remoteSSRC = remoteSSRC; | 418 rtcpPacketInformation.remoteSSRC = remoteSSRC; |
393 | 419 |
394 RTCPReceiveInformation* ptrReceiveInfo = CreateReceiveInformation(remoteSSRC); | 420 RTCPReceiveInformation* ptrReceiveInfo = CreateReceiveInformation(remoteSSRC); |
395 if (!ptrReceiveInfo) { | 421 if (!ptrReceiveInfo) |
396 rtcpParser.Iterate(); | |
397 return; | 422 return; |
398 } | |
399 | 423 |
400 TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "SR", | 424 TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "SR", |
401 "remote_ssrc", remoteSSRC, "ssrc", main_ssrc_); | 425 "remote_ssrc", remoteSSRC, "ssrc", main_ssrc_); |
402 | 426 |
403 // Have I received RTP packets from this party? | 427 // Have I received RTP packets from this party? |
404 if (_remoteSSRC == remoteSSRC) { | 428 if (_remoteSSRC == remoteSSRC) { |
405 // Only signal that we have received a SR when we accept one. | 429 // Only signal that we have received a SR when we accept one. |
406 rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSr; | 430 rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSr; |
407 | 431 |
408 rtcpPacketInformation.ntp_secs = rtcpPacket.SR.NTPMostSignificant; | 432 rtcpPacketInformation.ntp_secs = sender_report.ntp().seconds(); |
409 rtcpPacketInformation.ntp_frac = rtcpPacket.SR.NTPLeastSignificant; | 433 rtcpPacketInformation.ntp_frac = sender_report.ntp().fractions(); |
410 rtcpPacketInformation.rtp_timestamp = rtcpPacket.SR.RTPTimestamp; | 434 rtcpPacketInformation.rtp_timestamp = sender_report.rtp_timestamp(); |
411 | 435 |
412 // Save the NTP time of this report. | 436 // Save the NTP time of this report. |
413 _remoteSenderInfo.NTPseconds = rtcpPacket.SR.NTPMostSignificant; | 437 _remoteSenderInfo.NTPseconds = sender_report.ntp().seconds(); |
414 _remoteSenderInfo.NTPfraction = rtcpPacket.SR.NTPLeastSignificant; | 438 _remoteSenderInfo.NTPfraction = sender_report.ntp().fractions(); |
415 _remoteSenderInfo.RTPtimeStamp = rtcpPacket.SR.RTPTimestamp; | 439 _remoteSenderInfo.RTPtimeStamp = sender_report.rtp_timestamp(); |
416 _remoteSenderInfo.sendPacketCount = rtcpPacket.SR.SenderPacketCount; | 440 _remoteSenderInfo.sendPacketCount = sender_report.sender_packet_count(); |
417 _remoteSenderInfo.sendOctetCount = rtcpPacket.SR.SenderOctetCount; | 441 _remoteSenderInfo.sendOctetCount = sender_report.sender_octet_count(); |
418 | 442 |
419 _clock->CurrentNtp(_lastReceivedSRNTPsecs, _lastReceivedSRNTPfrac); | 443 _clock->CurrentNtp(_lastReceivedSRNTPsecs, _lastReceivedSRNTPfrac); |
420 } else { | 444 } else { |
421 // We will only store the send report from one source, but | 445 // We will only store the send report from one source, but |
422 // we will store all the receive blocks. | 446 // we will store all the receive blocks. |
423 rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRr; | 447 rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRr; |
424 } | 448 } |
425 // Update that this remote is alive. | 449 // Update that this remote is alive. |
426 ptrReceiveInfo->last_time_received_ms = _clock->TimeInMilliseconds(); | 450 ptrReceiveInfo->last_time_received_ms = _clock->TimeInMilliseconds(); |
427 | 451 |
428 rtcpPacketType = rtcpParser.Iterate(); | 452 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.
| |
429 | 453 HandleReportBlock(report_block, rtcpPacketInformation, remoteSSRC); |
430 while (rtcpPacketType == RTCPPacketTypes::kReportBlockItem) { | |
431 HandleReportBlock(rtcpPacket, rtcpPacketInformation, remoteSSRC); | |
432 rtcpPacketType = rtcpParser.Iterate(); | |
433 } | 454 } |
434 } | 455 } |
435 | 456 |
436 void RTCPReceiver::HandleReceiverReport( | 457 void RTCPReceiver::HandleReceiverReport( |
437 RTCPUtility::RTCPParserV2& rtcpParser, | 458 const CommonHeader& rtcp_block, |
438 RTCPPacketInformation& rtcpPacketInformation) { | 459 RTCPPacketInformation& rtcpPacketInformation) { |
439 RTCPUtility::RTCPPacketTypes rtcpPacketType = rtcpParser.PacketType(); | 460 rtcp::ReceiverReport receiver_report; |
440 const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet(); | 461 if (!receiver_report.Parse(rtcp_block)) { |
462 ++num_skipped_packets_; | |
463 return; | |
464 } | |
441 | 465 |
442 RTC_DCHECK(rtcpPacketType == RTCPPacketTypes::kRr); | 466 const uint32_t remoteSSRC = receiver_report.sender_ssrc(); |
443 | |
444 // rtcpPacket.RR.SenderSSRC | |
445 // The source of the packet sender, same as of SR? or is this a CE? | |
446 const uint32_t remoteSSRC = rtcpPacket.RR.SenderSSRC; | |
447 | 467 |
448 rtcpPacketInformation.remoteSSRC = remoteSSRC; | 468 rtcpPacketInformation.remoteSSRC = remoteSSRC; |
449 | 469 |
450 RTCPReceiveInformation* ptrReceiveInfo = CreateReceiveInformation(remoteSSRC); | 470 RTCPReceiveInformation* ptrReceiveInfo = CreateReceiveInformation(remoteSSRC); |
451 if (!ptrReceiveInfo) { | 471 if (!ptrReceiveInfo) |
452 rtcpParser.Iterate(); | |
453 return; | 472 return; |
454 } | |
455 | 473 |
456 TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RR", | 474 TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RR", |
457 "remote_ssrc", remoteSSRC, "ssrc", main_ssrc_); | 475 "remote_ssrc", remoteSSRC, "ssrc", main_ssrc_); |
458 | 476 |
459 rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRr; | 477 rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRr; |
460 | 478 |
461 // Update that this remote is alive. | 479 // Update that this remote is alive. |
462 ptrReceiveInfo->last_time_received_ms = _clock->TimeInMilliseconds(); | 480 ptrReceiveInfo->last_time_received_ms = _clock->TimeInMilliseconds(); |
463 | 481 |
464 rtcpPacketType = rtcpParser.Iterate(); | 482 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.
| |
465 | 483 HandleReportBlock(report_block, rtcpPacketInformation, remoteSSRC); |
466 while (rtcpPacketType == RTCPPacketTypes::kReportBlockItem) { | |
467 HandleReportBlock(rtcpPacket, rtcpPacketInformation, remoteSSRC); | |
468 rtcpPacketType = rtcpParser.Iterate(); | |
469 } | 484 } |
470 } | 485 } |
471 | 486 |
472 void RTCPReceiver::HandleReportBlock( | 487 void RTCPReceiver::HandleReportBlock( |
473 const RTCPUtility::RTCPPacket& rtcpPacket, | 488 const ReportBlock& report_block, |
474 RTCPPacketInformation& rtcpPacketInformation, | 489 RTCPPacketInformation& rtcpPacketInformation, |
475 uint32_t remoteSSRC) | 490 uint32_t remoteSSRC) |
476 EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver) { | 491 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.
| |
477 // This will be called once per report block in the RTCP packet. | 492 // This will be called once per report block in the RTCP packet. |
478 // We filter out all report blocks that are not for us. | 493 // We filter out all report blocks that are not for us. |
479 // Each packet has max 31 RR blocks. | 494 // Each packet has max 31 RR blocks. |
480 // | 495 // |
481 // We can calc RTT if we send a send report and get a report block back. | 496 // We can calc RTT if we send a send report and get a report block back. |
482 | 497 |
483 // |rtcpPacket.ReportBlockItem.SSRC| is the SSRC identifier of the source to | 498 // |rtcpPacket.ReportBlockItem.SSRC| is the SSRC identifier of the source to |
484 // which the information in this reception report block pertains. | 499 // which the information in this reception report block pertains. |
485 | 500 |
486 // Filter out all report blocks that are not for us. | 501 // Filter out all report blocks that are not for us. |
487 if (registered_ssrcs_.find(rtcpPacket.ReportBlockItem.SSRC) == | 502 if (registered_ssrcs_.find(report_block.source_ssrc()) == |
488 registered_ssrcs_.end()) { | 503 registered_ssrcs_.end()) { |
489 // This block is not for us ignore it. | 504 // This block is not for us ignore it. |
490 return; | 505 return; |
491 } | 506 } |
492 | 507 |
493 RTCPReportBlockInformation* reportBlock = CreateOrGetReportBlockInformation( | 508 RTCPReportBlockInformation* reportBlock = |
494 remoteSSRC, rtcpPacket.ReportBlockItem.SSRC); | 509 CreateOrGetReportBlockInformation(remoteSSRC, report_block.source_ssrc()); |
495 if (reportBlock == NULL) { | 510 if (reportBlock == NULL) { |
496 LOG(LS_WARNING) << "Failed to CreateReportBlockInformation(" << remoteSSRC | 511 LOG(LS_WARNING) << "Failed to CreateReportBlockInformation(" << remoteSSRC |
497 << ")"; | 512 << ")"; |
498 return; | 513 return; |
499 } | 514 } |
500 | 515 |
501 _lastReceivedRrMs = _clock->TimeInMilliseconds(); | 516 _lastReceivedRrMs = _clock->TimeInMilliseconds(); |
502 const RTCPPacketReportBlockItem& rb = rtcpPacket.ReportBlockItem; | |
503 reportBlock->remoteReceiveBlock.remoteSSRC = remoteSSRC; | 517 reportBlock->remoteReceiveBlock.remoteSSRC = remoteSSRC; |
504 reportBlock->remoteReceiveBlock.sourceSSRC = rb.SSRC; | 518 reportBlock->remoteReceiveBlock.sourceSSRC = report_block.source_ssrc(); |
505 reportBlock->remoteReceiveBlock.fractionLost = rb.FractionLost; | 519 reportBlock->remoteReceiveBlock.fractionLost = report_block.fraction_lost(); |
506 reportBlock->remoteReceiveBlock.cumulativeLost = | 520 reportBlock->remoteReceiveBlock.cumulativeLost = |
507 rb.CumulativeNumOfPacketsLost; | 521 report_block.cumulative_lost(); |
508 if (rb.ExtendedHighestSequenceNumber > | 522 if (report_block.extended_high_seq_num() > |
509 reportBlock->remoteReceiveBlock.extendedHighSeqNum) { | 523 reportBlock->remoteReceiveBlock.extendedHighSeqNum) { |
510 // We have successfully delivered new RTP packets to the remote side after | 524 // We have successfully delivered new RTP packets to the remote side after |
511 // the last RR was sent from the remote side. | 525 // the last RR was sent from the remote side. |
512 _lastIncreasedSequenceNumberMs = _lastReceivedRrMs; | 526 _lastIncreasedSequenceNumberMs = _lastReceivedRrMs; |
513 } | 527 } |
514 reportBlock->remoteReceiveBlock.extendedHighSeqNum = | 528 reportBlock->remoteReceiveBlock.extendedHighSeqNum = |
515 rb.ExtendedHighestSequenceNumber; | 529 report_block.extended_high_seq_num(); |
516 reportBlock->remoteReceiveBlock.jitter = rb.Jitter; | 530 reportBlock->remoteReceiveBlock.jitter = report_block.jitter(); |
517 reportBlock->remoteReceiveBlock.delaySinceLastSR = rb.DelayLastSR; | 531 reportBlock->remoteReceiveBlock.delaySinceLastSR = |
518 reportBlock->remoteReceiveBlock.lastSR = rb.LastSR; | 532 report_block.delay_since_last_sr(); |
533 reportBlock->remoteReceiveBlock.lastSR = report_block.last_sr(); | |
519 | 534 |
520 if (rtcpPacket.ReportBlockItem.Jitter > reportBlock->remoteMaxJitter) { | 535 if (report_block.jitter() > reportBlock->remoteMaxJitter) { |
521 reportBlock->remoteMaxJitter = rtcpPacket.ReportBlockItem.Jitter; | 536 reportBlock->remoteMaxJitter = report_block.jitter(); |
522 } | 537 } |
523 | 538 |
524 int64_t rtt = 0; | 539 int64_t rtt = 0; |
525 uint32_t send_time = rtcpPacket.ReportBlockItem.LastSR; | 540 uint32_t send_time = report_block.last_sr(); |
526 // RFC3550, section 6.4.1, LSR field discription states: | 541 // RFC3550, section 6.4.1, LSR field discription states: |
527 // If no SR has been received yet, the field is set to zero. | 542 // If no SR has been received yet, the field is set to zero. |
528 // Receiver rtp_rtcp module is not expected to calculate rtt using | 543 // Receiver rtp_rtcp module is not expected to calculate rtt using |
529 // Sender Reports even if it accidentally can. | 544 // Sender Reports even if it accidentally can. |
530 if (!receiver_only_ && send_time != 0) { | 545 if (!receiver_only_ && send_time != 0) { |
531 uint32_t delay = rtcpPacket.ReportBlockItem.DelayLastSR; | 546 uint32_t delay = report_block.delay_since_last_sr(); |
532 // Local NTP time. | 547 // Local NTP time. |
533 uint32_t receive_time = CompactNtp(NtpTime(*_clock)); | 548 uint32_t receive_time = CompactNtp(NtpTime(*_clock)); |
534 | 549 |
535 // RTT in 1/(2^16) seconds. | 550 // RTT in 1/(2^16) seconds. |
536 uint32_t rtt_ntp = receive_time - delay - send_time; | 551 uint32_t rtt_ntp = receive_time - delay - send_time; |
537 // Convert to 1/1000 seconds (milliseconds). | 552 // Convert to 1/1000 seconds (milliseconds). |
538 rtt = CompactNtpRttToMs(rtt_ntp); | 553 rtt = CompactNtpRttToMs(rtt_ntp); |
539 if (rtt > reportBlock->maxRTT) { | 554 if (rtt > reportBlock->maxRTT) { |
540 // Store max RTT. | 555 // Store max RTT. |
541 reportBlock->maxRTT = rtt; | 556 reportBlock->maxRTT = rtt; |
(...skipping 14 matching lines...) Expand all Loading... | |
556 float newAverage = | 571 float newAverage = |
557 ((ac / (ac + 1)) * reportBlock->avgRTT) + ((1 / (ac + 1)) * rtt); | 572 ((ac / (ac + 1)) * reportBlock->avgRTT) + ((1 / (ac + 1)) * rtt); |
558 reportBlock->avgRTT = static_cast<int64_t>(newAverage + 0.5f); | 573 reportBlock->avgRTT = static_cast<int64_t>(newAverage + 0.5f); |
559 } else { | 574 } else { |
560 // First RTT. | 575 // First RTT. |
561 reportBlock->avgRTT = rtt; | 576 reportBlock->avgRTT = rtt; |
562 } | 577 } |
563 reportBlock->numAverageCalcs++; | 578 reportBlock->numAverageCalcs++; |
564 } | 579 } |
565 | 580 |
566 TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RR_RTT", rb.SSRC, | 581 TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RR_RTT", |
567 rtt); | 582 report_block.source_ssrc(), rtt); |
568 | 583 |
569 rtcpPacketInformation.AddReportInfo(*reportBlock); | 584 rtcpPacketInformation.AddReportInfo(*reportBlock); |
570 } | 585 } |
571 | 586 |
572 RTCPReportBlockInformation* RTCPReceiver::CreateOrGetReportBlockInformation( | 587 RTCPReportBlockInformation* RTCPReceiver::CreateOrGetReportBlockInformation( |
573 uint32_t remote_ssrc, | 588 uint32_t remote_ssrc, |
574 uint32_t source_ssrc) { | 589 uint32_t source_ssrc) { |
575 RTCPReportBlockInformation* info = | 590 RTCPReportBlockInformation* info = |
576 GetReportBlockInformation(remote_ssrc, source_ssrc); | 591 GetReportBlockInformation(remote_ssrc, source_ssrc); |
577 if (info == NULL) { | 592 if (info == NULL) { |
(...skipping 156 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
734 if (receiveInfoIt == _receivedInfoMap.end()) { | 749 if (receiveInfoIt == _receivedInfoMap.end()) { |
735 return std::vector<rtcp::TmmbItem>(); | 750 return std::vector<rtcp::TmmbItem>(); |
736 } | 751 } |
737 RTCPReceiveInformation* receiveInfo = receiveInfoIt->second; | 752 RTCPReceiveInformation* receiveInfo = receiveInfoIt->second; |
738 RTC_DCHECK(receiveInfo); | 753 RTC_DCHECK(receiveInfo); |
739 | 754 |
740 *tmmbr_owner = TMMBRHelp::IsOwner(receiveInfo->tmmbn, main_ssrc_); | 755 *tmmbr_owner = TMMBRHelp::IsOwner(receiveInfo->tmmbn, main_ssrc_); |
741 return receiveInfo->tmmbn; | 756 return receiveInfo->tmmbn; |
742 } | 757 } |
743 | 758 |
744 void RTCPReceiver::HandleSDES(RTCPUtility::RTCPParserV2& rtcpParser, | 759 void RTCPReceiver::HandleSDES(const CommonHeader& rtcp_block, |
745 RTCPPacketInformation& rtcpPacketInformation) { | 760 RTCPPacketInformation& rtcpPacketInformation) { |
746 RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate(); | 761 rtcp::Sdes sdes; |
747 while (pktType == RTCPPacketTypes::kSdesChunk) { | 762 if (!sdes.Parse(rtcp_block)) { |
748 const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet(); | 763 ++num_skipped_packets_; |
749 RTCPCnameInformation* cnameInfo = | 764 return; |
750 CreateCnameInformation(rtcpPacket.CName.SenderSSRC); | 765 } |
766 | |
767 for (const auto& chunk : sdes.chunks()) { | |
768 RTCPCnameInformation* cnameInfo = CreateCnameInformation(chunk.ssrc); | |
751 RTC_DCHECK(cnameInfo); | 769 RTC_DCHECK(cnameInfo); |
752 | 770 |
753 cnameInfo->name[RTCP_CNAME_SIZE - 1] = 0; | 771 cnameInfo->name[RTCP_CNAME_SIZE - 1] = 0; |
754 strncpy(cnameInfo->name, rtcpPacket.CName.CName, RTCP_CNAME_SIZE - 1); | 772 strncpy(cnameInfo->name, chunk.cname.c_str(), RTCP_CNAME_SIZE - 1); |
755 { | 773 { |
756 rtc::CritScope lock(&_criticalSectionFeedbacks); | 774 rtc::CritScope lock(&_criticalSectionFeedbacks); |
757 if (stats_callback_) { | 775 if (stats_callback_) { |
758 stats_callback_->CNameChanged(rtcpPacket.CName.CName, | 776 stats_callback_->CNameChanged(chunk.cname.c_str(), chunk.ssrc); |
759 rtcpPacket.CName.SenderSSRC); | |
760 } | 777 } |
761 } | 778 } |
762 | |
763 pktType = rtcpParser.Iterate(); | |
764 } | 779 } |
765 rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSdes; | 780 rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSdes; |
766 } | 781 } |
767 | 782 |
768 void RTCPReceiver::HandleNACK(RTCPUtility::RTCPParserV2& rtcpParser, | 783 void RTCPReceiver::HandleNACK(const CommonHeader& rtcp_block, |
769 RTCPPacketInformation& rtcpPacketInformation) { | 784 RTCPPacketInformation& rtcpPacketInformation) { |
770 const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet(); | 785 rtcp::Nack nack; |
771 if (receiver_only_ || main_ssrc_ != rtcpPacket.NACK.MediaSSRC) { | 786 if (!nack.Parse(rtcp_block)) { |
772 // Not to us. | 787 ++num_skipped_packets_; |
773 rtcpParser.Iterate(); | |
774 return; | 788 return; |
775 } | 789 } |
776 rtcpPacketInformation.ResetNACKPacketIdArray(); | |
777 | 790 |
778 RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate(); | 791 if (receiver_only_ || main_ssrc_ != nack.media_ssrc()) { |
philipel
2016/09/19 11:01:38
remove {}
danilchap
2016/09/19 13:35:26
Done.
| |
779 while (pktType == RTCPPacketTypes::kRtpfbNackItem) { | 792 // Not to us. |
780 rtcpPacketInformation.AddNACKPacket(rtcpPacket.NACKItem.PacketID); | 793 return; |
781 nack_stats_.ReportRequest(rtcpPacket.NACKItem.PacketID); | 794 } |
782 | 795 rtcpPacketInformation.nackSequenceNumbers = nack.packet_ids(); |
783 uint16_t bitMask = rtcpPacket.NACKItem.BitMask; | 796 for (uint16_t packet_id : nack.packet_ids()) { |
philipel
2016/09/19 11:01:38
remove {}
danilchap
2016/09/19 13:35:26
Done.
| |
784 if (bitMask) { | 797 nack_stats_.ReportRequest(packet_id); |
785 for (int i = 1; i <= 16; ++i) { | |
786 if (bitMask & 0x01) { | |
787 rtcpPacketInformation.AddNACKPacket(rtcpPacket.NACKItem.PacketID + i); | |
788 nack_stats_.ReportRequest(rtcpPacket.NACKItem.PacketID + i); | |
789 } | |
790 bitMask = bitMask >> 1; | |
791 } | |
792 } | |
793 rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpNack; | |
794 | |
795 pktType = rtcpParser.Iterate(); | |
796 } | 798 } |
797 | 799 |
798 if (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpNack) { | 800 if (!nack.packet_ids().empty()) { |
801 rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpNack; | |
799 ++packet_type_counter_.nack_packets; | 802 ++packet_type_counter_.nack_packets; |
800 packet_type_counter_.nack_requests = nack_stats_.requests(); | 803 packet_type_counter_.nack_requests = nack_stats_.requests(); |
801 packet_type_counter_.unique_nack_requests = nack_stats_.unique_requests(); | 804 packet_type_counter_.unique_nack_requests = nack_stats_.unique_requests(); |
802 } | 805 } |
803 } | 806 } |
804 | 807 |
805 void RTCPReceiver::HandleBYE(RTCPUtility::RTCPParserV2& rtcpParser) { | 808 void RTCPReceiver::HandleBYE(const CommonHeader& rtcp_block) { |
806 const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet(); | 809 rtcp::Bye bye; |
810 if (!bye.Parse(rtcp_block)) { | |
811 ++num_skipped_packets_; | |
812 return; | |
813 } | |
807 | 814 |
808 // clear our lists | 815 // clear our lists |
809 ReportBlockMap::iterator it = _receivedReportBlockMap.begin(); | 816 ReportBlockMap::iterator it = _receivedReportBlockMap.begin(); |
810 for (; it != _receivedReportBlockMap.end(); ++it) { | 817 for (; it != _receivedReportBlockMap.end(); ++it) { |
811 ReportBlockInfoMap* info_map = &(it->second); | 818 ReportBlockInfoMap* info_map = &(it->second); |
812 ReportBlockInfoMap::iterator it_info = | 819 ReportBlockInfoMap::iterator it_info = info_map->find(bye.sender_ssrc()); |
813 info_map->find(rtcpPacket.BYE.SenderSSRC); | |
814 if (it_info != info_map->end()) { | 820 if (it_info != info_map->end()) { |
815 delete it_info->second; | 821 delete it_info->second; |
816 info_map->erase(it_info); | 822 info_map->erase(it_info); |
817 } | 823 } |
818 } | 824 } |
819 | 825 |
820 // we can't delete it due to TMMBR | 826 // we can't delete it due to TMMBR |
821 std::map<uint32_t, RTCPReceiveInformation*>::iterator receiveInfoIt = | 827 std::map<uint32_t, RTCPReceiveInformation*>::iterator receiveInfoIt = |
822 _receivedInfoMap.find(rtcpPacket.BYE.SenderSSRC); | 828 _receivedInfoMap.find(bye.sender_ssrc()); |
823 | 829 |
824 if (receiveInfoIt != _receivedInfoMap.end()) { | 830 if (receiveInfoIt != _receivedInfoMap.end()) { |
825 receiveInfoIt->second->ready_for_delete = true; | 831 receiveInfoIt->second->ready_for_delete = true; |
826 } | 832 } |
827 | 833 |
828 std::map<uint32_t, RTCPCnameInformation*>::iterator cnameInfoIt = | 834 std::map<uint32_t, RTCPCnameInformation*>::iterator cnameInfoIt = |
829 _receivedCnameMap.find(rtcpPacket.BYE.SenderSSRC); | 835 _receivedCnameMap.find(bye.sender_ssrc()); |
830 | 836 |
831 if (cnameInfoIt != _receivedCnameMap.end()) { | 837 if (cnameInfoIt != _receivedCnameMap.end()) { |
832 delete cnameInfoIt->second; | 838 delete cnameInfoIt->second; |
833 _receivedCnameMap.erase(cnameInfoIt); | 839 _receivedCnameMap.erase(cnameInfoIt); |
834 } | 840 } |
835 xr_rr_rtt_ms_ = 0; | 841 xr_rr_rtt_ms_ = 0; |
836 rtcpParser.Iterate(); | 842 } |
837 } | 843 |
838 | 844 void RTCPReceiver::HandleXr(const CommonHeader& rtcp_block, |
839 void RTCPReceiver::HandleXrHeader( | 845 RTCPPacketInformation& rtcpPacketInformation) { |
840 RTCPUtility::RTCPParserV2& parser, | 846 rtcp::ExtendedReports xr; |
847 if (!xr.Parse(rtcp_block)) { | |
848 ++num_skipped_packets_; | |
849 return; | |
850 } | |
851 | |
852 rtcpPacketInformation.xr_originator_ssrc = xr.sender_ssrc(); | |
853 for (const rtcp::Rrtr& rrtr : xr.rrtrs()) | |
854 HandleXrReceiveReferenceTime(rrtr, rtcpPacketInformation); | |
855 | |
856 for (const rtcp::Dlrr& dlrr : xr.dlrrs()) { | |
857 for (const rtcp::ReceiveTimeInfo& time_info : dlrr.sub_blocks()) | |
858 HandleXrDlrrReportBlock(time_info, rtcpPacketInformation); | |
859 } | |
860 } | |
861 | |
862 void RTCPReceiver::HandleXrReceiveReferenceTime( | |
863 const rtcp::Rrtr& rrtr, | |
841 RTCPPacketInformation& rtcpPacketInformation) { | 864 RTCPPacketInformation& rtcpPacketInformation) { |
842 const RTCPUtility::RTCPPacket& packet = parser.Packet(); | |
843 | |
844 rtcpPacketInformation.xr_originator_ssrc = packet.XR.OriginatorSSRC; | |
845 | |
846 parser.Iterate(); | |
847 } | |
848 | |
849 void RTCPReceiver::HandleXrReceiveReferenceTime( | |
850 RTCPUtility::RTCPParserV2& parser, | |
851 RTCPPacketInformation& rtcpPacketInformation) { | |
852 const RTCPUtility::RTCPPacket& packet = parser.Packet(); | |
853 | |
854 _remoteXRReceiveTimeInfo.sourceSSRC = | 865 _remoteXRReceiveTimeInfo.sourceSSRC = |
855 rtcpPacketInformation.xr_originator_ssrc; | 866 rtcpPacketInformation.xr_originator_ssrc; |
856 | 867 |
857 _remoteXRReceiveTimeInfo.lastRR = RTCPUtility::MidNtp( | 868 _remoteXRReceiveTimeInfo.lastRR = CompactNtp(rrtr.ntp()); |
858 packet.XRReceiverReferenceTimeItem.NTPMostSignificant, | |
859 packet.XRReceiverReferenceTimeItem.NTPLeastSignificant); | |
860 | 869 |
861 _clock->CurrentNtp(_lastReceivedXRNTPsecs, _lastReceivedXRNTPfrac); | 870 _clock->CurrentNtp(_lastReceivedXRNTPsecs, _lastReceivedXRNTPfrac); |
862 | 871 |
863 rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpXrReceiverReferenceTime; | 872 rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpXrReceiverReferenceTime; |
864 | |
865 parser.Iterate(); | |
866 } | 873 } |
867 | 874 |
868 void RTCPReceiver::HandleXrDlrrReportBlock( | 875 void RTCPReceiver::HandleXrDlrrReportBlock( |
869 RTCPUtility::RTCPParserV2& parser, | 876 const rtcp::ReceiveTimeInfo& rti, |
870 RTCPPacketInformation& rtcpPacketInformation) { | 877 RTCPPacketInformation& rtcpPacketInformation) { |
871 const RTCPUtility::RTCPPacket& packet = parser.Packet(); | 878 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.
| |
872 // Iterate through sub-block(s), if any. | 879 // Not to us. |
873 RTCPUtility::RTCPPacketTypes packet_type = parser.Iterate(); | 880 return; |
874 | 881 } |
875 while (packet_type == RTCPPacketTypes::kXrDlrrReportBlockItem) { | 882 |
876 if (registered_ssrcs_.find(packet.XRDLRRReportBlockItem.SSRC) == | 883 rtcpPacketInformation.xr_dlrr_item = true; |
877 registered_ssrcs_.end()) { | 884 |
878 // Not to us. | 885 // Caller should explicitly enable rtt calculation using extended reports. |
879 return; | 886 if (!xr_rrtr_status_) |
880 } | 887 return; |
881 | 888 |
882 rtcpPacketInformation.xr_dlrr_item = true; | 889 // The send_time and delay_rr fields are in units of 1/2^16 sec. |
883 | 890 uint32_t send_time = rti.last_rr; |
884 // Caller should explicitly enable rtt calculation using extended reports. | 891 // RFC3611, section 4.5, LRR field discription states: |
885 if (!xr_rrtr_status_) | 892 // If no such block has been received, the field is set to zero. |
886 return; | 893 if (send_time == 0) |
887 | 894 return; |
888 // The send_time and delay_rr fields are in units of 1/2^16 sec. | 895 |
889 uint32_t send_time = packet.XRDLRRReportBlockItem.LastRR; | 896 uint32_t delay_rr = rti.delay_since_last_rr; |
890 // RFC3611, section 4.5, LRR field discription states: | 897 uint32_t now = CompactNtp(NtpTime(*_clock)); |
891 // If no such block has been received, the field is set to zero. | 898 |
892 if (send_time == 0) | 899 uint32_t rtt_ntp = now - delay_rr - send_time; |
893 return; | 900 xr_rr_rtt_ms_ = CompactNtpRttToMs(rtt_ntp); |
894 | 901 |
895 uint32_t delay_rr = packet.XRDLRRReportBlockItem.DelayLastRR; | 902 rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpXrDlrrReportBlock; |
896 uint32_t now = CompactNtp(NtpTime(*_clock)); | 903 } |
897 | 904 |
898 uint32_t rtt_ntp = now - delay_rr - send_time; | 905 void RTCPReceiver::HandlePLI(const CommonHeader& rtcp_block, |
899 xr_rr_rtt_ms_ = CompactNtpRttToMs(rtt_ntp); | |
900 | |
901 rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpXrDlrrReportBlock; | |
902 | |
903 packet_type = parser.Iterate(); | |
904 } | |
905 } | |
906 | |
907 void RTCPReceiver::HandlePLI(RTCPUtility::RTCPParserV2& rtcpParser, | |
908 RTCPPacketInformation& rtcpPacketInformation) { | 906 RTCPPacketInformation& rtcpPacketInformation) { |
909 const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet(); | 907 rtcp::Pli pli; |
910 if (main_ssrc_ == rtcpPacket.PLI.MediaSSRC) { | 908 if (!pli.Parse(rtcp_block)) { |
909 ++num_skipped_packets_; | |
910 return; | |
911 } | |
912 | |
913 if (main_ssrc_ == pli.media_ssrc()) { | |
911 TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "PLI"); | 914 TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "PLI"); |
912 | 915 |
913 ++packet_type_counter_.pli_packets; | 916 ++packet_type_counter_.pli_packets; |
914 // Received a signal that we need to send a new key frame. | 917 // Received a signal that we need to send a new key frame. |
915 rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpPli; | 918 rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpPli; |
916 } | 919 } |
917 rtcpParser.Iterate(); | 920 } |
918 } | 921 |
919 | 922 void RTCPReceiver::HandleTMMBR(const CommonHeader& rtcp_block, |
920 void RTCPReceiver::HandleTMMBR(RTCPUtility::RTCPParserV2& rtcpParser, | |
921 RTCPPacketInformation& rtcpPacketInformation) { | 923 RTCPPacketInformation& rtcpPacketInformation) { |
922 const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet(); | 924 rtcp::Tmmbr tmmbr; |
923 | 925 if (!tmmbr.Parse(rtcp_block)) { |
924 uint32_t senderSSRC = rtcpPacket.TMMBR.SenderSSRC; | 926 ++num_skipped_packets_; |
927 return; | |
928 } | |
929 | |
930 uint32_t senderSSRC = tmmbr.sender_ssrc(); | |
925 RTCPReceiveInformation* ptrReceiveInfo = GetReceiveInformation(senderSSRC); | 931 RTCPReceiveInformation* ptrReceiveInfo = GetReceiveInformation(senderSSRC); |
926 if (ptrReceiveInfo == NULL) { | 932 if (ptrReceiveInfo == NULL) { |
927 // This remote SSRC must be saved before. | 933 // This remote SSRC must be saved before. |
928 rtcpParser.Iterate(); | 934 return; |
929 return; | 935 } |
930 } | 936 if (tmmbr.media_ssrc()) { |
931 if (rtcpPacket.TMMBR.MediaSSRC) { | |
932 // rtcpPacket.TMMBR.MediaSSRC SHOULD be 0 if same as SenderSSRC | 937 // rtcpPacket.TMMBR.MediaSSRC SHOULD be 0 if same as SenderSSRC |
933 // in relay mode this is a valid number | 938 // in relay mode this is a valid number |
934 senderSSRC = rtcpPacket.TMMBR.MediaSSRC; | 939 senderSSRC = tmmbr.media_ssrc(); |
935 } | 940 } |
936 | 941 |
937 // Use packet length to calc max number of TMMBR blocks | 942 for (const rtcp::TmmbItem& request : tmmbr.requests()) { |
938 // each TMMBR block is 8 bytes | 943 if (main_ssrc_ == request.ssrc() && request.bitrate_bps()) { |
939 ptrdiff_t maxNumOfTMMBRBlocks = rtcpParser.LengthLeft() / 8; | 944 ptrReceiveInfo->InsertTmmbrItem(senderSSRC, request, |
940 | 945 _clock->TimeInMilliseconds()); |
941 // sanity, we can't have more than what's in one packet | |
942 if (maxNumOfTMMBRBlocks > 200) { | |
943 assert(false); | |
944 rtcpParser.Iterate(); | |
945 return; | |
946 } | |
947 | |
948 RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate(); | |
949 while (pktType == RTCPPacketTypes::kRtpfbTmmbrItem) { | |
950 if (main_ssrc_ == rtcpPacket.TMMBRItem.SSRC && | |
951 rtcpPacket.TMMBRItem.MaxTotalMediaBitRate > 0) { | |
952 ptrReceiveInfo->InsertTmmbrItem( | |
953 senderSSRC, | |
954 rtcp::TmmbItem(rtcpPacket.TMMBRItem.SSRC, | |
955 rtcpPacket.TMMBRItem.MaxTotalMediaBitRate * 1000, | |
956 rtcpPacket.TMMBRItem.MeasuredOverhead), | |
957 _clock->TimeInMilliseconds()); | |
958 rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpTmmbr; | 946 rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpTmmbr; |
959 } | 947 } |
960 | 948 } |
961 pktType = rtcpParser.Iterate(); | 949 } |
962 } | 950 |
963 } | 951 void RTCPReceiver::HandleTMMBN(const CommonHeader& rtcp_block, |
964 | |
965 void RTCPReceiver::HandleTMMBN(RTCPUtility::RTCPParserV2& rtcpParser, | |
966 RTCPPacketInformation& rtcpPacketInformation) { | 952 RTCPPacketInformation& rtcpPacketInformation) { |
967 const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet(); | 953 rtcp::Tmmbn tmmbn; |
954 if (!tmmbn.Parse(rtcp_block)) { | |
955 ++num_skipped_packets_; | |
956 return; | |
957 } | |
958 | |
968 RTCPReceiveInformation* ptrReceiveInfo = | 959 RTCPReceiveInformation* ptrReceiveInfo = |
969 GetReceiveInformation(rtcpPacket.TMMBN.SenderSSRC); | 960 GetReceiveInformation(tmmbn.sender_ssrc()); |
970 if (ptrReceiveInfo == NULL) { | 961 if (ptrReceiveInfo == NULL) { |
971 // This remote SSRC must be saved before. | 962 // This remote SSRC must be saved before. |
972 rtcpParser.Iterate(); | |
973 return; | 963 return; |
974 } | 964 } |
975 rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpTmmbn; | 965 rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpTmmbn; |
976 // Use packet length to calc max number of TMMBN blocks | 966 |
977 // each TMMBN block is 8 bytes | 967 for (const auto& item : tmmbn.items()) { |
philipel
2016/09/19 11:01:38
remove {}
danilchap
2016/09/19 13:35:26
Done.
| |
978 ptrdiff_t maxNumOfTMMBNBlocks = rtcpParser.LengthLeft() / 8; | 968 ptrReceiveInfo->tmmbn.push_back(item); |
979 | 969 } |
980 // sanity, we cant have more than what's in one packet | 970 } |
981 if (maxNumOfTMMBNBlocks > 200) { | 971 |
982 assert(false); | 972 void RTCPReceiver::HandleSR_REQ(const CommonHeader& rtcp_block, |
983 rtcpParser.Iterate(); | |
984 return; | |
985 } | |
986 | |
987 RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate(); | |
988 while (pktType == RTCPPacketTypes::kRtpfbTmmbnItem) { | |
989 ptrReceiveInfo->tmmbn.emplace_back( | |
990 rtcpPacket.TMMBNItem.SSRC, | |
991 rtcpPacket.TMMBNItem.MaxTotalMediaBitRate * 1000, | |
992 rtcpPacket.TMMBNItem.MeasuredOverhead); | |
993 pktType = rtcpParser.Iterate(); | |
994 } | |
995 } | |
996 | |
997 void RTCPReceiver::HandleSR_REQ(RTCPUtility::RTCPParserV2& rtcpParser, | |
998 RTCPPacketInformation& rtcpPacketInformation) { | 973 RTCPPacketInformation& rtcpPacketInformation) { |
974 rtcp::RapidResyncRequest sr_req; | |
975 if (!sr_req.Parse(rtcp_block)) { | |
976 ++num_skipped_packets_; | |
977 return; | |
978 } | |
979 | |
999 rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSrReq; | 980 rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSrReq; |
1000 rtcpParser.Iterate(); | 981 } |
1001 } | 982 |
1002 | 983 void RTCPReceiver::HandleSLI(const CommonHeader& rtcp_block, |
1003 void RTCPReceiver::HandleSLI(RTCPUtility::RTCPParserV2& rtcpParser, | |
1004 RTCPPacketInformation& rtcpPacketInformation) { | 984 RTCPPacketInformation& rtcpPacketInformation) { |
1005 const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet(); | 985 rtcp::Sli sli; |
1006 RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate(); | 986 if (!sli.Parse(rtcp_block)) { |
1007 while (pktType == RTCPPacketTypes::kPsfbSliItem) { | 987 ++num_skipped_packets_; |
1008 // in theory there could be multiple slices lost | 988 return; |
1009 rtcpPacketInformation.rtcpPacketTypeFlags |= | 989 } |
1010 kRtcpSli; // received signal that we need to refresh a slice | 990 |
1011 rtcpPacketInformation.sliPictureId = rtcpPacket.SLIItem.PictureId; | 991 for (const rtcp::Sli::Macroblocks& item : sli.macroblocks()) { |
1012 | 992 // In theory there could be multiple slices lost. |
1013 pktType = rtcpParser.Iterate(); | 993 // Received signal that we need to refresh a slice. |
994 rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSli; | |
995 rtcpPacketInformation.sliPictureId = item.picture_id(); | |
1014 } | 996 } |
1015 } | 997 } |
1016 | 998 |
1017 void RTCPReceiver::HandleRPSI( | 999 void RTCPReceiver::HandleRPSI( |
1018 RTCPUtility::RTCPParserV2& rtcpParser, | 1000 const CommonHeader& rtcp_block, |
1019 RTCPHelp::RTCPPacketInformation& rtcpPacketInformation) { | 1001 RTCPHelp::RTCPPacketInformation& rtcpPacketInformation) { |
1020 const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet(); | 1002 rtcp::Rpsi rpsi; |
1021 RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate(); | 1003 if (!rpsi.Parse(rtcp_block)) { |
1022 if (pktType == RTCPPacketTypes::kPsfbRpsiItem) { | 1004 ++num_skipped_packets_; |
1023 if (rtcpPacket.RPSI.NumberOfValidBits % 8 != 0) { | 1005 return; |
1024 // to us unknown | 1006 } |
1025 // continue | 1007 |
1026 rtcpParser.Iterate(); | 1008 // Received signal that we have a confirmed reference picture. |
1027 return; | 1009 rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRpsi; |
1028 } | 1010 rtcpPacketInformation.rpsiPictureId = rpsi.picture_id(); |
1029 // Received signal that we have a confirmed reference picture. | 1011 } |
1030 rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRpsi; | 1012 |
1031 rtcpPacketInformation.rpsiPictureId = 0; | 1013 void RTCPReceiver::HandlePsfbApp(const CommonHeader& rtcp_block, |
1032 | |
1033 // convert NativeBitString to rpsiPictureId | |
1034 uint8_t numberOfBytes = rtcpPacket.RPSI.NumberOfValidBits / 8; | |
1035 for (uint8_t n = 0; n < (numberOfBytes - 1); n++) { | |
1036 rtcpPacketInformation.rpsiPictureId += | |
1037 (rtcpPacket.RPSI.NativeBitString[n] & 0x7f); | |
1038 rtcpPacketInformation.rpsiPictureId <<= 7; // prepare next | |
1039 } | |
1040 rtcpPacketInformation.rpsiPictureId += | |
1041 (rtcpPacket.RPSI.NativeBitString[numberOfBytes - 1] & 0x7f); | |
1042 } | |
1043 } | |
1044 | |
1045 void RTCPReceiver::HandlePsfbApp(RTCPUtility::RTCPParserV2& rtcpParser, | |
1046 RTCPPacketInformation& rtcpPacketInformation) { | 1014 RTCPPacketInformation& rtcpPacketInformation) { |
1047 RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate(); | 1015 rtcp::Remb remb; |
1048 if (pktType == RTCPPacketTypes::kPsfbRemb) { | 1016 if (remb.Parse(rtcp_block)) { |
1049 pktType = rtcpParser.Iterate(); | 1017 rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRemb; |
1050 if (pktType == RTCPPacketTypes::kPsfbRembItem) { | 1018 rtcpPacketInformation.receiverEstimatedMaxBitrate = remb.bitrate_bps(); |
1051 const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet(); | 1019 return; |
1052 rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRemb; | 1020 } |
1053 rtcpPacketInformation.receiverEstimatedMaxBitrate = | 1021 |
1054 rtcpPacket.REMBItem.BitRate; | 1022 ++num_skipped_packets_; |
1055 | 1023 } |
1056 rtcpParser.Iterate(); | 1024 |
1057 } | 1025 void RTCPReceiver::HandleFIR(const CommonHeader& rtcp_block, |
1058 } | |
1059 } | |
1060 | |
1061 void RTCPReceiver::HandleFIR(RTCPUtility::RTCPParserV2& rtcpParser, | |
1062 RTCPPacketInformation& rtcpPacketInformation) { | 1026 RTCPPacketInformation& rtcpPacketInformation) { |
1063 const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet(); | 1027 rtcp::Fir fir; |
1028 if (!fir.Parse(rtcp_block)) { | |
1029 ++num_skipped_packets_; | |
1030 return; | |
1031 } | |
1032 | |
1064 RTCPReceiveInformation* ptrReceiveInfo = | 1033 RTCPReceiveInformation* ptrReceiveInfo = |
1065 GetReceiveInformation(rtcpPacket.FIR.SenderSSRC); | 1034 GetReceiveInformation(fir.sender_ssrc()); |
1066 | 1035 |
1067 RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate(); | 1036 for (const rtcp::Fir::Request& fir_request : fir.requests()) { |
1068 while (pktType == RTCPPacketTypes::kPsfbFirItem) { | |
1069 // Is it our sender that is requested to generate a new keyframe | 1037 // Is it our sender that is requested to generate a new keyframe |
1070 if (main_ssrc_ != rtcpPacket.FIRItem.SSRC) { | 1038 if (main_ssrc_ != fir_request.ssrc) |
1071 return; | 1039 continue; |
1072 } | |
1073 | 1040 |
1074 ++packet_type_counter_.fir_packets; | 1041 ++packet_type_counter_.fir_packets; |
1075 | 1042 |
1076 // rtcpPacket.FIR.MediaSSRC SHOULD be 0 but we ignore to check it | 1043 // rtcpPacket.FIR.MediaSSRC SHOULD be 0 but we ignore to check it |
1077 // we don't know who this originate from | 1044 // we don't know who this originate from |
1078 if (ptrReceiveInfo) { | 1045 if (ptrReceiveInfo) { |
1079 // check if we have reported this FIRSequenceNumber before | 1046 // check if we have reported this FIRSequenceNumber before |
1080 if (rtcpPacket.FIRItem.CommandSequenceNumber != | 1047 if (fir_request.seq_nr != ptrReceiveInfo->last_fir_sequence_number) { |
1081 ptrReceiveInfo->last_fir_sequence_number) { | |
1082 int64_t now = _clock->TimeInMilliseconds(); | 1048 int64_t now = _clock->TimeInMilliseconds(); |
1083 // sanity; don't go crazy with the callbacks | 1049 // sanity; don't go crazy with the callbacks |
1084 if ((now - ptrReceiveInfo->last_fir_request_ms) > | 1050 if ((now - ptrReceiveInfo->last_fir_request_ms) > |
1085 RTCP_MIN_FRAME_LENGTH_MS) { | 1051 RTCP_MIN_FRAME_LENGTH_MS) { |
1086 ptrReceiveInfo->last_fir_request_ms = now; | 1052 ptrReceiveInfo->last_fir_request_ms = now; |
1087 ptrReceiveInfo->last_fir_sequence_number = | 1053 ptrReceiveInfo->last_fir_sequence_number = fir_request.seq_nr; |
1088 rtcpPacket.FIRItem.CommandSequenceNumber; | |
1089 // received signal that we need to send a new key frame | 1054 // received signal that we need to send a new key frame |
1090 rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpFir; | 1055 rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpFir; |
1091 } | 1056 } |
1092 } | 1057 } |
1093 } else { | 1058 } else { |
1094 // received signal that we need to send a new key frame | 1059 // received signal that we need to send a new key frame |
1095 rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpFir; | 1060 rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpFir; |
1096 } | 1061 } |
1097 | |
1098 pktType = rtcpParser.Iterate(); | |
1099 } | 1062 } |
1100 } | 1063 } |
1101 | 1064 |
1102 void RTCPReceiver::HandleTransportFeedback( | 1065 void RTCPReceiver::HandleTransportFeedback( |
1103 RTCPUtility::RTCPParserV2* rtcp_parser, | 1066 const CommonHeader& rtcp_block, |
1104 RTCPHelp::RTCPPacketInformation* rtcp_packet_information) { | 1067 RTCPHelp::RTCPPacketInformation* rtcp_packet_information) { |
1105 rtcp::RtcpPacket* packet = rtcp_parser->ReleaseRtcpPacket(); | 1068 std::unique_ptr<rtcp::TransportFeedback> transport_feedback( |
1106 RTC_DCHECK(packet != nullptr); | 1069 new rtcp::TransportFeedback()); |
1070 if (!transport_feedback->Parse(rtcp_block)) { | |
1071 ++num_skipped_packets_; | |
1072 return; | |
1073 } | |
1074 | |
1107 rtcp_packet_information->rtcpPacketTypeFlags |= kRtcpTransportFeedback; | 1075 rtcp_packet_information->rtcpPacketTypeFlags |= kRtcpTransportFeedback; |
1108 rtcp_packet_information->transport_feedback_.reset( | 1076 rtcp_packet_information->transport_feedback_ = std::move(transport_feedback); |
1109 static_cast<rtcp::TransportFeedback*>(packet)); | |
1110 | |
1111 rtcp_parser->Iterate(); | |
1112 } | 1077 } |
1113 | 1078 |
1114 void RTCPReceiver::UpdateTmmbr() { | 1079 void RTCPReceiver::UpdateTmmbr() { |
1115 // Find bounding set. | 1080 // Find bounding set. |
1116 std::vector<rtcp::TmmbItem> bounding = | 1081 std::vector<rtcp::TmmbItem> bounding = |
1117 TMMBRHelp::FindBoundingSet(TmmbrReceived()); | 1082 TMMBRHelp::FindBoundingSet(TmmbrReceived()); |
1118 | 1083 |
1119 if (!bounding.empty() && _cbRtcpBandwidthObserver) { | 1084 if (!bounding.empty() && _cbRtcpBandwidthObserver) { |
1120 // We have a new bandwidth estimate on this channel. | 1085 // We have a new bandwidth estimate on this channel. |
1121 uint64_t bitrate_bps = TMMBRHelp::CalcMinBitrateBps(bounding); | 1086 uint64_t bitrate_bps = TMMBRHelp::CalcMinBitrateBps(bounding); |
(...skipping 145 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
1267 | 1232 |
1268 for (const auto& kv : _receivedInfoMap) { | 1233 for (const auto& kv : _receivedInfoMap) { |
1269 RTCPReceiveInformation* receive_info = kv.second; | 1234 RTCPReceiveInformation* receive_info = kv.second; |
1270 RTC_DCHECK(receive_info); | 1235 RTC_DCHECK(receive_info); |
1271 receive_info->GetTmmbrSet(now_ms, &candidates); | 1236 receive_info->GetTmmbrSet(now_ms, &candidates); |
1272 } | 1237 } |
1273 return candidates; | 1238 return candidates; |
1274 } | 1239 } |
1275 | 1240 |
1276 } // namespace webrtc | 1241 } // namespace webrtc |
OLD | NEW |