Remove the unused and untested functions from VoERTP_RTCP.

webrtc/voice_engine/channel.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 270 matching lines @@
                                        capture_time_ms, bytes, retransmission);
     }
   }
 
  private:
   rtc::ThreadChecker thread_checker_;
   rtc::CriticalSection crit_;
   RtpPacketSender* rtp_packet_sender_ GUARDED_BY(&crit_);
 };
 
-// Extend the default RTCP statistics struct with max_jitter, defined as the
-// maximum jitter value seen in an RTCP report block.
-struct ChannelStatistics : public RtcpStatistics {
-  ChannelStatistics() : rtcp(), max_jitter(0) {}
-
-  RtcpStatistics rtcp;
-  uint32_t max_jitter;
-};
-
-// Statistics callback, called at each generation of a new RTCP report block.
-class StatisticsProxy : public RtcpStatisticsCallback {
- public:
-  StatisticsProxy(uint32_t ssrc) : ssrc_(ssrc) {}
-  virtual ~StatisticsProxy() {}
-
-  void StatisticsUpdated(const RtcpStatistics& statistics,
-                         uint32_t ssrc) override {
-    if (ssrc != ssrc_)
-      return;
-
-    rtc::CritScope cs(&stats_lock_);
-    stats_.rtcp = statistics;
-    if (statistics.jitter > stats_.max_jitter) {
-      stats_.max_jitter = statistics.jitter;
-    }
-  }
-
-  void CNameChanged(const char* cname, uint32_t ssrc) override {}
-
-  ChannelStatistics GetStats() {
-    rtc::CritScope cs(&stats_lock_);
-    return stats_;
-  }
-
- private:
-  // StatisticsUpdated calls are triggered from threads in the RTP module,
-  // while GetStats calls can be triggered from the public voice engine API,
-  // hence synchronization is needed.
-  rtc::CriticalSection stats_lock_;
-  const uint32_t ssrc_;
-  ChannelStatistics stats_;
-};
-
 class VoERtcpObserver : public RtcpBandwidthObserver {
  public:
   explicit VoERtcpObserver(Channel* owner)
       : owner_(owner), bandwidth_observer_(nullptr) {}
   virtual ~VoERtcpObserver() {}
 
   void SetBandwidthObserver(RtcpBandwidthObserver* bandwidth_observer) {
     rtc::CritScope lock(&crit_);
     bandwidth_observer_ = bandwidth_observer;
   }
@@ skipping 224 matching lines @@
                " payloadType=%u, audioChannel=%" PRIuS ")",
                payloadSize, rtpHeader->header.payloadType,
                rtpHeader->type.Audio.channel);
 
   if (!channel_state_.Get().playing) {
     // Avoid inserting into NetEQ when we are not playing. Count the
     // packet as discarded.
     WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, _channelId),
                  "received packet is discarded since playing is not"
                  " activated");
-    _numberOfDiscardedPackets++;
     return 0;
   }
 
   // Push the incoming payload (parsed and ready for decoding) into the ACM
   if (audio_coding_->IncomingPacket(payloadData, payloadSize, *rtpHeader) !=
       0) {
     _engineStatisticsPtr->SetLastError(
         VE_AUDIO_CODING_MODULE_ERROR, kTraceWarning,
         "Channel::OnReceivedPayloadData() unable to push data to the ACM");
     return -1;
@@ skipping 318 matching lines @@
       _outputFilePlayerId(VoEModuleId(instanceId, channelId) + 1025),
       _outputFileRecorderId(VoEModuleId(instanceId, channelId) + 1026),
       _outputFileRecording(false),
       _outputExternalMedia(false),
       _inputExternalMediaCallbackPtr(NULL),
       _outputExternalMediaCallbackPtr(NULL),
       _timeStamp(0),  // This is just an offset, RTP module will add it's own
                       // random offset
       ntp_estimator_(Clock::GetRealTimeClock()),
       playout_timestamp_rtp_(0),
-      playout_timestamp_rtcp_(0),
       playout_delay_ms_(0),
-      _numberOfDiscardedPackets(0),
       send_sequence_number_(0),
       rtp_ts_wraparound_handler_(new rtc::TimestampWrapAroundHandler()),
       capture_start_rtp_time_stamp_(-1),
       capture_start_ntp_time_ms_(-1),
       _engineStatisticsPtr(NULL),
       _outputMixerPtr(NULL),
       _transmitMixerPtr(NULL),
       _moduleProcessThreadPtr(NULL),
       _audioDeviceModulePtr(NULL),
       _voiceEngineObserverPtr(NULL),
@@ skipping 44 matching lines @@
         seq_num_allocator_proxy_.get();
     configuration.transport_feedback_callback = feedback_observer_proxy_.get();
   }
   configuration.event_log = &(*event_log_proxy_);
   configuration.rtt_stats = &(*rtcp_rtt_stats_proxy_);
   configuration.retransmission_rate_limiter =
       retransmission_rate_limiter_.get();
 
   _rtpRtcpModule.reset(RtpRtcp::CreateRtpRtcp(configuration));
   _rtpRtcpModule->SetSendingMediaStatus(false);
-
-  statistics_proxy_.reset(new StatisticsProxy(_rtpRtcpModule->SSRC()));
-  rtp_receive_statistics_->RegisterRtcpStatisticsCallback(
-      statistics_proxy_.get());
 }
 
 Channel::~Channel() {
   rtp_receive_statistics_->RegisterRtcpStatisticsCallback(NULL);
   WEBRTC_TRACE(kTraceMemory, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::~Channel() - dtor");
 
   if (_outputExternalMedia) {
     DeRegisterExternalMediaProcessing(kPlaybackPerChannel);
   }
@@ skipping 274 matching lines @@
   if (_rtpRtcpModule->SetSendingStatus(false) == -1) {
     _engineStatisticsPtr->SetLastError(
         VE_RTP_RTCP_MODULE_ERROR, kTraceWarning,
         "StartSend() RTP/RTCP failed to stop sending");
   }
   _rtpRtcpModule->SetSendingMediaStatus(false);
 
   return 0;
 }
 
-void Channel::ResetDiscardedPacketCount() {
-  WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
-               "Channel::ResetDiscardedPacketCount()");
-  _numberOfDiscardedPackets = 0;
-}
-
 int32_t Channel::RegisterVoiceEngineObserver(VoiceEngineObserver& observer) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::RegisterVoiceEngineObserver()");
   rtc::CritScope cs(&_callbackCritSect);
 
   if (_voiceEngineObserverPtr) {
     _engineStatisticsPtr->SetLastError(
         VE_INVALID_OPERATION, kTraceError,
         "RegisterVoiceEngineObserver() observer already enabled");
     return -1;
@@ skipping 1213 matching lines @@
   if (_rtpRtcpModule->RemoteCNAME(remoteSSRC, cname) != 0) {
     _engineStatisticsPtr->SetLastError(
         VE_CANNOT_RETRIEVE_CNAME, kTraceError,
         "GetRemoteRTCP_CNAME() failed to retrieve remote RTCP CNAME");
     return -1;
   }
   strcpy(cName, cname);
   return 0;
 }
 
-int Channel::GetRemoteRTCPData(unsigned int& NTPHigh,
-                               unsigned int& NTPLow,
-                               unsigned int& timestamp,
-                               unsigned int& playoutTimestamp,
-                               unsigned int* jitter,
-                               unsigned short* fractionLost) {
-  // --- Information from sender info in received Sender Reports
-
-  RTCPSenderInfo senderInfo;
-  if (_rtpRtcpModule->RemoteRTCPStat(&senderInfo) != 0) {
-    _engineStatisticsPtr->SetLastError(
-        VE_RTP_RTCP_MODULE_ERROR, kTraceError,
-        "GetRemoteRTCPData() failed to retrieve sender info for remote "
-        "side");
-    return -1;
-  }
-
-  // We only utilize 12 out of 20 bytes in the sender info (ignores packet
-  // and octet count)
-  NTPHigh = senderInfo.NTPseconds;
-  NTPLow = senderInfo.NTPfraction;
-  timestamp = senderInfo.RTPtimeStamp;
-
-  // --- Locally derived information
-
-  // This value is updated on each incoming RTCP packet (0 when no packet
-  // has been received)
-  playoutTimestamp = playout_timestamp_rtcp_;
-
-  if (NULL != jitter || NULL != fractionLost) {
-    // Get all RTCP receiver report blocks that have been received on this
-    // channel. If we receive RTP packets from a remote source we know the
-    // remote SSRC and use the report block from him.
-    // Otherwise use the first report block.
-    std::vector<RTCPReportBlock> remote_stats;
-    if (_rtpRtcpModule->RemoteRTCPStat(&remote_stats) != 0 ||
-        remote_stats.empty()) {
-      WEBRTC_TRACE(kTraceWarning, kTraceVoice, VoEId(_instanceId, _channelId),
-                   "GetRemoteRTCPData() failed to measure statistics due"
-                   " to lack of received RTP and/or RTCP packets");
-      return -1;
-    }
-
-    uint32_t remoteSSRC = rtp_receiver_->SSRC();
-    std::vector<RTCPReportBlock>::const_iterator it = remote_stats.begin();
-    for (; it != remote_stats.end(); ++it) {
-      if (it->remoteSSRC == remoteSSRC)
-        break;
-    }
-
-    if (it == remote_stats.end()) {
-      // If we have not received any RTCP packets from this SSRC it probably
-      // means that we have not received any RTP packets.
-      // Use the first received report block instead.
-      it = remote_stats.begin();
-      remoteSSRC = it->remoteSSRC;
-    }
-
-    if (jitter) {
-      *jitter = it->jitter;
-    }
-
-    if (fractionLost) {
-      *fractionLost = it->fractionLost;
-    }
-  }
-  return 0;
-}
-
 int Channel::SendApplicationDefinedRTCPPacket(
     unsigned char subType,
     unsigned int name,
     const char* data,
     unsigned short dataLengthInBytes) {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::SendApplicationDefinedRTCPPacket()");
   if (!channel_state_.Get().sending) {
     _engineStatisticsPtr->SetLastError(
         VE_NOT_SENDING, kTraceError,
@@ skipping 24 matching lines @@
   if (_rtpRtcpModule->SetRTCPApplicationSpecificData(
           subType, name, (const unsigned char*)data, dataLengthInBytes) != 0) {
     _engineStatisticsPtr->SetLastError(
         VE_SEND_ERROR, kTraceError,
         "SendApplicationDefinedRTCPPacket() failed to send RTCP packet");
     return -1;
   }
   return 0;
 }
 
-int Channel::GetRTPStatistics(unsigned int& averageJitterMs,
-                              unsigned int& maxJitterMs,
-                              unsigned int& discardedPackets) {
-  // The jitter statistics is updated for each received RTP packet and is
-  // based on received packets.
-  if (_rtpRtcpModule->RTCP() == RtcpMode::kOff) {
-    // If RTCP is off, there is no timed thread in the RTCP module regularly
-    // generating new stats, trigger the update manually here instead.
-    StreamStatistician* statistician =
-        rtp_receive_statistics_->GetStatistician(rtp_receiver_->SSRC());
-    if (statistician) {
-      // Don't use returned statistics, use data from proxy instead so that
-      // max jitter can be fetched atomically.
-      RtcpStatistics s;
-      statistician->GetStatistics(&s, true);
-    }
-  }
-
-  ChannelStatistics stats = statistics_proxy_->GetStats();
-  const int32_t playoutFrequency = audio_coding_->PlayoutFrequency();
-  if (playoutFrequency > 0) {
-    // Scale RTP statistics given the current playout frequency
-    maxJitterMs = stats.max_jitter / (playoutFrequency / 1000);
-    averageJitterMs = stats.rtcp.jitter / (playoutFrequency / 1000);
-  }
-
-  discardedPackets = _numberOfDiscardedPackets;
-
-  return 0;
-}
-
 int Channel::GetRemoteRTCPReportBlocks(
     std::vector<ReportBlock>* report_blocks) {
   if (report_blocks == NULL) {
     _engineStatisticsPtr->SetLastError(
         VE_INVALID_ARGUMENT, kTraceError,
         "GetRemoteRTCPReportBlock()s invalid report_blocks.");
     return -1;
   }
 
   // Get the report blocks from the latest received RTCP Sender or Receiver
@@ skipping 537 matching lines @@
 
   // Remove the playout delay.
   playout_timestamp -= (delay_ms * (GetRtpTimestampRateHz() / 1000));
 
   WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::UpdatePlayoutTimestamp() => playoutTimestamp = %lu",
                playout_timestamp);
 
   {
     rtc::CritScope lock(&video_sync_lock_);
-    if (rtcp) {
-      playout_timestamp_rtcp_ = playout_timestamp;
-    } else {
+    if (!rtcp) {
       playout_timestamp_rtp_ = playout_timestamp;
     }
     playout_delay_ms_ = delay_ms;
   }
 }
 
 void Channel::RegisterReceiveCodecsToRTPModule() {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::RegisterReceiveCodecsToRTPModule()");
 
@@ skipping 89 matching lines @@
   int64_t min_rtt = 0;
   if (_rtpRtcpModule->RTT(remoteSSRC, &rtt, &avg_rtt, &min_rtt, &max_rtt) !=
       0) {
     return 0;
   }
   return rtt;
 }
 
 }  // namespace voe
 }  // namespace webrtc