Adding cbr support for Opus

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

 /*
  *  Copyright (c) 2013 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 20 matching lines @@
 const size_t kOpusRateKhz = 48;
 // Number of samples-per-channel in a 20 ms frame, sampled at 48 kHz.
 const size_t kOpus20msFrameSamples = kOpusRateKhz * 20;
 // Number of samples-per-channel in a 10 ms frame, sampled at 48 kHz.
 const size_t kOpus10msFrameSamples = kOpusRateKhz * 10;
 
 class OpusTest : public TestWithParam<::testing::tuple<int, int>> {
  protected:
   OpusTest();
 
-  void TestDtxEffect(bool dtx, int block_length_ms);
+  void TestDtxAndCbrEffect(bool dtx, bool cbr, int block_length_ms);

[minyue-webrtc, 2017/03/31 18:37:43]

Merging DTX and CBR into this function isn't good. as you have seen, the test
fails if I call it with (true, true).

I see that my suggestion make it bad. My apologies. The common part of Dtx test
and Cbr test is only just a small portion. Maybe one or two helper functions are
enough. What you had in your last patch set was also good. Do you mind revert
this file back to last patch set. But good to use vector instead of raw pointer
on |output_data_decode|

 
   // Prepare |speech_data_| for encoding, read from a hard-coded file.
   // After preparation, |speech_data_.GetNextBlock()| returns a pointer to a
   // block of |block_length_ms| milliseconds. The data is looped every
   // |loop_length_ms| milliseconds.
   void PrepareSpeechData(size_t channel,
                          int block_length_ms,
                          int loop_length_ms);
 
   int EncodeDecode(WebRtcOpusEncInst* encoder,
@@ skipping 74 matching lines @@
   int est_len = WebRtcOpus_DurationEst(decoder, bitstream_, encoded_bytes_);
   int act_len = WebRtcOpus_Decode(decoder, bitstream_,
                                   encoded_bytes_, output_audio,
                                   audio_type);
   EXPECT_EQ(est_len, act_len);
   return act_len;
 }
 
 // Test if encoder/decoder can enter DTX mode properly and do not enter DTX when
 // they should not. This test is signal dependent.
-void OpusTest::TestDtxEffect(bool dtx, int block_length_ms) {
+void OpusTest::TestDtxAndCbrEffect(bool dtx, bool cbr, int block_length_ms) {
   PrepareSpeechData(channels_, block_length_ms, 2000);
   const size_t samples = kOpusRateKhz * block_length_ms;
+  int32_t max_pkt_size_diff = 0;
+  int32_t prev_pkt_size = 0;
 
   // Create encoder memory.
   EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_encoder_,
                                         channels_,
                                         application_));
   EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_decoder_, channels_));
 
   // Set bitrate.
   EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_encoder_,
                                      channels_ == 1 ? 32000 : 64000));
 
   // Set input audio as silence.
   std::vector<int16_t> silence(samples * channels_, 0);
 
   // Setting DTX.
   EXPECT_EQ(0, dtx ? WebRtcOpus_EnableDtx(opus_encoder_) :
       WebRtcOpus_DisableDtx(opus_encoder_));
 
+  // Setting CBR.
+  EXPECT_EQ(0, cbr ? WebRtcOpus_EnableCbr(opus_encoder_)
+                   : WebRtcOpus_DisableCbr(opus_encoder_));
+
   int16_t audio_type;
   int16_t* output_data_decode = new int16_t[samples * channels_];
 
   for (int i = 0; i < 100; ++i) {
     EXPECT_EQ(samples,
               static_cast<size_t>(EncodeDecode(
                   opus_encoder_, speech_data_.GetNextBlock(), opus_decoder_,
                   output_data_decode, &audio_type)));
     // If not DTX, it should never enter DTX mode. If DTX, we do not care since
     // whether it enters DTX depends on the signal type.
     if (!dtx) {
       EXPECT_GT(encoded_bytes_, 1U);
       EXPECT_EQ(0, opus_encoder_->in_dtx_mode);
       EXPECT_EQ(0, opus_decoder_->in_dtx_mode);
       EXPECT_EQ(0, audio_type);  // Speech.
     }
+    if (!opus_encoder_->in_dtx_mode) {
+      if (prev_pkt_size > 0) {
+        int32_t diff = std::abs((int32_t)encoded_bytes_ - prev_pkt_size);
+        max_pkt_size_diff = std::max(max_pkt_size_diff, diff);
+      }
+      prev_pkt_size = encoded_bytes_;
+    }
+  }
+
+  if (cbr) {
+    EXPECT_EQ(max_pkt_size_diff, 0);
+  } else {
+    EXPECT_GT(max_pkt_size_diff, 0);
   }
 
   // We input some silent segments. In DTX mode, the encoder will stop sending.
   // However, DTX may happen after a while.
   for (int i = 0; i < 30; ++i) {
     EXPECT_EQ(samples,
               static_cast<size_t>(EncodeDecode(
                   opus_encoder_, silence, opus_decoder_, output_data_decode,
                   &audio_type)));
     if (!dtx) {
@@ skipping 324 matching lines @@
   opus_encoder_ctl(opus_encoder_->encoder,
                    OPUS_GET_DTX(&dtx));
   EXPECT_EQ(0, dtx);
 
 
   // Free memory.
   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_encoder_));
 }
 
 TEST_P(OpusTest, OpusDtxOff) {
-  TestDtxEffect(false, 10);
-  TestDtxEffect(false, 20);
-  TestDtxEffect(false, 40);
+  TestDtxAndCbrEffect(false, false, 10);
+  TestDtxAndCbrEffect(false, false, 20);
+  TestDtxAndCbrEffect(false, false, 40);
 }
 
 TEST_P(OpusTest, OpusDtxOn) {
-  TestDtxEffect(true, 10);
-  TestDtxEffect(true, 20);
-  TestDtxEffect(true, 40);
+  TestDtxAndCbrEffect(true, false, 10);
+  TestDtxAndCbrEffect(true, false, 20);
+  TestDtxAndCbrEffect(true, false, 40);
 }
 
+TEST_P(OpusTest, OpusCbrOn) {
+  TestDtxAndCbrEffect(false, true, 10);
+  TestDtxAndCbrEffect(false, true, 20);
+  TestDtxAndCbrEffect(false, true, 40);
+}
+
+#if 0  // The DTX part fails when both dtx and cbr is on
+TEST_P(OpusTest, OpusDtxOnCbrOn) {
+  TestDtxAndCbrEffect(true, true, 10);
+  TestDtxAndCbrEffect(true, true, 20);
+  TestDtxAndCbrEffect(true, true, 40);
+}
+#endif
+
 TEST_P(OpusTest, OpusSetPacketLossRate) {
   // Test without creating encoder memory.
   EXPECT_EQ(-1, WebRtcOpus_SetPacketLossRate(opus_encoder_, 50));
 
   // Create encoder memory.
   EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_encoder_,
                                         channels_,
                                         application_));
 
   EXPECT_EQ(0, WebRtcOpus_SetPacketLossRate(opus_encoder_, 50));
@@ skipping 155 matching lines @@
   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_encoder_));
   EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_decoder_));
 }
 
 INSTANTIATE_TEST_CASE_P(VariousMode,
                         OpusTest,
                         Combine(Values(1, 2), Values(0, 1)));
 
 
 }  // namespace webrtc