Remove handling unused rtcp packets.

webrtc/modules/rtp_rtcp/source/rtcp_receiver.cc

 /*
  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 296 matching lines @@
         break;
       case RTCPPacketTypes::kXrHeader:
         HandleXrHeader(*rtcpParser, rtcpPacketInformation);
         break;
       case RTCPPacketTypes::kXrReceiverReferenceTime:
         HandleXrReceiveReferenceTime(*rtcpParser, rtcpPacketInformation);
         break;
       case RTCPPacketTypes::kXrDlrrReportBlock:
         HandleXrDlrrReportBlock(*rtcpParser, rtcpPacketInformation);
         break;
-      case RTCPPacketTypes::kXrVoipMetric:
-        HandleXRVOIPMetric(*rtcpParser, rtcpPacketInformation);
-        break;
       case RTCPPacketTypes::kBye:
         HandleBYE(*rtcpParser);
         break;
       case RTCPPacketTypes::kRtpfbNack:
         HandleNACK(*rtcpParser, rtcpPacketInformation);
         break;
       case RTCPPacketTypes::kRtpfbTmmbr:
         HandleTMMBR(*rtcpParser, rtcpPacketInformation);
         break;
       case RTCPPacketTypes::kRtpfbTmmbn:
         HandleTMMBN(*rtcpParser, rtcpPacketInformation);
         break;
       case RTCPPacketTypes::kRtpfbSrReq:
         HandleSR_REQ(*rtcpParser, rtcpPacketInformation);
         break;
       case RTCPPacketTypes::kPsfbPli:
         HandlePLI(*rtcpParser, rtcpPacketInformation);
         break;
       case RTCPPacketTypes::kPsfbSli:
         HandleSLI(*rtcpParser, rtcpPacketInformation);
         break;
       case RTCPPacketTypes::kPsfbRpsi:
         HandleRPSI(*rtcpParser, rtcpPacketInformation);
         break;
-      case RTCPPacketTypes::kExtendedIj:
-        HandleIJ(*rtcpParser, rtcpPacketInformation);
-        break;
       case RTCPPacketTypes::kPsfbFir:
         HandleFIR(*rtcpParser, rtcpPacketInformation);
         break;
       case RTCPPacketTypes::kPsfbApp:
         HandlePsfbApp(*rtcpParser, rtcpPacketInformation);
         break;
-      case RTCPPacketTypes::kApp:
-        // generic application messages
-        HandleAPP(*rtcpParser, rtcpPacketInformation);
-        break;
-      case RTCPPacketTypes::kAppItem:
-        // generic application messages
-        HandleAPPItem(*rtcpParser, rtcpPacketInformation);
-        break;
       case RTCPPacketTypes::kTransportFeedback:
         HandleTransportFeedback(rtcpParser, &rtcpPacketInformation);
         break;
       default:
         rtcpParser->Iterate();
         break;
     }
     pktType = rtcpParser->PacketType();
   }
 
@@ skipping 531 matching lines @@
 
   uint32_t delay_rr = packet.XRDLRRReportBlockItem.DelayLastRR;
   uint32_t now = CompactNtp(NtpTime(*_clock));
 
   uint32_t rtt_ntp = now - delay_rr - send_time;
   xr_rr_rtt_ms_ = CompactNtpRttToMs(rtt_ntp);
 
   rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpXrDlrrReportBlock;
 }
 
-void RTCPReceiver::HandleXRVOIPMetric(
-    RTCPUtility::RTCPParserV2& rtcpParser,
-    RTCPPacketInformation& rtcpPacketInformation) {
-  const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
-
-  if (rtcpPacket.XRVOIPMetricItem.SSRC == main_ssrc_) {
-    // Store VoIP metrics block if it's about me
-    // from OriginatorSSRC do we filter it?
-    // rtcpPacket.XR.OriginatorSSRC;
-
-    RTCPVoIPMetric receivedVoIPMetrics;
-    receivedVoIPMetrics.burstDensity = rtcpPacket.XRVOIPMetricItem.burstDensity;
-    receivedVoIPMetrics.burstDuration =
-        rtcpPacket.XRVOIPMetricItem.burstDuration;
-    receivedVoIPMetrics.discardRate = rtcpPacket.XRVOIPMetricItem.discardRate;
-    receivedVoIPMetrics.endSystemDelay =
-        rtcpPacket.XRVOIPMetricItem.endSystemDelay;
-    receivedVoIPMetrics.extRfactor = rtcpPacket.XRVOIPMetricItem.extRfactor;
-    receivedVoIPMetrics.gapDensity = rtcpPacket.XRVOIPMetricItem.gapDensity;
-    receivedVoIPMetrics.gapDuration = rtcpPacket.XRVOIPMetricItem.gapDuration;
-    receivedVoIPMetrics.Gmin = rtcpPacket.XRVOIPMetricItem.Gmin;
-    receivedVoIPMetrics.JBabsMax = rtcpPacket.XRVOIPMetricItem.JBabsMax;
-    receivedVoIPMetrics.JBmax = rtcpPacket.XRVOIPMetricItem.JBmax;
-    receivedVoIPMetrics.JBnominal = rtcpPacket.XRVOIPMetricItem.JBnominal;
-    receivedVoIPMetrics.lossRate = rtcpPacket.XRVOIPMetricItem.lossRate;
-    receivedVoIPMetrics.MOSCQ = rtcpPacket.XRVOIPMetricItem.MOSCQ;
-    receivedVoIPMetrics.MOSLQ = rtcpPacket.XRVOIPMetricItem.MOSLQ;
-    receivedVoIPMetrics.noiseLevel = rtcpPacket.XRVOIPMetricItem.noiseLevel;
-    receivedVoIPMetrics.RERL = rtcpPacket.XRVOIPMetricItem.RERL;
-    receivedVoIPMetrics.Rfactor = rtcpPacket.XRVOIPMetricItem.Rfactor;
-    receivedVoIPMetrics.roundTripDelay =
-        rtcpPacket.XRVOIPMetricItem.roundTripDelay;
-    receivedVoIPMetrics.RXconfig = rtcpPacket.XRVOIPMetricItem.RXconfig;
-    receivedVoIPMetrics.signalLevel = rtcpPacket.XRVOIPMetricItem.signalLevel;
-
-    rtcpPacketInformation.AddVoIPMetric(&receivedVoIPMetrics);
-
-    rtcpPacketInformation.rtcpPacketTypeFlags |=
-        kRtcpXrVoipMetric;  // received signal
-  }
-  rtcpParser.Iterate();
-}
-
 void RTCPReceiver::HandlePLI(RTCPUtility::RTCPParserV2& rtcpParser,
                              RTCPPacketInformation& rtcpPacketInformation) {
   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
   if (main_ssrc_ == rtcpPacket.PLI.MediaSSRC) {
     TRACE_EVENT_INSTANT0(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "PLI");
 
     ++packet_type_counter_.pli_packets;
     // Received a signal that we need to send a new key frame.
     rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpPli;
   }
@@ skipping 146 matching lines @@
   RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
   if (pktType == RTCPPacketTypes::kPsfbRemb) {
     pktType = rtcpParser.Iterate();
     if (pktType == RTCPPacketTypes::kPsfbRembItem) {
       HandleREMBItem(rtcpParser, rtcpPacketInformation);
       rtcpParser.Iterate();
     }
   }
 }
 
-void RTCPReceiver::HandleIJ(RTCPUtility::RTCPParserV2& rtcpParser,
-                            RTCPPacketInformation& rtcpPacketInformation) {
-  const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
-
-  RTCPUtility::RTCPPacketTypes pktType = rtcpParser.Iterate();
-  while (pktType == RTCPPacketTypes::kExtendedIjItem) {
-    HandleIJItem(rtcpPacket, rtcpPacketInformation);
-    pktType = rtcpParser.Iterate();
-  }
-}
-
-void RTCPReceiver::HandleIJItem(const RTCPUtility::RTCPPacket& rtcpPacket,
-                                RTCPPacketInformation& rtcpPacketInformation) {
-  rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpTransmissionTimeOffset;
-  rtcpPacketInformation.interArrivalJitter =
-      rtcpPacket.ExtendedJitterReportItem.Jitter;
-}
-
 void RTCPReceiver::HandleREMBItem(
     RTCPUtility::RTCPParserV2& rtcpParser,
     RTCPPacketInformation& rtcpPacketInformation) {
   const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
   rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpRemb;
   rtcpPacketInformation.receiverEstimatedMaxBitrate =
       rtcpPacket.REMBItem.BitRate;
 }
 
 void RTCPReceiver::HandleFIR(RTCPUtility::RTCPParserV2& rtcpParser,
@@ skipping 34 matching lines @@
         // received signal that we need to send a new key frame
         rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpFir;
       }
     }
   } else {
     // received signal that we need to send a new key frame
     rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpFir;
   }
 }
 
-void RTCPReceiver::HandleAPP(RTCPUtility::RTCPParserV2& rtcpParser,
-                             RTCPPacketInformation& rtcpPacketInformation) {
-  const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
-
-  rtcpPacketInformation.rtcpPacketTypeFlags |= kRtcpApp;
-  rtcpPacketInformation.applicationSubType = rtcpPacket.APP.SubType;
-  rtcpPacketInformation.applicationName = rtcpPacket.APP.Name;
-
-  rtcpParser.Iterate();
-}
-
-void RTCPReceiver::HandleAPPItem(RTCPUtility::RTCPParserV2& rtcpParser,
-                                 RTCPPacketInformation& rtcpPacketInformation) {
-  const RTCPUtility::RTCPPacket& rtcpPacket = rtcpParser.Packet();
-
-  rtcpPacketInformation.AddApplicationData(rtcpPacket.APP.Data,
-                                           rtcpPacket.APP.Size);
-
-  rtcpParser.Iterate();
-}
-
 void RTCPReceiver::HandleTransportFeedback(
     RTCPUtility::RTCPParserV2* rtcp_parser,
     RTCPHelp::RTCPPacketInformation* rtcp_packet_information) {
   rtcp::RtcpPacket* packet = rtcp_parser->ReleaseRtcpPacket();
   RTC_DCHECK(packet != nullptr);
   rtcp_packet_information->rtcpPacketTypeFlags |= kRtcpTransportFeedback;
   rtcp_packet_information->transport_feedback_.reset(
       static_cast<rtcp::TransportFeedback*>(packet));
 
   rtcp_parser->Iterate();
@@ skipping 155 matching lines @@
 
   for (const auto& kv : _receivedInfoMap) {
     RTCPReceiveInformation* receive_info = kv.second;
     RTC_DCHECK(receive_info);
     receive_info->GetTmmbrSet(now_ms, &candidates);
   }
   return candidates;
 }
 
 }  // namespace webrtc