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 <assert.h>
12 #include <stdlib.h>
13
14 #include <array>
15 #include <memory>
16 #include <string>
17 #include <vector>
18
19 #include "api/audio_codecs/opus/audio_encoder_opus.h"
20 #include "modules/audio_coding/codecs/g711/audio_decoder_pcm.h"
21 #include "modules/audio_coding/codecs/g711/audio_encoder_pcm.h"
22 #include "modules/audio_coding/codecs/g722/audio_decoder_g722.h"
23 #include "modules/audio_coding/codecs/g722/audio_encoder_g722.h"
24 #include "modules/audio_coding/codecs/ilbc/audio_decoder_ilbc.h"
25 #include "modules/audio_coding/codecs/ilbc/audio_encoder_ilbc.h"
26 #include "modules/audio_coding/codecs/isac/fix/include/audio_decoder_isacfix.h"
27 #include "modules/audio_coding/codecs/isac/fix/include/audio_encoder_isacfix.h"
28 #include "modules/audio_coding/codecs/isac/main/include/audio_decoder_isac.h"
29 #include "modules/audio_coding/codecs/isac/main/include/audio_encoder_isac.h"
30 #include "modules/audio_coding/codecs/opus/audio_decoder_opus.h"
31 #include "modules/audio_coding/codecs/pcm16b/audio_decoder_pcm16b.h"
32 #include "modules/audio_coding/codecs/pcm16b/audio_encoder_pcm16b.h"
33 #include "modules/audio_coding/neteq/tools/resample_input_audio_file.h"
34 #include "test/gtest.h"
35 #include "test/testsupport/file_utils.h"
36
37 namespace webrtc {
38
39 namespace {
40 // The absolute difference between the input and output (the first channel) is
41 // compared vs |tolerance|. The parameter |delay| is used to correct for codec
42 // delays.
CompareInputOutput(const std::vector<int16_t> & input,const std::vector<int16_t> & output,size_t num_samples,size_t channels,int tolerance,int delay)43 void CompareInputOutput(const std::vector<int16_t>& input,
44 const std::vector<int16_t>& output,
45 size_t num_samples,
46 size_t channels,
47 int tolerance,
48 int delay) {
49 ASSERT_LE(num_samples, input.size());
50 ASSERT_LE(num_samples * channels, output.size());
51 for (unsigned int n = 0; n < num_samples - delay; ++n) {
52 ASSERT_NEAR(input[n], output[channels * n + delay], tolerance)
53 << "Exit test on first diff; n = " << n;
54 }
55 }
56
57 // The absolute difference between the first two channels in |output| is
58 // compared vs |tolerance|.
CompareTwoChannels(const std::vector<int16_t> & output,size_t samples_per_channel,size_t channels,int tolerance)59 void CompareTwoChannels(const std::vector<int16_t>& output,
60 size_t samples_per_channel,
61 size_t channels,
62 int tolerance) {
63 ASSERT_GE(channels, 2u);
64 ASSERT_LE(samples_per_channel * channels, output.size());
65 for (unsigned int n = 0; n < samples_per_channel; ++n)
66 ASSERT_NEAR(output[channels * n], output[channels * n + 1], tolerance)
67 << "Stereo samples differ.";
68 }
69
70 // Calculates mean-squared error between input and output (the first channel).
71 // The parameter |delay| is used to correct for codec delays.
MseInputOutput(const std::vector<int16_t> & input,const std::vector<int16_t> & output,size_t num_samples,size_t channels,int delay)72 double MseInputOutput(const std::vector<int16_t>& input,
73 const std::vector<int16_t>& output,
74 size_t num_samples,
75 size_t channels,
76 int delay) {
77 assert(delay < static_cast<int>(num_samples));
78 assert(num_samples <= input.size());
79 assert(num_samples * channels <= output.size());
80 if (num_samples == 0)
81 return 0.0;
82 double squared_sum = 0.0;
83 for (unsigned int n = 0; n < num_samples - delay; ++n) {
84 squared_sum += (input[n] - output[channels * n + delay]) *
85 (input[n] - output[channels * n + delay]);
86 }
87 return squared_sum / (num_samples - delay);
88 }
89 } // namespace
90
91 class AudioDecoderTest : public ::testing::Test {
92 protected:
AudioDecoderTest()93 AudioDecoderTest()
94 : input_audio_(
95 webrtc::test::ResourcePath("audio_coding/testfile32kHz", "pcm"),
96 32000),
97 codec_input_rate_hz_(32000), // Legacy default value.
98 frame_size_(0),
99 data_length_(0),
100 channels_(1),
101 payload_type_(17),
102 decoder_(NULL) {}
103
~AudioDecoderTest()104 ~AudioDecoderTest() override {}
105
SetUp()106 void SetUp() override {
107 if (audio_encoder_)
108 codec_input_rate_hz_ = audio_encoder_->SampleRateHz();
109 // Create arrays.
110 ASSERT_GT(data_length_, 0u) << "The test must set data_length_ > 0";
111 }
112
TearDown()113 void TearDown() override {
114 delete decoder_;
115 decoder_ = NULL;
116 }
117
InitEncoder()118 virtual void InitEncoder() {}
119
120 // TODO(henrik.lundin) Change return type to size_t once most/all overriding
121 // implementations are gone.
EncodeFrame(const int16_t * input,size_t input_len_samples,rtc::Buffer * output)122 virtual int EncodeFrame(const int16_t* input,
123 size_t input_len_samples,
124 rtc::Buffer* output) {
125 AudioEncoder::EncodedInfo encoded_info;
126 const size_t samples_per_10ms = audio_encoder_->SampleRateHz() / 100;
127 RTC_CHECK_EQ(samples_per_10ms * audio_encoder_->Num10MsFramesInNextPacket(),
128 input_len_samples);
129 std::unique_ptr<int16_t[]> interleaved_input(
130 new int16_t[channels_ * samples_per_10ms]);
131 for (size_t i = 0; i < audio_encoder_->Num10MsFramesInNextPacket(); ++i) {
132 EXPECT_EQ(0u, encoded_info.encoded_bytes);
133
134 // Duplicate the mono input signal to however many channels the test
135 // wants.
136 test::InputAudioFile::DuplicateInterleaved(input + i * samples_per_10ms,
137 samples_per_10ms, channels_,
138 interleaved_input.get());
139
140 encoded_info =
141 audio_encoder_->Encode(0,
142 rtc::ArrayView<const int16_t>(
143 interleaved_input.get(),
144 audio_encoder_->NumChannels() *
145 audio_encoder_->SampleRateHz() / 100),
146 output);
147 }
148 EXPECT_EQ(payload_type_, encoded_info.payload_type);
149 return static_cast<int>(encoded_info.encoded_bytes);
150 }
151
152 // Encodes and decodes audio. The absolute difference between the input and
153 // output is compared vs |tolerance|, and the mean-squared error is compared
154 // with |mse|. The encoded stream should contain |expected_bytes|. For stereo
155 // audio, the absolute difference between the two channels is compared vs
156 // |channel_diff_tolerance|.
EncodeDecodeTest(size_t expected_bytes,int tolerance,double mse,int delay=0,int channel_diff_tolerance=0)157 void EncodeDecodeTest(size_t expected_bytes,
158 int tolerance,
159 double mse,
160 int delay = 0,
161 int channel_diff_tolerance = 0) {
162 ASSERT_GE(tolerance, 0) << "Test must define a tolerance >= 0";
163 ASSERT_GE(channel_diff_tolerance, 0)
164 << "Test must define a channel_diff_tolerance >= 0";
165 size_t processed_samples = 0u;
166 size_t encoded_bytes = 0u;
167 InitEncoder();
168 std::vector<int16_t> input;
169 std::vector<int16_t> decoded;
170 while (processed_samples + frame_size_ <= data_length_) {
171 // Extend input vector with |frame_size_|.
172 input.resize(input.size() + frame_size_, 0);
173 // Read from input file.
174 ASSERT_GE(input.size() - processed_samples, frame_size_);
175 ASSERT_TRUE(input_audio_.Read(frame_size_, codec_input_rate_hz_,
176 &input[processed_samples]));
177 rtc::Buffer encoded;
178 size_t enc_len =
179 EncodeFrame(&input[processed_samples], frame_size_, &encoded);
180 // Make sure that frame_size_ * channels_ samples are allocated and free.
181 decoded.resize((processed_samples + frame_size_) * channels_, 0);
182
183 const std::vector<AudioDecoder::ParseResult> parse_result =
184 decoder_->ParsePayload(std::move(encoded), /*timestamp=*/0);
185 RTC_CHECK_EQ(parse_result.size(), size_t{1});
186 auto decode_result = parse_result[0].frame->Decode(
187 rtc::ArrayView<int16_t>(&decoded[processed_samples * channels_],
188 frame_size_ * channels_ * sizeof(int16_t)));
189 RTC_CHECK(decode_result.has_value());
190 EXPECT_EQ(frame_size_ * channels_, decode_result->num_decoded_samples);
191 encoded_bytes += enc_len;
192 processed_samples += frame_size_;
193 }
194 // For some codecs it doesn't make sense to check expected number of bytes,
195 // since the number can vary for different platforms. Opus and iSAC are
196 // such codecs. In this case expected_bytes is set to 0.
197 if (expected_bytes) {
198 EXPECT_EQ(expected_bytes, encoded_bytes);
199 }
200 CompareInputOutput(input, decoded, processed_samples, channels_, tolerance,
201 delay);
202 if (channels_ == 2)
203 CompareTwoChannels(decoded, processed_samples, channels_,
204 channel_diff_tolerance);
205 EXPECT_LE(
206 MseInputOutput(input, decoded, processed_samples, channels_, delay),
207 mse);
208 }
209
210 // Encodes a payload and decodes it twice with decoder re-init before each
211 // decode. Verifies that the decoded result is the same.
ReInitTest()212 void ReInitTest() {
213 InitEncoder();
214 std::unique_ptr<int16_t[]> input(new int16_t[frame_size_]);
215 ASSERT_TRUE(
216 input_audio_.Read(frame_size_, codec_input_rate_hz_, input.get()));
217 std::array<rtc::Buffer, 2> encoded;
218 EncodeFrame(input.get(), frame_size_, &encoded[0]);
219 // Make a copy.
220 encoded[1].SetData(encoded[0].data(), encoded[0].size());
221
222 std::array<std::vector<int16_t>, 2> outputs;
223 for (size_t i = 0; i < outputs.size(); ++i) {
224 outputs[i].resize(frame_size_ * channels_);
225 decoder_->Reset();
226 const std::vector<AudioDecoder::ParseResult> parse_result =
227 decoder_->ParsePayload(std::move(encoded[i]), /*timestamp=*/0);
228 RTC_CHECK_EQ(parse_result.size(), size_t{1});
229 auto decode_result = parse_result[0].frame->Decode(outputs[i]);
230 RTC_CHECK(decode_result.has_value());
231 EXPECT_EQ(frame_size_ * channels_, decode_result->num_decoded_samples);
232 }
233 EXPECT_EQ(outputs[0], outputs[1]);
234 }
235
236 // Call DecodePlc and verify that the correct number of samples is produced.
DecodePlcTest()237 void DecodePlcTest() {
238 InitEncoder();
239 std::unique_ptr<int16_t[]> input(new int16_t[frame_size_]);
240 ASSERT_TRUE(
241 input_audio_.Read(frame_size_, codec_input_rate_hz_, input.get()));
242 rtc::Buffer encoded;
243 EncodeFrame(input.get(), frame_size_, &encoded);
244 decoder_->Reset();
245 std::vector<int16_t> output(frame_size_ * channels_);
246 const std::vector<AudioDecoder::ParseResult> parse_result =
247 decoder_->ParsePayload(std::move(encoded), /*timestamp=*/0);
248 RTC_CHECK_EQ(parse_result.size(), size_t{1});
249 auto decode_result = parse_result[0].frame->Decode(output);
250 RTC_CHECK(decode_result.has_value());
251 EXPECT_EQ(frame_size_ * channels_, decode_result->num_decoded_samples);
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 size_t dec_len =
256 decoder_->DecodePlc(/*num_frames=*/1, /*decoded=*/output.data());
257 EXPECT_EQ(frame_size_ * channels_, dec_len);
258 }
259
260 test::ResampleInputAudioFile input_audio_;
261 int codec_input_rate_hz_;
262 size_t frame_size_;
263 size_t data_length_;
264 size_t channels_;
265 const int payload_type_;
266 AudioDecoder* decoder_;
267 std::unique_ptr<AudioEncoder> audio_encoder_;
268 };
269
270 class AudioDecoderPcmUTest : public AudioDecoderTest {
271 protected:
AudioDecoderPcmUTest()272 AudioDecoderPcmUTest() : AudioDecoderTest() {
273 frame_size_ = 160;
274 data_length_ = 10 * frame_size_;
275 decoder_ = new AudioDecoderPcmU(1);
276 AudioEncoderPcmU::Config config;
277 config.frame_size_ms = static_cast<int>(frame_size_ / 8);
278 config.payload_type = payload_type_;
279 audio_encoder_.reset(new AudioEncoderPcmU(config));
280 }
281 };
282
283 class AudioDecoderPcmATest : public AudioDecoderTest {
284 protected:
AudioDecoderPcmATest()285 AudioDecoderPcmATest() : AudioDecoderTest() {
286 frame_size_ = 160;
287 data_length_ = 10 * frame_size_;
288 decoder_ = new AudioDecoderPcmA(1);
289 AudioEncoderPcmA::Config config;
290 config.frame_size_ms = static_cast<int>(frame_size_ / 8);
291 config.payload_type = payload_type_;
292 audio_encoder_.reset(new AudioEncoderPcmA(config));
293 }
294 };
295
296 class AudioDecoderPcm16BTest : public AudioDecoderTest {
297 protected:
AudioDecoderPcm16BTest()298 AudioDecoderPcm16BTest() : AudioDecoderTest() {
299 codec_input_rate_hz_ = 16000;
300 frame_size_ = 20 * codec_input_rate_hz_ / 1000;
301 data_length_ = 10 * frame_size_;
302 decoder_ = new AudioDecoderPcm16B(codec_input_rate_hz_, 1);
303 assert(decoder_);
304 AudioEncoderPcm16B::Config config;
305 config.sample_rate_hz = codec_input_rate_hz_;
306 config.frame_size_ms =
307 static_cast<int>(frame_size_ / (config.sample_rate_hz / 1000));
308 config.payload_type = payload_type_;
309 audio_encoder_.reset(new AudioEncoderPcm16B(config));
310 }
311 };
312
313 class AudioDecoderIlbcTest : public AudioDecoderTest {
314 protected:
AudioDecoderIlbcTest()315 AudioDecoderIlbcTest() : AudioDecoderTest() {
316 codec_input_rate_hz_ = 8000;
317 frame_size_ = 240;
318 data_length_ = 10 * frame_size_;
319 decoder_ = new AudioDecoderIlbcImpl;
320 assert(decoder_);
321 AudioEncoderIlbcConfig config;
322 config.frame_size_ms = 30;
323 audio_encoder_.reset(new AudioEncoderIlbcImpl(config, payload_type_));
324 }
325
326 // Overload the default test since iLBC's function WebRtcIlbcfix_NetEqPlc does
327 // not return any data. It simply resets a few states and returns 0.
DecodePlcTest()328 void DecodePlcTest() {
329 InitEncoder();
330 std::unique_ptr<int16_t[]> input(new int16_t[frame_size_]);
331 ASSERT_TRUE(
332 input_audio_.Read(frame_size_, codec_input_rate_hz_, input.get()));
333 rtc::Buffer encoded;
334 size_t enc_len = EncodeFrame(input.get(), frame_size_, &encoded);
335 AudioDecoder::SpeechType speech_type;
336 decoder_->Reset();
337 std::unique_ptr<int16_t[]> output(new int16_t[frame_size_ * channels_]);
338 size_t dec_len = decoder_->Decode(
339 encoded.data(), enc_len, codec_input_rate_hz_,
340 frame_size_ * channels_ * sizeof(int16_t), output.get(), &speech_type);
341 EXPECT_EQ(frame_size_, dec_len);
342 // Simply call DecodePlc and verify that we get 0 as return value.
343 EXPECT_EQ(0U, decoder_->DecodePlc(1, output.get()));
344 }
345 };
346
347 class AudioDecoderIsacFloatTest : public AudioDecoderTest {
348 protected:
AudioDecoderIsacFloatTest()349 AudioDecoderIsacFloatTest() : AudioDecoderTest() {
350 codec_input_rate_hz_ = 16000;
351 frame_size_ = 480;
352 data_length_ = 10 * frame_size_;
353 AudioEncoderIsacFloatImpl::Config config;
354 config.payload_type = payload_type_;
355 config.sample_rate_hz = codec_input_rate_hz_;
356 config.frame_size_ms =
357 1000 * static_cast<int>(frame_size_) / codec_input_rate_hz_;
358 audio_encoder_.reset(new AudioEncoderIsacFloatImpl(config));
359
360 AudioDecoderIsacFloatImpl::Config decoder_config;
361 decoder_config.sample_rate_hz = codec_input_rate_hz_;
362 decoder_ = new AudioDecoderIsacFloatImpl(decoder_config);
363 }
364 };
365
366 class AudioDecoderIsacSwbTest : public AudioDecoderTest {
367 protected:
AudioDecoderIsacSwbTest()368 AudioDecoderIsacSwbTest() : AudioDecoderTest() {
369 codec_input_rate_hz_ = 32000;
370 frame_size_ = 960;
371 data_length_ = 10 * frame_size_;
372 AudioEncoderIsacFloatImpl::Config config;
373 config.payload_type = payload_type_;
374 config.sample_rate_hz = codec_input_rate_hz_;
375 config.frame_size_ms =
376 1000 * static_cast<int>(frame_size_) / codec_input_rate_hz_;
377 audio_encoder_.reset(new AudioEncoderIsacFloatImpl(config));
378
379 AudioDecoderIsacFloatImpl::Config decoder_config;
380 decoder_config.sample_rate_hz = codec_input_rate_hz_;
381 decoder_ = new AudioDecoderIsacFloatImpl(decoder_config);
382 }
383 };
384
385 class AudioDecoderIsacFixTest : public AudioDecoderTest {
386 protected:
AudioDecoderIsacFixTest()387 AudioDecoderIsacFixTest() : AudioDecoderTest() {
388 codec_input_rate_hz_ = 16000;
389 frame_size_ = 480;
390 data_length_ = 10 * frame_size_;
391 AudioEncoderIsacFixImpl::Config config;
392 config.payload_type = payload_type_;
393 config.sample_rate_hz = codec_input_rate_hz_;
394 config.frame_size_ms =
395 1000 * static_cast<int>(frame_size_) / codec_input_rate_hz_;
396 audio_encoder_.reset(new AudioEncoderIsacFixImpl(config));
397
398 AudioDecoderIsacFixImpl::Config decoder_config;
399 decoder_config.sample_rate_hz = codec_input_rate_hz_;
400 decoder_ = new AudioDecoderIsacFixImpl(decoder_config);
401 }
402 };
403
404 class AudioDecoderG722Test : public AudioDecoderTest {
405 protected:
AudioDecoderG722Test()406 AudioDecoderG722Test() : AudioDecoderTest() {
407 codec_input_rate_hz_ = 16000;
408 frame_size_ = 160;
409 data_length_ = 10 * frame_size_;
410 decoder_ = new AudioDecoderG722Impl;
411 assert(decoder_);
412 AudioEncoderG722Config config;
413 config.frame_size_ms = 10;
414 config.num_channels = 1;
415 audio_encoder_.reset(new AudioEncoderG722Impl(config, payload_type_));
416 }
417 };
418
419 class AudioDecoderG722StereoTest : public AudioDecoderTest {
420 protected:
AudioDecoderG722StereoTest()421 AudioDecoderG722StereoTest() : AudioDecoderTest() {
422 channels_ = 2;
423 codec_input_rate_hz_ = 16000;
424 frame_size_ = 160;
425 data_length_ = 10 * frame_size_;
426 decoder_ = new AudioDecoderG722StereoImpl;
427 assert(decoder_);
428 AudioEncoderG722Config config;
429 config.frame_size_ms = 10;
430 config.num_channels = 2;
431 audio_encoder_.reset(new AudioEncoderG722Impl(config, payload_type_));
432 }
433 };
434
435 class AudioDecoderOpusTest
436 : public AudioDecoderTest,
437 public testing::WithParamInterface<std::tuple<int, int>> {
438 protected:
AudioDecoderOpusTest()439 AudioDecoderOpusTest() : AudioDecoderTest() {
440 channels_ = opus_num_channels_;
441 codec_input_rate_hz_ = opus_sample_rate_hz_;
442 frame_size_ = rtc::CheckedDivExact(opus_sample_rate_hz_, 100);
443 data_length_ = 10 * frame_size_;
444 decoder_ =
445 new AudioDecoderOpusImpl(opus_num_channels_, opus_sample_rate_hz_);
446 AudioEncoderOpusConfig config;
447 config.frame_size_ms = 10;
448 config.sample_rate_hz = opus_sample_rate_hz_;
449 config.num_channels = opus_num_channels_;
450 config.application = opus_num_channels_ == 1
451 ? AudioEncoderOpusConfig::ApplicationMode::kVoip
452 : AudioEncoderOpusConfig::ApplicationMode::kAudio;
453 audio_encoder_ = AudioEncoderOpus::MakeAudioEncoder(config, payload_type_);
454 }
455 const int opus_sample_rate_hz_{std::get<0>(GetParam())};
456 const int opus_num_channels_{std::get<1>(GetParam())};
457 };
458
459 INSTANTIATE_TEST_SUITE_P(Param,
460 AudioDecoderOpusTest,
461 testing::Combine(testing::Values(16000, 48000),
462 testing::Values(1, 2)));
463
TEST_F(AudioDecoderPcmUTest,EncodeDecode)464 TEST_F(AudioDecoderPcmUTest, EncodeDecode) {
465 int tolerance = 251;
466 double mse = 1734.0;
467 EncodeDecodeTest(data_length_, tolerance, mse);
468 ReInitTest();
469 EXPECT_FALSE(decoder_->HasDecodePlc());
470 }
471
472 namespace {
SetAndGetTargetBitrate(AudioEncoder * audio_encoder,int rate)473 int SetAndGetTargetBitrate(AudioEncoder* audio_encoder, int rate) {
474 audio_encoder->OnReceivedUplinkBandwidth(rate, absl::nullopt);
475 return audio_encoder->GetTargetBitrate();
476 }
TestSetAndGetTargetBitratesWithFixedCodec(AudioEncoder * audio_encoder,int fixed_rate)477 void TestSetAndGetTargetBitratesWithFixedCodec(AudioEncoder* audio_encoder,
478 int fixed_rate) {
479 EXPECT_EQ(fixed_rate, SetAndGetTargetBitrate(audio_encoder, 32000));
480 EXPECT_EQ(fixed_rate, SetAndGetTargetBitrate(audio_encoder, fixed_rate - 1));
481 EXPECT_EQ(fixed_rate, SetAndGetTargetBitrate(audio_encoder, fixed_rate));
482 EXPECT_EQ(fixed_rate, SetAndGetTargetBitrate(audio_encoder, fixed_rate + 1));
483 }
484 } // namespace
485
TEST_F(AudioDecoderPcmUTest,SetTargetBitrate)486 TEST_F(AudioDecoderPcmUTest, SetTargetBitrate) {
487 TestSetAndGetTargetBitratesWithFixedCodec(audio_encoder_.get(), 64000);
488 }
489
TEST_F(AudioDecoderPcmATest,EncodeDecode)490 TEST_F(AudioDecoderPcmATest, EncodeDecode) {
491 int tolerance = 308;
492 double mse = 1931.0;
493 EncodeDecodeTest(data_length_, tolerance, mse);
494 ReInitTest();
495 EXPECT_FALSE(decoder_->HasDecodePlc());
496 }
497
TEST_F(AudioDecoderPcmATest,SetTargetBitrate)498 TEST_F(AudioDecoderPcmATest, SetTargetBitrate) {
499 TestSetAndGetTargetBitratesWithFixedCodec(audio_encoder_.get(), 64000);
500 }
501
TEST_F(AudioDecoderPcm16BTest,EncodeDecode)502 TEST_F(AudioDecoderPcm16BTest, EncodeDecode) {
503 int tolerance = 0;
504 double mse = 0.0;
505 EncodeDecodeTest(2 * data_length_, tolerance, mse);
506 ReInitTest();
507 EXPECT_FALSE(decoder_->HasDecodePlc());
508 }
509
TEST_F(AudioDecoderPcm16BTest,SetTargetBitrate)510 TEST_F(AudioDecoderPcm16BTest, SetTargetBitrate) {
511 TestSetAndGetTargetBitratesWithFixedCodec(audio_encoder_.get(),
512 codec_input_rate_hz_ * 16);
513 }
514
TEST_F(AudioDecoderIlbcTest,EncodeDecode)515 TEST_F(AudioDecoderIlbcTest, EncodeDecode) {
516 int tolerance = 6808;
517 double mse = 2.13e6;
518 int delay = 80; // Delay from input to output.
519 EncodeDecodeTest(500, tolerance, mse, delay);
520 ReInitTest();
521 EXPECT_TRUE(decoder_->HasDecodePlc());
522 DecodePlcTest();
523 }
524
TEST_F(AudioDecoderIlbcTest,SetTargetBitrate)525 TEST_F(AudioDecoderIlbcTest, SetTargetBitrate) {
526 TestSetAndGetTargetBitratesWithFixedCodec(audio_encoder_.get(), 13333);
527 }
528
TEST_F(AudioDecoderIsacFloatTest,EncodeDecode)529 TEST_F(AudioDecoderIsacFloatTest, EncodeDecode) {
530 int tolerance = 3399;
531 double mse = 434951.0;
532 int delay = 48; // Delay from input to output.
533 EncodeDecodeTest(0, tolerance, mse, delay);
534 ReInitTest();
535 EXPECT_FALSE(decoder_->HasDecodePlc());
536 }
537
TEST_F(AudioDecoderIsacFloatTest,SetTargetBitrate)538 TEST_F(AudioDecoderIsacFloatTest, SetTargetBitrate) {
539 EXPECT_EQ(10000, SetAndGetTargetBitrate(audio_encoder_.get(), 9999));
540 EXPECT_EQ(10000, SetAndGetTargetBitrate(audio_encoder_.get(), 10000));
541 EXPECT_EQ(23456, SetAndGetTargetBitrate(audio_encoder_.get(), 23456));
542 EXPECT_EQ(32000, SetAndGetTargetBitrate(audio_encoder_.get(), 32000));
543 EXPECT_EQ(32000, SetAndGetTargetBitrate(audio_encoder_.get(), 32001));
544 }
545
TEST_F(AudioDecoderIsacSwbTest,EncodeDecode)546 TEST_F(AudioDecoderIsacSwbTest, EncodeDecode) {
547 int tolerance = 19757;
548 double mse = 8.18e6;
549 int delay = 160; // Delay from input to output.
550 EncodeDecodeTest(0, tolerance, mse, delay);
551 ReInitTest();
552 EXPECT_FALSE(decoder_->HasDecodePlc());
553 }
554
TEST_F(AudioDecoderIsacSwbTest,SetTargetBitrate)555 TEST_F(AudioDecoderIsacSwbTest, SetTargetBitrate) {
556 EXPECT_EQ(10000, SetAndGetTargetBitrate(audio_encoder_.get(), 9999));
557 EXPECT_EQ(10000, SetAndGetTargetBitrate(audio_encoder_.get(), 10000));
558 EXPECT_EQ(23456, SetAndGetTargetBitrate(audio_encoder_.get(), 23456));
559 EXPECT_EQ(56000, SetAndGetTargetBitrate(audio_encoder_.get(), 56000));
560 EXPECT_EQ(56000, SetAndGetTargetBitrate(audio_encoder_.get(), 56001));
561 }
562
TEST_F(AudioDecoderIsacFixTest,EncodeDecode)563 TEST_F(AudioDecoderIsacFixTest, EncodeDecode) {
564 int tolerance = 11034;
565 double mse = 3.46e6;
566 int delay = 54; // Delay from input to output.
567 #if defined(WEBRTC_ANDROID) && defined(WEBRTC_ARCH_ARM)
568 static const int kEncodedBytes = 685;
569 #elif defined(WEBRTC_ANDROID) && defined(WEBRTC_ARCH_ARM64)
570 static const int kEncodedBytes = 673;
571 #else
572 static const int kEncodedBytes = 671;
573 #endif
574 EncodeDecodeTest(kEncodedBytes, tolerance, mse, delay);
575 ReInitTest();
576 EXPECT_FALSE(decoder_->HasDecodePlc());
577 }
578
TEST_F(AudioDecoderIsacFixTest,SetTargetBitrate)579 TEST_F(AudioDecoderIsacFixTest, SetTargetBitrate) {
580 EXPECT_EQ(10000, SetAndGetTargetBitrate(audio_encoder_.get(), 9999));
581 EXPECT_EQ(10000, SetAndGetTargetBitrate(audio_encoder_.get(), 10000));
582 EXPECT_EQ(23456, SetAndGetTargetBitrate(audio_encoder_.get(), 23456));
583 EXPECT_EQ(32000, SetAndGetTargetBitrate(audio_encoder_.get(), 32000));
584 EXPECT_EQ(32000, SetAndGetTargetBitrate(audio_encoder_.get(), 32001));
585 }
586
TEST_F(AudioDecoderG722Test,EncodeDecode)587 TEST_F(AudioDecoderG722Test, EncodeDecode) {
588 int tolerance = 6176;
589 double mse = 238630.0;
590 int delay = 22; // Delay from input to output.
591 EncodeDecodeTest(data_length_ / 2, tolerance, mse, delay);
592 ReInitTest();
593 EXPECT_FALSE(decoder_->HasDecodePlc());
594 }
595
TEST_F(AudioDecoderG722Test,SetTargetBitrate)596 TEST_F(AudioDecoderG722Test, SetTargetBitrate) {
597 TestSetAndGetTargetBitratesWithFixedCodec(audio_encoder_.get(), 64000);
598 }
599
TEST_F(AudioDecoderG722StereoTest,EncodeDecode)600 TEST_F(AudioDecoderG722StereoTest, EncodeDecode) {
601 int tolerance = 6176;
602 int channel_diff_tolerance = 0;
603 double mse = 238630.0;
604 int delay = 22; // Delay from input to output.
605 EncodeDecodeTest(data_length_, tolerance, mse, delay, channel_diff_tolerance);
606 ReInitTest();
607 EXPECT_FALSE(decoder_->HasDecodePlc());
608 }
609
TEST_F(AudioDecoderG722StereoTest,SetTargetBitrate)610 TEST_F(AudioDecoderG722StereoTest, SetTargetBitrate) {
611 TestSetAndGetTargetBitratesWithFixedCodec(audio_encoder_.get(), 128000);
612 }
613
TEST_P(AudioDecoderOpusTest,EncodeDecode)614 TEST_P(AudioDecoderOpusTest, EncodeDecode) {
615 constexpr int tolerance = 6176;
616 constexpr int channel_diff_tolerance = 6;
617 constexpr double mse = 238630.0;
618 constexpr int delay = 22; // Delay from input to output.
619 EncodeDecodeTest(0, tolerance, mse, delay, channel_diff_tolerance);
620 ReInitTest();
621 EXPECT_FALSE(decoder_->HasDecodePlc());
622 }
623
TEST_P(AudioDecoderOpusTest,SetTargetBitrate)624 TEST_P(AudioDecoderOpusTest, SetTargetBitrate) {
625 EXPECT_EQ(6000, SetAndGetTargetBitrate(audio_encoder_.get(), 5999));
626 EXPECT_EQ(6000, SetAndGetTargetBitrate(audio_encoder_.get(), 6000));
627 EXPECT_EQ(32000, SetAndGetTargetBitrate(audio_encoder_.get(), 32000));
628 EXPECT_EQ(510000, SetAndGetTargetBitrate(audio_encoder_.get(), 510000));
629 EXPECT_EQ(510000, SetAndGetTargetBitrate(audio_encoder_.get(), 511000));
630 }
631
632 } // namespace webrtc
633