Adding bit exactness test for Opus decoding in NetEq.

webrtc/modules/audio_coding/neteq/neteq_unittest.cc

 /*
  *  Copyright (c) 2011 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 211 matching lines @@
   ASSERT_EQ(stats.preferred_buffer_size_ms,
             ref_stats.preferred_buffer_size_ms());
   ASSERT_EQ(stats.jitter_peaks_found, ref_stats.jitter_peaks_found());
   ASSERT_EQ(stats.packet_loss_rate, ref_stats.packet_loss_rate());
   ASSERT_EQ(stats.packet_discard_rate, ref_stats.packet_discard_rate());
   ASSERT_EQ(stats.expand_rate, ref_stats.expand_rate());
   ASSERT_EQ(stats.preemptive_rate, ref_stats.preemptive_rate());
   ASSERT_EQ(stats.accelerate_rate, ref_stats.accelerate_rate());
   ASSERT_EQ(stats.clockdrift_ppm, ref_stats.clockdrift_ppm());
   ASSERT_EQ(stats.added_zero_samples, ref_stats.added_zero_samples());
-  ASSERT_EQ(stats.secondary_decoded_rate, 0);
+  ASSERT_EQ(stats.secondary_decoded_rate, ref_stats.secondary_decoded_rate());
   ASSERT_LE(stats.speech_expand_rate, ref_stats.expand_rate());
 #else
   FAIL() << "Reading from reference file requires Proto Buffer.";
 #endif  // WEBRTC_NETEQ_UNITTEST_BITEXACT
 }
 
 void RefFiles::WriteToFile(const RtcpStatistics& stats_raw) {
 #ifdef WEBRTC_NETEQ_UNITTEST_BITEXACT
   if (!output_fp_)
     return;
@@ skipping 29 matching lines @@
 }
 
 class NetEqDecodingTest : public ::testing::Test {
  protected:
   // NetEQ must be polled for data once every 10 ms. Thus, neither of the
   // constants below can be changed.
   static const int kTimeStepMs = 10;
   static const size_t kBlockSize8kHz = kTimeStepMs * 8;
   static const size_t kBlockSize16kHz = kTimeStepMs * 16;
   static const size_t kBlockSize32kHz = kTimeStepMs * 32;
-  static const size_t kMaxBlockSize = kBlockSize32kHz;
+  static const size_t kBlockSize48kHz = kTimeStepMs * 48;
+  static const size_t kMaxBlockSize = kBlockSize48kHz;
   static const int kInitSampleRateHz = 8000;
 
   NetEqDecodingTest();
   virtual void SetUp();
   virtual void TearDown();
   void SelectDecoders(NetEqDecoder* used_codec);
   void LoadDecoders();
   void OpenInputFile(const std::string &rtp_file);
   void Process(size_t* out_len);
 
@@ skipping 81 matching lines @@
 #if defined(WEBRTC_CODEC_ISAC) || defined(WEBRTC_CODEC_ISACFX)
   // Load iSAC.
   ASSERT_EQ(
       0, neteq_->RegisterPayloadType(NetEqDecoder::kDecoderISAC, "isac", 103));
 #endif
 #ifdef WEBRTC_CODEC_ISAC
   // Load iSAC SWB.
   ASSERT_EQ(0, neteq_->RegisterPayloadType(NetEqDecoder::kDecoderISACswb,
                                            "isac-swb", 104));
 #endif
+#ifdef WEBRTC_CODEC_OPUS
+  ASSERT_EQ(0, neteq_->RegisterPayloadType(NetEqDecoder::kDecoderOpus,
+                                           "opus", 111));
+#endif
   // Load PCM16B nb.
   ASSERT_EQ(0, neteq_->RegisterPayloadType(NetEqDecoder::kDecoderPCM16B,
                                            "pcm16-nb", 93));
   // Load PCM16B wb.
   ASSERT_EQ(0, neteq_->RegisterPayloadType(NetEqDecoder::kDecoderPCM16Bwb,
                                            "pcm16-wb", 94));
   // Load PCM16B swb32.
   ASSERT_EQ(0, neteq_->RegisterPayloadType(NetEqDecoder::kDecoderPCM16Bswb32kHz,
                                            "pcm16-swb32", 95));
   // Load CNG 8 kHz.
@@ skipping 25 matching lines @@
     packet_.reset(rtp_source_->NextPacket());
   }
 
   // Get audio from NetEq.
   NetEqOutputType type;
   int num_channels;
   ASSERT_EQ(0, neteq_->GetAudio(kMaxBlockSize, out_data_, out_len,
                                 &num_channels, &type));
   ASSERT_TRUE((*out_len == kBlockSize8kHz) ||
               (*out_len == kBlockSize16kHz) ||
-              (*out_len == kBlockSize32kHz));
+              (*out_len == kBlockSize32kHz) ||
+              (*out_len == kBlockSize48kHz));
   output_sample_rate_ = static_cast<int>(*out_len / 10 * 1000);
   EXPECT_EQ(output_sample_rate_, neteq_->last_output_sample_rate_hz());
 
   // Increase time.
   sim_clock_ += kTimeStepMs;
 }
 
 void NetEqDecodingTest::DecodeAndCompare(const std::string& rtp_file,
                                          const std::string& ref_file,
                                          const std::string& stat_ref_file,
@@ skipping 64 matching lines @@
   rtp_info->header.sequenceNumber = frame_index;
   rtp_info->header.timestamp = timestamp;
   rtp_info->header.ssrc = 0x1234;  // Just an arbitrary SSRC.
   rtp_info->header.payloadType = 98;  // WB CNG.
   rtp_info->header.markerBit = 0;
   payload[0] = 64;  // Noise level -64 dBov, quite arbitrarily chosen.
   *payload_len = 1;  // Only noise level, no spectral parameters.
 }
 
 #if !defined(WEBRTC_IOS) && !defined(WEBRTC_ANDROID) &&             \
-     defined(WEBRTC_NETEQ_UNITTEST_BITEXACT) &&                     \
+    defined(WEBRTC_NETEQ_UNITTEST_BITEXACT) &&                      \
     (defined(WEBRTC_CODEC_ISAC) || defined(WEBRTC_CODEC_ISACFX)) && \
     defined(WEBRTC_CODEC_ILBC) && defined(WEBRTC_CODEC_G722)
 #define MAYBE_TestBitExactness TestBitExactness
 #else
 #define MAYBE_TestBitExactness DISABLED_TestBitExactness
 #endif
 TEST_F(NetEqDecodingTest, MAYBE_TestBitExactness) {
   const std::string input_rtp_file = webrtc::test::ProjectRootPath() +
       "resources/audio_coding/neteq_universal_new.rtp";
   // Note that neteq4_universal_ref.pcm and neteq4_universal_ref_win_32.pcm
@@ skipping 16 matching lines @@
   if (FLAGS_gen_ref) {
     DecodeAndCompare(input_rtp_file, "", "", "");
   } else {
     DecodeAndCompare(input_rtp_file,
                      input_ref_file,
                      network_stat_ref_file,
                      rtcp_stat_ref_file);
   }
 }
 
+#if !defined(WEBRTC_IOS) && !defined(WEBRTC_ANDROID) &&             \
+    defined(WEBRTC_NETEQ_UNITTEST_BITEXACT) &&                      \
+    defined(WEBRTC_CODEC_OPUS)
+#define MAYBE_TestOpusBitExactness TestOpusBitExactness
+#else
+#define MAYBE_TestOpusBitExactness DISABLED_TestOpusBitExactness
+#endif
+TEST_F(NetEqDecodingTest, MAYBE_TestOpusBitExactness) {
+  const std::string input_rtp_file =
+      webrtc::test::ResourcePath("audio_coding/neteq_opus", "rtp");
+  const std::string input_ref_file =
+      webrtc::test::ResourcePath("audio_coding/neteq4_opus_ref", "pcm");
+  const std::string network_stat_ref_file =
+      webrtc::test::ResourcePath("audio_coding/neteq4_opus_network_stats",
+                                 "dat");
+  const std::string rtcp_stat_ref_file =
+      webrtc::test::ResourcePath("audio_coding/neteq4_opus_rtcp_stats", "dat");
+
+  if (FLAGS_gen_ref) {
+    DecodeAndCompare(input_rtp_file, "", "", "");
+  } else {
+    DecodeAndCompare(input_rtp_file,
+                     input_ref_file,
+                     network_stat_ref_file,
+                     rtcp_stat_ref_file);
+  }
+}
+
 // Use fax mode to avoid time-scaling. This is to simplify the testing of
 // packet waiting times in the packet buffer.
 class NetEqDecodingTestFaxMode : public NetEqDecodingTest {
  protected:
   NetEqDecodingTestFaxMode() : NetEqDecodingTest() {
     config_.playout_mode = kPlayoutFax;
   }
 };
 
 TEST_F(NetEqDecodingTestFaxMode, TestFrameWaitingTimeStatistics) {
@@ skipping 1042 matching lines @@
     // Pull audio once.
     ASSERT_EQ(0, neteq_->GetAudio(kMaxBlockSize, out_data_, &out_len,
                                   &num_channels, &type));
     ASSERT_EQ(kBlockSize16kHz, out_len);
   }
   // Verify speech output.
   EXPECT_EQ(kOutputNormal, type);
 }
 
 }  // namespace webrtc