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 35 matching lines @@
   int EncodeDecode(WebRtcOpusEncInst* encoder,
                    const int16_t* input_audio,
                    size_t input_samples,
                    WebRtcOpusDecInst* decoder,
                    int16_t* output_audio,
                    int16_t* audio_type);
 
   void SetMaxPlaybackRate(WebRtcOpusEncInst* encoder,
                           opus_int32 expect, int32_t set);
 
+  // Verify that all samples in |audio| are bounded in [-|bound|, |bound|].
+  void CheckAudioBounded(int16_t* audio, size_t samples, int channels,
+                         uint16_t bound);
+
   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(int16_t* audio, size_t samples, int channels,
+                                 uint16_t bound) {
+  for (size_t i = 0; i < samples; ++i) {
+    for (int c = 0; c < channels; ++c, ++audio) {
+      EXPECT_GE(*audio, -bound);
+      EXPECT_LE(*audio, bound);
+    }
+  }
+}
+
 int OpusTest::EncodeDecode(WebRtcOpusEncInst* encoder,
                            const int16_t* input_audio,
                            size_t input_samples,
                            WebRtcOpusDecInst* decoder,
                            int16_t* output_audio,
                            int16_t* audio_type) {
   int encoded_bytes_int = WebRtcOpus_Encode(encoder, input_audio, input_samples,
                                             kMaxBytes, bitstream_);
   EXPECT_GE(encoded_bytes_int, 0);
   encoded_bytes_ = static_cast<size_t>(encoded_bytes_int);
@@ skipping 62 matching lines @@
     } 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
-  // 19 frames.
-  const int cycles = 5;
-  for (int j = 0; j < cycles; ++j) {
+  // 19 frames. We run 10 second of pure silence, which is about 25 cycles
+  // (420 ms/cycle).
+  const int kCycles = 24;
+
+  // We check that, after a certain cycles (given that the CNG in Opus needs
+  // time to adapt), the values of DTX decoded signal are bounded by [-1, 1].
+  const int kOutputValueCheckCycle = 18;
+  const uint16_t kOutputValueBound = 1;
+
+  for (int j = 0; j < kCycles; ++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, kOpus20msFrameSamples,
                     opus_decoder_, output_data_decode, &audio_type)));
       if (dtx) {
         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 (j >= kOutputValueCheckCycle) {
+          CheckAudioBounded(output_data_decode, kOpus20msFrameSamples,
+                            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.
       }
     }
 
     // Quit DTX after 19 frames.
     EXPECT_EQ(kOpus20msFrameSamples,
               static_cast<size_t>(EncodeDecode(
                   opus_encoder_, silence, kOpus20msFrameSamples, 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.
 
     // Enters DTX again immediately.
     EXPECT_EQ(kOpus20msFrameSamples,
               static_cast<size_t>(EncodeDecode(
                   opus_encoder_, silence, kOpus20msFrameSamples, 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 (j >= kOutputValueCheckCycle) {
+        CheckAudioBounded(output_data_decode, kOpus20msFrameSamples,
+                          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) {
@@ skipping 383 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