2 * Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
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.
12 #include "testing/gtest/include/gtest/gtest.h"
13 #include "webrtc/modules/audio_coding/codecs/opus/interface/opus_interface.h"
14 #include "webrtc/modules/audio_coding/codecs/opus/opus_inst.h"
15 #include "webrtc/test/testsupport/fileutils.h"
19 // Number of samples in a 60 ms stereo frame, sampled at 48 kHz.
20 const int kOpusMaxFrameSamples = 48 * 60 * 2;
21 // Maximum number of bytes in output bitstream.
22 const size_t kMaxBytes = 1000;
23 // Number of samples-per-channel in a 20 ms frame, sampled at 48 kHz.
24 const int kOpus20msFrameSamples = 48 * 20;
25 // Number of samples-per-channel in a 10 ms frame, sampled at 48 kHz.
26 const int kOpus10msFrameSamples = 48 * 10;
28 class OpusTest : public ::testing::Test {
33 void TestSetMaxPlaybackRate(opus_int32 expect, int32_t set);
35 WebRtcOpusEncInst* opus_mono_encoder_;
36 WebRtcOpusEncInst* opus_stereo_encoder_;
37 WebRtcOpusDecInst* opus_mono_decoder_;
38 WebRtcOpusDecInst* opus_mono_decoder_new_;
39 WebRtcOpusDecInst* opus_stereo_decoder_;
40 WebRtcOpusDecInst* opus_stereo_decoder_new_;
42 int16_t speech_data_[kOpusMaxFrameSamples];
43 int16_t output_data_[kOpusMaxFrameSamples];
44 uint8_t bitstream_[kMaxBytes];
48 : opus_mono_encoder_(NULL),
49 opus_stereo_encoder_(NULL),
50 opus_mono_decoder_(NULL),
51 opus_mono_decoder_new_(NULL),
52 opus_stereo_decoder_(NULL),
53 opus_stereo_decoder_new_(NULL) {
56 void OpusTest::SetUp() {
58 const std::string file_name =
59 webrtc::test::ResourcePath("audio_coding/speech_mono_32_48kHz", "pcm");
60 input_file = fopen(file_name.c_str(), "rb");
61 ASSERT_TRUE(input_file != NULL);
62 ASSERT_EQ(kOpusMaxFrameSamples,
63 static_cast<int32_t>(fread(speech_data_, sizeof(int16_t),
64 kOpusMaxFrameSamples, input_file)));
69 void OpusTest::TestSetMaxPlaybackRate(opus_int32 expect, int32_t set) {
72 EXPECT_EQ(0, WebRtcOpus_SetMaxPlaybackRate(opus_mono_encoder_, set));
73 opus_encoder_ctl(opus_mono_encoder_->encoder,
74 OPUS_GET_MAX_BANDWIDTH(&bandwidth));
75 EXPECT_EQ(expect, bandwidth);
76 // Test stereo encoder.
77 EXPECT_EQ(0, WebRtcOpus_SetMaxPlaybackRate(opus_stereo_encoder_, set));
78 opus_encoder_ctl(opus_stereo_encoder_->encoder,
79 OPUS_GET_MAX_BANDWIDTH(&bandwidth));
80 EXPECT_EQ(expect, bandwidth);
83 // Test failing Create.
84 TEST_F(OpusTest, OpusCreateFail) {
85 // Test to see that an invalid pointer is caught.
86 EXPECT_EQ(-1, WebRtcOpus_EncoderCreate(NULL, 1));
87 EXPECT_EQ(-1, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 3));
88 EXPECT_EQ(-1, WebRtcOpus_DecoderCreate(NULL, 1));
89 EXPECT_EQ(-1, WebRtcOpus_DecoderCreate(&opus_mono_decoder_, 3));
93 TEST_F(OpusTest, OpusFreeFail) {
94 // Test to see that an invalid pointer is caught.
95 EXPECT_EQ(-1, WebRtcOpus_EncoderFree(NULL));
96 EXPECT_EQ(-1, WebRtcOpus_DecoderFree(NULL));
99 // Test normal Create and Free.
100 TEST_F(OpusTest, OpusCreateFree) {
101 EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 1));
102 EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_mono_decoder_, 1));
103 EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2));
104 EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_stereo_decoder_, 2));
105 EXPECT_TRUE(opus_mono_encoder_ != NULL);
106 EXPECT_TRUE(opus_mono_decoder_ != NULL);
107 EXPECT_TRUE(opus_stereo_encoder_ != NULL);
108 EXPECT_TRUE(opus_stereo_decoder_ != NULL);
109 // Free encoder and decoder memory.
110 EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_mono_encoder_));
111 EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_mono_decoder_));
112 EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_));
113 EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_stereo_decoder_));
116 TEST_F(OpusTest, OpusEncodeDecodeMono) {
117 // Create encoder memory.
118 EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 1));
119 EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_mono_decoder_, 1));
120 EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_mono_decoder_new_, 1));
123 EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_mono_encoder_, 32000));
125 // Check number of channels for decoder.
126 EXPECT_EQ(1, WebRtcOpus_DecoderChannels(opus_mono_decoder_));
127 EXPECT_EQ(1, WebRtcOpus_DecoderChannels(opus_mono_decoder_new_));
130 int16_t encoded_bytes;
132 int16_t output_data_decode_new[kOpusMaxFrameSamples];
133 int16_t output_data_decode[kOpusMaxFrameSamples];
134 encoded_bytes = WebRtcOpus_Encode(opus_mono_encoder_, speech_data_,
135 kOpus20msFrameSamples, kMaxBytes,
137 EXPECT_EQ(kOpus20msFrameSamples,
138 WebRtcOpus_DecodeNew(opus_mono_decoder_new_, bitstream_,
139 encoded_bytes, output_data_decode_new,
141 EXPECT_EQ(kOpus20msFrameSamples,
142 WebRtcOpus_Decode(opus_mono_decoder_, bitstream_,
143 encoded_bytes, output_data_decode,
146 // Data in |output_data_decode_new| should be the same as in
147 // |output_data_decode|.
148 for (int i = 0; i < kOpus20msFrameSamples; i++) {
149 EXPECT_EQ(output_data_decode_new[i], output_data_decode[i]);
153 EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_mono_encoder_));
154 EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_mono_decoder_));
155 EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_mono_decoder_new_));
158 TEST_F(OpusTest, OpusEncodeDecodeStereo) {
159 // Create encoder memory.
160 EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2));
161 EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_stereo_decoder_, 2));
162 EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_stereo_decoder_new_, 2));
165 EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_stereo_encoder_, 64000));
167 // Check number of channels for decoder.
168 EXPECT_EQ(2, WebRtcOpus_DecoderChannels(opus_stereo_decoder_));
169 EXPECT_EQ(2, WebRtcOpus_DecoderChannels(opus_stereo_decoder_new_));
172 int16_t encoded_bytes;
174 int16_t output_data_decode_new[kOpusMaxFrameSamples];
175 int16_t output_data_decode[kOpusMaxFrameSamples];
176 int16_t output_data_decode_slave[kOpusMaxFrameSamples];
177 encoded_bytes = WebRtcOpus_Encode(opus_stereo_encoder_, speech_data_,
178 kOpus20msFrameSamples, kMaxBytes,
180 EXPECT_EQ(kOpus20msFrameSamples,
181 WebRtcOpus_DecodeNew(opus_stereo_decoder_new_, bitstream_,
182 encoded_bytes, output_data_decode_new,
184 EXPECT_EQ(kOpus20msFrameSamples,
185 WebRtcOpus_Decode(opus_stereo_decoder_, bitstream_,
186 encoded_bytes, output_data_decode,
188 EXPECT_EQ(kOpus20msFrameSamples,
189 WebRtcOpus_DecodeSlave(opus_stereo_decoder_, bitstream_,
190 encoded_bytes, output_data_decode_slave,
193 // Data in |output_data_decode_new| should be the same as in
194 // |output_data_decode| and |output_data_decode_slave| interleaved to a
196 for (int i = 0; i < kOpus20msFrameSamples; i++) {
197 EXPECT_EQ(output_data_decode_new[i * 2], output_data_decode[i]);
198 EXPECT_EQ(output_data_decode_new[i * 2 + 1], output_data_decode_slave[i]);
202 EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_));
203 EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_stereo_decoder_));
204 EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_stereo_decoder_new_));
207 TEST_F(OpusTest, OpusSetBitRate) {
208 // Test without creating encoder memory.
209 EXPECT_EQ(-1, WebRtcOpus_SetBitRate(opus_mono_encoder_, 60000));
210 EXPECT_EQ(-1, WebRtcOpus_SetBitRate(opus_stereo_encoder_, 60000));
212 // Create encoder memory, try with different bitrates.
213 EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 1));
214 EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2));
215 EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_mono_encoder_, 30000));
216 EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_stereo_encoder_, 60000));
217 EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_mono_encoder_, 300000));
218 EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_stereo_encoder_, 600000));
221 EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_mono_encoder_));
222 EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_));
225 TEST_F(OpusTest, OpusSetComplexity) {
226 // Test without creating encoder memory.
227 EXPECT_EQ(-1, WebRtcOpus_SetComplexity(opus_mono_encoder_, 9));
228 EXPECT_EQ(-1, WebRtcOpus_SetComplexity(opus_stereo_encoder_, 9));
230 // Create encoder memory, try with different complexities.
231 EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 1));
232 EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2));
234 EXPECT_EQ(0, WebRtcOpus_SetComplexity(opus_mono_encoder_, 0));
235 EXPECT_EQ(0, WebRtcOpus_SetComplexity(opus_stereo_encoder_, 0));
236 EXPECT_EQ(0, WebRtcOpus_SetComplexity(opus_mono_encoder_, 10));
237 EXPECT_EQ(0, WebRtcOpus_SetComplexity(opus_stereo_encoder_, 10));
238 EXPECT_EQ(-1, WebRtcOpus_SetComplexity(opus_mono_encoder_, 11));
239 EXPECT_EQ(-1, WebRtcOpus_SetComplexity(opus_stereo_encoder_, 11));
242 EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_mono_encoder_));
243 EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_));
246 // Encode and decode one frame (stereo), initialize the decoder and
248 TEST_F(OpusTest, OpusDecodeInit) {
249 // Create encoder memory.
250 EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2));
251 EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_stereo_decoder_, 2));
252 EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_stereo_decoder_new_, 2));
255 int16_t encoded_bytes;
257 int16_t output_data_decode_new[kOpusMaxFrameSamples];
258 int16_t output_data_decode[kOpusMaxFrameSamples];
259 int16_t output_data_decode_slave[kOpusMaxFrameSamples];
260 encoded_bytes = WebRtcOpus_Encode(opus_stereo_encoder_, speech_data_,
261 kOpus20msFrameSamples, kMaxBytes,
263 EXPECT_EQ(kOpus20msFrameSamples,
264 WebRtcOpus_DecodeNew(opus_stereo_decoder_new_, bitstream_,
265 encoded_bytes, output_data_decode_new,
267 EXPECT_EQ(kOpus20msFrameSamples,
268 WebRtcOpus_Decode(opus_stereo_decoder_, bitstream_,
269 encoded_bytes, output_data_decode,
271 EXPECT_EQ(kOpus20msFrameSamples,
272 WebRtcOpus_DecodeSlave(opus_stereo_decoder_, bitstream_,
273 encoded_bytes, output_data_decode_slave,
276 // Data in |output_data_decode_new| should be the same as in
277 // |output_data_decode| and |output_data_decode_slave| interleaved to a
279 for (int i = 0; i < kOpus20msFrameSamples; i++) {
280 EXPECT_EQ(output_data_decode_new[i * 2], output_data_decode[i]);
281 EXPECT_EQ(output_data_decode_new[i * 2 + 1], output_data_decode_slave[i]);
284 EXPECT_EQ(0, WebRtcOpus_DecoderInitNew(opus_stereo_decoder_new_));
285 EXPECT_EQ(0, WebRtcOpus_DecoderInit(opus_stereo_decoder_));
286 EXPECT_EQ(0, WebRtcOpus_DecoderInitSlave(opus_stereo_decoder_));
288 EXPECT_EQ(kOpus20msFrameSamples,
289 WebRtcOpus_DecodeNew(opus_stereo_decoder_new_, bitstream_,
290 encoded_bytes, output_data_decode_new,
292 EXPECT_EQ(kOpus20msFrameSamples,
293 WebRtcOpus_Decode(opus_stereo_decoder_, bitstream_,
294 encoded_bytes, output_data_decode,
296 EXPECT_EQ(kOpus20msFrameSamples,
297 WebRtcOpus_DecodeSlave(opus_stereo_decoder_, bitstream_,
298 encoded_bytes, output_data_decode_slave,
301 // Data in |output_data_decode_new| should be the same as in
302 // |output_data_decode| and |output_data_decode_slave| interleaved to a
304 for (int i = 0; i < kOpus20msFrameSamples; i++) {
305 EXPECT_EQ(output_data_decode_new[i * 2], output_data_decode[i]);
306 EXPECT_EQ(output_data_decode_new[i * 2 + 1], output_data_decode_slave[i]);
310 EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_));
311 EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_stereo_decoder_));
312 EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_stereo_decoder_new_));
315 TEST_F(OpusTest, OpusEnableDisableFec) {
316 // Test without creating encoder memory.
317 EXPECT_EQ(-1, WebRtcOpus_EnableFec(opus_mono_encoder_));
318 EXPECT_EQ(-1, WebRtcOpus_DisableFec(opus_stereo_encoder_));
320 // Create encoder memory, try with different bitrates.
321 EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 1));
322 EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2));
324 EXPECT_EQ(0, WebRtcOpus_EnableFec(opus_mono_encoder_));
325 EXPECT_EQ(0, WebRtcOpus_EnableFec(opus_stereo_encoder_));
326 EXPECT_EQ(0, WebRtcOpus_DisableFec(opus_mono_encoder_));
327 EXPECT_EQ(0, WebRtcOpus_DisableFec(opus_stereo_encoder_));
330 EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_mono_encoder_));
331 EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_));
334 TEST_F(OpusTest, OpusSetPacketLossRate) {
335 // Test without creating encoder memory.
336 EXPECT_EQ(-1, WebRtcOpus_SetPacketLossRate(opus_mono_encoder_, 50));
337 EXPECT_EQ(-1, WebRtcOpus_SetPacketLossRate(opus_stereo_encoder_, 50));
339 // Create encoder memory, try with different bitrates.
340 EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 1));
341 EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2));
343 EXPECT_EQ(0, WebRtcOpus_SetPacketLossRate(opus_mono_encoder_, 50));
344 EXPECT_EQ(0, WebRtcOpus_SetPacketLossRate(opus_stereo_encoder_, 50));
345 EXPECT_EQ(-1, WebRtcOpus_SetPacketLossRate(opus_mono_encoder_, -1));
346 EXPECT_EQ(-1, WebRtcOpus_SetPacketLossRate(opus_stereo_encoder_, -1));
347 EXPECT_EQ(-1, WebRtcOpus_SetPacketLossRate(opus_mono_encoder_, 101));
348 EXPECT_EQ(-1, WebRtcOpus_SetPacketLossRate(opus_stereo_encoder_, 101));
351 EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_mono_encoder_));
352 EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_));
355 TEST_F(OpusTest, OpusSetMaxPlaybackRate) {
356 // Test without creating encoder memory.
357 EXPECT_EQ(-1, WebRtcOpus_SetMaxPlaybackRate(opus_mono_encoder_, 20000));
358 EXPECT_EQ(-1, WebRtcOpus_SetMaxPlaybackRate(opus_stereo_encoder_, 20000));
360 // Create encoder memory, try with different bitrates.
361 EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 1));
362 EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2));
364 TestSetMaxPlaybackRate(OPUS_BANDWIDTH_FULLBAND, 48000);
365 TestSetMaxPlaybackRate(OPUS_BANDWIDTH_FULLBAND, 24001);
366 TestSetMaxPlaybackRate(OPUS_BANDWIDTH_SUPERWIDEBAND, 24000);
367 TestSetMaxPlaybackRate(OPUS_BANDWIDTH_SUPERWIDEBAND, 16001);
368 TestSetMaxPlaybackRate(OPUS_BANDWIDTH_WIDEBAND, 16000);
369 TestSetMaxPlaybackRate(OPUS_BANDWIDTH_WIDEBAND, 12001);
370 TestSetMaxPlaybackRate(OPUS_BANDWIDTH_MEDIUMBAND, 12000);
371 TestSetMaxPlaybackRate(OPUS_BANDWIDTH_MEDIUMBAND, 8001);
372 TestSetMaxPlaybackRate(OPUS_BANDWIDTH_NARROWBAND, 8000);
373 TestSetMaxPlaybackRate(OPUS_BANDWIDTH_NARROWBAND, 4000);
376 EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_mono_encoder_));
377 EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_));
381 TEST_F(OpusTest, OpusDecodePlcMono) {
382 // Create encoder memory.
383 EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 1));
384 EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_mono_decoder_, 1));
385 EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_mono_decoder_new_, 1));
388 EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_mono_encoder_, 32000));
390 // Check number of channels for decoder.
391 EXPECT_EQ(1, WebRtcOpus_DecoderChannels(opus_mono_decoder_));
392 EXPECT_EQ(1, WebRtcOpus_DecoderChannels(opus_mono_decoder_new_));
395 int16_t encoded_bytes;
397 int16_t output_data_decode_new[kOpusMaxFrameSamples];
398 int16_t output_data_decode[kOpusMaxFrameSamples];
399 encoded_bytes = WebRtcOpus_Encode(opus_mono_encoder_, speech_data_,
400 kOpus20msFrameSamples, kMaxBytes,
402 EXPECT_EQ(kOpus20msFrameSamples,
403 WebRtcOpus_DecodeNew(opus_mono_decoder_new_, bitstream_,
404 encoded_bytes, output_data_decode_new,
406 EXPECT_EQ(kOpus20msFrameSamples,
407 WebRtcOpus_Decode(opus_mono_decoder_, bitstream_,
408 encoded_bytes, output_data_decode,
411 // Call decoder PLC for both versions of the decoder.
412 int16_t plc_buffer[kOpusMaxFrameSamples];
413 int16_t plc_buffer_new[kOpusMaxFrameSamples];
414 EXPECT_EQ(kOpus20msFrameSamples,
415 WebRtcOpus_DecodePlcMaster(opus_mono_decoder_, plc_buffer, 1));
416 EXPECT_EQ(kOpus20msFrameSamples,
417 WebRtcOpus_DecodePlc(opus_mono_decoder_new_, plc_buffer_new, 1));
419 // Data in |plc_buffer| should be the same as in |plc_buffer_new|.
420 for (int i = 0; i < kOpus20msFrameSamples; i++) {
421 EXPECT_EQ(plc_buffer[i], plc_buffer_new[i]);
425 EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_mono_encoder_));
426 EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_mono_decoder_));
427 EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_mono_decoder_new_));
430 // PLC in stereo mode.
431 TEST_F(OpusTest, OpusDecodePlcStereo) {
432 // Create encoder memory.
433 EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2));
434 EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_stereo_decoder_, 2));
435 EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_stereo_decoder_new_, 2));
438 EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_stereo_encoder_, 64000));
440 // Check number of channels for decoder.
441 EXPECT_EQ(2, WebRtcOpus_DecoderChannels(opus_stereo_decoder_));
442 EXPECT_EQ(2, WebRtcOpus_DecoderChannels(opus_stereo_decoder_new_));
445 int16_t encoded_bytes;
447 int16_t output_data_decode_new[kOpusMaxFrameSamples];
448 int16_t output_data_decode[kOpusMaxFrameSamples];
449 int16_t output_data_decode_slave[kOpusMaxFrameSamples];
450 encoded_bytes = WebRtcOpus_Encode(opus_stereo_encoder_, speech_data_,
451 kOpus20msFrameSamples, kMaxBytes,
453 EXPECT_EQ(kOpus20msFrameSamples,
454 WebRtcOpus_DecodeNew(opus_stereo_decoder_new_, bitstream_,
455 encoded_bytes, output_data_decode_new,
457 EXPECT_EQ(kOpus20msFrameSamples,
458 WebRtcOpus_Decode(opus_stereo_decoder_, bitstream_,
459 encoded_bytes, output_data_decode,
461 EXPECT_EQ(kOpus20msFrameSamples,
462 WebRtcOpus_DecodeSlave(opus_stereo_decoder_, bitstream_,
464 output_data_decode_slave,
467 // Call decoder PLC for both versions of the decoder.
468 int16_t plc_buffer_left[kOpusMaxFrameSamples];
469 int16_t plc_buffer_right[kOpusMaxFrameSamples];
470 int16_t plc_buffer_new[kOpusMaxFrameSamples];
471 EXPECT_EQ(kOpus20msFrameSamples,
472 WebRtcOpus_DecodePlcMaster(opus_stereo_decoder_,
473 plc_buffer_left, 1));
474 EXPECT_EQ(kOpus20msFrameSamples,
475 WebRtcOpus_DecodePlcSlave(opus_stereo_decoder_,
476 plc_buffer_right, 1));
477 EXPECT_EQ(kOpus20msFrameSamples,
478 WebRtcOpus_DecodePlc(opus_stereo_decoder_new_, plc_buffer_new, 1));
479 // Data in |plc_buffer_left| and |plc_buffer_right|should be the same as the
480 // interleaved samples in |plc_buffer_new|.
481 for (int i = 0, j = 0; i < kOpus20msFrameSamples; i++) {
482 EXPECT_EQ(plc_buffer_left[i], plc_buffer_new[j++]);
483 EXPECT_EQ(plc_buffer_right[i], plc_buffer_new[j++]);
487 EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_));
488 EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_stereo_decoder_));
489 EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_stereo_decoder_new_));
492 // Duration estimation.
493 TEST_F(OpusTest, OpusDurationEstimation) {
495 EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2));
496 EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_stereo_decoder_, 2));
498 int16_t encoded_bytes;
501 encoded_bytes = WebRtcOpus_Encode(opus_stereo_encoder_, speech_data_,
502 kOpus10msFrameSamples, kMaxBytes,
504 EXPECT_EQ(kOpus10msFrameSamples,
505 WebRtcOpus_DurationEst(opus_stereo_decoder_, bitstream_,
509 encoded_bytes = WebRtcOpus_Encode(opus_stereo_encoder_, speech_data_,
510 kOpus20msFrameSamples, kMaxBytes,
512 EXPECT_EQ(kOpus20msFrameSamples,
513 WebRtcOpus_DurationEst(opus_stereo_decoder_, bitstream_,
517 EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_));
518 EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_stereo_decoder_));
521 } // namespace webrtc