Remove the deprecated EncodeInternal interface from AudioEncoder

webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.cc

 /*
  *  Copyright (c) 2014 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.
  */
 
 #include "webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.h"
 
+#include <algorithm>

[kwiberg-webrtc, 2016/04/07 08:23:16]

Why is this needed?

[ossu, 2016/04/07 08:52:53]

It's for std::min and std::max. It's another lint issue that I might've put in a
separate CL. Would you like me to put that separate in together with the other
small lint fix?

[kwiberg-webrtc, 2016/04/07 09:53:26]

That would be ideal. (I won't insist, though, since this one time isn't a big
deal. But there's no time like the present when it comes to establishing a new
good habit...)

+
 #include "webrtc/base/checks.h"
 #include "webrtc/base/safe_conversions.h"
 #include "webrtc/common_types.h"
 #include "webrtc/modules/audio_coding/codecs/opus/opus_interface.h"
 
 namespace webrtc {
 
 namespace {
 
 const int kSampleRateHz = 48000;
@@ skipping 70 matching lines @@
   RTC_CHECK(RecreateEncoderInstance(config));
 }
 
 AudioEncoderOpus::AudioEncoderOpus(const CodecInst& codec_inst)
     : AudioEncoderOpus(CreateConfig(codec_inst)) {}
 
 AudioEncoderOpus::~AudioEncoderOpus() {
   RTC_CHECK_EQ(0, WebRtcOpus_EncoderFree(inst_));
 }
 
-size_t AudioEncoderOpus::MaxEncodedBytes() const {
-  // Calculate the number of bytes we expect the encoder to produce,
-  // then multiply by two to give a wide margin for error.
-  const size_t bytes_per_millisecond =
-      static_cast<size_t>(config_.bitrate_bps / (1000 * 8) + 1);
-  const size_t approx_encoded_bytes =
-      Num10msFramesPerPacket() * 10 * bytes_per_millisecond;
-  return 2 * approx_encoded_bytes;
-}
-
 int AudioEncoderOpus::SampleRateHz() const {
   return kSampleRateHz;
 }
 
 size_t AudioEncoderOpus::NumChannels() const {
   return config_.num_channels;
 }
 
 size_t AudioEncoderOpus::Num10MsFramesInNextPacket() const {
   return Num10msFramesPerPacket();
@@ skipping 101 matching lines @@
 }
 
 size_t AudioEncoderOpus::Num10msFramesPerPacket() const {
   return static_cast<size_t>(rtc::CheckedDivExact(config_.frame_size_ms, 10));
 }
 
 size_t AudioEncoderOpus::SamplesPer10msFrame() const {
   return rtc::CheckedDivExact(kSampleRateHz, 100) * config_.num_channels;
 }
 
+size_t AudioEncoderOpus::MaxEncodedBytes() const {
+  // Calculate the number of bytes we expect the encoder to produce,
+  // then multiply by two to give a wide margin for error.
+  const size_t bytes_per_millisecond =
+      static_cast<size_t>(config_.bitrate_bps / (1000 * 8) + 1);
+  const size_t approx_encoded_bytes =
+      Num10msFramesPerPacket() * 10 * bytes_per_millisecond;
+  return 2 * approx_encoded_bytes;
+}
+
 // If the given config is OK, recreate the Opus encoder instance with those
 // settings, save the config, and return true. Otherwise, do nothing and return
 // false.
 bool AudioEncoderOpus::RecreateEncoderInstance(const Config& config) {
   if (!config.IsOk())
     return false;
   if (inst_)
     RTC_CHECK_EQ(0, WebRtcOpus_EncoderFree(inst_));
   input_buffer_.clear();
   input_buffer_.reserve(Num10msFramesPerPacket() * SamplesPer10msFrame());
@@ skipping 14 matching lines @@
     RTC_CHECK_EQ(0, WebRtcOpus_DisableDtx(inst_));
   }
   RTC_CHECK_EQ(0,
                WebRtcOpus_SetPacketLossRate(
                    inst_, static_cast<int32_t>(packet_loss_rate_ * 100 + .5)));
   config_ = config;
   return true;
 }
 
 }  // namespace webrtc