1 /*
2  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
3  *
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
6  *  tree. An additional intellectual property rights grant can be found
7  *  in the file PATENTS.  All contributing project authors may
8  *  be found in the AUTHORS file in the root of the source tree.
9  */
10 
11 #include "webrtc/modules/rtp_rtcp/source/rtcp_receiver.h"
12 
13 #include <assert.h>
14 #include <string.h>
15 
16 #include <algorithm>
17 
18 #include "webrtc/base/checks.h"
19 #include "webrtc/base/logging.h"
20 #include "webrtc/base/trace_event.h"
21 #include "webrtc/modules/rtp_rtcp/source/rtcp_packet/transport_feedback.h"
22 #include "webrtc/modules/rtp_rtcp/source/rtcp_utility.h"
23 #include "webrtc/modules/rtp_rtcp/source/rtp_rtcp_impl.h"
24 
25 namespace webrtc {
26 using RTCPHelp::RTCPPacketInformation;
27 using RTCPHelp::RTCPReceiveInformation;
28 using RTCPHelp::RTCPReportBlockInformation;
29 using RTCPUtility::kBtVoipMetric;
30 using RTCPUtility::RTCPCnameInformation;
31 using RTCPUtility::RTCPPacketReportBlockItem;
32 using RTCPUtility::RTCPPacketTypes;
33 
34 // The number of RTCP time intervals needed to trigger a timeout.
35 const int kRrTimeoutIntervals = 3;
36 
37 const int64_t kMaxWarningLogIntervalMs = 10000;
38 
RTCPReceiver(Clock * clock,bool receiver_only,RtcpPacketTypeCounterObserver * packet_type_counter_observer,RtcpBandwidthObserver * rtcp_bandwidth_observer,RtcpIntraFrameObserver * rtcp_intra_frame_observer,TransportFeedbackObserver * transport_feedback_observer,ModuleRtpRtcpImpl * owner)39 RTCPReceiver::RTCPReceiver(
40     Clock* clock,
41     bool receiver_only,
42     RtcpPacketTypeCounterObserver* packet_type_counter_observer,
43     RtcpBandwidthObserver* rtcp_bandwidth_observer,
44     RtcpIntraFrameObserver* rtcp_intra_frame_observer,
45     TransportFeedbackObserver* transport_feedback_observer,
46     ModuleRtpRtcpImpl* owner)
47     : TMMBRHelp(),
48       _clock(clock),
49       receiver_only_(receiver_only),
50       _method(RtcpMode::kOff),
51       _lastReceived(0),
52       _rtpRtcp(*owner),
53       _criticalSectionFeedbacks(
54           CriticalSectionWrapper::CreateCriticalSection()),
55       _cbRtcpBandwidthObserver(rtcp_bandwidth_observer),
56       _cbRtcpIntraFrameObserver(rtcp_intra_frame_observer),
57       _cbTransportFeedbackObserver(transport_feedback_observer),
58       _criticalSectionRTCPReceiver(
59           CriticalSectionWrapper::CreateCriticalSection()),
60       main_ssrc_(0),
61       _remoteSSRC(0),
62       _remoteSenderInfo(),
63       _lastReceivedSRNTPsecs(0),
64       _lastReceivedSRNTPfrac(0),
65       _lastReceivedXRNTPsecs(0),
66       _lastReceivedXRNTPfrac(0),
67       xr_rr_rtt_ms_(0),
68       _receivedInfoMap(),
69       _packetTimeOutMS(0),
70       _lastReceivedRrMs(0),
71       _lastIncreasedSequenceNumberMs(0),
72       stats_callback_(NULL),
73       packet_type_counter_observer_(packet_type_counter_observer),
74       num_skipped_packets_(0),
75       last_skipped_packets_warning_(clock->TimeInMilliseconds()) {
76   memset(&_remoteSenderInfo, 0, sizeof(_remoteSenderInfo));
77 }
78 
~RTCPReceiver()79 RTCPReceiver::~RTCPReceiver() {
80   delete _criticalSectionRTCPReceiver;
81   delete _criticalSectionFeedbacks;
82 
83   ReportBlockMap::iterator it = _receivedReportBlockMap.begin();
84   for (; it != _receivedReportBlockMap.end(); ++it) {
85     ReportBlockInfoMap* info_map = &(it->second);
86     while (!info_map->empty()) {
87       ReportBlockInfoMap::iterator it_info = info_map->begin();
88       delete it_info->second;
89       info_map->erase(it_info);
90     }
91   }
92   while (!_receivedInfoMap.empty()) {
93     std::map<uint32_t, RTCPReceiveInformation*>::iterator first =
94         _receivedInfoMap.begin();
95     delete first->second;
96     _receivedInfoMap.erase(first);
97   }
98   while (!_receivedCnameMap.empty()) {
99     std::map<uint32_t, RTCPCnameInformation*>::iterator first =
100         _receivedCnameMap.begin();
101     delete first->second;
102     _receivedCnameMap.erase(first);
103   }
104 }
105 
Status() const106 RtcpMode RTCPReceiver::Status() const {
107   CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
108   return _method;
109 }
110 
SetRTCPStatus(RtcpMode method)111 void RTCPReceiver::SetRTCPStatus(RtcpMode method) {
112   CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
113   _method = method;
114 }
115 
LastReceived()116 int64_t RTCPReceiver::LastReceived() {
117   CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
118   return _lastReceived;
119 }
120 
LastReceivedReceiverReport() const121 int64_t RTCPReceiver::LastReceivedReceiverReport() const {
122   CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
123   int64_t last_received_rr = -1;
124   for (ReceivedInfoMap::const_iterator it = _receivedInfoMap.begin();
125        it != _receivedInfoMap.end(); ++it) {
126     if (it->second->lastTimeReceived > last_received_rr) {
127       last_received_rr = it->second->lastTimeReceived;
128     }
129   }
130   return last_received_rr;
131 }
132 
SetRemoteSSRC(uint32_t ssrc)133 void RTCPReceiver::SetRemoteSSRC(uint32_t ssrc) {
134   CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
135 
136   // new SSRC reset old reports
137   memset(&_remoteSenderInfo, 0, sizeof(_remoteSenderInfo));
138   _lastReceivedSRNTPsecs = 0;
139   _lastReceivedSRNTPfrac = 0;
140 
141   _remoteSSRC = ssrc;
142 }
143 
RemoteSSRC() const144 uint32_t RTCPReceiver::RemoteSSRC() const {
145   CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
146   return _remoteSSRC;
147 }
148 
SetSsrcs(uint32_t main_ssrc,const std::set<uint32_t> & registered_ssrcs)149 void RTCPReceiver::SetSsrcs(uint32_t main_ssrc,
150                             const std::set<uint32_t>& registered_ssrcs) {
151   uint32_t old_ssrc = 0;
152   {
153     CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
154     old_ssrc = main_ssrc_;
155     main_ssrc_ = main_ssrc;
156     registered_ssrcs_ = registered_ssrcs;
157   }
158   {
159     if (_cbRtcpIntraFrameObserver && old_ssrc != main_ssrc) {
160       _cbRtcpIntraFrameObserver->OnLocalSsrcChanged(old_ssrc, main_ssrc);
161     }
162   }
163 }
164 
RTT(uint32_t remoteSSRC,int64_t * RTT,int64_t * avgRTT,int64_t * minRTT,int64_t * maxRTT) const165 int32_t RTCPReceiver::RTT(uint32_t remoteSSRC,
166                           int64_t* RTT,
167                           int64_t* avgRTT,
168                           int64_t* minRTT,
169                           int64_t* maxRTT) const {
170   CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
171 
172   RTCPReportBlockInformation* reportBlock =
173       GetReportBlockInformation(remoteSSRC, main_ssrc_);
174 
175   if (reportBlock == NULL) {
176     return -1;
177   }
178   if (RTT) {
179     *RTT = reportBlock->RTT;
180   }
181   if (avgRTT) {
182     *avgRTT = reportBlock->avgRTT;
183   }
184   if (minRTT) {
185     *minRTT = reportBlock->minRTT;
186   }
187   if (maxRTT) {
188     *maxRTT = reportBlock->maxRTT;
189   }
190   return 0;
191 }
192 
GetAndResetXrRrRtt(int64_t * rtt_ms)193 bool RTCPReceiver::GetAndResetXrRrRtt(int64_t* rtt_ms) {
194   assert(rtt_ms);
195   CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
196   if (xr_rr_rtt_ms_ == 0) {
197     return false;
198   }
199   *rtt_ms = xr_rr_rtt_ms_;
200   xr_rr_rtt_ms_ = 0;
201   return true;
202 }
203 
204 // TODO(pbos): Make this fail when we haven't received NTP.
NTP(uint32_t * ReceivedNTPsecs,uint32_t * ReceivedNTPfrac,uint32_t * RTCPArrivalTimeSecs,uint32_t * RTCPArrivalTimeFrac,uint32_t * rtcp_timestamp) const205 bool RTCPReceiver::NTP(uint32_t* ReceivedNTPsecs,
206                        uint32_t* ReceivedNTPfrac,
207                        uint32_t* RTCPArrivalTimeSecs,
208                        uint32_t* RTCPArrivalTimeFrac,
209                        uint32_t* rtcp_timestamp) const
210 {
211     CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
212     if(ReceivedNTPsecs)
213     {
214         *ReceivedNTPsecs = _remoteSenderInfo.NTPseconds; // NTP from incoming SendReport
215     }
216     if(ReceivedNTPfrac)
217     {
218         *ReceivedNTPfrac = _remoteSenderInfo.NTPfraction;
219     }
220     if(RTCPArrivalTimeFrac)
221     {
222         *RTCPArrivalTimeFrac = _lastReceivedSRNTPfrac; // local NTP time when we received a RTCP packet with a send block
223     }
224     if(RTCPArrivalTimeSecs)
225     {
226         *RTCPArrivalTimeSecs = _lastReceivedSRNTPsecs;
227     }
228     if (rtcp_timestamp) {
229       *rtcp_timestamp = _remoteSenderInfo.RTPtimeStamp;
230     }
231     return true;
232 }
233 
LastReceivedXrReferenceTimeInfo(RtcpReceiveTimeInfo * info) const234 bool RTCPReceiver::LastReceivedXrReferenceTimeInfo(
235     RtcpReceiveTimeInfo* info) const {
236   assert(info);
237   CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
238   if (_lastReceivedXRNTPsecs == 0 && _lastReceivedXRNTPfrac == 0) {
239     return false;
240   }
241 
242   info->sourceSSRC = _remoteXRReceiveTimeInfo.sourceSSRC;
243   info->lastRR = _remoteXRReceiveTimeInfo.lastRR;
244 
245   // Get the delay since last received report (RFC 3611).
246   uint32_t receive_time = RTCPUtility::MidNtp(_lastReceivedXRNTPsecs,
247                                               _lastReceivedXRNTPfrac);
248 
249   uint32_t ntp_sec = 0;
250   uint32_t ntp_frac = 0;
251   _clock->CurrentNtp(ntp_sec, ntp_frac);
252   uint32_t now = RTCPUtility::MidNtp(ntp_sec, ntp_frac);
253 
254   info->delaySinceLastRR = now - receive_time;
255   return true;
256 }
257 
SenderInfoReceived(RTCPSenderInfo * senderInfo) const258 int32_t RTCPReceiver::SenderInfoReceived(RTCPSenderInfo* senderInfo) const {
259   assert(senderInfo);
260   CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
261   if (_lastReceivedSRNTPsecs == 0) {
262     return -1;
263   }
264   memcpy(senderInfo, &(_remoteSenderInfo), sizeof(RTCPSenderInfo));
265   return 0;
266 }
267 
268 // statistics
269 // we can get multiple receive reports when we receive the report from a CE
StatisticsReceived(std::vector<RTCPReportBlock> * receiveBlocks) const270 int32_t RTCPReceiver::StatisticsReceived(
271     std::vector<RTCPReportBlock>* receiveBlocks) const {
272   assert(receiveBlocks);
273   CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
274   ReportBlockMap::const_iterator it = _receivedReportBlockMap.begin();
275   for (; it != _receivedReportBlockMap.end(); ++it) {
276     const ReportBlockInfoMap* info_map = &(it->second);
277     ReportBlockInfoMap::const_iterator it_info = info_map->begin();
278     for (; it_info != info_map->end(); ++it_info) {
279       receiveBlocks->push_back(it_info->second->remoteReceiveBlock);
280     }
281   }
282   return 0;
283 }
284 
285 int32_t
IncomingRTCPPacket(RTCPPacketInformation & rtcpPacketInformation,RTCPUtility::RTCPParserV2 * rtcpParser)286 RTCPReceiver::IncomingRTCPPacket(RTCPPacketInformation& rtcpPacketInformation,
287                                  RTCPUtility::RTCPParserV2* rtcpParser)
288 {
289     CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
290 
291     _lastReceived = _clock->TimeInMilliseconds();
292 
293     if (packet_type_counter_.first_packet_time_ms == -1) {
294       packet_type_counter_.first_packet_time_ms = _lastReceived;
295     }
296 
297     RTCPUtility::RTCPPacketTypes pktType = rtcpParser->Begin();
298     while (pktType != RTCPPacketTypes::kInvalid) {
299         // Each "case" is responsible for iterate the parser to the
300         // next top level packet.
301         switch (pktType)
302         {
303           case RTCPPacketTypes::kSr:
304           case RTCPPacketTypes::kRr:
305             HandleSenderReceiverReport(*rtcpParser, rtcpPacketInformation);
306             break;
307           case RTCPPacketTypes::kSdes:
308             HandleSDES(*rtcpParser, rtcpPacketInformation);
309             break;
310           case RTCPPacketTypes::kXrHeader:
311             HandleXrHeader(*rtcpParser, rtcpPacketInformation);
312             break;
313           case RTCPPacketTypes::kXrReceiverReferenceTime:
314             HandleXrReceiveReferenceTime(*rtcpParser, rtcpPacketInformation);
315             break;
316           case RTCPPacketTypes::kXrDlrrReportBlock:
317             HandleXrDlrrReportBlock(*rtcpParser, rtcpPacketInformation);
318             break;
319           case RTCPPacketTypes::kXrVoipMetric:
320             HandleXRVOIPMetric(*rtcpParser, rtcpPacketInformation);
321             break;
322           case RTCPPacketTypes::kBye:
323             HandleBYE(*rtcpParser);
324             break;
325           case RTCPPacketTypes::kRtpfbNack:
326             HandleNACK(*rtcpParser, rtcpPacketInformation);
327             break;
328           case RTCPPacketTypes::kRtpfbTmmbr:
329             HandleTMMBR(*rtcpParser, rtcpPacketInformation);
330             break;
331           case RTCPPacketTypes::kRtpfbTmmbn:
332             HandleTMMBN(*rtcpParser, rtcpPacketInformation);
333             break;
334           case RTCPPacketTypes::kRtpfbSrReq:
335             HandleSR_REQ(*rtcpParser, rtcpPacketInformation);
336             break;
337           case RTCPPacketTypes::kPsfbPli:
338             HandlePLI(*rtcpParser, rtcpPacketInformation);
339             break;
340           case RTCPPacketTypes::kPsfbSli:
341             HandleSLI(*rtcpParser, rtcpPacketInformation);
342             break;
343           case RTCPPacketTypes::kPsfbRpsi:
344             HandleRPSI(*rtcpParser, rtcpPacketInformation);
345             break;
346           case RTCPPacketTypes::kExtendedIj:
347             HandleIJ(*rtcpParser, rtcpPacketInformation);
348             break;
349           case RTCPPacketTypes::kPsfbFir:
350             HandleFIR(*rtcpParser, rtcpPacketInformation);
351             break;
352           case RTCPPacketTypes::kPsfbApp:
353             HandlePsfbApp(*rtcpParser, rtcpPacketInformation);
354             break;
355           case RTCPPacketTypes::kApp:
356             // generic application messages
357             HandleAPP(*rtcpParser, rtcpPacketInformation);
358             break;
359           case RTCPPacketTypes::kAppItem:
360             // generic application messages
361             HandleAPPItem(*rtcpParser, rtcpPacketInformation);
362             break;
363           case RTCPPacketTypes::kTransportFeedback:
364             HandleTransportFeedback(rtcpParser, &rtcpPacketInformation);
365             break;
366         default:
367             rtcpParser->Iterate();
368             break;
369         }
370         pktType = rtcpParser->PacketType();
371     }
372 
373     if (packet_type_counter_observer_ != NULL) {
374       packet_type_counter_observer_->RtcpPacketTypesCounterUpdated(
375           main_ssrc_, packet_type_counter_);
376     }
377 
378     num_skipped_packets_ += rtcpParser->NumSkippedBlocks();
379 
380     int64_t now = _clock->TimeInMilliseconds();
381     if (now - last_skipped_packets_warning_ >= kMaxWarningLogIntervalMs &&
382         num_skipped_packets_ > 0) {
383       last_skipped_packets_warning_ = now;
384       LOG(LS_WARNING)
385           << num_skipped_packets_
386           << " RTCP blocks were skipped due to being malformed or of "
387              "unrecognized/unsupported type, during the past "
388           << (kMaxWarningLogIntervalMs / 1000) << " second period.";
389     }
390 
391     return 0;
392 }
393 
394 void
HandleSenderReceiverReport(RTCPUtility::RTCPParserV2 & rtcpParser,RTCPPacketInformation & rtcpPacketInformation)395 RTCPReceiver::HandleSenderReceiverReport(RTCPUtility::RTCPParserV2& rtcpParser,
396                                          RTCPPacketInformation& rtcpPacketInformation)
397 {
398     RTCPUtility::RTCPPacketTypes rtcpPacketType = rtcpParser.PacketType();
399     const RTCPUtility::RTCPPacket& rtcpPacket   = rtcpParser.Packet();
400 
401     assert((rtcpPacketType == RTCPPacketTypes::kRr) ||
402            (rtcpPacketType == RTCPPacketTypes::kSr));
403 
404     // SR.SenderSSRC
405     // The synchronization source identifier for the originator of this SR packet
406 
407     // rtcpPacket.RR.SenderSSRC
408     // The source of the packet sender, same as of SR? or is this a CE?
409 
410     const uint32_t remoteSSRC = (rtcpPacketType == RTCPPacketTypes::kRr)
411                                     ? rtcpPacket.RR.SenderSSRC
412                                     : rtcpPacket.SR.SenderSSRC;
413 
414     rtcpPacketInformation.remoteSSRC = remoteSSRC;
415 
416     RTCPReceiveInformation* ptrReceiveInfo = CreateReceiveInformation(remoteSSRC);
417     if (!ptrReceiveInfo)
418     {
419         rtcpParser.Iterate();
420         return;
421     }
422 
423     if (rtcpPacketType == RTCPPacketTypes::kSr) {
424       TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "SR",
425                            "remote_ssrc", remoteSSRC, "ssrc", main_ssrc_);
426 
427         if (_remoteSSRC == remoteSSRC) // have I received RTP packets from this party
428         {
429             // only signal that we have received a SR when we accept one
430             rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSr;
431 
432             rtcpPacketInformation.ntp_secs = rtcpPacket.SR.NTPMostSignificant;
433             rtcpPacketInformation.ntp_frac = rtcpPacket.SR.NTPLeastSignificant;
434             rtcpPacketInformation.rtp_timestamp = rtcpPacket.SR.RTPTimestamp;
435 
436             // We will only store the send report from one source, but
437             // we will store all the receive block
438 
439             // Save the NTP time of this report
440             _remoteSenderInfo.NTPseconds = rtcpPacket.SR.NTPMostSignificant;
441             _remoteSenderInfo.NTPfraction = rtcpPacket.SR.NTPLeastSignificant;
442             _remoteSenderInfo.RTPtimeStamp = rtcpPacket.SR.RTPTimestamp;
443             _remoteSenderInfo.sendPacketCount = rtcpPacket.SR.SenderPacketCount;
444             _remoteSenderInfo.sendOctetCount = rtcpPacket.SR.SenderOctetCount;
445 
446             _clock->CurrentNtp(_lastReceivedSRNTPsecs, _lastReceivedSRNTPfrac);
447         }
448         else
449         {
450             rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRr;
451         }
452     } else
453     {
454       TRACE_EVENT_INSTANT2(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RR",
455                            "remote_ssrc", remoteSSRC, "ssrc", main_ssrc_);
456 
457         rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRr;
458     }
459     UpdateReceiveInformation(*ptrReceiveInfo);
460 
461     rtcpPacketType = rtcpParser.Iterate();
462 
463     while (rtcpPacketType == RTCPPacketTypes::kReportBlockItem) {
464         HandleReportBlock(rtcpPacket, rtcpPacketInformation, remoteSSRC);
465         rtcpPacketType = rtcpParser.Iterate();
466     }
467 }
468 
HandleReportBlock(const RTCPUtility::RTCPPacket & rtcpPacket,RTCPPacketInformation & rtcpPacketInformation,uint32_t remoteSSRC)469 void RTCPReceiver::HandleReportBlock(
470     const RTCPUtility::RTCPPacket& rtcpPacket,
471     RTCPPacketInformation& rtcpPacketInformation,
472     uint32_t remoteSSRC)
473     EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver) {
474   // This will be called once per report block in the RTCP packet.
475   // We filter out all report blocks that are not for us.
476   // Each packet has max 31 RR blocks.
477   //
478   // We can calc RTT if we send a send report and get a report block back.
479 
480   // |rtcpPacket.ReportBlockItem.SSRC| is the SSRC identifier of the source to
481   // which the information in this reception report block pertains.
482 
483   // Filter out all report blocks that are not for us.
484   if (registered_ssrcs_.find(rtcpPacket.ReportBlockItem.SSRC) ==
485       registered_ssrcs_.end()) {
486     // This block is not for us ignore it.
487     return;
488   }
489 
490   // To avoid problem with acquiring _criticalSectionRTCPSender while holding
491   // _criticalSectionRTCPReceiver.
492   _criticalSectionRTCPReceiver->Leave();
493   int64_t sendTimeMS =
494       _rtpRtcp.SendTimeOfSendReport(rtcpPacket.ReportBlockItem.LastSR);
495   _criticalSectionRTCPReceiver->Enter();
496 
497   RTCPReportBlockInformation* reportBlock =
498       CreateOrGetReportBlockInformation(remoteSSRC,
499                                         rtcpPacket.ReportBlockItem.SSRC);
500   if (reportBlock == NULL) {
501     LOG(LS_WARNING) << "Failed to CreateReportBlockInformation("
502                     << remoteSSRC << ")";
503     return;
504   }
505 
506   _lastReceivedRrMs = _clock->TimeInMilliseconds();
507   const RTCPPacketReportBlockItem& rb = rtcpPacket.ReportBlockItem;
508   reportBlock->remoteReceiveBlock.remoteSSRC = remoteSSRC;
509   reportBlock->remoteReceiveBlock.sourceSSRC = rb.SSRC;
510   reportBlock->remoteReceiveBlock.fractionLost = rb.FractionLost;
511   reportBlock->remoteReceiveBlock.cumulativeLost =
512       rb.CumulativeNumOfPacketsLost;
513   if (rb.ExtendedHighestSequenceNumber >
514       reportBlock->remoteReceiveBlock.extendedHighSeqNum) {
515     // We have successfully delivered new RTP packets to the remote side after
516     // the last RR was sent from the remote side.
517     _lastIncreasedSequenceNumberMs = _lastReceivedRrMs;
518   }
519   reportBlock->remoteReceiveBlock.extendedHighSeqNum =
520       rb.ExtendedHighestSequenceNumber;
521   reportBlock->remoteReceiveBlock.jitter = rb.Jitter;
522   reportBlock->remoteReceiveBlock.delaySinceLastSR = rb.DelayLastSR;
523   reportBlock->remoteReceiveBlock.lastSR = rb.LastSR;
524 
525   if (rtcpPacket.ReportBlockItem.Jitter > reportBlock->remoteMaxJitter) {
526     reportBlock->remoteMaxJitter = rtcpPacket.ReportBlockItem.Jitter;
527   }
528 
529   uint32_t delaySinceLastSendReport =
530       rtcpPacket.ReportBlockItem.DelayLastSR;
531 
532   // local NTP time when we received this
533   uint32_t lastReceivedRRNTPsecs = 0;
534   uint32_t lastReceivedRRNTPfrac = 0;
535 
536   _clock->CurrentNtp(lastReceivedRRNTPsecs, lastReceivedRRNTPfrac);
537 
538   // time when we received this in MS
539   int64_t receiveTimeMS = Clock::NtpToMs(lastReceivedRRNTPsecs,
540                                          lastReceivedRRNTPfrac);
541 
542   // Estimate RTT
543   uint32_t d = (delaySinceLastSendReport & 0x0000ffff) * 1000;
544   d /= 65536;
545   d += ((delaySinceLastSendReport & 0xffff0000) >> 16) * 1000;
546 
547   int64_t RTT = 0;
548 
549   if (sendTimeMS > 0) {
550     RTT = receiveTimeMS - d - sendTimeMS;
551     if (RTT <= 0) {
552       RTT = 1;
553     }
554     if (RTT > reportBlock->maxRTT) {
555       // store max RTT
556       reportBlock->maxRTT = RTT;
557     }
558     if (reportBlock->minRTT == 0) {
559       // first RTT
560       reportBlock->minRTT = RTT;
561     } else if (RTT < reportBlock->minRTT) {
562       // Store min RTT
563       reportBlock->minRTT = RTT;
564     }
565     // store last RTT
566     reportBlock->RTT = RTT;
567 
568     // store average RTT
569     if (reportBlock->numAverageCalcs != 0) {
570       float ac = static_cast<float>(reportBlock->numAverageCalcs);
571       float newAverage =
572           ((ac / (ac + 1)) * reportBlock->avgRTT) + ((1 / (ac + 1)) * RTT);
573       reportBlock->avgRTT = static_cast<int64_t>(newAverage + 0.5f);
574     } else {
575       // first RTT
576       reportBlock->avgRTT = RTT;
577     }
578     reportBlock->numAverageCalcs++;
579   }
580 
581   TRACE_COUNTER_ID1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RR_RTT", rb.SSRC,
582                     RTT);
583 
584   rtcpPacketInformation.AddReportInfo(*reportBlock);
585 }
586 
CreateOrGetReportBlockInformation(uint32_t remote_ssrc,uint32_t source_ssrc)587 RTCPReportBlockInformation* RTCPReceiver::CreateOrGetReportBlockInformation(
588     uint32_t remote_ssrc,
589     uint32_t source_ssrc) {
590   RTCPReportBlockInformation* info =
591       GetReportBlockInformation(remote_ssrc, source_ssrc);
592   if (info == NULL) {
593     info = new RTCPReportBlockInformation;
594     _receivedReportBlockMap[source_ssrc][remote_ssrc] = info;
595   }
596   return info;
597 }
598 
GetReportBlockInformation(uint32_t remote_ssrc,uint32_t source_ssrc) const599 RTCPReportBlockInformation* RTCPReceiver::GetReportBlockInformation(
600     uint32_t remote_ssrc,
601     uint32_t source_ssrc) const {
602   ReportBlockMap::const_iterator it = _receivedReportBlockMap.find(source_ssrc);
603   if (it == _receivedReportBlockMap.end()) {
604     return NULL;
605   }
606   const ReportBlockInfoMap* info_map = &(it->second);
607   ReportBlockInfoMap::const_iterator it_info = info_map->find(remote_ssrc);
608   if (it_info == info_map->end()) {
609     return NULL;
610   }
611   return it_info->second;
612 }
613 
614 RTCPCnameInformation*
CreateCnameInformation(uint32_t remoteSSRC)615 RTCPReceiver::CreateCnameInformation(uint32_t remoteSSRC) {
616   CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
617 
618   std::map<uint32_t, RTCPCnameInformation*>::iterator it =
619       _receivedCnameMap.find(remoteSSRC);
620 
621   if (it != _receivedCnameMap.end()) {
622     return it->second;
623   }
624   RTCPCnameInformation* cnameInfo = new RTCPCnameInformation;
625   memset(cnameInfo->name, 0, RTCP_CNAME_SIZE);
626   _receivedCnameMap[remoteSSRC] = cnameInfo;
627   return cnameInfo;
628 }
629 
630 RTCPCnameInformation*
GetCnameInformation(uint32_t remoteSSRC) const631 RTCPReceiver::GetCnameInformation(uint32_t remoteSSRC) const {
632   CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
633 
634   std::map<uint32_t, RTCPCnameInformation*>::const_iterator it =
635       _receivedCnameMap.find(remoteSSRC);
636 
637   if (it == _receivedCnameMap.end()) {
638     return NULL;
639   }
640   return it->second;
641 }
642 
643 RTCPReceiveInformation*
CreateReceiveInformation(uint32_t remoteSSRC)644 RTCPReceiver::CreateReceiveInformation(uint32_t remoteSSRC) {
645   CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
646 
647   std::map<uint32_t, RTCPReceiveInformation*>::iterator it =
648       _receivedInfoMap.find(remoteSSRC);
649 
650   if (it != _receivedInfoMap.end()) {
651     return it->second;
652   }
653   RTCPReceiveInformation* receiveInfo = new RTCPReceiveInformation;
654   _receivedInfoMap[remoteSSRC] = receiveInfo;
655   return receiveInfo;
656 }
657 
658 RTCPReceiveInformation*
GetReceiveInformation(uint32_t remoteSSRC)659 RTCPReceiver::GetReceiveInformation(uint32_t remoteSSRC) {
660   CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
661 
662   std::map<uint32_t, RTCPReceiveInformation*>::iterator it =
663       _receivedInfoMap.find(remoteSSRC);
664   if (it == _receivedInfoMap.end()) {
665     return NULL;
666   }
667   return it->second;
668 }
669 
UpdateReceiveInformation(RTCPReceiveInformation & receiveInformation)670 void RTCPReceiver::UpdateReceiveInformation(
671     RTCPReceiveInformation& receiveInformation) {
672   // Update that this remote is alive
673   receiveInformation.lastTimeReceived = _clock->TimeInMilliseconds();
674 }
675 
RtcpRrTimeout(int64_t rtcp_interval_ms)676 bool RTCPReceiver::RtcpRrTimeout(int64_t rtcp_interval_ms) {
677   CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
678   if (_lastReceivedRrMs == 0)
679     return false;
680 
681   int64_t time_out_ms = kRrTimeoutIntervals * rtcp_interval_ms;
682   if (_clock->TimeInMilliseconds() > _lastReceivedRrMs + time_out_ms) {
683     // Reset the timer to only trigger one log.
684     _lastReceivedRrMs = 0;
685     return true;
686   }
687   return false;
688 }
689 
RtcpRrSequenceNumberTimeout(int64_t rtcp_interval_ms)690 bool RTCPReceiver::RtcpRrSequenceNumberTimeout(int64_t rtcp_interval_ms) {
691   CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
692   if (_lastIncreasedSequenceNumberMs == 0)
693     return false;
694 
695   int64_t time_out_ms = kRrTimeoutIntervals * rtcp_interval_ms;
696   if (_clock->TimeInMilliseconds() > _lastIncreasedSequenceNumberMs +
697       time_out_ms) {
698     // Reset the timer to only trigger one log.
699     _lastIncreasedSequenceNumberMs = 0;
700     return true;
701   }
702   return false;
703 }
704 
UpdateRTCPReceiveInformationTimers()705 bool RTCPReceiver::UpdateRTCPReceiveInformationTimers() {
706   CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
707 
708   bool updateBoundingSet = false;
709   int64_t timeNow = _clock->TimeInMilliseconds();
710 
711   std::map<uint32_t, RTCPReceiveInformation*>::iterator receiveInfoIt =
712       _receivedInfoMap.begin();
713 
714   while (receiveInfoIt != _receivedInfoMap.end()) {
715     RTCPReceiveInformation* receiveInfo = receiveInfoIt->second;
716     if (receiveInfo == NULL) {
717       return updateBoundingSet;
718     }
719     // time since last received rtcp packet
720     // when we dont have a lastTimeReceived and the object is marked
721     // readyForDelete it's removed from the map
722     if (receiveInfo->lastTimeReceived) {
723       /// use audio define since we don't know what interval the remote peer is
724       // using
725       if ((timeNow - receiveInfo->lastTimeReceived) >
726           5 * RTCP_INTERVAL_AUDIO_MS) {
727         // no rtcp packet for the last five regular intervals, reset limitations
728         receiveInfo->TmmbrSet.clearSet();
729         // prevent that we call this over and over again
730         receiveInfo->lastTimeReceived = 0;
731         // send new TMMBN to all channels using the default codec
732         updateBoundingSet = true;
733       }
734       receiveInfoIt++;
735     } else if (receiveInfo->readyForDelete) {
736       // store our current receiveInfoItem
737       std::map<uint32_t, RTCPReceiveInformation*>::iterator
738       receiveInfoItemToBeErased = receiveInfoIt;
739       receiveInfoIt++;
740       delete receiveInfoItemToBeErased->second;
741       _receivedInfoMap.erase(receiveInfoItemToBeErased);
742     } else {
743       receiveInfoIt++;
744     }
745   }
746   return updateBoundingSet;
747 }
748 
BoundingSet(bool * tmmbrOwner,TMMBRSet * boundingSetRec)749 int32_t RTCPReceiver::BoundingSet(bool* tmmbrOwner, TMMBRSet* boundingSetRec) {
750   CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
751 
752   std::map<uint32_t, RTCPReceiveInformation*>::iterator receiveInfoIt =
753       _receivedInfoMap.find(_remoteSSRC);
754 
755   if (receiveInfoIt == _receivedInfoMap.end()) {
756     return -1;
757   }
758   RTCPReceiveInformation* receiveInfo = receiveInfoIt->second;
759   if (receiveInfo == NULL) {
760     return -1;
761   }
762   if (receiveInfo->TmmbnBoundingSet.lengthOfSet() > 0) {
763     boundingSetRec->VerifyAndAllocateSet(
764         receiveInfo->TmmbnBoundingSet.lengthOfSet() + 1);
765     for(uint32_t i=0; i< receiveInfo->TmmbnBoundingSet.lengthOfSet();
766         i++) {
767       if(receiveInfo->TmmbnBoundingSet.Ssrc(i) == main_ssrc_) {
768         // owner of bounding set
769         *tmmbrOwner = true;
770       }
771       boundingSetRec->SetEntry(i,
772                                receiveInfo->TmmbnBoundingSet.Tmmbr(i),
773                                receiveInfo->TmmbnBoundingSet.PacketOH(i),
774                                receiveInfo->TmmbnBoundingSet.Ssrc(i));
775     }
776   }
777   return receiveInfo->TmmbnBoundingSet.lengthOfSet();
778 }
779 
HandleSDES(RTCPUtility::RTCPParserV2 & rtcpParser,RTCPPacketInformation & rtcpPacketInformation)780 void RTCPReceiver::HandleSDES(RTCPUtility::RTCPParserV2& rtcpParser,
781                               RTCPPacketInformation& rtcpPacketInformation) {
782   RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
783   while (pktType == RTCPPacketTypes::kSdesChunk) {
784     HandleSDESChunk(rtcpParser);
785     pktType = rtcpParser.Iterate();
786   }
787   rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSdes;
788 }
789 
HandleSDESChunk(RTCPUtility::RTCPParserV2 & rtcpParser)790 void RTCPReceiver::HandleSDESChunk(RTCPUtility::RTCPParserV2& rtcpParser) {
791   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
792   RTCPCnameInformation* cnameInfo =
793       CreateCnameInformation(rtcpPacket.CName.SenderSSRC);
794   assert(cnameInfo);
795 
796   cnameInfo->name[RTCP_CNAME_SIZE - 1] = 0;
797   strncpy(cnameInfo->name, rtcpPacket.CName.CName, RTCP_CNAME_SIZE - 1);
798   {
799     CriticalSectionScoped lock(_criticalSectionFeedbacks);
800     if (stats_callback_ != NULL) {
801       stats_callback_->CNameChanged(rtcpPacket.CName.CName,
802                                     rtcpPacket.CName.SenderSSRC);
803     }
804   }
805 }
806 
HandleNACK(RTCPUtility::RTCPParserV2 & rtcpParser,RTCPPacketInformation & rtcpPacketInformation)807 void RTCPReceiver::HandleNACK(RTCPUtility::RTCPParserV2& rtcpParser,
808                               RTCPPacketInformation& rtcpPacketInformation) {
809   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
810   if (receiver_only_ || main_ssrc_ != rtcpPacket.NACK.MediaSSRC) {
811     // Not to us.
812     rtcpParser.Iterate();
813     return;
814   }
815   rtcpPacketInformation.ResetNACKPacketIdArray();
816 
817   RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
818   while (pktType == RTCPPacketTypes::kRtpfbNackItem) {
819     HandleNACKItem(rtcpPacket, rtcpPacketInformation);
820     pktType = rtcpParser.Iterate();
821   }
822 
823   if (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpNack) {
824     ++packet_type_counter_.nack_packets;
825     packet_type_counter_.nack_requests = nack_stats_.requests();
826     packet_type_counter_.unique_nack_requests = nack_stats_.unique_requests();
827   }
828 }
829 
830 void
HandleNACKItem(const RTCPUtility::RTCPPacket & rtcpPacket,RTCPPacketInformation & rtcpPacketInformation)831 RTCPReceiver::HandleNACKItem(const RTCPUtility::RTCPPacket& rtcpPacket,
832                              RTCPPacketInformation& rtcpPacketInformation) {
833   rtcpPacketInformation.AddNACKPacket(rtcpPacket.NACKItem.PacketID);
834   nack_stats_.ReportRequest(rtcpPacket.NACKItem.PacketID);
835 
836   uint16_t bitMask = rtcpPacket.NACKItem.BitMask;
837   if (bitMask) {
838     for (int i=1; i <= 16; ++i) {
839       if (bitMask & 0x01) {
840         rtcpPacketInformation.AddNACKPacket(rtcpPacket.NACKItem.PacketID + i);
841         nack_stats_.ReportRequest(rtcpPacket.NACKItem.PacketID + i);
842       }
843       bitMask = bitMask >>1;
844     }
845   }
846   rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpNack;
847 }
848 
HandleBYE(RTCPUtility::RTCPParserV2 & rtcpParser)849 void RTCPReceiver::HandleBYE(RTCPUtility::RTCPParserV2& rtcpParser) {
850   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
851 
852   // clear our lists
853   ReportBlockMap::iterator it = _receivedReportBlockMap.begin();
854   for (; it != _receivedReportBlockMap.end(); ++it) {
855     ReportBlockInfoMap* info_map = &(it->second);
856     ReportBlockInfoMap::iterator it_info = info_map->find(
857         rtcpPacket.BYE.SenderSSRC);
858     if (it_info != info_map->end()) {
859       delete it_info->second;
860       info_map->erase(it_info);
861     }
862   }
863 
864   //  we can't delete it due to TMMBR
865   std::map<uint32_t, RTCPReceiveInformation*>::iterator receiveInfoIt =
866       _receivedInfoMap.find(rtcpPacket.BYE.SenderSSRC);
867 
868   if (receiveInfoIt != _receivedInfoMap.end()) {
869     receiveInfoIt->second->readyForDelete = true;
870   }
871 
872   std::map<uint32_t, RTCPCnameInformation*>::iterator cnameInfoIt =
873       _receivedCnameMap.find(rtcpPacket.BYE.SenderSSRC);
874 
875   if (cnameInfoIt != _receivedCnameMap.end()) {
876     delete cnameInfoIt->second;
877     _receivedCnameMap.erase(cnameInfoIt);
878   }
879   xr_rr_rtt_ms_ = 0;
880   rtcpParser.Iterate();
881 }
882 
HandleXrHeader(RTCPUtility::RTCPParserV2 & parser,RTCPPacketInformation & rtcpPacketInformation)883 void RTCPReceiver::HandleXrHeader(
884     RTCPUtility::RTCPParserV2& parser,
885     RTCPPacketInformation& rtcpPacketInformation) {
886   const RTCPUtility::RTCPPacket& packet = parser.Packet();
887 
888   rtcpPacketInformation.xr_originator_ssrc = packet.XR.OriginatorSSRC;
889 
890   parser.Iterate();
891 }
892 
HandleXrReceiveReferenceTime(RTCPUtility::RTCPParserV2 & parser,RTCPPacketInformation & rtcpPacketInformation)893 void RTCPReceiver::HandleXrReceiveReferenceTime(
894     RTCPUtility::RTCPParserV2& parser,
895     RTCPPacketInformation& rtcpPacketInformation) {
896   const RTCPUtility::RTCPPacket& packet = parser.Packet();
897 
898   _remoteXRReceiveTimeInfo.sourceSSRC =
899       rtcpPacketInformation.xr_originator_ssrc;
900 
901   _remoteXRReceiveTimeInfo.lastRR = RTCPUtility::MidNtp(
902       packet.XRReceiverReferenceTimeItem.NTPMostSignificant,
903       packet.XRReceiverReferenceTimeItem.NTPLeastSignificant);
904 
905   _clock->CurrentNtp(_lastReceivedXRNTPsecs, _lastReceivedXRNTPfrac);
906 
907   rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpXrReceiverReferenceTime;
908 
909   parser.Iterate();
910 }
911 
HandleXrDlrrReportBlock(RTCPUtility::RTCPParserV2 & parser,RTCPPacketInformation & rtcpPacketInformation)912 void RTCPReceiver::HandleXrDlrrReportBlock(
913     RTCPUtility::RTCPParserV2& parser,
914     RTCPPacketInformation& rtcpPacketInformation) {
915   const RTCPUtility::RTCPPacket& packet = parser.Packet();
916   // Iterate through sub-block(s), if any.
917   RTCPUtility::RTCPPacketTypes packet_type = parser.Iterate();
918 
919   while (packet_type == RTCPPacketTypes::kXrDlrrReportBlockItem) {
920     HandleXrDlrrReportBlockItem(packet, rtcpPacketInformation);
921     packet_type = parser.Iterate();
922   }
923 }
924 
HandleXrDlrrReportBlockItem(const RTCPUtility::RTCPPacket & packet,RTCPPacketInformation & rtcpPacketInformation)925 void RTCPReceiver::HandleXrDlrrReportBlockItem(
926     const RTCPUtility::RTCPPacket& packet,
927     RTCPPacketInformation& rtcpPacketInformation)
928     EXCLUSIVE_LOCKS_REQUIRED(_criticalSectionRTCPReceiver) {
929   if (registered_ssrcs_.find(packet.XRDLRRReportBlockItem.SSRC) ==
930       registered_ssrcs_.end()) {
931     // Not to us.
932     return;
933   }
934 
935   rtcpPacketInformation.xr_dlrr_item = true;
936 
937   // To avoid problem with acquiring _criticalSectionRTCPSender while holding
938   // _criticalSectionRTCPReceiver.
939   _criticalSectionRTCPReceiver->Leave();
940 
941   int64_t send_time_ms;
942   bool found = _rtpRtcp.SendTimeOfXrRrReport(
943       packet.XRDLRRReportBlockItem.LastRR, &send_time_ms);
944 
945   _criticalSectionRTCPReceiver->Enter();
946 
947   if (!found) {
948     return;
949   }
950 
951   // The DelayLastRR field is in units of 1/65536 sec.
952   uint32_t delay_rr_ms =
953       (((packet.XRDLRRReportBlockItem.DelayLastRR & 0x0000ffff) * 1000) >> 16) +
954       (((packet.XRDLRRReportBlockItem.DelayLastRR & 0xffff0000) >> 16) * 1000);
955 
956   int64_t rtt = _clock->CurrentNtpInMilliseconds() - delay_rr_ms - send_time_ms;
957 
958   xr_rr_rtt_ms_ = std::max<int64_t>(rtt, 1);
959 
960   rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpXrDlrrReportBlock;
961 }
962 
963 void
HandleXRVOIPMetric(RTCPUtility::RTCPParserV2 & rtcpParser,RTCPPacketInformation & rtcpPacketInformation)964 RTCPReceiver::HandleXRVOIPMetric(RTCPUtility::RTCPParserV2& rtcpParser,
965                                  RTCPPacketInformation& rtcpPacketInformation)
966 {
967     const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
968 
969     if(rtcpPacket.XRVOIPMetricItem.SSRC == main_ssrc_)
970     {
971         // Store VoIP metrics block if it's about me
972         // from OriginatorSSRC do we filter it?
973         // rtcpPacket.XR.OriginatorSSRC;
974 
975         RTCPVoIPMetric receivedVoIPMetrics;
976         receivedVoIPMetrics.burstDensity = rtcpPacket.XRVOIPMetricItem.burstDensity;
977         receivedVoIPMetrics.burstDuration = rtcpPacket.XRVOIPMetricItem.burstDuration;
978         receivedVoIPMetrics.discardRate = rtcpPacket.XRVOIPMetricItem.discardRate;
979         receivedVoIPMetrics.endSystemDelay = rtcpPacket.XRVOIPMetricItem.endSystemDelay;
980         receivedVoIPMetrics.extRfactor = rtcpPacket.XRVOIPMetricItem.extRfactor;
981         receivedVoIPMetrics.gapDensity = rtcpPacket.XRVOIPMetricItem.gapDensity;
982         receivedVoIPMetrics.gapDuration = rtcpPacket.XRVOIPMetricItem.gapDuration;
983         receivedVoIPMetrics.Gmin = rtcpPacket.XRVOIPMetricItem.Gmin;
984         receivedVoIPMetrics.JBabsMax = rtcpPacket.XRVOIPMetricItem.JBabsMax;
985         receivedVoIPMetrics.JBmax = rtcpPacket.XRVOIPMetricItem.JBmax;
986         receivedVoIPMetrics.JBnominal = rtcpPacket.XRVOIPMetricItem.JBnominal;
987         receivedVoIPMetrics.lossRate = rtcpPacket.XRVOIPMetricItem.lossRate;
988         receivedVoIPMetrics.MOSCQ = rtcpPacket.XRVOIPMetricItem.MOSCQ;
989         receivedVoIPMetrics.MOSLQ = rtcpPacket.XRVOIPMetricItem.MOSLQ;
990         receivedVoIPMetrics.noiseLevel = rtcpPacket.XRVOIPMetricItem.noiseLevel;
991         receivedVoIPMetrics.RERL = rtcpPacket.XRVOIPMetricItem.RERL;
992         receivedVoIPMetrics.Rfactor = rtcpPacket.XRVOIPMetricItem.Rfactor;
993         receivedVoIPMetrics.roundTripDelay = rtcpPacket.XRVOIPMetricItem.roundTripDelay;
994         receivedVoIPMetrics.RXconfig = rtcpPacket.XRVOIPMetricItem.RXconfig;
995         receivedVoIPMetrics.signalLevel = rtcpPacket.XRVOIPMetricItem.signalLevel;
996 
997         rtcpPacketInformation.AddVoIPMetric(&receivedVoIPMetrics);
998 
999         rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpXrVoipMetric; // received signal
1000     }
1001     rtcpParser.Iterate();
1002 }
1003 
HandlePLI(RTCPUtility::RTCPParserV2 & rtcpParser,RTCPPacketInformation & rtcpPacketInformation)1004 void RTCPReceiver::HandlePLI(RTCPUtility::RTCPParserV2& rtcpParser,
1005                              RTCPPacketInformation& rtcpPacketInformation) {
1006   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
1007   if (main_ssrc_ == rtcpPacket.PLI.MediaSSRC) {
1008     TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "PLI");
1009 
1010     ++packet_type_counter_.pli_packets;
1011     // Received a signal that we need to send a new key frame.
1012     rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpPli;
1013   }
1014   rtcpParser.Iterate();
1015 }
1016 
HandleTMMBR(RTCPUtility::RTCPParserV2 & rtcpParser,RTCPPacketInformation & rtcpPacketInformation)1017 void RTCPReceiver::HandleTMMBR(RTCPUtility::RTCPParserV2& rtcpParser,
1018                                RTCPPacketInformation& rtcpPacketInformation) {
1019   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
1020 
1021   uint32_t senderSSRC = rtcpPacket.TMMBR.SenderSSRC;
1022   RTCPReceiveInformation* ptrReceiveInfo = GetReceiveInformation(senderSSRC);
1023   if (ptrReceiveInfo == NULL) {
1024     // This remote SSRC must be saved before.
1025     rtcpParser.Iterate();
1026     return;
1027   }
1028   if (rtcpPacket.TMMBR.MediaSSRC) {
1029     // rtcpPacket.TMMBR.MediaSSRC SHOULD be 0 if same as SenderSSRC
1030     // in relay mode this is a valid number
1031     senderSSRC = rtcpPacket.TMMBR.MediaSSRC;
1032   }
1033 
1034   // Use packet length to calc max number of TMMBR blocks
1035   // each TMMBR block is 8 bytes
1036   ptrdiff_t maxNumOfTMMBRBlocks = rtcpParser.LengthLeft() / 8;
1037 
1038   // sanity, we can't have more than what's in one packet
1039   if (maxNumOfTMMBRBlocks > 200) {
1040     assert(false);
1041     rtcpParser.Iterate();
1042     return;
1043   }
1044   ptrReceiveInfo->VerifyAndAllocateTMMBRSet((uint32_t)maxNumOfTMMBRBlocks);
1045 
1046   RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
1047   while (pktType == RTCPPacketTypes::kRtpfbTmmbrItem) {
1048     HandleTMMBRItem(*ptrReceiveInfo, rtcpPacket, rtcpPacketInformation, senderSSRC);
1049     pktType = rtcpParser.Iterate();
1050   }
1051 }
1052 
HandleTMMBRItem(RTCPReceiveInformation & receiveInfo,const RTCPUtility::RTCPPacket & rtcpPacket,RTCPPacketInformation & rtcpPacketInformation,uint32_t senderSSRC)1053 void RTCPReceiver::HandleTMMBRItem(RTCPReceiveInformation& receiveInfo,
1054                                    const RTCPUtility::RTCPPacket& rtcpPacket,
1055                                    RTCPPacketInformation& rtcpPacketInformation,
1056                                    uint32_t senderSSRC) {
1057   if (main_ssrc_ == rtcpPacket.TMMBRItem.SSRC &&
1058       rtcpPacket.TMMBRItem.MaxTotalMediaBitRate > 0) {
1059     receiveInfo.InsertTMMBRItem(senderSSRC, rtcpPacket.TMMBRItem,
1060                                 _clock->TimeInMilliseconds());
1061     rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpTmmbr;
1062   }
1063 }
1064 
HandleTMMBN(RTCPUtility::RTCPParserV2 & rtcpParser,RTCPPacketInformation & rtcpPacketInformation)1065 void RTCPReceiver::HandleTMMBN(RTCPUtility::RTCPParserV2& rtcpParser,
1066                                RTCPPacketInformation& rtcpPacketInformation) {
1067   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
1068   RTCPReceiveInformation* ptrReceiveInfo = GetReceiveInformation(
1069       rtcpPacket.TMMBN.SenderSSRC);
1070   if (ptrReceiveInfo == NULL) {
1071     // This remote SSRC must be saved before.
1072     rtcpParser.Iterate();
1073     return;
1074   }
1075   rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpTmmbn;
1076   // Use packet length to calc max number of TMMBN blocks
1077   // each TMMBN block is 8 bytes
1078   ptrdiff_t maxNumOfTMMBNBlocks = rtcpParser.LengthLeft() / 8;
1079 
1080   // sanity, we cant have more than what's in one packet
1081   if (maxNumOfTMMBNBlocks > 200) {
1082     assert(false);
1083     rtcpParser.Iterate();
1084     return;
1085   }
1086 
1087   ptrReceiveInfo->VerifyAndAllocateBoundingSet((uint32_t)maxNumOfTMMBNBlocks);
1088 
1089   RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
1090   while (pktType == RTCPPacketTypes::kRtpfbTmmbnItem) {
1091     HandleTMMBNItem(*ptrReceiveInfo, rtcpPacket);
1092     pktType = rtcpParser.Iterate();
1093   }
1094 }
1095 
HandleSR_REQ(RTCPUtility::RTCPParserV2 & rtcpParser,RTCPPacketInformation & rtcpPacketInformation)1096 void RTCPReceiver::HandleSR_REQ(RTCPUtility::RTCPParserV2& rtcpParser,
1097                                 RTCPPacketInformation& rtcpPacketInformation) {
1098   rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSrReq;
1099   rtcpParser.Iterate();
1100 }
1101 
HandleTMMBNItem(RTCPReceiveInformation & receiveInfo,const RTCPUtility::RTCPPacket & rtcpPacket)1102 void RTCPReceiver::HandleTMMBNItem(RTCPReceiveInformation& receiveInfo,
1103                                    const RTCPUtility::RTCPPacket& rtcpPacket) {
1104   receiveInfo.TmmbnBoundingSet.AddEntry(
1105       rtcpPacket.TMMBNItem.MaxTotalMediaBitRate,
1106       rtcpPacket.TMMBNItem.MeasuredOverhead,
1107       rtcpPacket.TMMBNItem.SSRC);
1108 }
1109 
HandleSLI(RTCPUtility::RTCPParserV2 & rtcpParser,RTCPPacketInformation & rtcpPacketInformation)1110 void RTCPReceiver::HandleSLI(RTCPUtility::RTCPParserV2& rtcpParser,
1111                              RTCPPacketInformation& rtcpPacketInformation) {
1112   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
1113   RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
1114   while (pktType == RTCPPacketTypes::kPsfbSliItem) {
1115     HandleSLIItem(rtcpPacket, rtcpPacketInformation);
1116     pktType = rtcpParser.Iterate();
1117   }
1118 }
1119 
HandleSLIItem(const RTCPUtility::RTCPPacket & rtcpPacket,RTCPPacketInformation & rtcpPacketInformation)1120 void RTCPReceiver::HandleSLIItem(const RTCPUtility::RTCPPacket& rtcpPacket,
1121                                  RTCPPacketInformation& rtcpPacketInformation) {
1122   // in theory there could be multiple slices lost
1123   rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpSli; // received signal that we need to refresh a slice
1124   rtcpPacketInformation.sliPictureId = rtcpPacket.SLIItem.PictureId;
1125 }
1126 
1127 void
HandleRPSI(RTCPUtility::RTCPParserV2 & rtcpParser,RTCPHelp::RTCPPacketInformation & rtcpPacketInformation)1128 RTCPReceiver::HandleRPSI(RTCPUtility::RTCPParserV2& rtcpParser,
1129                          RTCPHelp::RTCPPacketInformation& rtcpPacketInformation)
1130 {
1131     const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
1132     RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
1133     if (pktType == RTCPPacketTypes::kPsfbRpsi) {
1134         rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRpsi; // received signal that we have a confirmed reference picture
1135         if(rtcpPacket.RPSI.NumberOfValidBits%8 != 0)
1136         {
1137             // to us unknown
1138             // continue
1139             rtcpParser.Iterate();
1140             return;
1141         }
1142         rtcpPacketInformation.rpsiPictureId = 0;
1143 
1144         // convert NativeBitString to rpsiPictureId
1145         uint8_t numberOfBytes = rtcpPacket.RPSI.NumberOfValidBits /8;
1146         for(uint8_t n = 0; n < (numberOfBytes-1); n++)
1147         {
1148             rtcpPacketInformation.rpsiPictureId += (rtcpPacket.RPSI.NativeBitString[n] & 0x7f);
1149             rtcpPacketInformation.rpsiPictureId <<= 7; // prepare next
1150         }
1151         rtcpPacketInformation.rpsiPictureId += (rtcpPacket.RPSI.NativeBitString[numberOfBytes-1] & 0x7f);
1152     }
1153 }
1154 
HandlePsfbApp(RTCPUtility::RTCPParserV2 & rtcpParser,RTCPPacketInformation & rtcpPacketInformation)1155 void RTCPReceiver::HandlePsfbApp(RTCPUtility::RTCPParserV2& rtcpParser,
1156                                  RTCPPacketInformation& rtcpPacketInformation) {
1157   RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
1158   if (pktType == RTCPPacketTypes::kPsfbRemb) {
1159     pktType = rtcpParser.Iterate();
1160     if (pktType == RTCPPacketTypes::kPsfbRembItem) {
1161       HandleREMBItem(rtcpParser, rtcpPacketInformation);
1162       rtcpParser.Iterate();
1163     }
1164   }
1165 }
1166 
HandleIJ(RTCPUtility::RTCPParserV2 & rtcpParser,RTCPPacketInformation & rtcpPacketInformation)1167 void RTCPReceiver::HandleIJ(RTCPUtility::RTCPParserV2& rtcpParser,
1168                             RTCPPacketInformation& rtcpPacketInformation) {
1169   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
1170 
1171   RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
1172   while (pktType == RTCPPacketTypes::kExtendedIjItem) {
1173     HandleIJItem(rtcpPacket, rtcpPacketInformation);
1174     pktType = rtcpParser.Iterate();
1175   }
1176 }
1177 
HandleIJItem(const RTCPUtility::RTCPPacket & rtcpPacket,RTCPPacketInformation & rtcpPacketInformation)1178 void RTCPReceiver::HandleIJItem(const RTCPUtility::RTCPPacket& rtcpPacket,
1179                                 RTCPPacketInformation& rtcpPacketInformation) {
1180   rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpTransmissionTimeOffset;
1181   rtcpPacketInformation.interArrivalJitter =
1182   rtcpPacket.ExtendedJitterReportItem.Jitter;
1183 }
1184 
HandleREMBItem(RTCPUtility::RTCPParserV2 & rtcpParser,RTCPPacketInformation & rtcpPacketInformation)1185 void RTCPReceiver::HandleREMBItem(
1186     RTCPUtility::RTCPParserV2& rtcpParser,
1187     RTCPPacketInformation& rtcpPacketInformation) {
1188   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
1189   rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRemb;
1190   rtcpPacketInformation.receiverEstimatedMaxBitrate =
1191       rtcpPacket.REMBItem.BitRate;
1192 }
1193 
HandleFIR(RTCPUtility::RTCPParserV2 & rtcpParser,RTCPPacketInformation & rtcpPacketInformation)1194 void RTCPReceiver::HandleFIR(RTCPUtility::RTCPParserV2& rtcpParser,
1195                              RTCPPacketInformation& rtcpPacketInformation) {
1196   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
1197   RTCPReceiveInformation* ptrReceiveInfo =
1198       GetReceiveInformation(rtcpPacket.FIR.SenderSSRC);
1199 
1200   RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
1201   while (pktType == RTCPPacketTypes::kPsfbFirItem) {
1202     HandleFIRItem(ptrReceiveInfo, rtcpPacket, rtcpPacketInformation);
1203     pktType = rtcpParser.Iterate();
1204   }
1205 }
1206 
HandleFIRItem(RTCPReceiveInformation * receiveInfo,const RTCPUtility::RTCPPacket & rtcpPacket,RTCPPacketInformation & rtcpPacketInformation)1207 void RTCPReceiver::HandleFIRItem(RTCPReceiveInformation* receiveInfo,
1208                                  const RTCPUtility::RTCPPacket& rtcpPacket,
1209                                  RTCPPacketInformation& rtcpPacketInformation) {
1210   // Is it our sender that is requested to generate a new keyframe
1211   if (main_ssrc_ != rtcpPacket.FIRItem.SSRC) {
1212     return;
1213   }
1214 
1215   ++packet_type_counter_.fir_packets;
1216 
1217   // rtcpPacket.FIR.MediaSSRC SHOULD be 0 but we ignore to check it
1218   // we don't know who this originate from
1219   if (receiveInfo) {
1220     // check if we have reported this FIRSequenceNumber before
1221     if (rtcpPacket.FIRItem.CommandSequenceNumber !=
1222         receiveInfo->lastFIRSequenceNumber) {
1223       int64_t now = _clock->TimeInMilliseconds();
1224       // sanity; don't go crazy with the callbacks
1225       if ((now - receiveInfo->lastFIRRequest) > RTCP_MIN_FRAME_LENGTH_MS) {
1226         receiveInfo->lastFIRRequest = now;
1227         receiveInfo->lastFIRSequenceNumber =
1228             rtcpPacket.FIRItem.CommandSequenceNumber;
1229         // received signal that we need to send a new key frame
1230         rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpFir;
1231       }
1232     }
1233   } else {
1234     // received signal that we need to send a new key frame
1235     rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpFir;
1236   }
1237 }
1238 
HandleAPP(RTCPUtility::RTCPParserV2 & rtcpParser,RTCPPacketInformation & rtcpPacketInformation)1239 void RTCPReceiver::HandleAPP(RTCPUtility::RTCPParserV2& rtcpParser,
1240                              RTCPPacketInformation& rtcpPacketInformation) {
1241   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
1242 
1243   rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpApp;
1244   rtcpPacketInformation.applicationSubType = rtcpPacket.APP.SubType;
1245   rtcpPacketInformation.applicationName = rtcpPacket.APP.Name;
1246 
1247   rtcpParser.Iterate();
1248 }
1249 
HandleAPPItem(RTCPUtility::RTCPParserV2 & rtcpParser,RTCPPacketInformation & rtcpPacketInformation)1250 void RTCPReceiver::HandleAPPItem(RTCPUtility::RTCPParserV2& rtcpParser,
1251                                  RTCPPacketInformation& rtcpPacketInformation) {
1252   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
1253 
1254   rtcpPacketInformation.AddApplicationData(rtcpPacket.APP.Data, rtcpPacket.APP.Size);
1255 
1256   rtcpParser.Iterate();
1257 }
1258 
HandleTransportFeedback(RTCPUtility::RTCPParserV2 * rtcp_parser,RTCPHelp::RTCPPacketInformation * rtcp_packet_information)1259 void RTCPReceiver::HandleTransportFeedback(
1260     RTCPUtility::RTCPParserV2* rtcp_parser,
1261     RTCPHelp::RTCPPacketInformation* rtcp_packet_information) {
1262   rtcp::RtcpPacket* packet = rtcp_parser->ReleaseRtcpPacket();
1263   RTC_DCHECK(packet != nullptr);
1264   rtcp_packet_information->rtcpPacketTypeFlags |= kRtcpTransportFeedback;
1265   rtcp_packet_information->transport_feedback_.reset(
1266       static_cast<rtcp::TransportFeedback*>(packet));
1267 
1268   rtcp_parser->Iterate();
1269 }
UpdateTMMBR()1270 int32_t RTCPReceiver::UpdateTMMBR() {
1271   int32_t numBoundingSet = 0;
1272   uint32_t bitrate = 0;
1273   uint32_t accNumCandidates = 0;
1274 
1275   int32_t size = TMMBRReceived(0, 0, NULL);
1276   if (size > 0) {
1277     TMMBRSet* candidateSet = VerifyAndAllocateCandidateSet(size);
1278     // Get candidate set from receiver.
1279     accNumCandidates = TMMBRReceived(size, accNumCandidates, candidateSet);
1280   } else {
1281     // Candidate set empty.
1282     VerifyAndAllocateCandidateSet(0);  // resets candidate set
1283   }
1284   // Find bounding set
1285   TMMBRSet* boundingSet = NULL;
1286   numBoundingSet = FindTMMBRBoundingSet(boundingSet);
1287   if (numBoundingSet == -1) {
1288     LOG(LS_WARNING) << "Failed to find TMMBR bounding set.";
1289     return -1;
1290   }
1291   // Set bounding set
1292   // Inform remote clients about the new bandwidth
1293   // inform the remote client
1294   _rtpRtcp.SetTMMBN(boundingSet);
1295 
1296   // might trigger a TMMBN
1297   if (numBoundingSet == 0) {
1298     // owner of max bitrate request has timed out
1299     // empty bounding set has been sent
1300     return 0;
1301   }
1302   // Get net bitrate from bounding set depending on sent packet rate
1303   if (CalcMinBitRate(&bitrate)) {
1304     // we have a new bandwidth estimate on this channel
1305     if (_cbRtcpBandwidthObserver) {
1306         _cbRtcpBandwidthObserver->OnReceivedEstimatedBitrate(bitrate * 1000);
1307     }
1308   }
1309   return 0;
1310 }
1311 
RegisterRtcpStatisticsCallback(RtcpStatisticsCallback * callback)1312 void RTCPReceiver::RegisterRtcpStatisticsCallback(
1313     RtcpStatisticsCallback* callback) {
1314   CriticalSectionScoped cs(_criticalSectionFeedbacks);
1315   stats_callback_ = callback;
1316 }
1317 
GetRtcpStatisticsCallback()1318 RtcpStatisticsCallback* RTCPReceiver::GetRtcpStatisticsCallback() {
1319   CriticalSectionScoped cs(_criticalSectionFeedbacks);
1320   return stats_callback_;
1321 }
1322 
1323 // Holding no Critical section
TriggerCallbacksFromRTCPPacket(RTCPPacketInformation & rtcpPacketInformation)1324 void RTCPReceiver::TriggerCallbacksFromRTCPPacket(
1325     RTCPPacketInformation& rtcpPacketInformation) {
1326   // Process TMMBR and REMB first to avoid multiple callbacks
1327   // to OnNetworkChanged.
1328   if (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpTmmbr) {
1329     // Might trigger a OnReceivedBandwidthEstimateUpdate.
1330     UpdateTMMBR();
1331   }
1332   uint32_t local_ssrc;
1333   std::set<uint32_t> registered_ssrcs;
1334   {
1335     // We don't want to hold this critsect when triggering the callbacks below.
1336     CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
1337     local_ssrc = main_ssrc_;
1338     registered_ssrcs = registered_ssrcs_;
1339   }
1340   if (!receiver_only_ &&
1341       (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpSrReq)) {
1342     _rtpRtcp.OnRequestSendReport();
1343   }
1344   if (!receiver_only_ &&
1345       (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpNack)) {
1346     if (rtcpPacketInformation.nackSequenceNumbers.size() > 0) {
1347       LOG(LS_VERBOSE) << "Incoming NACK length: "
1348                    << rtcpPacketInformation.nackSequenceNumbers.size();
1349       _rtpRtcp.OnReceivedNACK(rtcpPacketInformation.nackSequenceNumbers);
1350     }
1351   }
1352   {
1353     // We need feedback that we have received a report block(s) so that we
1354     // can generate a new packet in a conference relay scenario, one received
1355     // report can generate several RTCP packets, based on number relayed/mixed
1356     // a send report block should go out to all receivers.
1357     if (_cbRtcpIntraFrameObserver) {
1358       RTC_DCHECK(!receiver_only_);
1359       if ((rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpPli) ||
1360           (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpFir)) {
1361         if (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpPli) {
1362           LOG(LS_VERBOSE) << "Incoming PLI from SSRC "
1363                           << rtcpPacketInformation.remoteSSRC;
1364         } else {
1365           LOG(LS_VERBOSE) << "Incoming FIR from SSRC "
1366                           << rtcpPacketInformation.remoteSSRC;
1367         }
1368         _cbRtcpIntraFrameObserver->OnReceivedIntraFrameRequest(local_ssrc);
1369       }
1370       if (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpSli) {
1371         _cbRtcpIntraFrameObserver->OnReceivedSLI(
1372             local_ssrc, rtcpPacketInformation.sliPictureId);
1373       }
1374       if (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpRpsi) {
1375         _cbRtcpIntraFrameObserver->OnReceivedRPSI(
1376             local_ssrc, rtcpPacketInformation.rpsiPictureId);
1377       }
1378     }
1379     if (_cbRtcpBandwidthObserver) {
1380       RTC_DCHECK(!receiver_only_);
1381       if (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpRemb) {
1382         LOG(LS_VERBOSE) << "Incoming REMB: "
1383                         << rtcpPacketInformation.receiverEstimatedMaxBitrate;
1384         _cbRtcpBandwidthObserver->OnReceivedEstimatedBitrate(
1385             rtcpPacketInformation.receiverEstimatedMaxBitrate);
1386       }
1387       if ((rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpSr) ||
1388           (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpRr)) {
1389         int64_t now = _clock->TimeInMilliseconds();
1390         _cbRtcpBandwidthObserver->OnReceivedRtcpReceiverReport(
1391             rtcpPacketInformation.report_blocks,
1392             rtcpPacketInformation.rtt,
1393             now);
1394       }
1395     }
1396     if (_cbTransportFeedbackObserver &&
1397         (rtcpPacketInformation.rtcpPacketTypeFlags & kRtcpTransportFeedback)) {
1398       uint32_t media_source_ssrc =
1399           rtcpPacketInformation.transport_feedback_->GetMediaSourceSsrc();
1400       if (media_source_ssrc == local_ssrc ||
1401           registered_ssrcs.find(media_source_ssrc) != registered_ssrcs.end()) {
1402         _cbTransportFeedbackObserver->OnTransportFeedback(
1403             *rtcpPacketInformation.transport_feedback_.get());
1404       }
1405     }
1406   }
1407 
1408   if (!receiver_only_) {
1409     CriticalSectionScoped cs(_criticalSectionFeedbacks);
1410     if (stats_callback_) {
1411       for (ReportBlockList::const_iterator it =
1412           rtcpPacketInformation.report_blocks.begin();
1413           it != rtcpPacketInformation.report_blocks.end();
1414           ++it) {
1415         RtcpStatistics stats;
1416         stats.cumulative_lost = it->cumulativeLost;
1417         stats.extended_max_sequence_number = it->extendedHighSeqNum;
1418         stats.fraction_lost = it->fractionLost;
1419         stats.jitter = it->jitter;
1420 
1421         stats_callback_->StatisticsUpdated(stats, it->sourceSSRC);
1422       }
1423     }
1424   }
1425 }
1426 
CNAME(uint32_t remoteSSRC,char cName[RTCP_CNAME_SIZE]) const1427 int32_t RTCPReceiver::CNAME(uint32_t remoteSSRC,
1428                             char cName[RTCP_CNAME_SIZE]) const {
1429   assert(cName);
1430 
1431   CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
1432   RTCPCnameInformation* cnameInfo = GetCnameInformation(remoteSSRC);
1433   if (cnameInfo == NULL) {
1434     return -1;
1435   }
1436   cName[RTCP_CNAME_SIZE - 1] = 0;
1437   strncpy(cName, cnameInfo->name, RTCP_CNAME_SIZE - 1);
1438   return 0;
1439 }
1440 
1441 // no callbacks allowed inside this function
TMMBRReceived(uint32_t size,uint32_t accNumCandidates,TMMBRSet * candidateSet) const1442 int32_t RTCPReceiver::TMMBRReceived(uint32_t size,
1443                                     uint32_t accNumCandidates,
1444                                     TMMBRSet* candidateSet) const {
1445   CriticalSectionScoped lock(_criticalSectionRTCPReceiver);
1446 
1447   std::map<uint32_t, RTCPReceiveInformation*>::const_iterator
1448       receiveInfoIt = _receivedInfoMap.begin();
1449   if (receiveInfoIt == _receivedInfoMap.end()) {
1450     return -1;
1451   }
1452   uint32_t num = accNumCandidates;
1453   if (candidateSet) {
1454     while( num < size && receiveInfoIt != _receivedInfoMap.end()) {
1455       RTCPReceiveInformation* receiveInfo = receiveInfoIt->second;
1456       if (receiveInfo == NULL) {
1457         return 0;
1458       }
1459       for (uint32_t i = 0;
1460            (num < size) && (i < receiveInfo->TmmbrSet.lengthOfSet()); i++) {
1461         if (receiveInfo->GetTMMBRSet(i, num, candidateSet,
1462                                      _clock->TimeInMilliseconds()) == 0) {
1463           num++;
1464         }
1465       }
1466       receiveInfoIt++;
1467     }
1468   } else {
1469     while (receiveInfoIt != _receivedInfoMap.end()) {
1470       RTCPReceiveInformation* receiveInfo = receiveInfoIt->second;
1471       if(receiveInfo == NULL) {
1472         return -1;
1473       }
1474       num += receiveInfo->TmmbrSet.lengthOfSet();
1475       receiveInfoIt++;
1476     }
1477   }
1478   return num;
1479 }
1480 
1481 }  // namespace webrtc
1482