AudioEncoder: add method MaxEncodedBytes

Added method AudioEncoder::MaxEncodedBytes() and provided implementations in derived encoders. This method returns the number of bytes that can be produced by the encoder at each Encode() call.
Unit tests were updated to use the new method.
Buffer allocation was not changed in AudioCodingModuleImpl::Encode(). It will be done after additional investigation.
Other refactoring work that was done, that may not be obvious why:
1. Moved some code into AudioEncoderCng::EncodePassive() to make it more consistent with EncodeActive().
2. Changed the order of NumChannels() and  RtpTimestampRateHz() declarations in AudioEncoderG722 and AudioEncoderCopyRed classes. It just bothered me that the order was not the same as in AudioEncoder class and its other derived classes.

R=kwiberg@webrtc.org

Review URL: https://webrtc-codereview.appspot.com/40259005

Cr-Commit-Position: refs/heads/master@{#8671}
git-svn-id: http://webrtc.googlecode.com/svn/trunk@8671 4adac7df-926f-26a2-2b94-8c16560cd09d

webrtc/modules/audio_coding/codecs/audio_encoder.h

@@ -74,6 +74,14 @@ class AudioEncoder {
   virtual int SampleRateHz() const = 0;
   virtual int NumChannels() const = 0;
 
+  // Return the maximum number of bytes that can be produced by the encoder
+  // at each Encode() call. The caller can use the return value to determine
+  // the size of the buffer that needs to be allocated. This value is allowed
+  // to depend on encoder parameters like bitrate, frame size etc., so if
+  // any of these change, the caller of Encode() is responsible for checking
+  // that the buffer is large enough by calling MaxEncodedBytes() again.
+  virtual size_t MaxEncodedBytes() const = 0;
+
   // Returns the rate with which the RTP timestamps are updated. By default,
   // this is the same as sample_rate_hz().
   virtual int RtpTimestampRateHz() const;

webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng.cc

@@ -10,10 +10,17 @@
 
 #include "webrtc/modules/audio_coding/codecs/cng/include/audio_encoder_cng.h"
 
+#include <algorithm>
 #include <limits>
 
 namespace webrtc {
 
+namespace {
+
+const int kMaxFrameSizeMs = 60;
+
+}  // namespace
+
 AudioEncoderCng::Config::Config()
     : num_channels(1),
       payload_type(13),
@@ -77,6 +84,13 @@ int AudioEncoderCng::NumChannels() const {
   return 1;
 }
 
+size_t AudioEncoderCng::MaxEncodedBytes() const {
+  const size_t max_encoded_bytes_active = speech_encoder_->MaxEncodedBytes();
+  const size_t max_encoded_bytes_passive =
+      rtc::CheckedDivExact(kMaxFrameSizeMs, 10) * SamplesPer10msFrame();
+  return std::max(max_encoded_bytes_active, max_encoded_bytes_passive);
+}
+
 int AudioEncoderCng::Num10MsFramesInNextPacket() const {
   return speech_encoder_->Num10MsFramesInNextPacket();
 }
@@ -114,8 +128,9 @@ void AudioEncoderCng::EncodeInternal(uint32_t rtp_timestamp,
   if (frames_in_buffer_ < speech_encoder_->Num10MsFramesInNextPacket()) {
     return;
   }
-  CHECK_LE(frames_in_buffer_, 6)
+  CHECK_LE(frames_in_buffer_ * 10, kMaxFrameSizeMs)
-      << "Frame size cannot be larger than 60 ms when using VAD/CNG.";
+      << "Frame size cannot be larger than " << kMaxFrameSizeMs
+      << " ms when using VAD/CNG.";
   const size_t samples_per_10ms_frame = 10 * SampleRateHz() / 1000;
   CHECK_EQ(speech_buffer_.size(),
            static_cast<size_t>(frames_in_buffer_) * samples_per_10ms_frame);
@@ -146,11 +161,7 @@ void AudioEncoderCng::EncodeInternal(uint32_t rtp_timestamp,
 
   switch (activity) {
     case Vad::kPassive: {
-      EncodePassive(encoded, &info->encoded_bytes);
+      EncodePassive(max_encoded_bytes, encoded, info);
-      info->encoded_timestamp = first_timestamp_in_buffer_;
-      info->payload_type = cng_payload_type_;
-      info->send_even_if_empty = true;
-      info->speech = false;
       last_frame_active_ = false;
       break;
     }
@@ -169,10 +180,13 @@ void AudioEncoderCng::EncodeInternal(uint32_t rtp_timestamp,
   frames_in_buffer_ = 0;
 }
 
-void AudioEncoderCng::EncodePassive(uint8_t* encoded, size_t* encoded_bytes) {
+void AudioEncoderCng::EncodePassive(size_t max_encoded_bytes,
+                                    uint8_t* encoded,
+                                    EncodedInfo* info) {
   bool force_sid = last_frame_active_;
   bool output_produced = false;
-  const size_t samples_per_10ms_frame = 10 * SampleRateHz() / 1000;
+  const size_t samples_per_10ms_frame = SamplesPer10msFrame();
+  CHECK_GE(max_encoded_bytes, frames_in_buffer_ * samples_per_10ms_frame);
   for (int i = 0; i < frames_in_buffer_; ++i) {
     int16_t encoded_bytes_tmp = 0;
     CHECK_GE(WebRtcCng_Encode(cng_inst_.get(),
@@ -181,17 +195,21 @@ void AudioEncoderCng::EncodePassive(uint8_t* encoded, size_t* encoded_bytes) {
                               encoded, &encoded_bytes_tmp, force_sid), 0);
     if (encoded_bytes_tmp > 0) {
       CHECK(!output_produced);
-      *encoded_bytes = static_cast<size_t>(encoded_bytes_tmp);
+      info->encoded_bytes = static_cast<size_t>(encoded_bytes_tmp);
       output_produced = true;
       force_sid = false;
     }
   }
+  info->encoded_timestamp = first_timestamp_in_buffer_;
+  info->payload_type = cng_payload_type_;
+  info->send_even_if_empty = true;
+  info->speech = false;
 }
 
 void AudioEncoderCng::EncodeActive(size_t max_encoded_bytes,
                                    uint8_t* encoded,
                                    EncodedInfo* info) {
-  const size_t samples_per_10ms_frame = 10 * SampleRateHz() / 1000;
+  const size_t samples_per_10ms_frame = SamplesPer10msFrame();
   for (int i = 0; i < frames_in_buffer_; ++i) {
     speech_encoder_->Encode(first_timestamp_in_buffer_,
                             &speech_buffer_[i * samples_per_10ms_frame],
@@ -203,4 +221,8 @@ void AudioEncoderCng::EncodeActive(size_t max_encoded_bytes,
   }
 }
 
+size_t AudioEncoderCng::SamplesPer10msFrame() const {
+  return rtc::CheckedDivExact(10 * SampleRateHz(), 1000);
+}
+
 }  // namespace webrtc

webrtc/modules/audio_coding/codecs/cng/audio_encoder_cng_unittest.cc

@@ -8,6 +8,8 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <vector>
+
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/common_audio/vad/mock/mock_vad.h"
@@ -23,7 +25,7 @@ using ::testing::Invoke;
 namespace webrtc {
 
 namespace {
-static const size_t kMaxEncodedBytes = 1000;
+static const size_t kMockMaxEncodedBytes = 1000;
 static const size_t kMaxNumSamples = 48 * 10 * 2;  // 10 ms @ 48 kHz stereo.
 static const size_t kMockReturnEncodedBytes = 17;
 static const int kCngPayloadType = 18;
@@ -36,7 +38,6 @@ class AudioEncoderCngTest : public ::testing::Test {
         timestamp_(4711),
         num_audio_samples_10ms_(0),
         sample_rate_hz_(8000) {
-    memset(encoded_, 0, kMaxEncodedBytes);
     memset(audio_, 0, kMaxNumSamples * 2);
     config_.speech_encoder = &mock_encoder_;
     EXPECT_CALL(mock_encoder_, NumChannels()).WillRepeatedly(Return(1));
@@ -66,14 +67,17 @@ class AudioEncoderCngTest : public ::testing::Test {
     // is not too small. The return value does not matter that much, as long as
     // it is smaller than 10.
     EXPECT_CALL(mock_encoder_, Max10MsFramesInAPacket()).WillOnce(Return(1));
+    EXPECT_CALL(mock_encoder_, MaxEncodedBytes())
+        .WillRepeatedly(Return(kMockMaxEncodedBytes));
     cng_.reset(new AudioEncoderCng(config_));
+    encoded_.resize(cng_->MaxEncodedBytes(), 0);
   }
 
   void Encode() {
     ASSERT_TRUE(cng_) << "Must call CreateCng() first.";
     encoded_info_ = AudioEncoder::EncodedInfo();
     cng_->Encode(timestamp_, audio_, num_audio_samples_10ms_,
-                 kMaxEncodedBytes, encoded_, &encoded_info_);
+                 encoded_.size(), &encoded_[0], &encoded_info_);
     timestamp_ += num_audio_samples_10ms_;
   }
 
@@ -182,7 +186,7 @@ class AudioEncoderCngTest : public ::testing::Test {
   uint32_t timestamp_;
   int16_t audio_[kMaxNumSamples];
   size_t num_audio_samples_10ms_;
-  uint8_t encoded_[kMaxEncodedBytes];
+  std::vector<uint8_t> encoded_;
   AudioEncoder::EncodedInfo encoded_info_;
   int sample_rate_hz_;
 };

webrtc/modules/audio_coding/codecs/cng/include/audio_encoder_cng.h

@@ -48,6 +48,7 @@ class AudioEncoderCng final : public AudioEncoder {
 
   int SampleRateHz() const override;
   int NumChannels() const override;
+  size_t MaxEncodedBytes() const override;
   int RtpTimestampRateHz() const override;
   int Num10MsFramesInNextPacket() const override;
   int Max10MsFramesInAPacket() const override;
@@ -68,11 +69,13 @@ class AudioEncoderCng final : public AudioEncoder {
     inline void operator()(CNG_enc_inst* ptr) const { WebRtcCng_FreeEnc(ptr); }
   };
 
-  void EncodePassive(uint8_t* encoded, size_t* encoded_bytes);
+  void EncodePassive(size_t max_encoded_bytes,
-
+                    uint8_t* encoded,
+                    EncodedInfo* info);
   void EncodeActive(size_t max_encoded_bytes,
                     uint8_t* encoded,
                     EncodedInfo* info);
+  size_t SamplesPer10msFrame() const;
 
   AudioEncoder* speech_encoder_;
   const int cng_payload_type_;

webrtc/modules/audio_coding/codecs/g711/audio_encoder_pcm.cc

@@ -49,9 +49,15 @@ AudioEncoderPcm::~AudioEncoderPcm() {
 int AudioEncoderPcm::SampleRateHz() const {
   return sample_rate_hz_;
 }
+
 int AudioEncoderPcm::NumChannels() const {
   return num_channels_;
 }
+
+size_t AudioEncoderPcm::MaxEncodedBytes() const {
+  return full_frame_samples_;
+}
+
 int AudioEncoderPcm::Num10MsFramesInNextPacket() const {
   return num_10ms_frames_per_packet_;
 }
@@ -72,11 +78,12 @@ void AudioEncoderPcm::EncodeInternal(uint32_t rtp_timestamp,
   for (int i = 0; i < num_samples; ++i) {
     speech_buffer_.push_back(audio[i]);
   }
-  if (speech_buffer_.size() < static_cast<size_t>(full_frame_samples_)) {
+  if (speech_buffer_.size() < full_frame_samples_) {
     info->encoded_bytes = 0;
     return;
   }
-  CHECK_EQ(speech_buffer_.size(), static_cast<size_t>(full_frame_samples_));
+  CHECK_EQ(speech_buffer_.size(), full_frame_samples_);
+  CHECK_GE(max_encoded_bytes, full_frame_samples_);
   int16_t ret = EncodeCall(&speech_buffer_[0], full_frame_samples_, encoded);
   CHECK_GE(ret, 0);
   speech_buffer_.clear();

webrtc/modules/audio_coding/codecs/g711/include/audio_encoder_pcm.h

@@ -34,6 +34,7 @@ class AudioEncoderPcm : public AudioEncoder {
 
   int SampleRateHz() const override;
   int NumChannels() const override;
+  size_t MaxEncodedBytes() const override;
   int Num10MsFramesInNextPacket() const override;
   int Max10MsFramesInAPacket() const override;
 
@@ -55,7 +56,7 @@ class AudioEncoderPcm : public AudioEncoder {
   const int num_channels_;
   const int payload_type_;
   const int num_10ms_frames_per_packet_;
-  const int16_t full_frame_samples_;
+  const size_t full_frame_samples_;
   std::vector<int16_t> speech_buffer_;
   uint32_t first_timestamp_in_buffer_;
 };

webrtc/modules/audio_coding/codecs/g722/audio_encoder_g722.cc

@@ -54,17 +54,25 @@ AudioEncoderG722::~AudioEncoderG722() {}
 int AudioEncoderG722::SampleRateHz() const {
   return kSampleRateHz;
 }
+
 int AudioEncoderG722::RtpTimestampRateHz() const {
   // The RTP timestamp rate for G.722 is 8000 Hz, even though it is a 16 kHz
   // codec.
   return kSampleRateHz / 2;
 }
+
 int AudioEncoderG722::NumChannels() const {
   return num_channels_;
 }
+
+size_t AudioEncoderG722::MaxEncodedBytes() const {
+  return static_cast<size_t>(SamplesPerChannel() / 2 * num_channels_);
+}
+
 int AudioEncoderG722::Num10MsFramesInNextPacket() const {
   return num_10ms_frames_per_packet_;
 }
+
 int AudioEncoderG722::Max10MsFramesInAPacket() const {
   return num_10ms_frames_per_packet_;
 }
@@ -74,10 +82,7 @@ void AudioEncoderG722::EncodeInternal(uint32_t rtp_timestamp,
                                       size_t max_encoded_bytes,
                                       uint8_t* encoded,
                                       EncodedInfo* info) {
-  const int samples_per_channel =
+  CHECK_GE(max_encoded_bytes, MaxEncodedBytes());
-      kSampleRateHz / 100 * num_10ms_frames_per_packet_;
-  CHECK_GE(max_encoded_bytes,
-           static_cast<size_t>(samples_per_channel) / 2 * num_channels_);
 
   if (num_10ms_frames_buffered_ == 0)
     first_timestamp_in_buffer_ = rtp_timestamp;
@@ -97,6 +102,7 @@ void AudioEncoderG722::EncodeInternal(uint32_t rtp_timestamp,
   // Encode each channel separately.
   CHECK_EQ(num_10ms_frames_buffered_, num_10ms_frames_per_packet_);
   num_10ms_frames_buffered_ = 0;
+  const int samples_per_channel = SamplesPerChannel();
   for (int i = 0; i < num_channels_; ++i) {
     const int encoded = WebRtcG722_Encode(
         encoders_[i].encoder, encoders_[i].speech_buffer.get(),
@@ -123,4 +129,8 @@ void AudioEncoderG722::EncodeInternal(uint32_t rtp_timestamp,
   info->payload_type = payload_type_;
 }
 
+int AudioEncoderG722::SamplesPerChannel() const {
+  return kSampleRateHz / 100 * num_10ms_frames_per_packet_;
+}
+
 }  // namespace webrtc

webrtc/modules/audio_coding/codecs/g722/include/audio_encoder_g722.h

@@ -31,8 +31,9 @@ class AudioEncoderG722 : public AudioEncoder {
   ~AudioEncoderG722() override;
 
   int SampleRateHz() const override;
-  int RtpTimestampRateHz() const override;
   int NumChannels() const override;
+  size_t MaxEncodedBytes() const override;
+  int RtpTimestampRateHz() const override;
   int Num10MsFramesInNextPacket() const override;
   int Max10MsFramesInAPacket() const override;
 
@@ -53,6 +54,8 @@ class AudioEncoderG722 : public AudioEncoder {
     ~EncoderState();
   };
 
+  int SamplesPerChannel() const;
+
   const int num_channels_;
   const int payload_type_;
   const int num_10ms_frames_per_packet_;

webrtc/modules/audio_coding/codecs/ilbc/audio_encoder_ilbc.cc

@@ -46,12 +46,19 @@ AudioEncoderIlbc::~AudioEncoderIlbc() {
 int AudioEncoderIlbc::SampleRateHz() const {
   return kSampleRateHz;
 }
+
 int AudioEncoderIlbc::NumChannels() const {
   return 1;
 }
+
+size_t AudioEncoderIlbc::MaxEncodedBytes() const {
+  return RequiredOutputSizeBytes();
+}
+
 int AudioEncoderIlbc::Num10MsFramesInNextPacket() const {
   return num_10ms_frames_per_packet_;
 }
+
 int AudioEncoderIlbc::Max10MsFramesInAPacket() const {
   return num_10ms_frames_per_packet_;
 }
@@ -61,24 +68,7 @@ void AudioEncoderIlbc::EncodeInternal(uint32_t rtp_timestamp,
                                       size_t max_encoded_bytes,
                                       uint8_t* encoded,
                                       EncodedInfo* info) {
-  size_t expected_output_len;
+  DCHECK_GE(max_encoded_bytes, RequiredOutputSizeBytes());
-  switch (num_10ms_frames_per_packet_) {
-    case 2:
-      expected_output_len = 38;
-      break;
-    case 3:
-      expected_output_len = 50;
-      break;
-    case 4:
-      expected_output_len = 2 * 38;
-      break;
-    case 6:
-      expected_output_len = 2 * 50;
-      break;
-    default:
-      FATAL();
-  }
-  DCHECK_GE(max_encoded_bytes, expected_output_len);
 
   // Save timestamp if starting a new packet.
   if (num_10ms_frames_buffered_ == 0)
@@ -105,10 +95,20 @@ void AudioEncoderIlbc::EncodeInternal(uint32_t rtp_timestamp,
       kSampleRateHz / 100 * num_10ms_frames_per_packet_,
       encoded);
   CHECK_GE(output_len, 0);
-  DCHECK_EQ(output_len, static_cast<int>(expected_output_len));
   info->encoded_bytes = output_len;
+  DCHECK_EQ(info->encoded_bytes, RequiredOutputSizeBytes());
   info->encoded_timestamp = first_timestamp_in_buffer_;
   info->payload_type = payload_type_;
 }
 
+size_t AudioEncoderIlbc::RequiredOutputSizeBytes() const {
+  switch (num_10ms_frames_per_packet_) {
+    case 2:   return 38;
+    case 3:   return 50;
+    case 4:   return 2 * 38;
+    case 6:   return 2 * 50;
+    default:  FATAL();
+  }
+}
+
 }  // namespace webrtc

webrtc/modules/audio_coding/codecs/ilbc/interface/audio_encoder_ilbc.h

@@ -33,6 +33,7 @@ class AudioEncoderIlbc : public AudioEncoder {
 
   int SampleRateHz() const override;
   int NumChannels() const override;
+  size_t MaxEncodedBytes() const override;
   int Num10MsFramesInNextPacket() const override;
   int Max10MsFramesInAPacket() const override;
 
@@ -44,6 +45,8 @@ class AudioEncoderIlbc : public AudioEncoder {
                       EncodedInfo* info) override;
 
  private:
+  size_t RequiredOutputSizeBytes() const;
+
   static const int kMaxSamplesPerPacket = 480;
   const int payload_type_;
   const int num_10ms_frames_per_packet_;

webrtc/modules/audio_coding/codecs/isac/audio_encoder_isac_t.h

@@ -71,6 +71,7 @@ class AudioEncoderDecoderIsacT : public AudioEncoder, public AudioDecoder {
   // AudioEncoder public methods.
   int SampleRateHz() const override;
   int NumChannels() const override;
+  size_t MaxEncodedBytes() const override;
   int Num10MsFramesInNextPacket() const override;
   int Max10MsFramesInAPacket() const override;
 

webrtc/modules/audio_coding/codecs/isac/audio_encoder_isac_t_impl.h

@@ -184,6 +184,11 @@ int AudioEncoderDecoderIsacT<T>::NumChannels() const {
   return 1;
 }
 
+template <typename T>
+size_t AudioEncoderDecoderIsacT<T>::MaxEncodedBytes() const {
+  return kSufficientEncodeBufferSizeBytes;
+}
+
 template <typename T>
 int AudioEncoderDecoderIsacT<T>::Num10MsFramesInNextPacket() const {
   CriticalSectionScoped cs(state_lock_.get());

webrtc/modules/audio_coding/codecs/isac/main/source/audio_encoder_isac_red_unittest.cc

@@ -30,12 +30,11 @@ TEST(AudioEncoderIsacRedTest, CompareRedAndNoRed) {
     double r = rand();  // NOLINT(runtime/threadsafe_fn)
     input[i] = (r / RAND_MAX) * 2000 - 1000;
   }
-  static const size_t kMaxEncodedSizeBytes = 1000;
-  uint8_t encoded[kMaxEncodedSizeBytes];
-  uint8_t red_encoded[kMaxEncodedSizeBytes];
   AudioEncoderDecoderIsac::Config config;
   config.sample_rate_hz = kSampleRateHz;
   AudioEncoderDecoderIsac isac_encoder(config);
+  size_t max_encoded_bytes = isac_encoder.MaxEncodedBytes();
+  rtc::scoped_ptr<uint8_t[]> encoded(new uint8_t[max_encoded_bytes]);
   AudioEncoderDecoderIsac::Config red_config;
   red_config.sample_rate_hz = kSampleRateHz;
   red_config.red_payload_type = kRedPayloadType;
@@ -43,6 +42,8 @@ TEST(AudioEncoderIsacRedTest, CompareRedAndNoRed) {
   ASSERT_NE(red_config.red_payload_type, red_config.payload_type)
       << "iSAC and RED payload types must be different.";
   AudioEncoderDecoderIsac isac_red_encoder(red_config);
+  size_t max_red_encoded_bytes = isac_red_encoder.MaxEncodedBytes();
+  rtc::scoped_ptr<uint8_t[]> red_encoded(new uint8_t[max_red_encoded_bytes]);
   AudioEncoder::EncodedInfo info, red_info;
 
   // Note that we are not expecting any output from the redundant encoder until
@@ -52,10 +53,11 @@ TEST(AudioEncoderIsacRedTest, CompareRedAndNoRed) {
     EXPECT_EQ(0u, red_info.encoded_bytes);
     EXPECT_EQ(0u, red_info.redundant.size());
     const uint32_t timestamp = static_cast<uint32_t>(i);
-    isac_encoder.Encode(timestamp, input, k10MsSamples, kMaxEncodedSizeBytes,
+    isac_encoder.Encode(timestamp, input, k10MsSamples, max_encoded_bytes,
-                        encoded, &info);
+                        encoded.get(), &info);
     isac_red_encoder.Encode(timestamp, input, k10MsSamples,
-                            kMaxEncodedSizeBytes, red_encoded, &red_info);
+                            max_red_encoded_bytes, red_encoded.get(),
+                            &red_info);
   }
   EXPECT_GT(info.encoded_bytes, 0u)
       << "Regular codec did not produce any output";
@@ -65,7 +67,7 @@ TEST(AudioEncoderIsacRedTest, CompareRedAndNoRed) {
   ASSERT_EQ(info.encoded_bytes, red_info.redundant[0].encoded_bytes)
       << "Primary payload should be same length as non-redundant payload";
   // Check that |encoded| and the primary part of |red_encoded| are identical.
-  EXPECT_EQ(0, memcmp(encoded, red_encoded, info.encoded_bytes));
+  EXPECT_EQ(0, memcmp(encoded.get(), red_encoded.get(), info.encoded_bytes));
   EXPECT_GT(red_info.redundant[0].encoded_bytes,
             red_info.redundant[1].encoded_bytes)
       << "Redundant payload should be smaller than primary";

webrtc/modules/audio_coding/codecs/mock/mock_audio_encoder.h

@@ -23,6 +23,7 @@ class MockAudioEncoder : public AudioEncoder {
   MOCK_METHOD0(Die, void());
   MOCK_CONST_METHOD0(SampleRateHz, int());
   MOCK_CONST_METHOD0(NumChannels, int());
+  MOCK_CONST_METHOD0(MaxEncodedBytes, size_t());
   MOCK_CONST_METHOD0(Num10MsFramesInNextPacket, int());
   MOCK_CONST_METHOD0(Max10MsFramesInAPacket, int());
   MOCK_METHOD1(SetTargetBitrate, void(int));

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

@@ -111,6 +111,16 @@ int AudioEncoderOpus::NumChannels() const {
   return 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.
+  int frame_size_ms = num_10ms_frames_per_packet_ * 10;
+  int bytes_per_millisecond = bitrate_bps_ / (1000 * 8) + 1;
+  size_t approx_encoded_bytes =
+      static_cast<size_t>(frame_size_ms * bytes_per_millisecond);
+  return 2 * approx_encoded_bytes;
+}
+
 int AudioEncoderOpus::Num10MsFramesInNextPacket() const {
   return num_10ms_frames_per_packet_;
 }
@@ -120,10 +130,9 @@ int AudioEncoderOpus::Max10MsFramesInAPacket() const {
 }
 
 void AudioEncoderOpus::SetTargetBitrate(int bits_per_second) {
-  CHECK_EQ(WebRtcOpus_SetBitRate(
+  bitrate_bps_ = std::max(std::min(bits_per_second, kMaxBitrateBps),
-               inst_, std::max(std::min(bits_per_second, kMaxBitrateBps),
+                          kMinBitrateBps);
-                               kMinBitrateBps)),
+  CHECK_EQ(WebRtcOpus_SetBitRate(inst_, bitrate_bps_), 0);
-           0);
 }
 
 void AudioEncoderOpus::SetProjectedPacketLossRate(double fraction) {

webrtc/modules/audio_coding/codecs/opus/interface/audio_encoder_opus.h

@@ -47,10 +47,12 @@ class AudioEncoderOpus final : public AudioEncoder {
 
   int SampleRateHz() const override;
   int NumChannels() const override;
+  size_t MaxEncodedBytes() const override;
   int Num10MsFramesInNextPacket() const override;
   int Max10MsFramesInAPacket() const override;
   void SetTargetBitrate(int bits_per_second) override;
   void SetProjectedPacketLossRate(double fraction) override;
+
   double packet_loss_rate() const { return packet_loss_rate_; }
   ApplicationMode application() const { return application_; }
 
@@ -66,6 +68,7 @@ class AudioEncoderOpus final : public AudioEncoder {
   const int num_channels_;
   const int payload_type_;
   const ApplicationMode application_;
+  int bitrate_bps_;
   const int samples_per_10ms_frame_;
   std::vector<int16_t> input_buffer_;
   OpusEncInst* inst_;

webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red.cc

@@ -38,6 +38,10 @@ int AudioEncoderCopyRed::NumChannels() const {
   return speech_encoder_->NumChannels();
 }
 
+size_t AudioEncoderCopyRed::MaxEncodedBytes() const {
+  return 2 * speech_encoder_->MaxEncodedBytes();
+}
+
 int AudioEncoderCopyRed::Num10MsFramesInNextPacket() const {
   return speech_encoder_->Num10MsFramesInNextPacket();
 }

webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red.h

@@ -36,8 +36,9 @@ class AudioEncoderCopyRed : public AudioEncoder {
   ~AudioEncoderCopyRed() override;
 
   int SampleRateHz() const override;
-  int RtpTimestampRateHz() const override;
   int NumChannels() const override;
+  size_t MaxEncodedBytes() const override;
+  int RtpTimestampRateHz() const override;
   int Num10MsFramesInNextPacket() const override;
   int Max10MsFramesInAPacket() const override;
   void SetTargetBitrate(int bits_per_second) override;

webrtc/modules/audio_coding/codecs/red/audio_encoder_copy_red_unittest.cc

@@ -8,6 +8,8 @@
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
+#include <vector>
+
 #include "testing/gtest/include/gtest/gtest.h"
 #include "webrtc/base/checks.h"
 #include "webrtc/base/scoped_ptr.h"
@@ -24,7 +26,7 @@ using ::testing::MockFunction;
 namespace webrtc {
 
 namespace {
-static const size_t kMaxEncodedBytes = 1000;
+static const size_t kMockMaxEncodedBytes = 1000;
 static const size_t kMaxNumSamples = 48 * 10 * 2;  // 10 ms @ 48 kHz stereo.
 }
 
@@ -39,11 +41,13 @@ class AudioEncoderCopyRedTest : public ::testing::Test {
     config.payload_type = red_payload_type_;
     config.speech_encoder = &mock_encoder_;
     red_.reset(new AudioEncoderCopyRed(config));
-    memset(encoded_, 0, sizeof(encoded_));
     memset(audio_, 0, sizeof(audio_));
     EXPECT_CALL(mock_encoder_, NumChannels()).WillRepeatedly(Return(1));
     EXPECT_CALL(mock_encoder_, SampleRateHz())
         .WillRepeatedly(Return(sample_rate_hz_));
+    EXPECT_CALL(mock_encoder_, MaxEncodedBytes())
+        .WillRepeatedly(Return(kMockMaxEncodedBytes));
+    encoded_.resize(red_->MaxEncodedBytes(), 0);
   }
 
   void TearDown() override {
@@ -58,7 +62,7 @@ class AudioEncoderCopyRedTest : public ::testing::Test {
     ASSERT_TRUE(red_.get() != NULL);
     encoded_info_ = AudioEncoder::EncodedInfo();
     red_->Encode(timestamp_, audio_, num_audio_samples_10ms,
-                 kMaxEncodedBytes, encoded_, &encoded_info_);
+                 encoded_.size(), &encoded_[0], &encoded_info_);
     timestamp_ += num_audio_samples_10ms;
   }
 
@@ -68,7 +72,7 @@ class AudioEncoderCopyRedTest : public ::testing::Test {
   int16_t audio_[kMaxNumSamples];
   const int sample_rate_hz_;
   size_t num_audio_samples_10ms;
-  uint8_t encoded_[kMaxEncodedBytes];
+  std::vector<uint8_t> encoded_;
   AudioEncoder::EncodedInfo encoded_info_;
   const int red_payload_type_;
 };