Voe::Channel: Turned GetPlayoutFrequency into GetRtpTimestampRateHz.

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 656 matching lines @@
   }
 
   if (capture_start_rtp_time_stamp_ >= 0) {
     // audioFrame.timestamp_ should be valid from now on.
 
     // Compute elapsed time.
     int64_t unwrap_timestamp =
         rtp_ts_wraparound_handler_->Unwrap(audioFrame->timestamp_);
     audioFrame->elapsed_time_ms_ =
         (unwrap_timestamp - capture_start_rtp_time_stamp_) /
-        (GetPlayoutFrequency() / 1000);
+        (GetRtpTimestampRateHz() / 1000);
 
     {
       rtc::CritScope lock(&ts_stats_lock_);
       // Compute ntp time.
       audioFrame->ntp_time_ms_ =
           ntp_estimator_.Estimate(audioFrame->timestamp_);
       // |ntp_time_ms_| won't be valid until at least 2 RTCP SRs are received.
       if (audioFrame->ntp_time_ms_ > 0) {
         // Compute |capture_start_ntp_time_ms_| so that
         // |capture_start_ntp_time_ms_| + |elapsed_time_ms_| == |ntp_time_ms_|
@@ skipping 2385 matching lines @@
     _engineStatisticsPtr->SetLastError(
         VE_CANNOT_RETRIEVE_VALUE, kTraceError,
         "UpdatePlayoutTimestamp() failed to retrieve playout delay");
     return;
   }
 
   RTC_DCHECK(jitter_buffer_playout_timestamp_);
   uint32_t playout_timestamp = *jitter_buffer_playout_timestamp_;
 
   // Remove the playout delay.
-  playout_timestamp -= (delay_ms * (GetPlayoutFrequency() / 1000));
+  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 {
@@ skipping 39 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() 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) {
-      // We are resampling Opus internally to 32,000 Hz until all our
-      // DSP routines can operate at 48,000 Hz, but the RTP clock
-      // rate for the Opus payload format is standardized to 48,000 Hz,
-      // because that is the maximum supported decoding sampling rate.
-      playout_frequency = 48000;
-    }
-  }
-  return playout_frequency;
+int Channel::GetRtpTimestampRateHz() const {
+  const auto format = audio_coding_->ReceiveFormat();
+  // Default to the playout frequency if we've not gotten any packets yet.
+  // TODO(ossu): Zero clockrate can only happen if we've added an external
+  // decoder for a format we don't support internally. Remove once that way of
+  // adding decoders is gone!
+  return (format && format->clockrate_hz != 0)
+             ? format->clockrate_hz
+             : audio_coding_->PlayoutFrequency();
 }
 
 int64_t Channel::GetRTT(bool allow_associate_channel) const {
   RtcpMode method = _rtpRtcpModule->RTCP();
   if (method == RtcpMode::kOff) {
     return 0;
   }
   std::vector<RTCPReportBlock> report_blocks;
   _rtpRtcpModule->RemoteRTCPStat(&report_blocks);
 
@@ skipping 33 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