Revert of Prevent Opus DTX from generating intermittent noise during silence

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.
  */
 #include <string>
@@ skipping 18 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 TestDtxEffect(bool dtx);
 
   // 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(int channel, int block_length_ms, int loop_length_ms);
 
   int EncodeDecode(WebRtcOpusEncInst* encoder,
                    rtc::ArrayView<const int16_t> input_audio,
                    WebRtcOpusDecInst* decoder,
                    int16_t* output_audio,
                    int16_t* audio_type);
 
   void SetMaxPlaybackRate(WebRtcOpusEncInst* encoder,
                           opus_int32 expect, int32_t set);
 
-  void CheckAudioBounded(const int16_t* audio, size_t samples, int channels,
-                         uint16_t bound) const;
-
   WebRtcOpusEncInst* opus_encoder_;
   WebRtcOpusDecInst* opus_decoder_;
 
   AudioLoop speech_data_;
   uint8_t bitstream_[kMaxBytes];
   size_t encoded_bytes_;
   int channels_;
   int application_;
 };
 
@@ skipping 22 matching lines @@
 void OpusTest::SetMaxPlaybackRate(WebRtcOpusEncInst* encoder,
                                   opus_int32 expect,
                                   int32_t set) {
   opus_int32 bandwidth;
   EXPECT_EQ(0, WebRtcOpus_SetMaxPlaybackRate(opus_encoder_, set));
   opus_encoder_ctl(opus_encoder_->encoder,
                    OPUS_GET_MAX_BANDWIDTH(&bandwidth));
   EXPECT_EQ(expect, bandwidth);
 }
 
-void OpusTest::CheckAudioBounded(const int16_t* audio, size_t samples,
-                                 int channels, uint16_t bound) const {
-  for (size_t i = 0; i < samples; ++i) {
-    for (int c = 0; c < channels; ++c) {
-      ASSERT_GE(audio[i * channels + c], -bound);
-      ASSERT_LE(audio[i * channels + c], bound);
-    }
-  }
-}
-
 int OpusTest::EncodeDecode(WebRtcOpusEncInst* encoder,
                            rtc::ArrayView<const int16_t> input_audio,
                            WebRtcOpusDecInst* decoder,
                            int16_t* output_audio,
                            int16_t* audio_type) {
   int encoded_bytes_int = WebRtcOpus_Encode(
       encoder, input_audio.data(),
       rtc::CheckedDivExact(input_audio.size(), static_cast<size_t>(channels_)),
       kMaxBytes, bitstream_);
   EXPECT_GE(encoded_bytes_int, 0);
   encoded_bytes_ = static_cast<size_t>(encoded_bytes_int);
   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) {
-  PrepareSpeechData(channels_, block_length_ms, 2000);
-  const size_t samples = kOpusRateKhz * block_length_ms;
+void OpusTest::TestDtxEffect(bool dtx) {
+  PrepareSpeechData(channels_, 20, 2000);
 
   // 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);
+  std::vector<int16_t> silence(kOpus20msFrameSamples * channels_, 0);
 
   // Setting DTX.
   EXPECT_EQ(0, dtx ? WebRtcOpus_EnableDtx(opus_encoder_) :
       WebRtcOpus_DisableDtx(opus_encoder_));
 
   int16_t audio_type;
-  int16_t* output_data_decode = new int16_t[samples * channels_];
+  int16_t* output_data_decode = new int16_t[kOpus20msFrameSamples * channels_];
 
   for (int i = 0; i < 100; ++i) {
-    EXPECT_EQ(samples,
+    EXPECT_EQ(kOpus20msFrameSamples,
               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.
     }
   }
 
   // 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)));
+    EXPECT_EQ(kOpus20msFrameSamples, static_cast<size_t>(EncodeDecode(
+                                         opus_encoder_, silence, opus_decoder_,
+                                         output_data_decode, &audio_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.
     } else if (encoded_bytes_ == 1) {
       EXPECT_EQ(1, opus_encoder_->in_dtx_mode);
       EXPECT_EQ(1, opus_decoder_->in_dtx_mode);
       EXPECT_EQ(2, audio_type);  // Comfort noise.
       break;
     }
   }
 
   // When Opus is in DTX, it wakes up in a regular basis. It sends two packets,
   // one with an arbitrary size and the other of 1-byte, then stops sending for
-  // a certain number of frames.
-
-  // |max_dtx_frames| is the maximum number of frames Opus can stay in DTX.
-  const int max_dtx_frames = 400 / block_length_ms + 1;
-
-  // We run |kRunTimeMs| milliseconds of pure silence.
-  const int kRunTimeMs = 2000;
-
-  // We check that, after a |kCheckTimeMs| milliseconds (given that the CNG in
-  // Opus needs time to adapt), the absolute values of DTX decoded signal are
-  // bounded by |kOutputValueBound|.
-  const int kCheckTimeMs = 1500;
-
-#if defined(OPUS_FIXED_POINT)
-  const uint16_t kOutputValueBound = 20;
-#else
-  const uint16_t kOutputValueBound = 2;
-#endif
-
-  int time = 0;
-  while (time < kRunTimeMs) {
-    // DTX mode is maintained for maximum |max_dtx_frames| frames.
-    int i = 0;
-    for (; i < max_dtx_frames; ++i) {
-      time += block_length_ms;
-      EXPECT_EQ(samples,
-                static_cast<size_t>(EncodeDecode(
-                    opus_encoder_, silence, opus_decoder_, output_data_decode,
-                    &audio_type)));
+  // 19 frames.
+  const int cycles = 5;
+  for (int j = 0; j < cycles; ++j) {
+    // DTX mode is maintained 19 frames.
+    for (int i = 0; i < 19; ++i) {
+      EXPECT_EQ(kOpus20msFrameSamples,
+                static_cast<size_t>(
+                    EncodeDecode(opus_encoder_, silence, opus_decoder_,
+                                 output_data_decode, &audio_type)));
       if (dtx) {
-        if (encoded_bytes_ > 1)
-          break;
         EXPECT_EQ(0U, encoded_bytes_)  // Send 0 byte.
             << "Opus should have entered DTX mode.";
         EXPECT_EQ(1, opus_encoder_->in_dtx_mode);
         EXPECT_EQ(1, opus_decoder_->in_dtx_mode);
         EXPECT_EQ(2, audio_type);  // Comfort noise.
-        if (time >= kCheckTimeMs) {
-          CheckAudioBounded(output_data_decode, samples, channels_,
-                            kOutputValueBound);
-        }
       } else {
         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 (dtx) {
-      // With DTX, Opus must stop transmission for some time.
-      EXPECT_GT(i, 1);
-    }
+    // Quit DTX after 19 frames.
+    EXPECT_EQ(kOpus20msFrameSamples, static_cast<size_t>(EncodeDecode(
+                                         opus_encoder_, silence, opus_decoder_,
+                                         output_data_decode, &audio_type)));
 
-    // We expect a normal payload.
+    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.
 
     // Enters DTX again immediately.
-    time += block_length_ms;
-    EXPECT_EQ(samples,
-              static_cast<size_t>(EncodeDecode(
-                  opus_encoder_, silence, opus_decoder_, output_data_decode,
-                  &audio_type)));
+    EXPECT_EQ(kOpus20msFrameSamples, static_cast<size_t>(EncodeDecode(
+                                         opus_encoder_, silence, opus_decoder_,
+                                         output_data_decode, &audio_type)));
     if (dtx) {
       EXPECT_EQ(1U, encoded_bytes_);  // Send 1 byte.
       EXPECT_EQ(1, opus_encoder_->in_dtx_mode);
       EXPECT_EQ(1, opus_decoder_->in_dtx_mode);
       EXPECT_EQ(2, audio_type);  // Comfort noise.
-      if (time >= kCheckTimeMs) {
-        CheckAudioBounded(output_data_decode, samples, channels_,
-                          kOutputValueBound);
-      }
     } else {
       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.
     }
   }
 
   silence[0] = 10000;
   if (dtx) {
     // Verify that encoder/decoder can jump out from DTX mode.
-    EXPECT_EQ(samples,
-              static_cast<size_t>(EncodeDecode(
-                  opus_encoder_, silence, opus_decoder_, output_data_decode,
-                  &audio_type)));
+    EXPECT_EQ(kOpus20msFrameSamples, static_cast<size_t>(EncodeDecode(
+                                         opus_encoder_, silence, opus_decoder_,
+                                         output_data_decode, &audio_type)));
     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.
   }
 
   // Free memory.
   delete[] output_data_decode;
   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_encoder_));
   EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_decoder_));
@@ skipping 185 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);
+  TestDtxEffect(false);
 }
 
 TEST_P(OpusTest, OpusDtxOn) {
-  TestDtxEffect(true, 10);
-  TestDtxEffect(true, 20);
-  TestDtxEffect(true, 40);
+  TestDtxEffect(true);
 }
 
 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_));
@@ skipping 159 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