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