opus_unittest.cc revision 8f8503d947e820cce35fa3d0f2b25b6b893cf141 
1/*
2 *  Copyright (c) 2013 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#include <string>
11
12#include "testing/gtest/include/gtest/gtest.h"
13#include "webrtc/modules/audio_coding/codecs/opus/interface/opus_interface.h"
14#include "webrtc/test/testsupport/fileutils.h"
15
16struct WebRtcOpusEncInst;
17struct WebRtcOpusDecInst;
18
19namespace webrtc {
20
21// Number of samples in a 60 ms stereo frame, sampled at 48 kHz.
22const int kOpusMaxFrameSamples = 48 * 60 * 2;
23// Maximum number of bytes in output bitstream.
24const size_t kMaxBytes = 1000;
25// Number of samples-per-channel in a 20 ms frame, sampled at 48 kHz.
26const int kOpus20msFrameSamples = 48 * 20;
27// Number of samples-per-channel in a 10 ms frame, sampled at 48 kHz.
28const int kOpus10msFrameSamples = 48 * 10;
29
30class OpusTest : public ::testing::Test {
31 protected:
32  OpusTest();
33  virtual void SetUp();
34
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_;
41
42  int16_t speech_data_[kOpusMaxFrameSamples];
43  int16_t output_data_[kOpusMaxFrameSamples];
44  uint8_t bitstream_[kMaxBytes];
45};
46
47OpusTest::OpusTest()
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) {
54}
55
56void OpusTest::SetUp() {
57  FILE* input_file;
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)));
65  fclose(input_file);
66  input_file = NULL;
67}
68
69// Test failing Create.
70TEST_F(OpusTest, OpusCreateFail) {
71  // Test to see that an invalid pointer is caught.
72  EXPECT_EQ(-1, WebRtcOpus_EncoderCreate(NULL, 1));
73  EXPECT_EQ(-1, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 3));
74  EXPECT_EQ(-1, WebRtcOpus_DecoderCreate(NULL, 1));
75  EXPECT_EQ(-1, WebRtcOpus_DecoderCreate(&opus_mono_decoder_, 3));
76}
77
78// Test failing Free.
79TEST_F(OpusTest, OpusFreeFail) {
80  // Test to see that an invalid pointer is caught.
81  EXPECT_EQ(-1, WebRtcOpus_EncoderFree(NULL));
82  EXPECT_EQ(-1, WebRtcOpus_DecoderFree(NULL));
83}
84
85// Test normal Create and Free.
86TEST_F(OpusTest, OpusCreateFree) {
87  EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 1));
88  EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_mono_decoder_, 1));
89  EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2));
90  EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_stereo_decoder_, 2));
91  EXPECT_TRUE(opus_mono_encoder_ != NULL);
92  EXPECT_TRUE(opus_mono_decoder_ != NULL);
93  EXPECT_TRUE(opus_stereo_encoder_ != NULL);
94  EXPECT_TRUE(opus_stereo_decoder_ != NULL);
95  // Free encoder and decoder memory.
96  EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_mono_encoder_));
97  EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_mono_decoder_));
98  EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_));
99  EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_stereo_decoder_));
100}
101
102TEST_F(OpusTest, OpusEncodeDecodeMono) {
103  // Create encoder memory.
104  EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 1));
105  EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_mono_decoder_, 1));
106  EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_mono_decoder_new_, 1));
107
108  // Set bitrate.
109  EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_mono_encoder_, 32000));
110
111  // Check number of channels for decoder.
112  EXPECT_EQ(1, WebRtcOpus_DecoderChannels(opus_mono_decoder_));
113  EXPECT_EQ(1, WebRtcOpus_DecoderChannels(opus_mono_decoder_new_));
114
115  // Encode & decode.
116  int16_t encoded_bytes;
117  int16_t audio_type;
118  int16_t output_data_decode_new[kOpusMaxFrameSamples];
119  int16_t output_data_decode[kOpusMaxFrameSamples];
120  int16_t* coded = reinterpret_cast<int16_t*>(bitstream_);
121  encoded_bytes = WebRtcOpus_Encode(opus_mono_encoder_, speech_data_,
122                                    kOpus20msFrameSamples, kMaxBytes,
123                                    bitstream_);
124  EXPECT_EQ(kOpus20msFrameSamples,
125            WebRtcOpus_DecodeNew(opus_mono_decoder_new_, bitstream_,
126                                 encoded_bytes, output_data_decode_new,
127                                 &audio_type));
128  EXPECT_EQ(kOpus20msFrameSamples,
129            WebRtcOpus_Decode(opus_mono_decoder_, coded,
130                              encoded_bytes, output_data_decode,
131                              &audio_type));
132
133  // Data in |output_data_decode_new| should be the same as in
134  // |output_data_decode|.
135  for (int i = 0; i < kOpus20msFrameSamples; i++) {
136    EXPECT_EQ(output_data_decode_new[i], output_data_decode[i]);
137  }
138
139  // Free memory.
140  EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_mono_encoder_));
141  EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_mono_decoder_));
142  EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_mono_decoder_new_));
143}
144
145TEST_F(OpusTest, OpusEncodeDecodeStereo) {
146  // Create encoder memory.
147  EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2));
148  EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_stereo_decoder_, 2));
149  EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_stereo_decoder_new_, 2));
150
151  // Set bitrate.
152  EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_stereo_encoder_, 64000));
153
154  // Check number of channels for decoder.
155  EXPECT_EQ(2, WebRtcOpus_DecoderChannels(opus_stereo_decoder_));
156  EXPECT_EQ(2, WebRtcOpus_DecoderChannels(opus_stereo_decoder_new_));
157
158  // Encode & decode.
159  int16_t encoded_bytes;
160  int16_t audio_type;
161  int16_t output_data_decode_new[kOpusMaxFrameSamples];
162  int16_t output_data_decode[kOpusMaxFrameSamples];
163  int16_t output_data_decode_slave[kOpusMaxFrameSamples];
164  int16_t* coded = reinterpret_cast<int16_t*>(bitstream_);
165  encoded_bytes = WebRtcOpus_Encode(opus_stereo_encoder_, speech_data_,
166                                    kOpus20msFrameSamples, kMaxBytes,
167                                    bitstream_);
168  EXPECT_EQ(kOpus20msFrameSamples,
169            WebRtcOpus_DecodeNew(opus_stereo_decoder_new_, bitstream_,
170                                 encoded_bytes, output_data_decode_new,
171                                 &audio_type));
172  EXPECT_EQ(kOpus20msFrameSamples,
173            WebRtcOpus_Decode(opus_stereo_decoder_, coded,
174                              encoded_bytes, output_data_decode,
175                              &audio_type));
176  EXPECT_EQ(kOpus20msFrameSamples,
177            WebRtcOpus_DecodeSlave(opus_stereo_decoder_, coded,
178                                   encoded_bytes, output_data_decode_slave,
179                                   &audio_type));
180
181  // Data in |output_data_decode_new| should be the same as in
182  // |output_data_decode| and |output_data_decode_slave| interleaved to a
183  // stereo signal.
184  for (int i = 0; i < kOpus20msFrameSamples; i++) {
185    EXPECT_EQ(output_data_decode_new[i * 2], output_data_decode[i]);
186    EXPECT_EQ(output_data_decode_new[i * 2 + 1], output_data_decode_slave[i]);
187  }
188
189  // Free memory.
190  EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_));
191  EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_stereo_decoder_));
192  EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_stereo_decoder_new_));
193}
194
195TEST_F(OpusTest, OpusSetBitRate) {
196  // Test without creating encoder memory.
197  EXPECT_EQ(-1, WebRtcOpus_SetBitRate(opus_mono_encoder_, 60000));
198  EXPECT_EQ(-1, WebRtcOpus_SetBitRate(opus_stereo_encoder_, 60000));
199
200  // Create encoder memory, try with different bitrates.
201  EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 1));
202  EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2));
203  EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_mono_encoder_, 30000));
204  EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_stereo_encoder_, 60000));
205  EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_mono_encoder_, 300000));
206  EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_stereo_encoder_, 600000));
207
208  // Free memory.
209  EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_mono_encoder_));
210  EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_));
211}
212
213TEST_F(OpusTest, OpusSetComplexity) {
214  // Test without creating encoder memory.
215  EXPECT_EQ(-1, WebRtcOpus_SetComplexity(opus_mono_encoder_, 9));
216  EXPECT_EQ(-1, WebRtcOpus_SetComplexity(opus_stereo_encoder_, 9));
217
218  // Create encoder memory, try with different complexities.
219  EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 1));
220  EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2));
221
222  EXPECT_EQ(0, WebRtcOpus_SetComplexity(opus_mono_encoder_, 0));
223  EXPECT_EQ(0, WebRtcOpus_SetComplexity(opus_stereo_encoder_, 0));
224  EXPECT_EQ(0, WebRtcOpus_SetComplexity(opus_mono_encoder_, 10));
225  EXPECT_EQ(0, WebRtcOpus_SetComplexity(opus_stereo_encoder_, 10));
226  EXPECT_EQ(-1, WebRtcOpus_SetComplexity(opus_mono_encoder_, 11));
227  EXPECT_EQ(-1, WebRtcOpus_SetComplexity(opus_stereo_encoder_, 11));
228
229  // Free memory.
230  EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_mono_encoder_));
231  EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_));
232}
233
234// Encode and decode one frame (stereo), initialize the decoder and
235// decode once more.
236TEST_F(OpusTest, OpusDecodeInit) {
237  // Create encoder memory.
238  EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2));
239  EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_stereo_decoder_, 2));
240  EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_stereo_decoder_new_, 2));
241
242  // Encode & decode.
243  int16_t encoded_bytes;
244  int16_t audio_type;
245  int16_t output_data_decode_new[kOpusMaxFrameSamples];
246  int16_t output_data_decode[kOpusMaxFrameSamples];
247  int16_t output_data_decode_slave[kOpusMaxFrameSamples];
248  int16_t* coded = reinterpret_cast<int16_t*>(bitstream_);
249  encoded_bytes = WebRtcOpus_Encode(opus_stereo_encoder_, speech_data_,
250                                    kOpus20msFrameSamples, kMaxBytes,
251                                    bitstream_);
252  EXPECT_EQ(kOpus20msFrameSamples,
253            WebRtcOpus_DecodeNew(opus_stereo_decoder_new_, bitstream_,
254                                 encoded_bytes, output_data_decode_new,
255                                 &audio_type));
256  EXPECT_EQ(kOpus20msFrameSamples,
257            WebRtcOpus_Decode(opus_stereo_decoder_, coded,
258                              encoded_bytes, output_data_decode,
259                              &audio_type));
260  EXPECT_EQ(kOpus20msFrameSamples,
261            WebRtcOpus_DecodeSlave(opus_stereo_decoder_, coded,
262                                   encoded_bytes, output_data_decode_slave,
263                                   &audio_type));
264
265  // Data in |output_data_decode_new| should be the same as in
266  // |output_data_decode| and |output_data_decode_slave| interleaved to a
267  // stereo signal.
268  for (int i = 0; i < kOpus20msFrameSamples; i++) {
269    EXPECT_EQ(output_data_decode_new[i * 2], output_data_decode[i]);
270    EXPECT_EQ(output_data_decode_new[i * 2 + 1], output_data_decode_slave[i]);
271  }
272
273  EXPECT_EQ(0, WebRtcOpus_DecoderInitNew(opus_stereo_decoder_new_));
274  EXPECT_EQ(0, WebRtcOpus_DecoderInit(opus_stereo_decoder_));
275  EXPECT_EQ(0, WebRtcOpus_DecoderInitSlave(opus_stereo_decoder_));
276
277  EXPECT_EQ(kOpus20msFrameSamples,
278            WebRtcOpus_DecodeNew(opus_stereo_decoder_new_, bitstream_,
279                                 encoded_bytes, output_data_decode_new,
280                                 &audio_type));
281  EXPECT_EQ(kOpus20msFrameSamples,
282            WebRtcOpus_Decode(opus_stereo_decoder_, coded,
283                              encoded_bytes, output_data_decode,
284                              &audio_type));
285  EXPECT_EQ(kOpus20msFrameSamples,
286            WebRtcOpus_DecodeSlave(opus_stereo_decoder_, coded,
287                                   encoded_bytes, output_data_decode_slave,
288                                   &audio_type));
289
290  // Data in |output_data_decode_new| should be the same as in
291  // |output_data_decode| and |output_data_decode_slave| interleaved to a
292  // stereo signal.
293  for (int i = 0; i < kOpus20msFrameSamples; i++) {
294    EXPECT_EQ(output_data_decode_new[i * 2], output_data_decode[i]);
295    EXPECT_EQ(output_data_decode_new[i * 2 + 1], output_data_decode_slave[i]);
296  }
297
298  // Free memory.
299  EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_));
300  EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_stereo_decoder_));
301  EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_stereo_decoder_new_));
302}
303
304TEST_F(OpusTest, OpusEnableDisableFec) {
305  // Test without creating encoder memory.
306  EXPECT_EQ(-1, WebRtcOpus_EnableFec(opus_mono_encoder_));
307  EXPECT_EQ(-1, WebRtcOpus_DisableFec(opus_stereo_encoder_));
308
309  // Create encoder memory, try with different bitrates.
310  EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 1));
311  EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2));
312
313  EXPECT_EQ(0, WebRtcOpus_EnableFec(opus_mono_encoder_));
314  EXPECT_EQ(0, WebRtcOpus_EnableFec(opus_stereo_encoder_));
315  EXPECT_EQ(0, WebRtcOpus_DisableFec(opus_mono_encoder_));
316  EXPECT_EQ(0, WebRtcOpus_DisableFec(opus_stereo_encoder_));
317
318  // Free memory.
319  EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_mono_encoder_));
320  EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_));
321}
322
323TEST_F(OpusTest, OpusSetPacketLossRate) {
324  // Test without creating encoder memory.
325  EXPECT_EQ(-1, WebRtcOpus_SetPacketLossRate(opus_mono_encoder_, 50));
326  EXPECT_EQ(-1, WebRtcOpus_SetPacketLossRate(opus_stereo_encoder_, 50));
327
328  // Create encoder memory, try with different bitrates.
329  EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 1));
330  EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2));
331
332  EXPECT_EQ(0, WebRtcOpus_SetPacketLossRate(opus_mono_encoder_, 50));
333  EXPECT_EQ(0, WebRtcOpus_SetPacketLossRate(opus_stereo_encoder_, 50));
334  EXPECT_EQ(-1, WebRtcOpus_SetPacketLossRate(opus_mono_encoder_, -1));
335  EXPECT_EQ(-1, WebRtcOpus_SetPacketLossRate(opus_stereo_encoder_, -1));
336  EXPECT_EQ(-1, WebRtcOpus_SetPacketLossRate(opus_mono_encoder_, 101));
337  EXPECT_EQ(-1, WebRtcOpus_SetPacketLossRate(opus_stereo_encoder_, 101));
338
339  // Free memory.
340  EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_mono_encoder_));
341  EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_));
342}
343
344
345// PLC in mono mode.
346TEST_F(OpusTest, OpusDecodePlcMono) {
347  // Create encoder memory.
348  EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 1));
349  EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_mono_decoder_, 1));
350  EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_mono_decoder_new_, 1));
351
352  // Set bitrate.
353  EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_mono_encoder_, 32000));
354
355  // Check number of channels for decoder.
356  EXPECT_EQ(1, WebRtcOpus_DecoderChannels(opus_mono_decoder_));
357  EXPECT_EQ(1, WebRtcOpus_DecoderChannels(opus_mono_decoder_new_));
358
359  // Encode & decode.
360  int16_t encoded_bytes;
361  int16_t audio_type;
362  int16_t output_data_decode_new[kOpusMaxFrameSamples];
363  int16_t output_data_decode[kOpusMaxFrameSamples];
364  int16_t* coded = reinterpret_cast<int16_t*>(bitstream_);
365  encoded_bytes = WebRtcOpus_Encode(opus_mono_encoder_, speech_data_,
366                                    kOpus20msFrameSamples, kMaxBytes,
367                                    bitstream_);
368  EXPECT_EQ(kOpus20msFrameSamples,
369            WebRtcOpus_DecodeNew(opus_mono_decoder_new_, bitstream_,
370                                 encoded_bytes, output_data_decode_new,
371                                 &audio_type));
372  EXPECT_EQ(kOpus20msFrameSamples,
373            WebRtcOpus_Decode(opus_mono_decoder_, coded,
374                              encoded_bytes, output_data_decode,
375                              &audio_type));
376
377  // Call decoder PLC for both versions of the decoder.
378  int16_t plc_buffer[kOpusMaxFrameSamples];
379  int16_t plc_buffer_new[kOpusMaxFrameSamples];
380  EXPECT_EQ(kOpus20msFrameSamples,
381            WebRtcOpus_DecodePlcMaster(opus_mono_decoder_, plc_buffer, 1));
382  EXPECT_EQ(kOpus20msFrameSamples,
383            WebRtcOpus_DecodePlc(opus_mono_decoder_new_, plc_buffer_new, 1));
384
385  // Data in |plc_buffer| should be the same as in |plc_buffer_new|.
386  for (int i = 0; i < kOpus20msFrameSamples; i++) {
387    EXPECT_EQ(plc_buffer[i], plc_buffer_new[i]);
388  }
389
390  // Free memory.
391  EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_mono_encoder_));
392  EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_mono_decoder_));
393  EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_mono_decoder_new_));
394}
395
396// PLC in stereo mode.
397TEST_F(OpusTest, OpusDecodePlcStereo) {
398  // Create encoder memory.
399  EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2));
400  EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_stereo_decoder_, 2));
401  EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_stereo_decoder_new_, 2));
402
403  // Set bitrate.
404  EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_stereo_encoder_, 64000));
405
406  // Check number of channels for decoder.
407  EXPECT_EQ(2, WebRtcOpus_DecoderChannels(opus_stereo_decoder_));
408  EXPECT_EQ(2, WebRtcOpus_DecoderChannels(opus_stereo_decoder_new_));
409
410  // Encode & decode.
411  int16_t encoded_bytes;
412  int16_t audio_type;
413  int16_t output_data_decode_new[kOpusMaxFrameSamples];
414  int16_t output_data_decode[kOpusMaxFrameSamples];
415  int16_t output_data_decode_slave[kOpusMaxFrameSamples];
416  int16_t* coded = reinterpret_cast<int16_t*>(bitstream_);
417  encoded_bytes = WebRtcOpus_Encode(opus_stereo_encoder_, speech_data_,
418                                    kOpus20msFrameSamples, kMaxBytes,
419                                    bitstream_);
420  EXPECT_EQ(kOpus20msFrameSamples,
421            WebRtcOpus_DecodeNew(opus_stereo_decoder_new_, bitstream_,
422                                 encoded_bytes, output_data_decode_new,
423                                 &audio_type));
424  EXPECT_EQ(kOpus20msFrameSamples,
425            WebRtcOpus_Decode(opus_stereo_decoder_, coded,
426                              encoded_bytes, output_data_decode,
427                              &audio_type));
428  EXPECT_EQ(kOpus20msFrameSamples,
429            WebRtcOpus_DecodeSlave(opus_stereo_decoder_, coded,
430                                   encoded_bytes,
431                                   output_data_decode_slave,
432                                   &audio_type));
433
434  // Call decoder PLC for both versions of the decoder.
435  int16_t plc_buffer_left[kOpusMaxFrameSamples];
436  int16_t plc_buffer_right[kOpusMaxFrameSamples];
437  int16_t plc_buffer_new[kOpusMaxFrameSamples];
438  EXPECT_EQ(kOpus20msFrameSamples,
439            WebRtcOpus_DecodePlcMaster(opus_stereo_decoder_,
440                                       plc_buffer_left, 1));
441  EXPECT_EQ(kOpus20msFrameSamples,
442            WebRtcOpus_DecodePlcSlave(opus_stereo_decoder_,
443                                      plc_buffer_right, 1));
444  EXPECT_EQ(kOpus20msFrameSamples,
445            WebRtcOpus_DecodePlc(opus_stereo_decoder_new_, plc_buffer_new, 1));
446  // Data in |plc_buffer_left| and |plc_buffer_right|should be the same as the
447  // interleaved samples in |plc_buffer_new|.
448  for (int i = 0, j = 0; i < kOpus20msFrameSamples; i++) {
449    EXPECT_EQ(plc_buffer_left[i], plc_buffer_new[j++]);
450    EXPECT_EQ(plc_buffer_right[i], plc_buffer_new[j++]);
451  }
452
453  // Free memory.
454  EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_));
455  EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_stereo_decoder_));
456  EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_stereo_decoder_new_));
457}
458
459// Duration estimation.
460TEST_F(OpusTest, OpusDurationEstimation) {
461  // Create.
462  EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2));
463  EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_stereo_decoder_, 2));
464
465  int16_t encoded_bytes;
466
467  // 10 ms.
468  encoded_bytes = WebRtcOpus_Encode(opus_stereo_encoder_, speech_data_,
469                                    kOpus10msFrameSamples, kMaxBytes,
470                                    bitstream_);
471  EXPECT_EQ(kOpus10msFrameSamples,
472            WebRtcOpus_DurationEst(opus_stereo_decoder_, bitstream_,
473                                   encoded_bytes));
474
475  // 20 ms
476  encoded_bytes = WebRtcOpus_Encode(opus_stereo_encoder_, speech_data_,
477                                    kOpus20msFrameSamples, kMaxBytes,
478                                    bitstream_);
479  EXPECT_EQ(kOpus20msFrameSamples,
480            WebRtcOpus_DurationEst(opus_stereo_decoder_, bitstream_,
481                                   encoded_bytes));
482
483  // Free memory.
484  EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_));
485  EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_stereo_decoder_));
486}
487
488}  // namespace webrtc
489