src/third_party/webrtc/modules/audio_coding/main/test/TestStereo.cc

   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 "webrtc/modules/audio_coding/main/test/TestStereo.h"
  12
  13 #include <assert.h>
  14
  15 #include <string>
  16
  17 #include "testing/gtest/include/gtest/gtest.h"
  18 #include "webrtc/common_types.h"
  19 #include "webrtc/engine_configurations.h"
  20 #include "webrtc/modules/audio_coding/main/interface/audio_coding_module_typedefs.h"
  21 #include "webrtc/modules/audio_coding/main/test/utility.h"
  22 #include "webrtc/system_wrappers/interface/trace.h"
  23 #include "webrtc/test/testsupport/fileutils.h"
  24
  25 namespace webrtc {
  26
  27 // Class for simulating packet handling
  28 TestPackStereo::TestPackStereo()
  29     : receiver_acm_(NULL),
  30       seq_no_(0),
  31       timestamp_diff_(0),
  32       last_in_timestamp_(0),
  33       total_bytes_(0),
  34       payload_size_(0),
  35       codec_mode_(kNotSet),
  36       lost_packet_(false) {
  37 }
  38
  39 TestPackStereo::~TestPackStereo() {
  40 }
  41
  42 void TestPackStereo::RegisterReceiverACM(AudioCodingModule* acm) {
  43   receiver_acm_ = acm;
  44   return;
  45 }
  46
  47 int32_t TestPackStereo::SendData(const FrameType frame_type,
  48                                  const uint8_t payload_type,
  49                                  const uint32_t timestamp,
  50                                  const uint8_t* payload_data,
  51                                  const uint16_t payload_size,
  52                                  const RTPFragmentationHeader* fragmentation) {
  53   WebRtcRTPHeader rtp_info;
  54   int32_t status = 0;
  55
  56   rtp_info.header.markerBit = false;
  57   rtp_info.header.ssrc = 0;
  58   rtp_info.header.sequenceNumber = seq_no_++;
  59   rtp_info.header.payloadType = payload_type;
  60   rtp_info.header.timestamp = timestamp;
  61   if (frame_type == kFrameEmpty) {
  62     // Skip this frame
  63     return 0;
  64   }
  65
  66   if (lost_packet_ == false) {
  67     if (frame_type != kAudioFrameCN) {
  68       rtp_info.type.Audio.isCNG = false;
  69       rtp_info.type.Audio.channel = static_cast<int>(codec_mode_);
  70     } else {
  71       rtp_info.type.Audio.isCNG = true;
  72       rtp_info.type.Audio.channel = static_cast<int>(kMono);
  73     }
  74     status = receiver_acm_->IncomingPacket(payload_data, payload_size,
  75                                            rtp_info);
  76
  77     if (frame_type != kAudioFrameCN) {
  78       payload_size_ = static_cast<int>(payload_size);
  79     } else {
  80       payload_size_ = -1;
  81     }
  82
  83     timestamp_diff_ = timestamp - last_in_timestamp_;
  84     last_in_timestamp_ = timestamp;
  85     total_bytes_ += payload_size;
  86   }
  87   return status;
  88 }
  89
  90 uint16_t TestPackStereo::payload_size() {
  91   return static_cast<uint16_t>(payload_size_);
  92 }
  93
  94 uint32_t TestPackStereo::timestamp_diff() {
  95   return timestamp_diff_;
  96 }
  97
  98 void TestPackStereo::reset_payload_size() {
  99   payload_size_ = 0;
 100 }
 101
 102 void TestPackStereo::set_codec_mode(enum StereoMonoMode mode) {
 103   codec_mode_ = mode;
 104 }
 105
 106 void TestPackStereo::set_lost_packet(bool lost) {
 107   lost_packet_ = lost;
 108 }
 109
 110 TestStereo::TestStereo(int test_mode)
 111     : acm_a_(AudioCodingModule::Create(0)),
 112       acm_b_(AudioCodingModule::Create(1)),
 113       channel_a2b_(NULL),
 114       test_cntr_(0),
 115       pack_size_samp_(0),
 116       pack_size_bytes_(0),
 117       counter_(0),
 118       g722_pltype_(0),
 119       l16_8khz_pltype_(-1),
 120       l16_16khz_pltype_(-1),
 121       l16_32khz_pltype_(-1),
 122       pcma_pltype_(-1),
 123       pcmu_pltype_(-1),
 124       celt_pltype_(-1),
 125       opus_pltype_(-1),
 126       cn_8khz_pltype_(-1),
 127       cn_16khz_pltype_(-1),
 128       cn_32khz_pltype_(-1) {
 129   // test_mode = 0 for silent test (auto test)
 130   test_mode_ = test_mode;
 131 }
 132
 133 TestStereo::~TestStereo() {
 134   if (channel_a2b_ != NULL) {
 135     delete channel_a2b_;
 136     channel_a2b_ = NULL;
 137   }
 138 }
 139
 140 void TestStereo::Perform() {
 141   uint16_t frequency_hz;
 142   int audio_channels;
 143   int codec_channels;
 144   bool dtx;
 145   bool vad;
 146   ACMVADMode vad_mode;
 147
 148   // Open both mono and stereo test files in 32 kHz.
 149   const std::string file_name_stereo = webrtc::test::ResourcePath(
 150       "audio_coding/teststereo32kHz", "pcm");
 151   const std::string file_name_mono = webrtc::test::ResourcePath(
 152       "audio_coding/testfile32kHz", "pcm");
 153   frequency_hz = 32000;
 154   in_file_stereo_ = new PCMFile();
 155   in_file_mono_ = new PCMFile();
 156   in_file_stereo_->Open(file_name_stereo, frequency_hz, "rb");
 157   in_file_stereo_->ReadStereo(true);
 158   in_file_mono_->Open(file_name_mono, frequency_hz, "rb");
 159   in_file_mono_->ReadStereo(false);
 160
 161   // Create and initialize two ACMs, one for each side of a one-to-one call.
 162   ASSERT_TRUE((acm_a_.get() != NULL) && (acm_b_.get() != NULL));
 163   EXPECT_EQ(0, acm_a_->InitializeReceiver());
 164   EXPECT_EQ(0, acm_b_->InitializeReceiver());
 165
 166   // Register all available codes as receiving codecs.
 167   uint8_t num_encoders = acm_a_->NumberOfCodecs();
 168   CodecInst my_codec_param;
 169   for (uint8_t n = 0; n < num_encoders; n++) {
 170     EXPECT_EQ(0, acm_b_->Codec(n, &my_codec_param));
 171     EXPECT_EQ(0, acm_b_->RegisterReceiveCodec(my_codec_param));
 172   }
 173
 174   // Test that unregister all receive codecs works.
 175   for (uint8_t n = 0; n < num_encoders; n++) {
 176     EXPECT_EQ(0, acm_b_->Codec(n, &my_codec_param));
 177     EXPECT_EQ(0, acm_b_->UnregisterReceiveCodec(my_codec_param.pltype));
 178   }
 179
 180   // Register all available codes as receiving codecs once more.
 181   for (uint8_t n = 0; n < num_encoders; n++) {
 182     EXPECT_EQ(0, acm_b_->Codec(n, &my_codec_param));
 183     EXPECT_EQ(0, acm_b_->RegisterReceiveCodec(my_codec_param));
 184   }
 185
 186   // Create and connect the channel.
 187   channel_a2b_ = new TestPackStereo;
 188   EXPECT_EQ(0, acm_a_->RegisterTransportCallback(channel_a2b_));
 189   channel_a2b_->RegisterReceiverACM(acm_b_.get());
 190
 191   // Start with setting VAD/DTX, before we know we will send stereo.
 192   // Continue with setting a stereo codec as send codec and verify that
 193   // VAD/DTX gets turned off.
 194   EXPECT_EQ(0, acm_a_->SetVAD(true, true, VADNormal));
 195   EXPECT_EQ(0, acm_a_->VAD(&dtx, &vad, &vad_mode));
 196   EXPECT_TRUE(dtx);
 197   EXPECT_TRUE(vad);
 198   char codec_pcma_temp[] = "PCMA";
 199   RegisterSendCodec('A', codec_pcma_temp, 8000, 64000, 80, 2, pcma_pltype_);
 200   EXPECT_EQ(0, acm_a_->VAD(&dtx, &vad, &vad_mode));
 201   EXPECT_FALSE(dtx);
 202   EXPECT_FALSE(vad);
 203   if (test_mode_ != 0) {
 204     printf("\n");
 205   }
 206
 207   //
 208   // Test Stereo-To-Stereo for all codecs.
 209   //
 210   audio_channels = 2;
 211   codec_channels = 2;
 212
 213   // All codecs are tested for all allowed sampling frequencies, rates and
 214   // packet sizes.
 215 #ifdef WEBRTC_CODEC_G722
 216   if (test_mode_ != 0) {
 217     printf("===========================================================\n");
 218     printf("Test number: %d\n", test_cntr_ + 1);
 219     printf("Test type: Stereo-to-stereo\n");
 220   }
 221   channel_a2b_->set_codec_mode(kStereo);
 222   test_cntr_++;
 223   OpenOutFile(test_cntr_);
 224   char codec_g722[] = "G722";
 225   RegisterSendCodec('A', codec_g722, 16000, 64000, 160, codec_channels,
 226       g722_pltype_);
 227   Run(channel_a2b_, audio_channels, codec_channels);
 228   RegisterSendCodec('A', codec_g722, 16000, 64000, 320, codec_channels,
 229       g722_pltype_);
 230   Run(channel_a2b_, audio_channels, codec_channels);
 231   RegisterSendCodec('A', codec_g722, 16000, 64000, 480, codec_channels,
 232       g722_pltype_);
 233   Run(channel_a2b_, audio_channels, codec_channels);
 234   RegisterSendCodec('A', codec_g722, 16000, 64000, 640, codec_channels,
 235       g722_pltype_);
 236   Run(channel_a2b_, audio_channels, codec_channels);
 237   RegisterSendCodec('A', codec_g722, 16000, 64000, 800, codec_channels,
 238       g722_pltype_);
 239   Run(channel_a2b_, audio_channels, codec_channels);
 240   RegisterSendCodec('A', codec_g722, 16000, 64000, 960, codec_channels,
 241       g722_pltype_);
 242   Run(channel_a2b_, audio_channels, codec_channels);
 243   out_file_.Close();
 244 #endif
 245 #ifdef WEBRTC_CODEC_PCM16
 246   if (test_mode_ != 0) {
 247     printf("===========================================================\n");
 248     printf("Test number: %d\n", test_cntr_ + 1);
 249     printf("Test type: Stereo-to-stereo\n");
 250   }
 251   channel_a2b_->set_codec_mode(kStereo);
 252   test_cntr_++;
 253   OpenOutFile(test_cntr_);
 254   char codec_l16[] = "L16";
 255   RegisterSendCodec('A', codec_l16, 8000, 128000, 80, codec_channels,
 256       l16_8khz_pltype_);
 257   Run(channel_a2b_, audio_channels, codec_channels);
 258   RegisterSendCodec('A', codec_l16, 8000, 128000, 160, codec_channels,
 259       l16_8khz_pltype_);
 260   Run(channel_a2b_, audio_channels, codec_channels);
 261   RegisterSendCodec('A', codec_l16, 8000, 128000, 240, codec_channels,
 262       l16_8khz_pltype_);
 263   Run(channel_a2b_, audio_channels, codec_channels);
 264   RegisterSendCodec('A', codec_l16, 8000, 128000, 320, codec_channels,
 265       l16_8khz_pltype_);
 266   Run(channel_a2b_, audio_channels, codec_channels);
 267   out_file_.Close();
 268
 269   if (test_mode_ != 0) {
 270     printf("===========================================================\n");
 271     printf("Test number: %d\n", test_cntr_ + 1);
 272     printf("Test type: Stereo-to-stereo\n");
 273   }
 274   test_cntr_++;
 275   OpenOutFile(test_cntr_);
 276   RegisterSendCodec('A', codec_l16, 16000, 256000, 160, codec_channels,
 277       l16_16khz_pltype_);
 278   Run(channel_a2b_, audio_channels, codec_channels);
 279   RegisterSendCodec('A', codec_l16, 16000, 256000, 320, codec_channels,
 280       l16_16khz_pltype_);
 281   Run(channel_a2b_, audio_channels, codec_channels);
 282   RegisterSendCodec('A', codec_l16, 16000, 256000, 480, codec_channels,
 283       l16_16khz_pltype_);
 284   Run(channel_a2b_, audio_channels, codec_channels);
 285   RegisterSendCodec('A', codec_l16, 16000, 256000, 640, codec_channels,
 286       l16_16khz_pltype_);
 287   Run(channel_a2b_, audio_channels, codec_channels);
 288   out_file_.Close();
 289
 290   if (test_mode_ != 0) {
 291     printf("===========================================================\n");
 292     printf("Test number: %d\n", test_cntr_ + 1);
 293     printf("Test type: Stereo-to-stereo\n");
 294   }
 295   test_cntr_++;
 296   OpenOutFile(test_cntr_);
 297   RegisterSendCodec('A', codec_l16, 32000, 512000, 320, codec_channels,
 298       l16_32khz_pltype_);
 299   Run(channel_a2b_, audio_channels, codec_channels);
 300   RegisterSendCodec('A', codec_l16, 32000, 512000, 640, codec_channels,
 301       l16_32khz_pltype_);
 302   Run(channel_a2b_, audio_channels, codec_channels);
 303   out_file_.Close();
 304 #endif
 305 #define PCMA_AND_PCMU
 306 #ifdef PCMA_AND_PCMU
 307   if (test_mode_ != 0) {
 308     printf("===========================================================\n");
 309     printf("Test number: %d\n", test_cntr_ + 1);
 310     printf("Test type: Stereo-to-stereo\n");
 311   }
 312   channel_a2b_->set_codec_mode(kStereo);
 313   audio_channels = 2;
 314   codec_channels = 2;
 315   test_cntr_++;
 316   OpenOutFile(test_cntr_);
 317   char codec_pcma[] = "PCMA";
 318   RegisterSendCodec('A', codec_pcma, 8000, 64000, 80, codec_channels,
 319                     pcma_pltype_);
 320   Run(channel_a2b_, audio_channels, codec_channels);
 321   RegisterSendCodec('A', codec_pcma, 8000, 64000, 160, codec_channels,
 322                     pcma_pltype_);
 323   Run(channel_a2b_, audio_channels, codec_channels);
 324   RegisterSendCodec('A', codec_pcma, 8000, 64000, 240, codec_channels,
 325                     pcma_pltype_);
 326   Run(channel_a2b_, audio_channels, codec_channels);
 327   RegisterSendCodec('A', codec_pcma, 8000, 64000, 320, codec_channels,
 328                     pcma_pltype_);
 329   Run(channel_a2b_, audio_channels, codec_channels);
 330   RegisterSendCodec('A', codec_pcma, 8000, 64000, 400, codec_channels,
 331                     pcma_pltype_);
 332   Run(channel_a2b_, audio_channels, codec_channels);
 333   RegisterSendCodec('A', codec_pcma, 8000, 64000, 480, codec_channels,
 334                     pcma_pltype_);
 335   Run(channel_a2b_, audio_channels, codec_channels);
 336
 337   // Test that VAD/DTX cannot be turned on while sending stereo.
 338   EXPECT_EQ(-1, acm_a_->SetVAD(true, true, VADNormal));
 339   EXPECT_EQ(0, acm_a_->VAD(&dtx, &vad, &vad_mode));
 340   EXPECT_FALSE(dtx);
 341   EXPECT_FALSE(vad);
 342   EXPECT_EQ(-1, acm_a_->SetVAD(true, false, VADNormal));
 343   EXPECT_EQ(0, acm_a_->VAD(&dtx, &vad, &vad_mode));
 344   EXPECT_FALSE(dtx);
 345   EXPECT_FALSE(vad);
 346   EXPECT_EQ(-1, acm_a_->SetVAD(false, true, VADNormal));
 347   EXPECT_EQ(0, acm_a_->VAD(&dtx, &vad, &vad_mode));
 348   EXPECT_FALSE(dtx);
 349   EXPECT_FALSE(vad);
 350   EXPECT_EQ(0, acm_a_->SetVAD(false, false, VADNormal));
 351   EXPECT_EQ(0, acm_a_->VAD(&dtx, &vad, &vad_mode));
 352   EXPECT_FALSE(dtx);
 353   EXPECT_FALSE(vad);
 354
 355   out_file_.Close();
 356   if (test_mode_ != 0) {
 357     printf("===========================================================\n");
 358     printf("Test number: %d\n", test_cntr_ + 1);
 359     printf("Test type: Stereo-to-stereo\n");
 360   }
 361   test_cntr_++;
 362   OpenOutFile(test_cntr_);
 363   char codec_pcmu[] = "PCMU";
 364   RegisterSendCodec('A', codec_pcmu, 8000, 64000, 80, codec_channels,
 365                     pcmu_pltype_);
 366   Run(channel_a2b_, audio_channels, codec_channels);
 367   RegisterSendCodec('A', codec_pcmu, 8000, 64000, 160, codec_channels,
 368                     pcmu_pltype_);
 369   Run(channel_a2b_, audio_channels, codec_channels);
 370   RegisterSendCodec('A', codec_pcmu, 8000, 64000, 240, codec_channels,
 371                     pcmu_pltype_);
 372   Run(channel_a2b_, audio_channels, codec_channels);
 373   RegisterSendCodec('A', codec_pcmu, 8000, 64000, 320, codec_channels,
 374                     pcmu_pltype_);
 375   Run(channel_a2b_, audio_channels, codec_channels);
 376   RegisterSendCodec('A', codec_pcmu, 8000, 64000, 400, codec_channels,
 377                     pcmu_pltype_);
 378   Run(channel_a2b_, audio_channels, codec_channels);
 379   RegisterSendCodec('A', codec_pcmu, 8000, 64000, 480, codec_channels,
 380                     pcmu_pltype_);
 381   Run(channel_a2b_, audio_channels, codec_channels);
 382   out_file_.Close();
 383 #endif
 384 #ifdef WEBRTC_CODEC_CELT
 385   if (test_mode_ != 0) {
 386     printf("===========================================================\n");
 387     printf("Test number: %d\n", test_cntr_ + 1);
 388     printf("Test type: Stereo-to-stereo\n");
 389   }
 390   channel_a2b_->set_codec_mode(kStereo);
 391   audio_channels = 2;
 392   codec_channels = 2;
 393   test_cntr_++;
 394   OpenOutFile(test_cntr_);
 395   char codec_celt[] = "CELT";
 396   RegisterSendCodec('A', codec_celt, 32000, 48000, 640, codec_channels,
 397       celt_pltype_);
 398   Run(channel_a2b_, audio_channels, codec_channels);
 399   RegisterSendCodec('A', codec_celt, 32000, 64000, 640, codec_channels,
 400       celt_pltype_);
 401   Run(channel_a2b_, audio_channels, codec_channels);
 402   RegisterSendCodec('A', codec_celt, 32000, 128000, 640, codec_channels,
 403       celt_pltype_);
 404   Run(channel_a2b_, audio_channels, codec_channels);
 405   out_file_.Close();
 406 #endif
 407 #ifdef WEBRTC_CODEC_OPUS
 408   if (test_mode_ != 0) {
 409     printf("===========================================================\n");
 410     printf("Test number: %d\n", test_cntr_ + 1);
 411     printf("Test type: Stereo-to-stereo\n");
 412   }
 413   channel_a2b_->set_codec_mode(kStereo);
 414   audio_channels = 2;
 415   codec_channels = 2;
 416   test_cntr_++;
 417   OpenOutFile(test_cntr_);
 418
 419   char codec_opus[] = "opus";
 420   // Run Opus with 10 ms frame size.
 421   RegisterSendCodec('A', codec_opus, 48000, 64000, 480, codec_channels,
 422       opus_pltype_);
 423   Run(channel_a2b_, audio_channels, codec_channels);
 424   // Run Opus with 20 ms frame size.
 425   RegisterSendCodec('A', codec_opus, 48000, 64000, 480*2, codec_channels,
 426       opus_pltype_);
 427   Run(channel_a2b_, audio_channels, codec_channels);
 428   // Run Opus with 40 ms frame size.
 429   RegisterSendCodec('A', codec_opus, 48000, 64000, 480*4, codec_channels,
 430       opus_pltype_);
 431   Run(channel_a2b_, audio_channels, codec_channels);
 432   // Run Opus with 60 ms frame size.
 433   RegisterSendCodec('A', codec_opus, 48000, 64000, 480*6, codec_channels,
 434       opus_pltype_);
 435   Run(channel_a2b_, audio_channels, codec_channels);
 436   // Run Opus with 20 ms frame size and different bitrates.
 437   RegisterSendCodec('A', codec_opus, 48000, 40000, 960, codec_channels,
 438       opus_pltype_);
 439   Run(channel_a2b_, audio_channels, codec_channels);
 440   RegisterSendCodec('A', codec_opus, 48000, 510000, 960, codec_channels,
 441       opus_pltype_);
 442   Run(channel_a2b_, audio_channels, codec_channels);
 443   out_file_.Close();
 444 #endif
 445   //
 446   // Test Mono-To-Stereo for all codecs.
 447   //
 448   audio_channels = 1;
 449   codec_channels = 2;
 450
 451 #ifdef WEBRTC_CODEC_G722
 452   if (test_mode_ != 0) {
 453     printf("===============================================================\n");
 454     printf("Test number: %d\n", test_cntr_ + 1);
 455     printf("Test type: Mono-to-stereo\n");
 456   }
 457   test_cntr_++;
 458   channel_a2b_->set_codec_mode(kStereo);
 459   OpenOutFile(test_cntr_);
 460   RegisterSendCodec('A', codec_g722, 16000, 64000, 160, codec_channels,
 461       g722_pltype_);
 462   Run(channel_a2b_, audio_channels, codec_channels);
 463   out_file_.Close();
 464 #endif
 465 #ifdef WEBRTC_CODEC_PCM16
 466   if (test_mode_ != 0) {
 467     printf("===============================================================\n");
 468     printf("Test number: %d\n", test_cntr_ + 1);
 469     printf("Test type: Mono-to-stereo\n");
 470   }
 471   test_cntr_++;
 472   channel_a2b_->set_codec_mode(kStereo);
 473   OpenOutFile(test_cntr_);
 474   RegisterSendCodec('A', codec_l16, 8000, 128000, 80, codec_channels,
 475       l16_8khz_pltype_);
 476   Run(channel_a2b_, audio_channels, codec_channels);
 477   out_file_.Close();
 478   if (test_mode_ != 0) {
 479     printf("===============================================================\n");
 480     printf("Test number: %d\n", test_cntr_ + 1);
 481     printf("Test type: Mono-to-stereo\n");
 482   }
 483   test_cntr_++;
 484   OpenOutFile(test_cntr_);
 485   RegisterSendCodec('A', codec_l16, 16000, 256000, 160, codec_channels,
 486       l16_16khz_pltype_);
 487   Run(channel_a2b_, audio_channels, codec_channels);
 488   out_file_.Close();
 489   if (test_mode_ != 0) {
 490     printf("===============================================================\n");
 491     printf("Test number: %d\n", test_cntr_ + 1);
 492     printf("Test type: Mono-to-stereo\n");
 493   }
 494   test_cntr_++;
 495   OpenOutFile(test_cntr_);
 496   RegisterSendCodec('A', codec_l16, 32000, 512000, 320, codec_channels,
 497       l16_32khz_pltype_);
 498   Run(channel_a2b_, audio_channels, codec_channels);
 499   out_file_.Close();
 500 #endif
 501 #ifdef PCMA_AND_PCMU
 502   if (test_mode_ != 0) {
 503     printf("===============================================================\n");
 504     printf("Test number: %d\n", test_cntr_ + 1);
 505     printf("Test type: Mono-to-stereo\n");
 506   }
 507   test_cntr_++;
 508   channel_a2b_->set_codec_mode(kStereo);
 509   OpenOutFile(test_cntr_);
 510   RegisterSendCodec('A', codec_pcmu, 8000, 64000, 80, codec_channels,
 511                     pcmu_pltype_);
 512   Run(channel_a2b_, audio_channels, codec_channels);
 513   RegisterSendCodec('A', codec_pcma, 8000, 64000, 80, codec_channels,
 514                     pcma_pltype_);
 515   Run(channel_a2b_, audio_channels, codec_channels);
 516   out_file_.Close();
 517 #endif
 518 #ifdef WEBRTC_CODEC_CELT
 519   if (test_mode_ != 0) {
 520     printf("===============================================================\n");
 521     printf("Test number: %d\n", test_cntr_ + 1);
 522     printf("Test type: Mono-to-stereo\n");
 523   }
 524   test_cntr_++;
 525   channel_a2b_->set_codec_mode(kStereo);
 526   OpenOutFile(test_cntr_);
 527   RegisterSendCodec('A', codec_celt, 32000, 64000, 640, codec_channels,
 528       celt_pltype_);
 529   Run(channel_a2b_, audio_channels, codec_channels);
 530   out_file_.Close();
 531 #endif
 532 #ifdef WEBRTC_CODEC_OPUS
 533   if (test_mode_ != 0) {
 534     printf("===============================================================\n");
 535     printf("Test number: %d\n", test_cntr_ + 1);
 536     printf("Test type: Mono-to-stereo\n");
 537   }
 538
 539   // Keep encode and decode in stereo.
 540   test_cntr_++;
 541   channel_a2b_->set_codec_mode(kStereo);
 542   OpenOutFile(test_cntr_);
 543   RegisterSendCodec('A', codec_opus, 48000, 64000, 960, codec_channels,
 544       opus_pltype_);
 545   Run(channel_a2b_, audio_channels, codec_channels);
 546
 547   // Encode in mono, decode in stereo mode.
 548   RegisterSendCodec('A', codec_opus, 48000, 64000, 960, 1, opus_pltype_);
 549   Run(channel_a2b_, audio_channels, codec_channels);
 550   out_file_.Close();
 551 #endif
 552
 553   //
 554   // Test Stereo-To-Mono for all codecs.
 555   //
 556   audio_channels = 2;
 557   codec_channels = 1;
 558   channel_a2b_->set_codec_mode(kMono);
 559
 560 #ifdef WEBRTC_CODEC_G722
 561   // Run stereo audio and mono codec.
 562   if (test_mode_ != 0) {
 563     printf("===============================================================\n");
 564     printf("Test number: %d\n", test_cntr_ + 1);
 565     printf("Test type: Stereo-to-mono\n");
 566   }
 567   test_cntr_++;
 568   OpenOutFile(test_cntr_);
 569   RegisterSendCodec('A', codec_g722, 16000, 64000, 160, codec_channels,
 570       g722_pltype_);
 571
 572   // Make sure it is possible to set VAD/CNG, now that we are sending mono
 573   // again.
 574   EXPECT_EQ(0, acm_a_->SetVAD(true, true, VADNormal));
 575   EXPECT_EQ(0, acm_a_->VAD(&dtx, &vad, &vad_mode));
 576   EXPECT_TRUE(dtx);
 577   EXPECT_TRUE(vad);
 578   EXPECT_EQ(0, acm_a_->SetVAD(false, false, VADNormal));
 579   Run(channel_a2b_, audio_channels, codec_channels);
 580   out_file_.Close();
 581 #endif
 582 #ifdef WEBRTC_CODEC_PCM16
 583   if (test_mode_ != 0) {
 584     printf("===============================================================\n");
 585     printf("Test number: %d\n", test_cntr_ + 1);
 586     printf("Test type: Stereo-to-mono\n");
 587   }
 588   test_cntr_++;
 589   OpenOutFile(test_cntr_);
 590   RegisterSendCodec('A', codec_l16, 8000, 128000, 80, codec_channels,
 591       l16_8khz_pltype_);
 592   Run(channel_a2b_, audio_channels, codec_channels);
 593   out_file_.Close();
 594   if (test_mode_ != 0) {
 595     printf("===============================================================\n");
 596     printf("Test number: %d\n", test_cntr_ + 1);
 597     printf("Test type: Stereo-to-mono\n");
 598   }
 599   test_cntr_++;
 600   OpenOutFile(test_cntr_);
 601   RegisterSendCodec('A', codec_l16, 16000, 256000, 160, codec_channels,
 602       l16_16khz_pltype_);
 603   Run(channel_a2b_, audio_channels, codec_channels);
 604   out_file_.Close();
 605   if (test_mode_ != 0) {
 606     printf("==============================================================\n");
 607     printf("Test number: %d\n", test_cntr_ + 1);
 608     printf("Test type: Stereo-to-mono\n");
 609   }
 610   test_cntr_++;
 611   OpenOutFile(test_cntr_);
 612   RegisterSendCodec('A', codec_l16, 32000, 512000, 320, codec_channels,
 613       l16_32khz_pltype_);
 614   Run(channel_a2b_, audio_channels, codec_channels);
 615   out_file_.Close();
 616 #endif
 617 #ifdef PCMA_AND_PCMU
 618   if (test_mode_ != 0) {
 619     printf("===============================================================\n");
 620     printf("Test number: %d\n", test_cntr_ + 1);
 621     printf("Test type: Stereo-to-mono\n");
 622   }
 623   test_cntr_++;
 624   OpenOutFile(test_cntr_);
 625   RegisterSendCodec('A', codec_pcmu, 8000, 64000, 80, codec_channels,
 626                     pcmu_pltype_);
 627   Run(channel_a2b_, audio_channels, codec_channels);
 628   RegisterSendCodec('A', codec_pcma, 8000, 64000, 80, codec_channels,
 629                     pcma_pltype_);
 630   Run(channel_a2b_, audio_channels, codec_channels);
 631   out_file_.Close();
 632 #endif
 633 #ifdef WEBRTC_CODEC_CELT
 634   if (test_mode_ != 0) {
 635     printf("===============================================================\n");
 636     printf("Test number: %d\n", test_cntr_ + 1);
 637     printf("Test type: Stereo-to-mono\n");
 638   }
 639   test_cntr_++;
 640   OpenOutFile(test_cntr_);
 641   RegisterSendCodec('A', codec_celt, 32000, 64000, 640, codec_channels,
 642       celt_pltype_);
 643   Run(channel_a2b_, audio_channels, codec_channels);
 644   out_file_.Close();
 645 #endif
 646 #ifdef WEBRTC_CODEC_OPUS
 647   if (test_mode_ != 0) {
 648     printf("===============================================================\n");
 649     printf("Test number: %d\n", test_cntr_ + 1);
 650     printf("Test type: Stereo-to-mono\n");
 651   }
 652   test_cntr_++;
 653   OpenOutFile(test_cntr_);
 654   // Encode and decode in mono.
 655   RegisterSendCodec('A', codec_opus, 48000, 32000, 960, codec_channels,
 656       opus_pltype_);
 657   CodecInst opus_codec_param;
 658   for (uint8_t n = 0; n < num_encoders; n++) {
 659     EXPECT_EQ(0, acm_b_->Codec(n, &opus_codec_param));
 660     if (!strcmp(opus_codec_param.plname, "opus")) {
 661       opus_codec_param.channels = 1;
 662       EXPECT_EQ(0, acm_b_->RegisterReceiveCodec(opus_codec_param));
 663       break;
 664     }
 665   }
 666   Run(channel_a2b_, audio_channels, codec_channels);
 667
 668   // Encode in stereo, decode in mono.
 669   RegisterSendCodec('A', codec_opus, 48000, 32000, 960, 2, opus_pltype_);
 670   Run(channel_a2b_, audio_channels, codec_channels);
 671
 672   out_file_.Close();
 673
 674   // Test switching between decoding mono and stereo for Opus.
 675
 676   // Decode in mono.
 677   test_cntr_++;
 678   OpenOutFile(test_cntr_);
 679   if (test_mode_ != 0) {
 680     // Print out codec and settings
 681     printf("Test number: %d\nCodec: Opus Freq: 48000 Rate :32000 PackSize: 960"
 682         " Decode: mono\n", test_cntr_);
 683   }
 684   Run(channel_a2b_, audio_channels, codec_channels);
 685   out_file_.Close();
 686   // Decode in stereo.
 687   test_cntr_++;
 688   OpenOutFile(test_cntr_);
 689   if (test_mode_ != 0) {
 690     // Print out codec and settings
 691     printf("Test number: %d\nCodec: Opus Freq: 48000 Rate :32000 PackSize: 960"
 692         " Decode: stereo\n", test_cntr_);
 693   }
 694   opus_codec_param.channels = 2;
 695   EXPECT_EQ(0, acm_b_->RegisterReceiveCodec(opus_codec_param));
 696   Run(channel_a2b_, audio_channels, 2);
 697   out_file_.Close();
 698   // Decode in mono.
 699   test_cntr_++;
 700   OpenOutFile(test_cntr_);
 701   if (test_mode_ != 0) {
 702     // Print out codec and settings
 703     printf("Test number: %d\nCodec: Opus Freq: 48000 Rate :32000 PackSize: 960"
 704         " Decode: mono\n", test_cntr_);
 705   }
 706   opus_codec_param.channels = 1;
 707   EXPECT_EQ(0, acm_b_->RegisterReceiveCodec(opus_codec_param));
 708   Run(channel_a2b_, audio_channels, codec_channels);
 709   out_file_.Close();
 710
 711 #endif
 712
 713   // Print out which codecs were tested, and which were not, in the run.
 714   if (test_mode_ != 0) {
 715     printf("\nThe following codecs was INCLUDED in the test:\n");
 716 #ifdef WEBRTC_CODEC_G722
 717     printf("   G.722\n");
 718 #endif
 719 #ifdef WEBRTC_CODEC_PCM16
 720     printf("   PCM16\n");
 721 #endif
 722     printf("   G.711\n");
 723 #ifdef WEBRTC_CODEC_CELT
 724     printf("   CELT\n");
 725 #endif
 726 #ifdef WEBRTC_CODEC_OPUS
 727     printf("   Opus\n");
 728 #endif
 729     printf("\nTo complete the test, listen to the %d number of output "
 730            "files.\n",
 731            test_cntr_);
 732   }
 733
 734   // Delete the file pointers.
 735   delete in_file_stereo_;
 736   delete in_file_mono_;
 737 }
 738
 739 // Register Codec to use in the test
 740 //
 741 // Input:   side             - which ACM to use, 'A' or 'B'
 742 //          codec_name       - name to use when register the codec
 743 //          sampling_freq_hz - sampling frequency in Herz
 744 //          rate             - bitrate in bytes
 745 //          pack_size        - packet size in samples
 746 //          channels         - number of channels; 1 for mono, 2 for stereo
 747 //          payload_type     - payload type for the codec
 748 void TestStereo::RegisterSendCodec(char side, char* codec_name,
 749                                    int32_t sampling_freq_hz, int rate,
 750                                    int pack_size, int channels,
 751                                    int payload_type) {
 752   if (test_mode_ != 0) {
 753     // Print out codec and settings
 754     printf("Codec: %s Freq: %d Rate: %d PackSize: %d\n", codec_name,
 755            sampling_freq_hz, rate, pack_size);
 756   }
 757
 758   // Store packet size in samples, used to validate the received packet
 759   pack_size_samp_ = pack_size;
 760
 761   // Store the expected packet size in bytes, used to validate the received
 762   // packet. Add 0.875 to always round up to a whole byte.
 763   // For Celt the packet size in bytes is already counting the stereo part.
 764   if (!strcmp(codec_name, "CELT")) {
 765     pack_size_bytes_ = (uint16_t)(
 766         static_cast<float>(pack_size * rate) /
 767             static_cast<float>(sampling_freq_hz * 8) + 0.875) / channels;
 768   } else {
 769     pack_size_bytes_ = (uint16_t)(
 770         static_cast<float>(pack_size * rate) /
 771             static_cast<float>(sampling_freq_hz * 8) + 0.875);
 772   }
 773
 774   // Set pointer to the ACM where to register the codec
 775   AudioCodingModule* my_acm = NULL;
 776   switch (side) {
 777     case 'A': {
 778       my_acm = acm_a_.get();
 779       break;
 780     }
 781     case 'B': {
 782       my_acm = acm_b_.get();
 783       break;
 784     }
 785     default:
 786       break;
 787   }
 788   ASSERT_TRUE(my_acm != NULL);
 789
 790   CodecInst my_codec_param;
 791   // Get all codec parameters before registering
 792   EXPECT_GT(AudioCodingModule::Codec(codec_name, &my_codec_param,
 793                                      sampling_freq_hz, channels), -1);
 794   my_codec_param.rate = rate;
 795   my_codec_param.pacsize = pack_size;
 796   EXPECT_EQ(0, my_acm->RegisterSendCodec(my_codec_param));
 797
 798   send_codec_name_ = codec_name;
 799 }
 800
 801 void TestStereo::Run(TestPackStereo* channel, int in_channels, int out_channels,
 802                      int percent_loss) {
 803   AudioFrame audio_frame;
 804
 805   int32_t out_freq_hz_b = out_file_.SamplingFrequency();
 806   uint16_t rec_size;
 807   uint32_t time_stamp_diff;
 808   channel->reset_payload_size();
 809   int error_count = 0;
 810   int variable_bytes = 0;
 811   int variable_packets = 0;
 812
 813   while (1) {
 814     // Simulate packet loss by setting |packet_loss_| to "true" in
 815     // |percent_loss| percent of the loops.
 816     if (percent_loss > 0) {
 817       if (counter_ == floor((100 / percent_loss) + 0.5)) {
 818         counter_ = 0;
 819         channel->set_lost_packet(true);
 820       } else {
 821         channel->set_lost_packet(false);
 822       }
 823       counter_++;
 824     }
 825
 826     // Add 10 msec to ACM
 827     if (in_channels == 1) {
 828       if (in_file_mono_->EndOfFile()) {
 829         break;
 830       }
 831       in_file_mono_->Read10MsData(audio_frame);
 832     } else {
 833       if (in_file_stereo_->EndOfFile()) {
 834         break;
 835       }
 836       in_file_stereo_->Read10MsData(audio_frame);
 837     }
 838     EXPECT_EQ(0, acm_a_->Add10MsData(audio_frame));
 839
 840     // Run sender side of ACM
 841     EXPECT_GT(acm_a_->Process(), -1);
 842
 843     // Verify that the received packet size matches the settings.
 844     rec_size = channel->payload_size();
 845     if ((0 < rec_size) & (rec_size < 65535)) {
 846       if (strcmp(send_codec_name_, "opus") == 0) {
 847         // Opus is a variable rate codec, hence calculate the average packet
 848         // size, and later make sure the average is in the right range.
 849         variable_bytes += rec_size;
 850         variable_packets++;
 851       } else {
 852         // For fixed rate codecs, check that packet size is correct.
 853         if ((rec_size != pack_size_bytes_ * out_channels)
 854             && (pack_size_bytes_ < 65535)) {
 855           error_count++;
 856         }
 857       }
 858       // Verify that the timestamp is updated with expected length
 859       time_stamp_diff = channel->timestamp_diff();
 860       if ((counter_ > 10) && (time_stamp_diff != pack_size_samp_)) {
 861         error_count++;
 862       }
 863     }
 864
 865     // Run received side of ACM
 866     EXPECT_EQ(0, acm_b_->PlayoutData10Ms(out_freq_hz_b, &audio_frame));
 867
 868     // Write output speech to file
 869     out_file_.Write10MsData(
 870         audio_frame.data_,
 871         audio_frame.samples_per_channel_ * audio_frame.num_channels_);
 872   }
 873
 874   EXPECT_EQ(0, error_count);
 875
 876   // Check that packet size is in the right range for variable rate codecs,
 877   // such as Opus.
 878   if (variable_packets > 0) {
 879     variable_bytes /= variable_packets;
 880     EXPECT_NEAR(variable_bytes, pack_size_bytes_, 3);
 881   }
 882
 883   if (in_file_mono_->EndOfFile()) {
 884     in_file_mono_->Rewind();
 885   }
 886   if (in_file_stereo_->EndOfFile()) {
 887     in_file_stereo_->Rewind();
 888   }
 889   // Reset in case we ended with a lost packet
 890   channel->set_lost_packet(false);
 891 }
 892
 893 void TestStereo::OpenOutFile(int16_t test_number) {
 894   std::string file_name;
 895   std::stringstream file_stream;
 896   file_stream << webrtc::test::OutputPath() << "teststereo_out_" << test_number
 897       << ".pcm";
 898   file_name = file_stream.str();
 899   out_file_.Open(file_name, 32000, "wb");
 900 }
 901
 902 void TestStereo::DisplaySendReceiveCodec() {
 903   CodecInst my_codec_param;
 904   acm_a_->SendCodec(&my_codec_param);
 905   if (test_mode_ != 0) {
 906     printf("%s -> ", my_codec_param.plname);
 907   }
 908   acm_b_->ReceiveCodec(&my_codec_param);
 909   if (test_mode_ != 0) {
 910     printf("%s\n", my_codec_param.plname);
 911   }
 912 }
 913
 914 }  // namespace webrtc