src/third_party/webrtc/modules/audio_coding/neteq/audio_decoder_unittest.cc

   1 /*
   2  *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
   3  *
   4  *  Use of this source code is governed by a BSD-style license
   5  *  that can be found in the LICENSE file in the root of the source
   6  *  tree. An additional intellectual property rights grant can be found
   7  *  in the file PATENTS.  All contributing project authors may
   8  *  be found in the AUTHORS file in the root of the source tree.
   9  */
  10
  11 #include "webrtc/modules/audio_coding/neteq/audio_decoder_impl.h"
  12
  13 #include <assert.h>
  14 #include <stdlib.h>
  15
  16 #include <string>
  17
  18 #include "testing/gtest/include/gtest/gtest.h"
  19 #include "webrtc/common_audio/resampler/include/resampler.h"
  20 #ifdef WEBRTC_CODEC_CELT
  21 #include "webrtc/modules/audio_coding/codecs/celt/include/celt_interface.h"
  22 #endif
  23 #include "webrtc/modules/audio_coding/codecs/g711/include/g711_interface.h"
  24 #include "webrtc/modules/audio_coding/codecs/g722/include/g722_interface.h"
  25 #include "webrtc/modules/audio_coding/codecs/ilbc/interface/ilbc.h"
  26 #include "webrtc/modules/audio_coding/codecs/isac/fix/interface/isacfix.h"
  27 #include "webrtc/modules/audio_coding/codecs/isac/main/interface/isac.h"
  28 #include "webrtc/modules/audio_coding/codecs/opus/interface/opus_interface.h"
  29 #include "webrtc/modules/audio_coding/codecs/pcm16b/include/pcm16b.h"
  30 #include "webrtc/system_wrappers/interface/data_log.h"
  31 #include "webrtc/test/testsupport/fileutils.h"
  32
  33 namespace webrtc {
  34
  35 class AudioDecoderTest : public ::testing::Test {
  36  protected:
  37   AudioDecoderTest()
  38     : input_fp_(NULL),
  39       input_(NULL),
  40       encoded_(NULL),
  41       decoded_(NULL),
  42       frame_size_(0),
  43       data_length_(0),
  44       encoded_bytes_(0),
  45       channels_(1),
  46       decoder_(NULL) {
  47     input_file_ = webrtc::test::ProjectRootPath() +
  48         "resources/audio_coding/testfile32kHz.pcm";
  49   }
  50
  51   virtual ~AudioDecoderTest() {}
  52
  53   virtual void SetUp() {
  54     // Create arrays.
  55     ASSERT_GT(data_length_, 0u) << "The test must set data_length_ > 0";
  56     input_ = new int16_t[data_length_];
  57     // Longest encoded data is produced by PCM16b with 2 bytes per sample.
  58     encoded_ = new uint8_t[data_length_ * 2];
  59     decoded_ = new int16_t[data_length_ * channels_];
  60     // Open input file.
  61     input_fp_ = fopen(input_file_.c_str(), "rb");
  62     ASSERT_TRUE(input_fp_ != NULL) << "Failed to open file " << input_file_;
  63     // Read data to |input_|.
  64     ASSERT_EQ(data_length_,
  65               fread(input_, sizeof(int16_t), data_length_, input_fp_)) <<
  66                   "Could not read enough data from file";
  67     // Logging to view input and output in Matlab.
  68     // Use 'gyp -Denable_data_logging=1' to enable logging.
  69     DataLog::CreateLog();
  70     DataLog::AddTable("CodecTest");
  71     DataLog::AddColumn("CodecTest", "input", 1);
  72     DataLog::AddColumn("CodecTest", "output", 1);
  73   }
  74
  75   virtual void TearDown() {
  76     delete decoder_;
  77     decoder_ = NULL;
  78     // Close input file.
  79     fclose(input_fp_);
  80     // Delete arrays.
  81     delete [] input_;
  82     input_ = NULL;
  83     delete [] encoded_;
  84     encoded_ = NULL;
  85     delete [] decoded_;
  86     decoded_ = NULL;
  87     // Close log.
  88     DataLog::ReturnLog();
  89   }
  90
  91   virtual void InitEncoder() { }
  92
  93   // This method must be implemented for all tests derived from this class.
  94   virtual int EncodeFrame(const int16_t* input, size_t input_len,
  95                           uint8_t* output) = 0;
  96
  97   // Encodes and decodes audio. The absolute difference between the input and
  98   // output is compared vs |tolerance|, and the mean-squared error is compared
  99   // with |mse|. The encoded stream should contain |expected_bytes|. For stereo
 100   // audio, the absolute difference between the two channels is compared vs
 101   // |channel_diff_tolerance|.
 102   void EncodeDecodeTest(size_t expected_bytes, int tolerance, double mse,
 103                         int delay = 0, int channel_diff_tolerance = 0) {
 104     ASSERT_GE(tolerance, 0) << "Test must define a tolerance >= 0";
 105     ASSERT_GE(channel_diff_tolerance, 0) <<
 106         "Test must define a channel_diff_tolerance >= 0";
 107     size_t processed_samples = 0u;
 108     encoded_bytes_ = 0u;
 109     InitEncoder();
 110     EXPECT_EQ(0, decoder_->Init());
 111     while (processed_samples + frame_size_ <= data_length_) {
 112       size_t enc_len = EncodeFrame(&input_[processed_samples], frame_size_,
 113                                    &encoded_[encoded_bytes_]);
 114       AudioDecoder::SpeechType speech_type;
 115       size_t dec_len = decoder_->Decode(&encoded_[encoded_bytes_], enc_len,
 116                                         &decoded_[processed_samples *
 117                                                   channels_],
 118                                         &speech_type);
 119       EXPECT_EQ(frame_size_ * channels_, dec_len);
 120       encoded_bytes_ += enc_len;
 121       processed_samples += frame_size_;
 122     }
 123     // For some codecs it doesn't make sense to check expected number of bytes,
 124     // since the number can vary for different platforms. Opus and iSAC are
 125     // such codecs. In this case expected_bytes is set to 0.
 126     if (expected_bytes) {
 127       EXPECT_EQ(expected_bytes, encoded_bytes_);
 128     }
 129     CompareInputOutput(processed_samples, tolerance, delay);
 130     if (channels_ == 2)
 131       CompareTwoChannels(processed_samples, channel_diff_tolerance);
 132     EXPECT_LE(MseInputOutput(processed_samples, delay), mse);
 133   }
 134
 135   // The absolute difference between the input and output (the first channel) is
 136   // compared vs |tolerance|. The parameter |delay| is used to correct for codec
 137   // delays.
 138   virtual void CompareInputOutput(size_t num_samples, int tolerance,
 139                                   int delay) const {
 140     assert(num_samples <= data_length_);
 141     for (unsigned int n = 0; n < num_samples - delay; ++n) {
 142       ASSERT_NEAR(input_[n], decoded_[channels_ * n + delay], tolerance) <<
 143           "Exit test on first diff; n = " << n;
 144       DataLog::InsertCell("CodecTest", "input", input_[n]);
 145       DataLog::InsertCell("CodecTest", "output", decoded_[channels_ * n]);
 146       DataLog::NextRow("CodecTest");
 147     }
 148   }
 149
 150   // The absolute difference between the two channels in a stereo is compared vs
 151   // |tolerance|.
 152   virtual void CompareTwoChannels(size_t samples_per_channel,
 153                                   int tolerance) const {
 154     assert(samples_per_channel <= data_length_);
 155     for (unsigned int n = 0; n < samples_per_channel; ++n)
 156       ASSERT_NEAR(decoded_[channels_ * n], decoded_[channels_ * n + 1],
 157                   tolerance) << "Stereo samples differ.";
 158   }
 159
 160   // Calculates mean-squared error between input and output (the first channel).
 161   // The parameter |delay| is used to correct for codec delays.
 162   virtual double MseInputOutput(size_t num_samples, int delay) const {
 163     assert(num_samples <= data_length_);
 164     if (num_samples == 0) return 0.0;
 165     double squared_sum = 0.0;
 166     for (unsigned int n = 0; n < num_samples - delay; ++n) {
 167       squared_sum += (input_[n] - decoded_[channels_ * n + delay]) *
 168           (input_[n] - decoded_[channels_ * n + delay]);
 169     }
 170     return squared_sum / (num_samples - delay);
 171   }
 172
 173   // Encodes a payload and decodes it twice with decoder re-init before each
 174   // decode. Verifies that the decoded result is the same.
 175   void ReInitTest() {
 176     int16_t* output1 = decoded_;
 177     int16_t* output2 = decoded_ + frame_size_;
 178     InitEncoder();
 179     size_t enc_len = EncodeFrame(input_, frame_size_, encoded_);
 180     size_t dec_len;
 181     AudioDecoder::SpeechType speech_type1, speech_type2;
 182     EXPECT_EQ(0, decoder_->Init());
 183     dec_len = decoder_->Decode(encoded_, enc_len, output1, &speech_type1);
 184     EXPECT_EQ(frame_size_ * channels_, dec_len);
 185     // Re-init decoder and decode again.
 186     EXPECT_EQ(0, decoder_->Init());
 187     dec_len = decoder_->Decode(encoded_, enc_len, output2, &speech_type2);
 188     EXPECT_EQ(frame_size_ * channels_, dec_len);
 189     for (unsigned int n = 0; n < frame_size_; ++n) {
 190       ASSERT_EQ(output1[n], output2[n]) << "Exit test on first diff; n = " << n;
 191     }
 192     EXPECT_EQ(speech_type1, speech_type2);
 193   }
 194
 195   // Call DecodePlc and verify that the correct number of samples is produced.
 196   void DecodePlcTest() {
 197     InitEncoder();
 198     size_t enc_len = EncodeFrame(input_, frame_size_, encoded_);
 199     AudioDecoder::SpeechType speech_type;
 200     EXPECT_EQ(0, decoder_->Init());
 201     size_t dec_len =
 202         decoder_->Decode(encoded_, enc_len, decoded_, &speech_type);
 203     EXPECT_EQ(frame_size_ * channels_, dec_len);
 204     // Call DecodePlc and verify that we get one frame of data.
 205     // (Overwrite the output from the above Decode call, but that does not
 206     // matter.)
 207     dec_len = decoder_->DecodePlc(1, decoded_);
 208     EXPECT_EQ(frame_size_ * channels_, dec_len);
 209   }
 210
 211   std::string input_file_;
 212   FILE* input_fp_;
 213   int16_t* input_;
 214   uint8_t* encoded_;
 215   int16_t* decoded_;
 216   size_t frame_size_;
 217   size_t data_length_;
 218   size_t encoded_bytes_;
 219   size_t channels_;
 220   AudioDecoder* decoder_;
 221 };
 222
 223 class AudioDecoderPcmUTest : public AudioDecoderTest {
 224  protected:
 225   AudioDecoderPcmUTest() : AudioDecoderTest() {
 226     frame_size_ = 160;
 227     data_length_ = 10 * frame_size_;
 228     decoder_ = new AudioDecoderPcmU;
 229     assert(decoder_);
 230   }
 231
 232   virtual int EncodeFrame(const int16_t* input, size_t input_len_samples,
 233                           uint8_t* output) {
 234     int enc_len_bytes =
 235         WebRtcG711_EncodeU(NULL, const_cast<int16_t*>(input),
 236                            static_cast<int>(input_len_samples),
 237                            reinterpret_cast<int16_t*>(output));
 238     EXPECT_EQ(input_len_samples, static_cast<size_t>(enc_len_bytes));
 239     return enc_len_bytes;
 240   }
 241 };
 242
 243 class AudioDecoderPcmATest : public AudioDecoderTest {
 244  protected:
 245   AudioDecoderPcmATest() : AudioDecoderTest() {
 246     frame_size_ = 160;
 247     data_length_ = 10 * frame_size_;
 248     decoder_ = new AudioDecoderPcmA;
 249     assert(decoder_);
 250   }
 251
 252   virtual int EncodeFrame(const int16_t* input, size_t input_len_samples,
 253                           uint8_t* output) {
 254     int enc_len_bytes =
 255         WebRtcG711_EncodeA(NULL, const_cast<int16_t*>(input),
 256                            static_cast<int>(input_len_samples),
 257                            reinterpret_cast<int16_t*>(output));
 258     EXPECT_EQ(input_len_samples, static_cast<size_t>(enc_len_bytes));
 259     return enc_len_bytes;
 260   }
 261 };
 262
 263 class AudioDecoderPcm16BTest : public AudioDecoderTest {
 264  protected:
 265   AudioDecoderPcm16BTest() : AudioDecoderTest() {
 266     frame_size_ = 160;
 267     data_length_ = 10 * frame_size_;
 268     decoder_ = new AudioDecoderPcm16B(kDecoderPCM16B);
 269     assert(decoder_);
 270   }
 271
 272   virtual int EncodeFrame(const int16_t* input, size_t input_len_samples,
 273                           uint8_t* output) {
 274     int enc_len_bytes = WebRtcPcm16b_EncodeW16(
 275         const_cast<int16_t*>(input), static_cast<int>(input_len_samples),
 276         reinterpret_cast<int16_t*>(output));
 277     EXPECT_EQ(2 * input_len_samples, static_cast<size_t>(enc_len_bytes));
 278     return enc_len_bytes;
 279   }
 280 };
 281
 282 class AudioDecoderIlbcTest : public AudioDecoderTest {
 283  protected:
 284   AudioDecoderIlbcTest() : AudioDecoderTest() {
 285     frame_size_ = 240;
 286     data_length_ = 10 * frame_size_;
 287     decoder_ = new AudioDecoderIlbc;
 288     assert(decoder_);
 289     WebRtcIlbcfix_EncoderCreate(&encoder_);
 290   }
 291
 292   ~AudioDecoderIlbcTest() {
 293     WebRtcIlbcfix_EncoderFree(encoder_);
 294   }
 295
 296   virtual void InitEncoder() {
 297     ASSERT_EQ(0, WebRtcIlbcfix_EncoderInit(encoder_, 30));  // 30 ms.
 298   }
 299
 300   virtual int EncodeFrame(const int16_t* input, size_t input_len_samples,
 301                           uint8_t* output) {
 302     int enc_len_bytes =
 303         WebRtcIlbcfix_Encode(encoder_, input,
 304                              static_cast<int>(input_len_samples),
 305                              reinterpret_cast<int16_t*>(output));
 306     EXPECT_EQ(50, enc_len_bytes);
 307     return enc_len_bytes;
 308   }
 309
 310   // Overload the default test since iLBC's function WebRtcIlbcfix_NetEqPlc does
 311   // not return any data. It simply resets a few states and returns 0.
 312   void DecodePlcTest() {
 313     InitEncoder();
 314     size_t enc_len = EncodeFrame(input_, frame_size_, encoded_);
 315     AudioDecoder::SpeechType speech_type;
 316     EXPECT_EQ(0, decoder_->Init());
 317     size_t dec_len =
 318         decoder_->Decode(encoded_, enc_len, decoded_, &speech_type);
 319     EXPECT_EQ(frame_size_, dec_len);
 320     // Simply call DecodePlc and verify that we get 0 as return value.
 321     EXPECT_EQ(0, decoder_->DecodePlc(1, decoded_));
 322   }
 323
 324   iLBC_encinst_t* encoder_;
 325 };
 326
 327 class AudioDecoderIsacFloatTest : public AudioDecoderTest {
 328  protected:
 329   AudioDecoderIsacFloatTest() : AudioDecoderTest() {
 330     input_size_ = 160;
 331     frame_size_ = 480;
 332     data_length_ = 10 * frame_size_;
 333     decoder_ = new AudioDecoderIsac;
 334     assert(decoder_);
 335     WebRtcIsac_Create(&encoder_);
 336     WebRtcIsac_SetEncSampRate(encoder_, 16000);
 337   }
 338
 339   ~AudioDecoderIsacFloatTest() {
 340     WebRtcIsac_Free(encoder_);
 341   }
 342
 343   virtual void InitEncoder() {
 344     ASSERT_EQ(0, WebRtcIsac_EncoderInit(encoder_, 1));  // Fixed mode.
 345     ASSERT_EQ(0, WebRtcIsac_Control(encoder_, 32000, 30));  // 32 kbps, 30 ms.
 346   }
 347
 348   virtual int EncodeFrame(const int16_t* input, size_t input_len_samples,
 349                           uint8_t* output) {
 350     // Insert 3 * 10 ms. Expect non-zero output on third call.
 351     EXPECT_EQ(0, WebRtcIsac_Encode(encoder_, input, output));
 352     input += input_size_;
 353     EXPECT_EQ(0, WebRtcIsac_Encode(encoder_, input, output));
 354     input += input_size_;
 355     int enc_len_bytes = WebRtcIsac_Encode(encoder_, input, output);
 356     EXPECT_GT(enc_len_bytes, 0);
 357     return enc_len_bytes;
 358   }
 359
 360   ISACStruct* encoder_;
 361   int input_size_;
 362 };
 363
 364 class AudioDecoderIsacSwbTest : public AudioDecoderTest {
 365  protected:
 366   AudioDecoderIsacSwbTest() : AudioDecoderTest() {
 367     input_size_ = 320;
 368     frame_size_ = 960;
 369     data_length_ = 10 * frame_size_;
 370     decoder_ = new AudioDecoderIsacSwb;
 371     assert(decoder_);
 372     WebRtcIsac_Create(&encoder_);
 373     WebRtcIsac_SetEncSampRate(encoder_, 32000);
 374   }
 375
 376   ~AudioDecoderIsacSwbTest() {
 377     WebRtcIsac_Free(encoder_);
 378   }
 379
 380   virtual void InitEncoder() {
 381     ASSERT_EQ(0, WebRtcIsac_EncoderInit(encoder_, 1));  // Fixed mode.
 382     ASSERT_EQ(0, WebRtcIsac_Control(encoder_, 32000, 30));  // 32 kbps, 30 ms.
 383   }
 384
 385   virtual int EncodeFrame(const int16_t* input, size_t input_len_samples,
 386                           uint8_t* output) {
 387     // Insert 3 * 10 ms. Expect non-zero output on third call.
 388     EXPECT_EQ(0, WebRtcIsac_Encode(encoder_, input, output));
 389     input += input_size_;
 390     EXPECT_EQ(0, WebRtcIsac_Encode(encoder_, input, output));
 391     input += input_size_;
 392     int enc_len_bytes = WebRtcIsac_Encode(encoder_, input, output);
 393     EXPECT_GT(enc_len_bytes, 0);
 394     return enc_len_bytes;
 395   }
 396
 397   ISACStruct* encoder_;
 398   int input_size_;
 399 };
 400
 401 // This test is identical to AudioDecoderIsacSwbTest, except that it creates
 402 // an AudioDecoderIsacFb decoder object.
 403 class AudioDecoderIsacFbTest : public AudioDecoderIsacSwbTest {
 404  protected:
 405   AudioDecoderIsacFbTest() : AudioDecoderIsacSwbTest() {
 406     // Delete the |decoder_| that was created by AudioDecoderIsacSwbTest and
 407     // create an AudioDecoderIsacFb object instead.
 408     delete decoder_;
 409     decoder_ = new AudioDecoderIsacFb;
 410     assert(decoder_);
 411   }
 412 };
 413
 414 class AudioDecoderIsacFixTest : public AudioDecoderTest {
 415  protected:
 416   AudioDecoderIsacFixTest() : AudioDecoderTest() {
 417     input_size_ = 160;
 418     frame_size_ = 480;
 419     data_length_ = 10 * frame_size_;
 420     decoder_ = new AudioDecoderIsacFix;
 421     assert(decoder_);
 422     WebRtcIsacfix_Create(&encoder_);
 423   }
 424
 425   ~AudioDecoderIsacFixTest() {
 426     WebRtcIsacfix_Free(encoder_);
 427   }
 428
 429   virtual void InitEncoder() {
 430     ASSERT_EQ(0, WebRtcIsacfix_EncoderInit(encoder_, 1));  // Fixed mode.
 431     ASSERT_EQ(0,
 432               WebRtcIsacfix_Control(encoder_, 32000, 30));  // 32 kbps, 30 ms.
 433   }
 434
 435   virtual int EncodeFrame(const int16_t* input, size_t input_len_samples,
 436                           uint8_t* output) {
 437     // Insert 3 * 10 ms. Expect non-zero output on third call.
 438     EXPECT_EQ(0, WebRtcIsacfix_Encode(encoder_, input, output));
 439     input += input_size_;
 440     EXPECT_EQ(0, WebRtcIsacfix_Encode(encoder_, input, output));
 441     input += input_size_;
 442     int enc_len_bytes = WebRtcIsacfix_Encode(encoder_, input, output);
 443     EXPECT_GT(enc_len_bytes, 0);
 444     return enc_len_bytes;
 445   }
 446
 447   ISACFIX_MainStruct* encoder_;
 448   int input_size_;
 449 };
 450
 451 class AudioDecoderG722Test : public AudioDecoderTest {
 452  protected:
 453   AudioDecoderG722Test() : AudioDecoderTest() {
 454     frame_size_ = 160;
 455     data_length_ = 10 * frame_size_;
 456     decoder_ = new AudioDecoderG722;
 457     assert(decoder_);
 458     WebRtcG722_CreateEncoder(&encoder_);
 459   }
 460
 461   ~AudioDecoderG722Test() {
 462     WebRtcG722_FreeEncoder(encoder_);
 463   }
 464
 465   virtual void InitEncoder() {
 466     ASSERT_EQ(0, WebRtcG722_EncoderInit(encoder_));
 467   }
 468
 469   virtual int EncodeFrame(const int16_t* input, size_t input_len_samples,
 470                           uint8_t* output) {
 471     int enc_len_bytes =
 472         WebRtcG722_Encode(encoder_, const_cast<int16_t*>(input),
 473                           static_cast<int>(input_len_samples),
 474                           reinterpret_cast<int16_t*>(output));
 475     EXPECT_EQ(80, enc_len_bytes);
 476     return enc_len_bytes;
 477   }
 478
 479   G722EncInst* encoder_;
 480 };
 481
 482 class AudioDecoderG722StereoTest : public AudioDecoderG722Test {
 483  protected:
 484   AudioDecoderG722StereoTest() : AudioDecoderG722Test() {
 485     channels_ = 2;
 486     // Delete the |decoder_| that was created by AudioDecoderG722Test and
 487     // create an AudioDecoderG722Stereo object instead.
 488     delete decoder_;
 489     decoder_ = new AudioDecoderG722Stereo;
 490     assert(decoder_);
 491   }
 492
 493   virtual int EncodeFrame(const int16_t* input, size_t input_len_samples,
 494                           uint8_t* output) {
 495     uint8_t* temp_output = new uint8_t[data_length_ * 2];
 496     // Encode a mono payload using the base test class.
 497     int mono_enc_len_bytes =
 498         AudioDecoderG722Test::EncodeFrame(input, input_len_samples,
 499                                           temp_output);
 500     // The bit-stream consists of 4-bit samples:
 501     // +--------+--------+--------+
 502     // | s0  s1 | s2  s3 | s4  s5 |
 503     // +--------+--------+--------+
 504     //
 505     // Duplicate them to the |output| such that the stereo stream becomes:
 506     // +--------+--------+--------+
 507     // | s0  s0 | s1  s1 | s2  s2 |
 508     // +--------+--------+--------+
 509     EXPECT_LE(mono_enc_len_bytes * 2, static_cast<int>(data_length_ * 2));
 510     uint8_t* output_ptr = output;
 511     for (int i = 0; i < mono_enc_len_bytes; ++i) {
 512       *output_ptr = (temp_output[i] & 0xF0) + (temp_output[i] >> 4);
 513       ++output_ptr;
 514       *output_ptr = (temp_output[i] << 4) + (temp_output[i] & 0x0F);
 515       ++output_ptr;
 516     }
 517     delete [] temp_output;
 518     return mono_enc_len_bytes * 2;
 519   }
 520 };
 521
 522 #ifdef WEBRTC_CODEC_CELT
 523 class AudioDecoderCeltTest : public AudioDecoderTest {
 524  protected:
 525   static const int kEncodingRateBitsPerSecond = 64000;
 526   AudioDecoderCeltTest() : AudioDecoderTest(), encoder_(NULL) {
 527     frame_size_ = 640;
 528     data_length_ = 10 * frame_size_;
 529     decoder_ = AudioDecoder::CreateAudioDecoder(kDecoderCELT_32);
 530     assert(decoder_);
 531     WebRtcCelt_CreateEnc(&encoder_, static_cast<int>(channels_));
 532   }
 533
 534   ~AudioDecoderCeltTest() {
 535     WebRtcCelt_FreeEnc(encoder_);
 536   }
 537
 538   virtual void InitEncoder() {
 539     assert(encoder_);
 540     ASSERT_EQ(0, WebRtcCelt_EncoderInit(
 541         encoder_, static_cast<int>(channels_), kEncodingRateBitsPerSecond));
 542   }
 543
 544   virtual int EncodeFrame(const int16_t* input, size_t input_len_samples,
 545                           uint8_t* output) {
 546     assert(encoder_);
 547     return WebRtcCelt_Encode(encoder_, input, output);
 548   }
 549
 550   CELT_encinst_t* encoder_;
 551 };
 552
 553 class AudioDecoderCeltStereoTest : public AudioDecoderTest {
 554  protected:
 555   static const int kEncodingRateBitsPerSecond = 64000;
 556   AudioDecoderCeltStereoTest() : AudioDecoderTest(), encoder_(NULL) {
 557     channels_ = 2;
 558     frame_size_ = 640;
 559     data_length_ = 10 * frame_size_;
 560     decoder_ = AudioDecoder::CreateAudioDecoder(kDecoderCELT_32_2ch);
 561     assert(decoder_);
 562     stereo_input_ = new int16_t[frame_size_ * channels_];
 563     WebRtcCelt_CreateEnc(&encoder_, static_cast<int>(channels_));
 564   }
 565
 566   ~AudioDecoderCeltStereoTest() {
 567     delete [] stereo_input_;
 568     WebRtcCelt_FreeEnc(encoder_);
 569   }
 570
 571   virtual void InitEncoder() {
 572     assert(encoder_);
 573     ASSERT_EQ(0, WebRtcCelt_EncoderInit(
 574         encoder_, static_cast<int>(channels_), kEncodingRateBitsPerSecond));
 575   }
 576
 577   virtual int EncodeFrame(const int16_t* input, size_t input_len_samples,
 578                           uint8_t* output) {
 579     assert(encoder_);
 580     assert(stereo_input_);
 581     for (size_t n = 0; n < frame_size_; ++n) {
 582       stereo_input_[n * 2] = stereo_input_[n * 2 + 1] = input[n];
 583     }
 584     return WebRtcCelt_Encode(encoder_, stereo_input_, output);
 585   }
 586
 587   int16_t* stereo_input_;
 588   CELT_encinst_t* encoder_;
 589 };
 590
 591 #endif
 592
 593 class AudioDecoderOpusTest : public AudioDecoderTest {
 594  protected:
 595   AudioDecoderOpusTest() : AudioDecoderTest() {
 596     frame_size_ = 480;
 597     data_length_ = 10 * frame_size_;
 598     decoder_ = new AudioDecoderOpus(kDecoderOpus);
 599     assert(decoder_);
 600     WebRtcOpus_EncoderCreate(&encoder_, 1);
 601   }
 602
 603   ~AudioDecoderOpusTest() {
 604     WebRtcOpus_EncoderFree(encoder_);
 605   }
 606
 607   virtual void SetUp() OVERRIDE {
 608     AudioDecoderTest::SetUp();
 609     // Upsample from 32 to 48 kHz.
 610     // Because Opus is 48 kHz codec but the input file is 32 kHz, so the data
 611     // read in |AudioDecoderTest::SetUp| has to be upsampled.
 612     // |AudioDecoderTest::SetUp| has read |data_length_| samples, which is more
 613     // than necessary after upsampling, so the end of audio that has been read
 614     // is unused and the end of the buffer is overwritten by the resampled data.
 615     Resampler rs;
 616     rs.Reset(32000, 48000, kResamplerSynchronous);
 617     const int before_resamp_len_samples = static_cast<int>(data_length_) * 2
 618         / 3;
 619     int16_t* before_resamp_input = new int16_t[before_resamp_len_samples];
 620     memcpy(before_resamp_input, input_,
 621            sizeof(int16_t) * before_resamp_len_samples);
 622     int resamp_len_samples;
 623     EXPECT_EQ(0, rs.Push(before_resamp_input, before_resamp_len_samples,
 624                          input_, static_cast<int>(data_length_),
 625                          resamp_len_samples));
 626     EXPECT_EQ(static_cast<int>(data_length_), resamp_len_samples);
 627     delete[] before_resamp_input;
 628   }
 629
 630   virtual void InitEncoder() {}
 631
 632   virtual int EncodeFrame(const int16_t* input, size_t input_len_samples,
 633                           uint8_t* output) OVERRIDE {
 634     int enc_len_bytes = WebRtcOpus_Encode(encoder_, const_cast<int16_t*>(input),
 635         static_cast<int16_t>(input_len_samples),
 636         static_cast<int16_t>(data_length_), output);
 637     EXPECT_GT(enc_len_bytes, 0);
 638     return enc_len_bytes;
 639   }
 640
 641   OpusEncInst* encoder_;
 642 };
 643
 644 class AudioDecoderOpusStereoTest : public AudioDecoderOpusTest {
 645  protected:
 646   AudioDecoderOpusStereoTest() : AudioDecoderOpusTest() {
 647     channels_ = 2;
 648     WebRtcOpus_EncoderFree(encoder_);
 649     delete decoder_;
 650     decoder_ = new AudioDecoderOpus(kDecoderOpus_2ch);
 651     assert(decoder_);
 652     WebRtcOpus_EncoderCreate(&encoder_, 2);
 653   }
 654
 655   virtual int EncodeFrame(const int16_t* input, size_t input_len_samples,
 656                           uint8_t* output) OVERRIDE {
 657     // Create stereo by duplicating each sample in |input|.
 658     const int input_stereo_samples = static_cast<int>(input_len_samples) * 2;
 659     int16_t* input_stereo = new int16_t[input_stereo_samples];
 660     for (size_t i = 0; i < input_len_samples; i++)
 661       input_stereo[i * 2] = input_stereo[i * 2 + 1] = input[i];
 662
 663     int enc_len_bytes = WebRtcOpus_Encode(
 664         encoder_, input_stereo, static_cast<int16_t>(input_len_samples),
 665         static_cast<int16_t>(data_length_), output);
 666     EXPECT_GT(enc_len_bytes, 0);
 667     delete[] input_stereo;
 668     return enc_len_bytes;
 669   }
 670 };
 671
 672 TEST_F(AudioDecoderPcmUTest, EncodeDecode) {
 673   int tolerance = 251;
 674   double mse = 1734.0;
 675   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderPCMu));
 676   EncodeDecodeTest(data_length_, tolerance, mse);
 677   ReInitTest();
 678   EXPECT_FALSE(decoder_->HasDecodePlc());
 679 }
 680
 681 TEST_F(AudioDecoderPcmATest, EncodeDecode) {
 682   int tolerance = 308;
 683   double mse = 1931.0;
 684   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderPCMa));
 685   EncodeDecodeTest(data_length_, tolerance, mse);
 686   ReInitTest();
 687   EXPECT_FALSE(decoder_->HasDecodePlc());
 688 }
 689
 690 TEST_F(AudioDecoderPcm16BTest, EncodeDecode) {
 691   int tolerance = 0;
 692   double mse = 0.0;
 693   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderPCM16B));
 694   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderPCM16Bwb));
 695   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderPCM16Bswb32kHz));
 696   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderPCM16Bswb48kHz));
 697   EncodeDecodeTest(2 * data_length_, tolerance, mse);
 698   ReInitTest();
 699   EXPECT_FALSE(decoder_->HasDecodePlc());
 700 }
 701
 702 TEST_F(AudioDecoderIlbcTest, EncodeDecode) {
 703   int tolerance = 6808;
 704   double mse = 2.13e6;
 705   int delay = 80;  // Delay from input to output.
 706   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderILBC));
 707   EncodeDecodeTest(500, tolerance, mse, delay);
 708   ReInitTest();
 709   EXPECT_TRUE(decoder_->HasDecodePlc());
 710   DecodePlcTest();
 711 }
 712
 713 TEST_F(AudioDecoderIsacFloatTest, EncodeDecode) {
 714   int tolerance = 3399;
 715   double mse = 434951.0;
 716   int delay = 48;  // Delay from input to output.
 717   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderISAC));
 718   EncodeDecodeTest(0, tolerance, mse, delay);
 719   ReInitTest();
 720   EXPECT_TRUE(decoder_->HasDecodePlc());
 721   DecodePlcTest();
 722 }
 723
 724 TEST_F(AudioDecoderIsacSwbTest, EncodeDecode) {
 725   int tolerance = 19757;
 726   double mse = 8.18e6;
 727   int delay = 160;  // Delay from input to output.
 728   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderISACswb));
 729   EncodeDecodeTest(0, tolerance, mse, delay);
 730   ReInitTest();
 731   EXPECT_TRUE(decoder_->HasDecodePlc());
 732   DecodePlcTest();
 733 }
 734
 735 TEST_F(AudioDecoderIsacFbTest, EncodeDecode) {
 736   int tolerance = 19757;
 737   double mse = 8.18e6;
 738   int delay = 160;  // Delay from input to output.
 739   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderISACswb));
 740   EncodeDecodeTest(0, tolerance, mse, delay);
 741   ReInitTest();
 742   EXPECT_TRUE(decoder_->HasDecodePlc());
 743   DecodePlcTest();
 744 }
 745
 746 TEST_F(AudioDecoderIsacFixTest, DISABLED_EncodeDecode) {
 747   int tolerance = 11034;
 748   double mse = 3.46e6;
 749   int delay = 54;  // Delay from input to output.
 750   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderISAC));
 751   EncodeDecodeTest(735, tolerance, mse, delay);
 752   ReInitTest();
 753   EXPECT_FALSE(decoder_->HasDecodePlc());
 754 }
 755
 756 TEST_F(AudioDecoderG722Test, EncodeDecode) {
 757   int tolerance = 6176;
 758   double mse = 238630.0;
 759   int delay = 22;  // Delay from input to output.
 760   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderG722));
 761   EncodeDecodeTest(data_length_ / 2, tolerance, mse, delay);
 762   ReInitTest();
 763   EXPECT_FALSE(decoder_->HasDecodePlc());
 764 }
 765
 766 TEST_F(AudioDecoderG722StereoTest, CreateAndDestroy) {
 767   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderG722_2ch));
 768 }
 769
 770 TEST_F(AudioDecoderG722StereoTest, EncodeDecode) {
 771   int tolerance = 6176;
 772   int channel_diff_tolerance = 0;
 773   double mse = 238630.0;
 774   int delay = 22;  // Delay from input to output.
 775   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderG722_2ch));
 776   EncodeDecodeTest(data_length_, tolerance, mse, delay, channel_diff_tolerance);
 777   ReInitTest();
 778   EXPECT_FALSE(decoder_->HasDecodePlc());
 779 }
 780
 781 TEST_F(AudioDecoderOpusTest, EncodeDecode) {
 782   int tolerance = 6176;
 783   double mse = 238630.0;
 784   int delay = 22;  // Delay from input to output.
 785   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderOpus));
 786   EncodeDecodeTest(0, tolerance, mse, delay);
 787   ReInitTest();
 788   EXPECT_FALSE(decoder_->HasDecodePlc());
 789 }
 790
 791 TEST_F(AudioDecoderOpusStereoTest, EncodeDecode) {
 792   int tolerance = 6176;
 793   int channel_diff_tolerance = 0;
 794   double mse = 238630.0;
 795   int delay = 22;  // Delay from input to output.
 796   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderOpus_2ch));
 797   EncodeDecodeTest(0, tolerance, mse, delay, channel_diff_tolerance);
 798   ReInitTest();
 799   EXPECT_FALSE(decoder_->HasDecodePlc());
 800 }
 801
 802 #ifdef WEBRTC_CODEC_CELT
 803 // In the two following CELT tests, the low amplitude of the test signal allow
 804 // us to have such low error thresholds, i.e. |tolerance|, |mse|. Furthermore,
 805 // in general, stereo signals with identical channels do not result in identical
 806 // encoded channels.
 807 TEST_F(AudioDecoderCeltTest, EncodeDecode) {
 808   int tolerance = 20;
 809   double mse = 17.0;
 810   int delay = 80;  // Delay from input to output in samples.
 811   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderCELT_32));
 812   EncodeDecodeTest(1600, tolerance, mse, delay);
 813   ReInitTest();
 814   EXPECT_TRUE(decoder_->HasDecodePlc());
 815   DecodePlcTest();
 816 }
 817
 818 TEST_F(AudioDecoderCeltStereoTest, EncodeDecode) {
 819   int tolerance = 20;
 820   // If both channels are identical, CELT not necessarily decodes identical
 821   // channels. However, for this input this is the case.
 822   int channel_diff_tolerance = 0;
 823   double mse = 20.0;
 824   // Delay from input to output in samples, accounting for stereo.
 825   int delay = 160;
 826   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderCELT_32_2ch));
 827   EncodeDecodeTest(1600, tolerance, mse, delay, channel_diff_tolerance);
 828   ReInitTest();
 829   EXPECT_TRUE(decoder_->HasDecodePlc());
 830   DecodePlcTest();
 831 }
 832 #endif
 833
 834 TEST(AudioDecoder, CodecSampleRateHz) {
 835   EXPECT_EQ(8000, AudioDecoder::CodecSampleRateHz(kDecoderPCMu));
 836   EXPECT_EQ(8000, AudioDecoder::CodecSampleRateHz(kDecoderPCMa));
 837   EXPECT_EQ(8000, AudioDecoder::CodecSampleRateHz(kDecoderPCMu_2ch));
 838   EXPECT_EQ(8000, AudioDecoder::CodecSampleRateHz(kDecoderPCMa_2ch));
 839   EXPECT_EQ(8000, AudioDecoder::CodecSampleRateHz(kDecoderILBC));
 840   EXPECT_EQ(16000, AudioDecoder::CodecSampleRateHz(kDecoderISAC));
 841   EXPECT_EQ(32000, AudioDecoder::CodecSampleRateHz(kDecoderISACswb));
 842   EXPECT_EQ(32000, AudioDecoder::CodecSampleRateHz(kDecoderISACfb));
 843   EXPECT_EQ(8000, AudioDecoder::CodecSampleRateHz(kDecoderPCM16B));
 844   EXPECT_EQ(16000, AudioDecoder::CodecSampleRateHz(kDecoderPCM16Bwb));
 845   EXPECT_EQ(32000, AudioDecoder::CodecSampleRateHz(kDecoderPCM16Bswb32kHz));
 846   EXPECT_EQ(48000, AudioDecoder::CodecSampleRateHz(kDecoderPCM16Bswb48kHz));
 847   EXPECT_EQ(8000, AudioDecoder::CodecSampleRateHz(kDecoderPCM16B_2ch));
 848   EXPECT_EQ(16000, AudioDecoder::CodecSampleRateHz(kDecoderPCM16Bwb_2ch));
 849   EXPECT_EQ(32000, AudioDecoder::CodecSampleRateHz(kDecoderPCM16Bswb32kHz_2ch));
 850   EXPECT_EQ(48000, AudioDecoder::CodecSampleRateHz(kDecoderPCM16Bswb48kHz_2ch));
 851   EXPECT_EQ(8000, AudioDecoder::CodecSampleRateHz(kDecoderPCM16B_5ch));
 852   EXPECT_EQ(16000, AudioDecoder::CodecSampleRateHz(kDecoderG722));
 853   EXPECT_EQ(16000, AudioDecoder::CodecSampleRateHz(kDecoderG722_2ch));
 854   EXPECT_EQ(-1, AudioDecoder::CodecSampleRateHz(kDecoderRED));
 855   EXPECT_EQ(-1, AudioDecoder::CodecSampleRateHz(kDecoderAVT));
 856   EXPECT_EQ(8000, AudioDecoder::CodecSampleRateHz(kDecoderCNGnb));
 857   EXPECT_EQ(16000, AudioDecoder::CodecSampleRateHz(kDecoderCNGwb));
 858   EXPECT_EQ(32000, AudioDecoder::CodecSampleRateHz(kDecoderCNGswb32kHz));
 859   EXPECT_EQ(48000, AudioDecoder::CodecSampleRateHz(kDecoderOpus));
 860   EXPECT_EQ(48000, AudioDecoder::CodecSampleRateHz(kDecoderOpus_2ch));
 861   // TODO(tlegrand): Change 32000 to 48000 below once ACM has 48 kHz support.
 862   EXPECT_EQ(32000, AudioDecoder::CodecSampleRateHz(kDecoderCNGswb48kHz));
 863   EXPECT_EQ(-1, AudioDecoder::CodecSampleRateHz(kDecoderArbitrary));
 864 #ifdef WEBRTC_CODEC_CELT
 865   EXPECT_EQ(32000, AudioDecoder::CodecSampleRateHz(kDecoderCELT_32));
 866   EXPECT_EQ(32000, AudioDecoder::CodecSampleRateHz(kDecoderCELT_32_2ch));
 867 #else
 868   EXPECT_EQ(-1, AudioDecoder::CodecSampleRateHz(kDecoderCELT_32));
 869   EXPECT_EQ(-1, AudioDecoder::CodecSampleRateHz(kDecoderCELT_32_2ch));
 870 #endif
 871 }
 872
 873 TEST(AudioDecoder, CodecSupported) {
 874   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderPCMu));
 875   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderPCMa));
 876   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderPCMu_2ch));
 877   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderPCMa_2ch));
 878   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderILBC));
 879   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderISAC));
 880   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderISACswb));
 881   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderISACfb));
 882   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderPCM16B));
 883   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderPCM16Bwb));
 884   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderPCM16Bswb32kHz));
 885   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderPCM16Bswb48kHz));
 886   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderPCM16B_2ch));
 887   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderPCM16Bwb_2ch));
 888   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderPCM16Bswb32kHz_2ch));
 889   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderPCM16Bswb48kHz_2ch));
 890   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderPCM16B_5ch));
 891   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderG722));
 892   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderG722_2ch));
 893   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderRED));
 894   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderAVT));
 895   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderCNGnb));
 896   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderCNGwb));
 897   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderCNGswb32kHz));
 898   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderCNGswb48kHz));
 899   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderArbitrary));
 900   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderOpus));
 901   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderOpus_2ch));
 902 #ifdef WEBRTC_CODEC_CELT
 903   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderCELT_32));
 904   EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderCELT_32_2ch));
 905 #else
 906   EXPECT_FALSE(AudioDecoder::CodecSupported(kDecoderCELT_32));
 907   EXPECT_FALSE(AudioDecoder::CodecSupported(kDecoderCELT_32_2ch));
 908 #endif
 909 }
 910
 911 }  // namespace webrtc