src/third_party/webrtc/modules/audio_coding/codecs/opus/opus_unittest.cc

   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/modules/audio_coding/codecs/opus/opus_inst.h"
  15 #include "webrtc/test/testsupport/fileutils.h"
  16
  17 namespace webrtc {
  18
  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;
  27
  28 class OpusTest : public ::testing::Test {
  29  protected:
  30   OpusTest();
  31   virtual void SetUp();
  32
  33   void TestSetMaxPlaybackRate(opus_int32 expect, int32_t set);
  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
  47 OpusTest::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
  56 void 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 void OpusTest::TestSetMaxPlaybackRate(opus_int32 expect, int32_t set) {
  70   opus_int32 bandwidth;
  71   // Test mono encoder.
  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);
  81 }
  82
  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));
  90 }
  91
  92 // Test failing Free.
  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));
  97 }
  98
  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_));
 114 }
 115
 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));
 121
 122   // Set bitrate.
 123   EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_mono_encoder_, 32000));
 124
 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_));
 128
 129   // Encode & decode.
 130   int16_t encoded_bytes;
 131   int16_t audio_type;
 132   int16_t output_data_decode_new[kOpusMaxFrameSamples];
 133   int16_t output_data_decode[kOpusMaxFrameSamples];
 134   int16_t* coded = reinterpret_cast<int16_t*>(bitstream_);
 135   encoded_bytes = WebRtcOpus_Encode(opus_mono_encoder_, speech_data_,
 136                                     kOpus20msFrameSamples, kMaxBytes,
 137                                     bitstream_);
 138   EXPECT_EQ(kOpus20msFrameSamples,
 139             WebRtcOpus_DecodeNew(opus_mono_decoder_new_, bitstream_,
 140                                  encoded_bytes, output_data_decode_new,
 141                                  &audio_type));
 142   EXPECT_EQ(kOpus20msFrameSamples,
 143             WebRtcOpus_Decode(opus_mono_decoder_, coded,
 144                               encoded_bytes, output_data_decode,
 145                               &audio_type));
 146
 147   // Data in |output_data_decode_new| should be the same as in
 148   // |output_data_decode|.
 149   for (int i = 0; i < kOpus20msFrameSamples; i++) {
 150     EXPECT_EQ(output_data_decode_new[i], output_data_decode[i]);
 151   }
 152
 153   // Free memory.
 154   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_mono_encoder_));
 155   EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_mono_decoder_));
 156   EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_mono_decoder_new_));
 157 }
 158
 159 TEST_F(OpusTest, OpusEncodeDecodeStereo) {
 160   // Create encoder memory.
 161   EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2));
 162   EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_stereo_decoder_, 2));
 163   EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_stereo_decoder_new_, 2));
 164
 165   // Set bitrate.
 166   EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_stereo_encoder_, 64000));
 167
 168   // Check number of channels for decoder.
 169   EXPECT_EQ(2, WebRtcOpus_DecoderChannels(opus_stereo_decoder_));
 170   EXPECT_EQ(2, WebRtcOpus_DecoderChannels(opus_stereo_decoder_new_));
 171
 172   // Encode & decode.
 173   int16_t encoded_bytes;
 174   int16_t audio_type;
 175   int16_t output_data_decode_new[kOpusMaxFrameSamples];
 176   int16_t output_data_decode[kOpusMaxFrameSamples];
 177   int16_t output_data_decode_slave[kOpusMaxFrameSamples];
 178   int16_t* coded = reinterpret_cast<int16_t*>(bitstream_);
 179   encoded_bytes = WebRtcOpus_Encode(opus_stereo_encoder_, speech_data_,
 180                                     kOpus20msFrameSamples, kMaxBytes,
 181                                     bitstream_);
 182   EXPECT_EQ(kOpus20msFrameSamples,
 183             WebRtcOpus_DecodeNew(opus_stereo_decoder_new_, bitstream_,
 184                                  encoded_bytes, output_data_decode_new,
 185                                  &audio_type));
 186   EXPECT_EQ(kOpus20msFrameSamples,
 187             WebRtcOpus_Decode(opus_stereo_decoder_, coded,
 188                               encoded_bytes, output_data_decode,
 189                               &audio_type));
 190   EXPECT_EQ(kOpus20msFrameSamples,
 191             WebRtcOpus_DecodeSlave(opus_stereo_decoder_, coded,
 192                                    encoded_bytes, output_data_decode_slave,
 193                                    &audio_type));
 194
 195   // Data in |output_data_decode_new| should be the same as in
 196   // |output_data_decode| and |output_data_decode_slave| interleaved to a
 197   // stereo signal.
 198   for (int i = 0; i < kOpus20msFrameSamples; i++) {
 199     EXPECT_EQ(output_data_decode_new[i * 2], output_data_decode[i]);
 200     EXPECT_EQ(output_data_decode_new[i * 2 + 1], output_data_decode_slave[i]);
 201   }
 202
 203   // Free memory.
 204   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_));
 205   EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_stereo_decoder_));
 206   EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_stereo_decoder_new_));
 207 }
 208
 209 TEST_F(OpusTest, OpusSetBitRate) {
 210   // Test without creating encoder memory.
 211   EXPECT_EQ(-1, WebRtcOpus_SetBitRate(opus_mono_encoder_, 60000));
 212   EXPECT_EQ(-1, WebRtcOpus_SetBitRate(opus_stereo_encoder_, 60000));
 213
 214   // Create encoder memory, try with different bitrates.
 215   EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 1));
 216   EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2));
 217   EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_mono_encoder_, 30000));
 218   EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_stereo_encoder_, 60000));
 219   EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_mono_encoder_, 300000));
 220   EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_stereo_encoder_, 600000));
 221
 222   // Free memory.
 223   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_mono_encoder_));
 224   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_));
 225 }
 226
 227 TEST_F(OpusTest, OpusSetComplexity) {
 228   // Test without creating encoder memory.
 229   EXPECT_EQ(-1, WebRtcOpus_SetComplexity(opus_mono_encoder_, 9));
 230   EXPECT_EQ(-1, WebRtcOpus_SetComplexity(opus_stereo_encoder_, 9));
 231
 232   // Create encoder memory, try with different complexities.
 233   EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 1));
 234   EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2));
 235
 236   EXPECT_EQ(0, WebRtcOpus_SetComplexity(opus_mono_encoder_, 0));
 237   EXPECT_EQ(0, WebRtcOpus_SetComplexity(opus_stereo_encoder_, 0));
 238   EXPECT_EQ(0, WebRtcOpus_SetComplexity(opus_mono_encoder_, 10));
 239   EXPECT_EQ(0, WebRtcOpus_SetComplexity(opus_stereo_encoder_, 10));
 240   EXPECT_EQ(-1, WebRtcOpus_SetComplexity(opus_mono_encoder_, 11));
 241   EXPECT_EQ(-1, WebRtcOpus_SetComplexity(opus_stereo_encoder_, 11));
 242
 243   // Free memory.
 244   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_mono_encoder_));
 245   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_));
 246 }
 247
 248 // Encode and decode one frame (stereo), initialize the decoder and
 249 // decode once more.
 250 TEST_F(OpusTest, OpusDecodeInit) {
 251   // Create encoder memory.
 252   EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2));
 253   EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_stereo_decoder_, 2));
 254   EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_stereo_decoder_new_, 2));
 255
 256   // Encode & decode.
 257   int16_t encoded_bytes;
 258   int16_t audio_type;
 259   int16_t output_data_decode_new[kOpusMaxFrameSamples];
 260   int16_t output_data_decode[kOpusMaxFrameSamples];
 261   int16_t output_data_decode_slave[kOpusMaxFrameSamples];
 262   int16_t* coded = reinterpret_cast<int16_t*>(bitstream_);
 263   encoded_bytes = WebRtcOpus_Encode(opus_stereo_encoder_, speech_data_,
 264                                     kOpus20msFrameSamples, kMaxBytes,
 265                                     bitstream_);
 266   EXPECT_EQ(kOpus20msFrameSamples,
 267             WebRtcOpus_DecodeNew(opus_stereo_decoder_new_, bitstream_,
 268                                  encoded_bytes, output_data_decode_new,
 269                                  &audio_type));
 270   EXPECT_EQ(kOpus20msFrameSamples,
 271             WebRtcOpus_Decode(opus_stereo_decoder_, coded,
 272                               encoded_bytes, output_data_decode,
 273                               &audio_type));
 274   EXPECT_EQ(kOpus20msFrameSamples,
 275             WebRtcOpus_DecodeSlave(opus_stereo_decoder_, coded,
 276                                    encoded_bytes, output_data_decode_slave,
 277                                    &audio_type));
 278
 279   // Data in |output_data_decode_new| should be the same as in
 280   // |output_data_decode| and |output_data_decode_slave| interleaved to a
 281   // stereo signal.
 282   for (int i = 0; i < kOpus20msFrameSamples; i++) {
 283     EXPECT_EQ(output_data_decode_new[i * 2], output_data_decode[i]);
 284     EXPECT_EQ(output_data_decode_new[i * 2 + 1], output_data_decode_slave[i]);
 285   }
 286
 287   EXPECT_EQ(0, WebRtcOpus_DecoderInitNew(opus_stereo_decoder_new_));
 288   EXPECT_EQ(0, WebRtcOpus_DecoderInit(opus_stereo_decoder_));
 289   EXPECT_EQ(0, WebRtcOpus_DecoderInitSlave(opus_stereo_decoder_));
 290
 291   EXPECT_EQ(kOpus20msFrameSamples,
 292             WebRtcOpus_DecodeNew(opus_stereo_decoder_new_, bitstream_,
 293                                  encoded_bytes, output_data_decode_new,
 294                                  &audio_type));
 295   EXPECT_EQ(kOpus20msFrameSamples,
 296             WebRtcOpus_Decode(opus_stereo_decoder_, coded,
 297                               encoded_bytes, output_data_decode,
 298                               &audio_type));
 299   EXPECT_EQ(kOpus20msFrameSamples,
 300             WebRtcOpus_DecodeSlave(opus_stereo_decoder_, coded,
 301                                    encoded_bytes, output_data_decode_slave,
 302                                    &audio_type));
 303
 304   // Data in |output_data_decode_new| should be the same as in
 305   // |output_data_decode| and |output_data_decode_slave| interleaved to a
 306   // stereo signal.
 307   for (int i = 0; i < kOpus20msFrameSamples; i++) {
 308     EXPECT_EQ(output_data_decode_new[i * 2], output_data_decode[i]);
 309     EXPECT_EQ(output_data_decode_new[i * 2 + 1], output_data_decode_slave[i]);
 310   }
 311
 312   // Free memory.
 313   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_));
 314   EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_stereo_decoder_));
 315   EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_stereo_decoder_new_));
 316 }
 317
 318 TEST_F(OpusTest, OpusEnableDisableFec) {
 319   // Test without creating encoder memory.
 320   EXPECT_EQ(-1, WebRtcOpus_EnableFec(opus_mono_encoder_));
 321   EXPECT_EQ(-1, WebRtcOpus_DisableFec(opus_stereo_encoder_));
 322
 323   // Create encoder memory, try with different bitrates.
 324   EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 1));
 325   EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2));
 326
 327   EXPECT_EQ(0, WebRtcOpus_EnableFec(opus_mono_encoder_));
 328   EXPECT_EQ(0, WebRtcOpus_EnableFec(opus_stereo_encoder_));
 329   EXPECT_EQ(0, WebRtcOpus_DisableFec(opus_mono_encoder_));
 330   EXPECT_EQ(0, WebRtcOpus_DisableFec(opus_stereo_encoder_));
 331
 332   // Free memory.
 333   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_mono_encoder_));
 334   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_));
 335 }
 336
 337 TEST_F(OpusTest, OpusSetPacketLossRate) {
 338   // Test without creating encoder memory.
 339   EXPECT_EQ(-1, WebRtcOpus_SetPacketLossRate(opus_mono_encoder_, 50));
 340   EXPECT_EQ(-1, WebRtcOpus_SetPacketLossRate(opus_stereo_encoder_, 50));
 341
 342   // Create encoder memory, try with different bitrates.
 343   EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 1));
 344   EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2));
 345
 346   EXPECT_EQ(0, WebRtcOpus_SetPacketLossRate(opus_mono_encoder_, 50));
 347   EXPECT_EQ(0, WebRtcOpus_SetPacketLossRate(opus_stereo_encoder_, 50));
 348   EXPECT_EQ(-1, WebRtcOpus_SetPacketLossRate(opus_mono_encoder_, -1));
 349   EXPECT_EQ(-1, WebRtcOpus_SetPacketLossRate(opus_stereo_encoder_, -1));
 350   EXPECT_EQ(-1, WebRtcOpus_SetPacketLossRate(opus_mono_encoder_, 101));
 351   EXPECT_EQ(-1, WebRtcOpus_SetPacketLossRate(opus_stereo_encoder_, 101));
 352
 353   // Free memory.
 354   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_mono_encoder_));
 355   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_));
 356 }
 357
 358 TEST_F(OpusTest, OpusSetMaxPlaybackRate) {
 359   // Test without creating encoder memory.
 360   EXPECT_EQ(-1, WebRtcOpus_SetMaxPlaybackRate(opus_mono_encoder_, 20000));
 361   EXPECT_EQ(-1, WebRtcOpus_SetMaxPlaybackRate(opus_stereo_encoder_, 20000));
 362
 363   // Create encoder memory, try with different bitrates.
 364   EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 1));
 365   EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2));
 366
 367   TestSetMaxPlaybackRate(OPUS_BANDWIDTH_FULLBAND, 48000);
 368   TestSetMaxPlaybackRate(OPUS_BANDWIDTH_FULLBAND, 24001);
 369   TestSetMaxPlaybackRate(OPUS_BANDWIDTH_SUPERWIDEBAND, 24000);
 370   TestSetMaxPlaybackRate(OPUS_BANDWIDTH_SUPERWIDEBAND, 16001);
 371   TestSetMaxPlaybackRate(OPUS_BANDWIDTH_WIDEBAND, 16000);
 372   TestSetMaxPlaybackRate(OPUS_BANDWIDTH_WIDEBAND, 12001);
 373   TestSetMaxPlaybackRate(OPUS_BANDWIDTH_MEDIUMBAND, 12000);
 374   TestSetMaxPlaybackRate(OPUS_BANDWIDTH_MEDIUMBAND, 8001);
 375   TestSetMaxPlaybackRate(OPUS_BANDWIDTH_NARROWBAND, 8000);
 376   TestSetMaxPlaybackRate(OPUS_BANDWIDTH_NARROWBAND, 4000);
 377
 378   // Free memory.
 379   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_mono_encoder_));
 380   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_));
 381 }
 382
 383 // PLC in mono mode.
 384 TEST_F(OpusTest, OpusDecodePlcMono) {
 385   // Create encoder memory.
 386   EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 1));
 387   EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_mono_decoder_, 1));
 388   EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_mono_decoder_new_, 1));
 389
 390   // Set bitrate.
 391   EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_mono_encoder_, 32000));
 392
 393   // Check number of channels for decoder.
 394   EXPECT_EQ(1, WebRtcOpus_DecoderChannels(opus_mono_decoder_));
 395   EXPECT_EQ(1, WebRtcOpus_DecoderChannels(opus_mono_decoder_new_));
 396
 397   // Encode & decode.
 398   int16_t encoded_bytes;
 399   int16_t audio_type;
 400   int16_t output_data_decode_new[kOpusMaxFrameSamples];
 401   int16_t output_data_decode[kOpusMaxFrameSamples];
 402   int16_t* coded = reinterpret_cast<int16_t*>(bitstream_);
 403   encoded_bytes = WebRtcOpus_Encode(opus_mono_encoder_, speech_data_,
 404                                     kOpus20msFrameSamples, kMaxBytes,
 405                                     bitstream_);
 406   EXPECT_EQ(kOpus20msFrameSamples,
 407             WebRtcOpus_DecodeNew(opus_mono_decoder_new_, bitstream_,
 408                                  encoded_bytes, output_data_decode_new,
 409                                  &audio_type));
 410   EXPECT_EQ(kOpus20msFrameSamples,
 411             WebRtcOpus_Decode(opus_mono_decoder_, coded,
 412                               encoded_bytes, output_data_decode,
 413                               &audio_type));
 414
 415   // Call decoder PLC for both versions of the decoder.
 416   int16_t plc_buffer[kOpusMaxFrameSamples];
 417   int16_t plc_buffer_new[kOpusMaxFrameSamples];
 418   EXPECT_EQ(kOpus20msFrameSamples,
 419             WebRtcOpus_DecodePlcMaster(opus_mono_decoder_, plc_buffer, 1));
 420   EXPECT_EQ(kOpus20msFrameSamples,
 421             WebRtcOpus_DecodePlc(opus_mono_decoder_new_, plc_buffer_new, 1));
 422
 423   // Data in |plc_buffer| should be the same as in |plc_buffer_new|.
 424   for (int i = 0; i < kOpus20msFrameSamples; i++) {
 425     EXPECT_EQ(plc_buffer[i], plc_buffer_new[i]);
 426   }
 427
 428   // Free memory.
 429   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_mono_encoder_));
 430   EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_mono_decoder_));
 431   EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_mono_decoder_new_));
 432 }
 433
 434 // PLC in stereo mode.
 435 TEST_F(OpusTest, OpusDecodePlcStereo) {
 436   // Create encoder memory.
 437   EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2));
 438   EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_stereo_decoder_, 2));
 439   EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_stereo_decoder_new_, 2));
 440
 441   // Set bitrate.
 442   EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_stereo_encoder_, 64000));
 443
 444   // Check number of channels for decoder.
 445   EXPECT_EQ(2, WebRtcOpus_DecoderChannels(opus_stereo_decoder_));
 446   EXPECT_EQ(2, WebRtcOpus_DecoderChannels(opus_stereo_decoder_new_));
 447
 448   // Encode & decode.
 449   int16_t encoded_bytes;
 450   int16_t audio_type;
 451   int16_t output_data_decode_new[kOpusMaxFrameSamples];
 452   int16_t output_data_decode[kOpusMaxFrameSamples];
 453   int16_t output_data_decode_slave[kOpusMaxFrameSamples];
 454   int16_t* coded = reinterpret_cast<int16_t*>(bitstream_);
 455   encoded_bytes = WebRtcOpus_Encode(opus_stereo_encoder_, speech_data_,
 456                                     kOpus20msFrameSamples, kMaxBytes,
 457                                     bitstream_);
 458   EXPECT_EQ(kOpus20msFrameSamples,
 459             WebRtcOpus_DecodeNew(opus_stereo_decoder_new_, bitstream_,
 460                                  encoded_bytes, output_data_decode_new,
 461                                  &audio_type));
 462   EXPECT_EQ(kOpus20msFrameSamples,
 463             WebRtcOpus_Decode(opus_stereo_decoder_, coded,
 464                               encoded_bytes, output_data_decode,
 465                               &audio_type));
 466   EXPECT_EQ(kOpus20msFrameSamples,
 467             WebRtcOpus_DecodeSlave(opus_stereo_decoder_, coded,
 468                                    encoded_bytes,
 469                                    output_data_decode_slave,
 470                                    &audio_type));
 471
 472   // Call decoder PLC for both versions of the decoder.
 473   int16_t plc_buffer_left[kOpusMaxFrameSamples];
 474   int16_t plc_buffer_right[kOpusMaxFrameSamples];
 475   int16_t plc_buffer_new[kOpusMaxFrameSamples];
 476   EXPECT_EQ(kOpus20msFrameSamples,
 477             WebRtcOpus_DecodePlcMaster(opus_stereo_decoder_,
 478                                        plc_buffer_left, 1));
 479   EXPECT_EQ(kOpus20msFrameSamples,
 480             WebRtcOpus_DecodePlcSlave(opus_stereo_decoder_,
 481                                       plc_buffer_right, 1));
 482   EXPECT_EQ(kOpus20msFrameSamples,
 483             WebRtcOpus_DecodePlc(opus_stereo_decoder_new_, plc_buffer_new, 1));
 484   // Data in |plc_buffer_left| and |plc_buffer_right|should be the same as the
 485   // interleaved samples in |plc_buffer_new|.
 486   for (int i = 0, j = 0; i < kOpus20msFrameSamples; i++) {
 487     EXPECT_EQ(plc_buffer_left[i], plc_buffer_new[j++]);
 488     EXPECT_EQ(plc_buffer_right[i], plc_buffer_new[j++]);
 489   }
 490
 491   // Free memory.
 492   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_));
 493   EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_stereo_decoder_));
 494   EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_stereo_decoder_new_));
 495 }
 496
 497 // Duration estimation.
 498 TEST_F(OpusTest, OpusDurationEstimation) {
 499   // Create.
 500   EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2));
 501   EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_stereo_decoder_, 2));
 502
 503   int16_t encoded_bytes;
 504
 505   // 10 ms.
 506   encoded_bytes = WebRtcOpus_Encode(opus_stereo_encoder_, speech_data_,
 507                                     kOpus10msFrameSamples, kMaxBytes,
 508                                     bitstream_);
 509   EXPECT_EQ(kOpus10msFrameSamples,
 510             WebRtcOpus_DurationEst(opus_stereo_decoder_, bitstream_,
 511                                    encoded_bytes));
 512
 513   // 20 ms
 514   encoded_bytes = WebRtcOpus_Encode(opus_stereo_encoder_, speech_data_,
 515                                     kOpus20msFrameSamples, kMaxBytes,
 516                                     bitstream_);
 517   EXPECT_EQ(kOpus20msFrameSamples,
 518             WebRtcOpus_DurationEst(opus_stereo_decoder_, bitstream_,
 519                                    encoded_bytes));
 520
 521   // Free memory.
 522   EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_));
 523   EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_stereo_decoder_));
 524 }
 525
 526 }  // namespace webrtc