Add AudioEncoder::GetTargetBitrate

webrtc/modules/audio_coding/neteq/audio_decoder_unittest.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 467 matching lines @@
 
 TEST_F(AudioDecoderPcmUTest, EncodeDecode) {
   int tolerance = 251;
   double mse = 1734.0;
   EXPECT_TRUE(CodecSupported(kDecoderPCMu));
   EncodeDecodeTest(data_length_, tolerance, mse);
   ReInitTest();
   EXPECT_FALSE(decoder_->HasDecodePlc());
 }
 
+namespace {
+void TestPcmSetTargetBitrates(AudioEncoder* audio_encoder, int fixed_rate) {
+  EXPECT_EQ(fixed_rate, audio_encoder->SetTargetBitrate(32000));
+  EXPECT_EQ(fixed_rate, audio_encoder->SetTargetBitrate(fixed_rate - 1));
+  EXPECT_EQ(fixed_rate, audio_encoder->SetTargetBitrate(fixed_rate));
+  EXPECT_EQ(fixed_rate, audio_encoder->SetTargetBitrate(fixed_rate + 1));
+}
+}  // namespace
+
+TEST_F(AudioDecoderPcmUTest, SetTargetBitrate) {
+  TestPcmSetTargetBitrates(audio_encoder_.get(), 64000);
+}
+
 TEST_F(AudioDecoderPcmATest, EncodeDecode) {
   int tolerance = 308;
   double mse = 1931.0;
   EXPECT_TRUE(CodecSupported(kDecoderPCMa));
   EncodeDecodeTest(data_length_, tolerance, mse);
   ReInitTest();
   EXPECT_FALSE(decoder_->HasDecodePlc());
 }
 
+TEST_F(AudioDecoderPcmATest, SetTargetBitrate) {
+  TestPcmSetTargetBitrates(audio_encoder_.get(), 64000);
+}
+
 TEST_F(AudioDecoderPcm16BTest, EncodeDecode) {
   int tolerance = 0;
   double mse = 0.0;
   EXPECT_TRUE(CodecSupported(kDecoderPCM16B));
   EXPECT_TRUE(CodecSupported(kDecoderPCM16Bwb));
   EXPECT_TRUE(CodecSupported(kDecoderPCM16Bswb32kHz));
   EXPECT_TRUE(CodecSupported(kDecoderPCM16Bswb48kHz));
   EncodeDecodeTest(2 * data_length_, tolerance, mse);
   ReInitTest();
   EXPECT_FALSE(decoder_->HasDecodePlc());
 }
 
+TEST_F(AudioDecoderPcm16BTest, SetTargetBitrate) {
+  TestPcmSetTargetBitrates(audio_encoder_.get(), codec_input_rate_hz_ * 16);
+}
+
 TEST_F(AudioDecoderIlbcTest, EncodeDecode) {
   int tolerance = 6808;
   double mse = 2.13e6;
   int delay = 80;  // Delay from input to output.
   EXPECT_TRUE(CodecSupported(kDecoderILBC));
   EncodeDecodeTest(500, tolerance, mse, delay);
   ReInitTest();
   EXPECT_TRUE(decoder_->HasDecodePlc());
   DecodePlcTest();
 }
 
+TEST_F(AudioDecoderIlbcTest, SetTargetBitrate) {
+  EXPECT_EQ(13333, audio_encoder_->SetTargetBitrate(10000));
+  EXPECT_EQ(13333, audio_encoder_->SetTargetBitrate(13333));
+  EXPECT_EQ(13333, audio_encoder_->SetTargetBitrate(20000));
+}
+
 TEST_F(AudioDecoderIsacFloatTest, EncodeDecode) {
   int tolerance = 3399;
   double mse = 434951.0;
   int delay = 48;  // Delay from input to output.
   EXPECT_TRUE(CodecSupported(kDecoderISAC));
   EncodeDecodeTest(0, tolerance, mse, delay);
   ReInitTest();
   EXPECT_FALSE(decoder_->HasDecodePlc());
 }
 
+namespace {
+void TestIsacSetTargetBitrates(AudioEncoder* audio_encoder, bool swb) {
+  const int max_rate_bps = (swb ? 56000 : 32000);
+  EXPECT_EQ(10000, audio_encoder->SetTargetBitrate(9000));
+  EXPECT_EQ(10000, audio_encoder->SetTargetBitrate(10000));
+  EXPECT_EQ(32000, audio_encoder->SetTargetBitrate(32000));
+  EXPECT_EQ(std::min(max_rate_bps, 33000),
+            audio_encoder->SetTargetBitrate(33000));
+  EXPECT_EQ(std::min(max_rate_bps, 56000),
+            audio_encoder->SetTargetBitrate(56000));
+  EXPECT_EQ(std::min(max_rate_bps, 56000),
+            audio_encoder->SetTargetBitrate(57000));
+}
+}  // namespace
+
+TEST_F(AudioDecoderIsacFloatTest, SetTargetBitrate) {
+  TestIsacSetTargetBitrates(audio_encoder_.get(), false /* swb */);
+}
+
 TEST_F(AudioDecoderIsacSwbTest, EncodeDecode) {
   int tolerance = 19757;
   double mse = 8.18e6;
   int delay = 160;  // Delay from input to output.
   EXPECT_TRUE(CodecSupported(kDecoderISACswb));
   EncodeDecodeTest(0, tolerance, mse, delay);
   ReInitTest();
   EXPECT_FALSE(decoder_->HasDecodePlc());
 }
 
+TEST_F(AudioDecoderIsacSwbTest, SetTargetBitrate) {
+  TestIsacSetTargetBitrates(audio_encoder_.get(), true /* swb */);
+}
+
 // Fails Android ARM64. https://code.google.com/p/webrtc/issues/detail?id=4198
 #if defined(WEBRTC_ANDROID) && defined(WEBRTC_ARCH_ARM64)
 #define MAYBE_EncodeDecode DISABLED_EncodeDecode
 #else
 #define MAYBE_EncodeDecode EncodeDecode
 #endif
 TEST_F(AudioDecoderIsacFixTest, MAYBE_EncodeDecode) {
   int tolerance = 11034;
   double mse = 3.46e6;
   int delay = 54;  // Delay from input to output.
   EXPECT_TRUE(CodecSupported(kDecoderISAC));
 #ifdef WEBRTC_ANDROID
   static const int kEncodedBytes = 685;
 #else
   static const int kEncodedBytes = 671;
 #endif
   EncodeDecodeTest(kEncodedBytes, tolerance, mse, delay);
   ReInitTest();
   EXPECT_FALSE(decoder_->HasDecodePlc());
 }
 
+TEST_F(AudioDecoderIsacFixTest, SetTargetBitrate) {
+  TestIsacSetTargetBitrates(audio_encoder_.get(), false /* swb */);
+}
+
 TEST_F(AudioDecoderG722Test, EncodeDecode) {
   int tolerance = 6176;
   double mse = 238630.0;
   int delay = 22;  // Delay from input to output.
   EXPECT_TRUE(CodecSupported(kDecoderG722));
   EncodeDecodeTest(data_length_ / 2, tolerance, mse, delay);
   ReInitTest();
   EXPECT_FALSE(decoder_->HasDecodePlc());
 }
 
+namespace {
+void TestG722SetTargetBitrates(AudioEncoder* audio_encoder, bool stereo) {
+  const int fixed_rate_bps = (stereo ? 128000 : 64000);
+  EXPECT_EQ(fixed_rate_bps, audio_encoder->SetTargetBitrate(32000));
+  EXPECT_EQ(fixed_rate_bps, audio_encoder->SetTargetBitrate(64000));
+  EXPECT_EQ(fixed_rate_bps, audio_encoder->SetTargetBitrate(65000));
+  EXPECT_EQ(fixed_rate_bps, audio_encoder->SetTargetBitrate(128000));
+  EXPECT_EQ(fixed_rate_bps, audio_encoder->SetTargetBitrate(129000));
+}
+}  // namespace
+
+TEST_F(AudioDecoderG722Test, SetTargetBitrate) {
+  TestG722SetTargetBitrates(audio_encoder_.get(), false /* stereo */);
+}
+
 TEST_F(AudioDecoderG722StereoTest, CreateAndDestroy) {
   EXPECT_TRUE(CodecSupported(kDecoderG722_2ch));
 }
 
 TEST_F(AudioDecoderG722StereoTest, EncodeDecode) {
   int tolerance = 6176;
   int channel_diff_tolerance = 0;
   double mse = 238630.0;
   int delay = 22;  // Delay from input to output.
   EXPECT_TRUE(CodecSupported(kDecoderG722_2ch));
   EncodeDecodeTest(data_length_, tolerance, mse, delay, channel_diff_tolerance);
   ReInitTest();
   EXPECT_FALSE(decoder_->HasDecodePlc());
 }
 
+TEST_F(AudioDecoderG722StereoTest, SetTargetBitrate) {
+  TestG722SetTargetBitrates(audio_encoder_.get(), true /* stereo */);
+}
+
 TEST_F(AudioDecoderOpusTest, EncodeDecode) {
   int tolerance = 6176;
   double mse = 238630.0;
   int delay = 22;  // Delay from input to output.
   EXPECT_TRUE(CodecSupported(kDecoderOpus));
   EncodeDecodeTest(0, tolerance, mse, delay);
   ReInitTest();
   EXPECT_FALSE(decoder_->HasDecodePlc());
 }
 
+namespace {
+void TestOpusSetTargetBitrates(AudioEncoder* audio_encoder) {
+  EXPECT_EQ(500, audio_encoder->SetTargetBitrate(499));
+  EXPECT_EQ(500, audio_encoder->SetTargetBitrate(500));
+  EXPECT_EQ(32000, audio_encoder->SetTargetBitrate(32000));
+  EXPECT_EQ(512000, audio_encoder->SetTargetBitrate(512000));
+  EXPECT_EQ(512000, audio_encoder->SetTargetBitrate(513000));
+}
+}  // namespace
+
+TEST_F(AudioDecoderOpusTest, SetTargetBitrate) {
+  TestOpusSetTargetBitrates(audio_encoder_.get());
+}
+
 TEST_F(AudioDecoderOpusStereoTest, EncodeDecode) {
   int tolerance = 6176;
   int channel_diff_tolerance = 0;
   double mse = 238630.0;
   int delay = 22;  // Delay from input to output.
   EXPECT_TRUE(CodecSupported(kDecoderOpus_2ch));
   EncodeDecodeTest(0, tolerance, mse, delay, channel_diff_tolerance);
   ReInitTest();
   EXPECT_FALSE(decoder_->HasDecodePlc());
 }
 
+TEST_F(AudioDecoderOpusStereoTest, SetTargetBitrate) {
+  TestOpusSetTargetBitrates(audio_encoder_.get());
+}
+
 TEST(AudioDecoder, CodecSampleRateHz) {
   EXPECT_EQ(8000, CodecSampleRateHz(kDecoderPCMu));
   EXPECT_EQ(8000, CodecSampleRateHz(kDecoderPCMa));
   EXPECT_EQ(8000, CodecSampleRateHz(kDecoderPCMu_2ch));
   EXPECT_EQ(8000, CodecSampleRateHz(kDecoderPCMa_2ch));
   EXPECT_EQ(8000, CodecSampleRateHz(kDecoderILBC));
   EXPECT_EQ(16000, CodecSampleRateHz(kDecoderISAC));
   EXPECT_EQ(32000, CodecSampleRateHz(kDecoderISACswb));
   EXPECT_EQ(32000, CodecSampleRateHz(kDecoderISACfb));
   EXPECT_EQ(8000, CodecSampleRateHz(kDecoderPCM16B));
@@ skipping 44 matching lines @@
   EXPECT_TRUE(CodecSupported(kDecoderCNGnb));
   EXPECT_TRUE(CodecSupported(kDecoderCNGwb));
   EXPECT_TRUE(CodecSupported(kDecoderCNGswb32kHz));
   EXPECT_TRUE(CodecSupported(kDecoderCNGswb48kHz));
   EXPECT_TRUE(CodecSupported(kDecoderArbitrary));
   EXPECT_TRUE(CodecSupported(kDecoderOpus));
   EXPECT_TRUE(CodecSupported(kDecoderOpus_2ch));
 }
 
 }  // namespace webrtc