Change opus min bitrate.

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

 /*
  *  Copyright (c) 2015 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 <array>
 #include <memory>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/fakeclock.h"
 #include "webrtc/common_audio/mocks/mock_smoothing_filter.h"
 #include "webrtc/common_types.h"
 #include "webrtc/modules/audio_coding/audio_network_adaptor/mock/mock_audio_network_adaptor.h"
 #include "webrtc/modules/audio_coding/codecs/opus/audio_encoder_opus.h"
+#include "webrtc/modules/audio_coding/neteq/tools/audio_loop.h"
 #include "webrtc/test/field_trial.h"
 #include "webrtc/test/gmock.h"
 #include "webrtc/test/gtest.h"
+#include "webrtc/test/testsupport/fileutils.h"
 #include "webrtc/system_wrappers/include/clock.h"
 
 namespace webrtc {
 using ::testing::NiceMock;
 using ::testing::Return;
 
 namespace {
 
 const CodecInst kDefaultOpusSettings = {105, "opus", 48000, 960, 1, 32000};
 constexpr int64_t kInitialTimeUs = 12345678;
@@ skipping 73 matching lines @@
 void CheckEncoderRuntimeConfig(
     const AudioEncoderOpus* encoder,
     const AudioNetworkAdaptor::EncoderRuntimeConfig& config) {
   EXPECT_EQ(*config.bitrate_bps, encoder->GetTargetBitrate());
   EXPECT_EQ(*config.frame_length_ms, encoder->next_frame_length_ms());
   EXPECT_EQ(*config.enable_fec, encoder->fec_enabled());
   EXPECT_EQ(*config.enable_dtx, encoder->GetDtx());
   EXPECT_EQ(*config.num_channels, encoder->num_channels_to_encode());
 }
 
+// Create 10ms audio data blocks for a total packet size of "packet_size_ms".
+std::unique_ptr<test::AudioLoop> Create10msAudioBlocks(
+    const std::unique_ptr<AudioEncoderOpus>& encoder,
+    int packet_size_ms) {
+  const std::string file_name =
+      test::ResourcePath("audio_coding/testfile32kHz", "pcm");
+
+  std::unique_ptr<test::AudioLoop> speech_data(new test::AudioLoop());
+  int audio_samples_per_ms =
+      rtc::CheckedDivExact(encoder->SampleRateHz(), 1000);
+  RTC_DCHECK(speech_data->Init(

[hlundin-webrtc, 2017/03/03 14:32:59]

This is wrong for two reasons:
1. It won't call Init when the test is run in Release mode.
2. Don't use (D)CHECKs in test code. Use EXPECT or ASSERT.

[minyue-webrtc, 2017/03/03 14:40:41]

Right, thanks! Weird that the test still passes.
I think it was my fault to introduce D(CHECKs) in tests. What I wanted was to
let D(CHECKs) capture wrong test implementation, and let EXPECT to capture wrong
product implementation. But, that may not be necessary.

[michaelt, 2017/03/06 10:09:52]

In general i like the idea of separation of test's and test setup (Open files
...) by using (D)CHECKs and use of EXPECT or ASSERT.

For situations like this one we have a additional problem. 
In this case we should use ASSERT, but we are not allowed to use ASSERT in
functions which are called by the test. 

So it seams best to me to just replace the RTC_DCHECK by a a RTC_CHECK.

[hlundin-webrtc, 2017/03/06 10:49:13]

The test still passes on the bots (Debug and Release alike) because they always
run with DCHECK_ALWAYS_ON set.

The reason I regularly dislike (D)CHECKs in tests is that the same binary runs
many test cases, and if the (D)CHECK triggers, you get no results at all from
the ones that did not have a chance to run yet.

The problem with ASSERT_* is that, due to how it is implemented, it can only be
used in void-returning functions. What you can do is have this method return an
empty result (nullptr) if init fails, and then let the test itself ASSERT_TRUE
on that.

[michaelt, 2017/03/06 12:01:32]

Acknowledged.

+      file_name,
+      packet_size_ms * audio_samples_per_ms * encoder->num_channels_to_encode(),
+      10 * audio_samples_per_ms * encoder->num_channels_to_encode()));
+  return speech_data;
+}
+
 }  // namespace
 
 TEST(AudioEncoderOpusTest, DefaultApplicationModeMono) {
   auto states = CreateCodec(1);
   EXPECT_EQ(AudioEncoderOpus::kVoip, states.encoder->application());
 }
 
 TEST(AudioEncoderOpusTest, DefaultApplicationModeStereo) {
   auto states = CreateCodec(2);
   EXPECT_EQ(AudioEncoderOpus::kAudio, states.encoder->application());
@@ skipping 32 matching lines @@
   // Verify that the mode is still kAudio.
   EXPECT_EQ(AudioEncoderOpus::kAudio, states.encoder->application());
   // Turn off DTX.
   EXPECT_TRUE(states.encoder->SetDtx(false));
 }
 
 TEST(AudioEncoderOpusTest,
      OnReceivedUplinkBandwidthWithoutAudioNetworkAdaptor) {
   auto states = CreateCodec(1);
   // Constants are replicated from audio_states.encoderopus.cc.
-  const int kMinBitrateBps = 500;
+  const int kMinBitrateBps = 6000;
   const int kMaxBitrateBps = 512000;
   // Set a too low bitrate.
   states.encoder->OnReceivedUplinkBandwidth(kMinBitrateBps - 1,
                                             rtc::Optional<int64_t>());
   EXPECT_EQ(kMinBitrateBps, states.encoder->GetTargetBitrate());
   // Set a too high bitrate.
   states.encoder->OnReceivedUplinkBandwidth(kMaxBitrateBps + 1,
                                             rtc::Optional<int64_t>());
   EXPECT_EQ(kMaxBitrateBps, states.encoder->GetTargetBitrate());
   // Set the minimum rate.
   states.encoder->OnReceivedUplinkBandwidth(kMinBitrateBps,
                                             rtc::Optional<int64_t>());
   EXPECT_EQ(kMinBitrateBps, states.encoder->GetTargetBitrate());
   // Set the maximum rate.
   states.encoder->OnReceivedUplinkBandwidth(kMaxBitrateBps,
                                             rtc::Optional<int64_t>());
   EXPECT_EQ(kMaxBitrateBps, states.encoder->GetTargetBitrate());
-  // Set rates from 1000 up to 32000 bps.
-  for (int rate = 1000; rate <= 32000; rate += 1000) {
+  // Set rates from kMaxBitrateBps up to 32000 bps.
+  for (int rate = kMinBitrateBps; rate <= 32000; rate += 1000) {
     states.encoder->OnReceivedUplinkBandwidth(rate, rtc::Optional<int64_t>());
     EXPECT_EQ(rate, states.encoder->GetTargetBitrate());
   }
 }
 
 namespace {
 
 // Returns a vector with the n evenly-spaced numbers a, a + (b - a)/(n - 1),
 // ..., b.
 std::vector<float> IntervalSteps(float a, float b, size_t n) {
@@ skipping 193 matching lines @@
   int packet_rate = rtc::CheckedDivExact(48000, kDefaultOpusSettings.pacsize);
   EXPECT_EQ(kTargetBitrateBps -
                 8 * static_cast<int>(kOverheadBytesPerPacket) * packet_rate,
             states.encoder->GetTargetBitrate());
 }
 
 TEST(AudioEncoderOpusTest, BitrateBounded) {
   test::ScopedFieldTrials override_field_trials(
       "WebRTC-SendSideBwe-WithOverhead/Enabled/");
 
-  constexpr int kMinBitrateBps = 500;
+  constexpr int kMinBitrateBps = 6000;
   constexpr int kMaxBitrateBps = 512000;
 
   auto states = CreateCodec(2);
 
   constexpr size_t kOverheadBytesPerPacket = 64;
   states.encoder->OnReceivedOverhead(kOverheadBytesPerPacket);
 
   int packet_rate = rtc::CheckedDivExact(48000, kDefaultOpusSettings.pacsize);
 
   // Set a target rate that is smaller than |kMinBitrateBps| when overhead is
@@ skipping 80 matching lines @@
     // Update when it is time to update.
     EXPECT_CALL(*states.mock_bitrate_smoother, GetAverage())
         .WillOnce(Return(rtc::Optional<float>(40000)));
     EXPECT_CALL(**states.mock_audio_network_adaptor, SetUplinkBandwidth(40000));
     fake_clock.AdvanceTime(rtc::TimeDelta::FromMilliseconds(1));
     states.encoder->Encode(
         0, rtc::ArrayView<const int16_t>(audio.data(), audio.size()), &encoded);
   }
 }
 
+TEST(AudioEncoderOpusTest, EncodeAtMinBitrate) {
+  auto states = CreateCodec(1);
+  constexpr int kNumPacketsToEncode = 2;
+  auto audio_frames =
+      Create10msAudioBlocks(states.encoder, kNumPacketsToEncode * 20);
+  rtc::Buffer encoded;
+  uint32_t rtp_timestamp = 12345;  // Just a number not important to this test.
+
+  states.encoder->OnReceivedUplinkBandwidth(0, rtc::Optional<int64_t>());
+  for (int packet_index = 0; packet_index < kNumPacketsToEncode;
+       packet_index++) {
+    // Make sure we are not encoding before we have enough data for
+    // a 20ms packet.
+    for (int index = 0; index < 1; index++) {
+      states.encoder->Encode(rtp_timestamp, audio_frames->GetNextBlock(),
+                             &encoded);
+      EXPECT_EQ(0u, encoded.size());
+    }
+
+    // Should encode now.
+    states.encoder->Encode(rtp_timestamp, audio_frames->GetNextBlock(),
+                           &encoded);
+    EXPECT_GT(encoded.size(), 0u);
+    encoded.Clear();
+  }
+}
+
 }  // namespace webrtc