src/third_party/webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc

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