Remove Channel::UpdatePacketDelay and some member variables

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 512 matching lines @@
 
   // 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;
   }
 
-  // Update the packet delay.
-  UpdatePacketDelay(rtpHeader->header.timestamp,
-                    rtpHeader->header.sequenceNumber);
-
   int64_t round_trip_time = 0;
   _rtpRtcpModule->RTT(rtp_receiver_->SSRC(), &round_trip_time, NULL, NULL,
                       NULL);
 
   std::vector<uint16_t> nack_list = audio_coding_->GetNackList(round_trip_time);
   if (!nack_list.empty()) {
     // Can't use nack_list.data() since it's not supported by all
     // compilers.
     ResendPackets(&(nack_list[0]), static_cast<int>(nack_list.size()));
   }
@@ skipping 326 matching lines @@
       _mixFileWithMicrophone(false),
       input_mute_(false),
       previous_frame_muted_(false),
       _panLeft(1.0f),
       _panRight(1.0f),
       _outputGain(1.0f),
       _lastLocalTimeStamp(0),
       _lastPayloadType(0),
       _includeAudioLevelIndication(false),
       _outputSpeechType(AudioFrame::kNormalSpeech),
-      _average_jitter_buffer_delay_us(0),
-      _previousTimestamp(0),
-      _recPacketDelayMs(20),
       _RxVadDetection(false),
       _rxAgcIsEnabled(false),
       _rxNsIsEnabled(false),
       restored_packet_in_use_(false),
       rtcp_observer_(new VoERtcpObserver(this)),
       network_predictor_(new NetworkPredictor(Clock::GetRealTimeClock())),
       associate_send_channel_(ChannelOwner(nullptr)),
       pacing_enabled_(config.Get<VoicePacing>().enabled),
       feedback_observer_proxy_(new TransportFeedbackProxy()),
       seq_num_allocator_proxy_(new TransportSequenceNumberProxy()),
@@ skipping 2482 matching lines @@
     rtc::CritScope lock(&video_sync_lock_);
     if (rtcp) {
       playout_timestamp_rtcp_ = playout_timestamp;
     } else {
       playout_timestamp_rtp_ = playout_timestamp;
     }
     playout_delay_ms_ = delay_ms;
   }
 }
 
-// Called for incoming RTP packets after successful RTP header parsing.
-// TODO(henrik.lundin): Clean out this method. With the introduction of
-// AudioCoding::FilteredCurrentDelayMs() most (if not all) of this method can
-// be deleted, along with a few member variables. (WebRTC issue 6237.)
-void Channel::UpdatePacketDelay(uint32_t rtp_timestamp,
-                                uint16_t sequence_number) {
-  WEBRTC_TRACE(kTraceStream, kTraceVoice, VoEId(_instanceId, _channelId),
-               "Channel::UpdatePacketDelay(timestamp=%lu, sequenceNumber=%u)",
-               rtp_timestamp, sequence_number);
-
-  // Get frequency of last received payload
-  int rtp_receive_frequency = GetPlayoutFrequency();
-
-  // |jitter_buffer_playout_timestamp_| updated in UpdatePlayoutTimestamp for
-  // every incoming packet. May be empty if no valid playout timestamp is
-  // available.
-  // If |rtp_timestamp| is newer than |jitter_buffer_playout_timestamp_|, the
-  // resulting difference is positive and will be used. When the inverse is
-  // true (can happen when a network glitch causes a packet to arrive late,
-  // and during long comfort noise periods with clock drift), or when
-  // |jitter_buffer_playout_timestamp_| has no value, the difference is not
-  // changed from the initial 0.
-  uint32_t timestamp_diff_ms = 0;
-  if (jitter_buffer_playout_timestamp_ &&
-      IsNewerTimestamp(rtp_timestamp, *jitter_buffer_playout_timestamp_)) {
-    timestamp_diff_ms = (rtp_timestamp - *jitter_buffer_playout_timestamp_) /
-                        (rtp_receive_frequency / 1000);
-    if (timestamp_diff_ms > (2 * kVoiceEngineMaxMinPlayoutDelayMs)) {
-      // Diff is too large; set it to zero instead.
-      timestamp_diff_ms = 0;
-    }
-  }
-
-  uint16_t packet_delay_ms =
-      (rtp_timestamp - _previousTimestamp) / (rtp_receive_frequency / 1000);
-
-  _previousTimestamp = rtp_timestamp;
-
-  if (timestamp_diff_ms == 0)
-    return;
-
-  {
-    rtc::CritScope lock(&video_sync_lock_);
-
-    if (packet_delay_ms >= 10 && packet_delay_ms <= 60) {
-      _recPacketDelayMs = packet_delay_ms;
-    }
-
-    if (_average_jitter_buffer_delay_us == 0) {
-      _average_jitter_buffer_delay_us = timestamp_diff_ms * 1000;
-      return;
-    }
-
-    // Filter average delay value using exponential filter (alpha is
-    // 7/8). We derive 1000 *_average_jitter_buffer_delay_us here (reduces
-    // risk of rounding error) and compensate for it in GetDelayEstimate()
-    // later.
-    _average_jitter_buffer_delay_us =
-        (_average_jitter_buffer_delay_us * 7 + 1000 * timestamp_diff_ms + 500) /
-        8;
-  }
-}
-
 void Channel::RegisterReceiveCodecsToRTPModule() {
   WEBRTC_TRACE(kTraceInfo, kTraceVoice, VoEId(_instanceId, _channelId),
                "Channel::RegisterReceiveCodecsToRTPModule()");
 
   CodecInst codec;
   const uint8_t nSupportedCodecs = AudioCodingModule::NumberOfCodecs();
 
   for (int idx = 0; idx < nSupportedCodecs; idx++) {
     // Open up the RTP/RTCP receiver for all supported codecs
     if ((audio_coding_->Codec(idx, &codec) == -1) ||
@@ skipping 23 matching lines @@
                                        RTPExtensionType type,
                                        unsigned char id) {
   int error = 0;
   _rtpRtcpModule->DeregisterSendRtpHeaderExtension(type);
   if (enable) {
     error = _rtpRtcpModule->RegisterSendRtpHeaderExtension(type, id);
   }
   return error;
 }
 
-int32_t Channel::GetPlayoutFrequency() {
+int32_t Channel::GetPlayoutFrequency() const {
   int32_t playout_frequency = audio_coding_->PlayoutFrequency();
   CodecInst current_recive_codec;
   if (audio_coding_->ReceiveCodec(&current_recive_codec) == 0) {
     if (STR_CASE_CMP("G722", current_recive_codec.plname) == 0) {
       // Even though the actual sampling rate for G.722 audio is
       // 16,000 Hz, the RTP clock rate for the G722 payload format is
       // 8,000 Hz because that value was erroneously assigned in
       // RFC 1890 and must remain unchanged for backward compatibility.
       playout_frequency = 8000;
     } else if (STR_CASE_CMP("opus", current_recive_codec.plname) == 0) {
@@ skipping 51 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