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 912
