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