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
33namespace webrtc {
34
35class 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
223class 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
243class 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
263class 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
282class 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
327class 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
364class 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.
403class 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
414class 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
451class 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
482class 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
523class 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
553class 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
593class 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
644class 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
672TEST_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
681TEST_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
690TEST_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
702TEST_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
713TEST_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
724TEST_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
735TEST_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
746TEST_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
756TEST_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
766TEST_F(AudioDecoderG722StereoTest, CreateAndDestroy) {
767  EXPECT_TRUE(AudioDecoder::CodecSupported(kDecoderG722_2ch));
768}
769
770TEST_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
781TEST_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
791TEST_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.
807TEST_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
818TEST_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
834TEST(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
873TEST(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
912