src/third_party/webrtc/modules/audio_coding/main/test/TestAllCodecs.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/TestAllCodecs.h"
  12
  13 #include <stdio.h>
  14 #include <string>
  15
  16 #include "testing/gtest/include/gtest/gtest.h"
  17
  18 #include "webrtc/common_types.h"
  19 #include "webrtc/engine_configurations.h"
  20 #include "webrtc/modules/audio_coding/main/interface/audio_coding_module.h"
  21 #include "webrtc/modules/audio_coding/main/interface/audio_coding_module_typedefs.h"
  22 #include "webrtc/modules/audio_coding/main/test/utility.h"
  23 #include "webrtc/system_wrappers/interface/trace.h"
  24 #include "webrtc/test/testsupport/fileutils.h"
  25 #include "webrtc/typedefs.h"
  26
  27 // Description of the test:
  28 // In this test we set up a one-way communication channel from a participant
  29 // called "a" to a participant called "b".
  30 // a -> channel_a_to_b -> b
  31 //
  32 // The test loops through all available mono codecs, encode at "a" sends over
  33 // the channel, and decodes at "b".
  34
  35 namespace webrtc {
  36
  37 // Class for simulating packet handling.
  38 TestPack::TestPack()
  39     : receiver_acm_(NULL),
  40       sequence_number_(0),
  41       timestamp_diff_(0),
  42       last_in_timestamp_(0),
  43       total_bytes_(0),
  44       payload_size_(0) {
  45 }
  46
  47 TestPack::~TestPack() {
  48 }
  49
  50 void TestPack::RegisterReceiverACM(AudioCodingModule* acm) {
  51   receiver_acm_ = acm;
  52   return;
  53 }
  54
  55 int32_t TestPack::SendData(FrameType frame_type, uint8_t payload_type,
  56                            uint32_t timestamp, const uint8_t* payload_data,
  57                            uint16_t payload_size,
  58                            const RTPFragmentationHeader* fragmentation) {
  59   WebRtcRTPHeader rtp_info;
  60   int32_t status;
  61
  62   rtp_info.header.markerBit = false;
  63   rtp_info.header.ssrc = 0;
  64   rtp_info.header.sequenceNumber = sequence_number_++;
  65   rtp_info.header.payloadType = payload_type;
  66   rtp_info.header.timestamp = timestamp;
  67   if (frame_type == kAudioFrameCN) {
  68     rtp_info.type.Audio.isCNG = true;
  69   } else {
  70     rtp_info.type.Audio.isCNG = false;
  71   }
  72   if (frame_type == kFrameEmpty) {
  73     // Skip this frame.
  74     return 0;
  75   }
  76
  77   // Only run mono for all test cases.
  78   rtp_info.type.Audio.channel = 1;
  79   memcpy(payload_data_, payload_data, payload_size);
  80
  81   status = receiver_acm_->IncomingPacket(payload_data_, payload_size, rtp_info);
  82
  83   payload_size_ = payload_size;
  84   timestamp_diff_ = timestamp - last_in_timestamp_;
  85   last_in_timestamp_ = timestamp;
  86   total_bytes_ += payload_size;
  87   return status;
  88 }
  89
  90 uint16_t TestPack::payload_size() {
  91   return payload_size_;
  92 }
  93
  94 uint32_t TestPack::timestamp_diff() {
  95   return timestamp_diff_;
  96 }
  97
  98 void TestPack::reset_payload_size() {
  99   payload_size_ = 0;
 100 }
 101
 102 TestAllCodecs::TestAllCodecs(int test_mode)
 103     : acm_a_(AudioCodingModule::Create(0)),
 104       acm_b_(AudioCodingModule::Create(1)),
 105       channel_a_to_b_(NULL),
 106       test_count_(0),
 107       packet_size_samples_(0),
 108       packet_size_bytes_(0) {
 109   // test_mode = 0 for silent test (auto test)
 110   test_mode_ = test_mode;
 111 }
 112
 113 TestAllCodecs::~TestAllCodecs() {
 114   if (channel_a_to_b_ != NULL) {
 115     delete channel_a_to_b_;
 116     channel_a_to_b_ = NULL;
 117   }
 118 }
 119
 120 void TestAllCodecs::Perform() {
 121   const std::string file_name = webrtc::test::ResourcePath(
 122       "audio_coding/testfile32kHz", "pcm");
 123   infile_a_.Open(file_name, 32000, "rb");
 124
 125   if (test_mode_ == 0) {
 126     WEBRTC_TRACE(kTraceStateInfo, kTraceAudioCoding, -1,
 127                  "---------- TestAllCodecs ----------");
 128   }
 129
 130   acm_a_->InitializeReceiver();
 131   acm_b_->InitializeReceiver();
 132
 133   uint8_t num_encoders = acm_a_->NumberOfCodecs();
 134   CodecInst my_codec_param;
 135   for (uint8_t n = 0; n < num_encoders; n++) {
 136     acm_b_->Codec(n, &my_codec_param);
 137     if (!strcmp(my_codec_param.plname, "opus")) {
 138       my_codec_param.channels = 1;
 139     }
 140     acm_b_->RegisterReceiveCodec(my_codec_param);
 141   }
 142
 143   // Create and connect the channel
 144   channel_a_to_b_ = new TestPack;
 145   acm_a_->RegisterTransportCallback(channel_a_to_b_);
 146   channel_a_to_b_->RegisterReceiverACM(acm_b_.get());
 147
 148   // All codecs are tested for all allowed sampling frequencies, rates and
 149   // packet sizes.
 150 #ifdef WEBRTC_CODEC_AMR
 151   if (test_mode_ != 0) {
 152     printf("===============================================================\n");
 153   }
 154   test_count_++;
 155   OpenOutFile(test_count_);
 156   char codec_amr[] = "AMR";
 157   RegisterSendCodec('A', codec_amr, 8000, 4750, 160, 2);
 158   Run(channel_a_to_b_);
 159   RegisterSendCodec('A', codec_amr, 8000, 4750, 320, 2);
 160   Run(channel_a_to_b_);
 161   RegisterSendCodec('A', codec_amr, 8000, 4750, 480, 3);
 162   Run(channel_a_to_b_);
 163   RegisterSendCodec('A', codec_amr, 8000, 5150, 160, 2);
 164   Run(channel_a_to_b_);
 165   RegisterSendCodec('A', codec_amr, 8000, 5150, 320, 2);
 166   Run(channel_a_to_b_);
 167   RegisterSendCodec('A', codec_amr, 8000, 5150, 480, 3);
 168   Run(channel_a_to_b_);
 169   RegisterSendCodec('A', codec_amr, 8000, 5900, 160, 1);
 170   Run(channel_a_to_b_);
 171   RegisterSendCodec('A', codec_amr, 8000, 5900, 320, 2);
 172   Run(channel_a_to_b_);
 173   RegisterSendCodec('A', codec_amr, 8000, 5900, 480, 2);
 174   Run(channel_a_to_b_);
 175   RegisterSendCodec('A', codec_amr, 8000, 6700, 160, 1);
 176   Run(channel_a_to_b_);
 177   RegisterSendCodec('A', codec_amr, 8000, 6700, 320, 2);
 178   Run(channel_a_to_b_);
 179   RegisterSendCodec('A', codec_amr, 8000, 6700, 480, 2);
 180   Run(channel_a_to_b_);
 181   RegisterSendCodec('A', codec_amr, 8000, 7400, 160, 1);
 182   Run(channel_a_to_b_);
 183   RegisterSendCodec('A', codec_amr, 8000, 7400, 320, 2);
 184   Run(channel_a_to_b_);
 185   RegisterSendCodec('A', codec_amr, 8000, 7400, 480, 3);
 186   Run(channel_a_to_b_);
 187   RegisterSendCodec('A', codec_amr, 8000, 7950, 160, 2);
 188   Run(channel_a_to_b_);
 189   RegisterSendCodec('A', codec_amr, 8000, 7950, 320, 2);
 190   Run(channel_a_to_b_);
 191   RegisterSendCodec('A', codec_amr, 8000, 7950, 480, 3);
 192   Run(channel_a_to_b_);
 193   RegisterSendCodec('A', codec_amr, 8000, 10200, 160, 1);
 194   Run(channel_a_to_b_);
 195   RegisterSendCodec('A', codec_amr, 8000, 10200, 320, 2);
 196   Run(channel_a_to_b_);
 197   RegisterSendCodec('A', codec_amr, 8000, 10200, 480, 3);
 198   Run(channel_a_to_b_);
 199   RegisterSendCodec('A', codec_amr, 8000, 12200, 160, 1);
 200   Run(channel_a_to_b_);
 201   RegisterSendCodec('A', codec_amr, 8000, 12200, 320, 2);
 202   Run(channel_a_to_b_);
 203   RegisterSendCodec('A', codec_amr, 8000, 12200, 480, 3);
 204   Run(channel_a_to_b_);
 205   outfile_b_.Close();
 206 #endif
 207 #ifdef WEBRTC_CODEC_AMRWB
 208   if (test_mode_ != 0) {
 209     printf("===============================================================\n");
 210   }
 211   test_count_++;
 212   char codec_amrwb[] = "AMR-WB";
 213   OpenOutFile(test_count_);
 214   RegisterSendCodec('A', codec_amrwb, 16000, 7000, 320, 0);
 215   Run(channel_a_to_b_);
 216   RegisterSendCodec('A', codec_amrwb, 16000, 7000, 640, 0);
 217   Run(channel_a_to_b_);
 218   RegisterSendCodec('A', codec_amrwb, 16000, 7000, 960, 0);
 219   Run(channel_a_to_b_);
 220   RegisterSendCodec('A', codec_amrwb, 16000, 9000, 320, 1);
 221   Run(channel_a_to_b_);
 222   RegisterSendCodec('A', codec_amrwb, 16000, 9000, 640, 2);
 223   Run(channel_a_to_b_);
 224   RegisterSendCodec('A', codec_amrwb, 16000, 9000, 960, 2);
 225   Run(channel_a_to_b_);
 226   RegisterSendCodec('A', codec_amrwb, 16000, 12000, 320, 3);
 227   Run(channel_a_to_b_);
 228   RegisterSendCodec('A', codec_amrwb, 16000, 12000, 640, 6);
 229   Run(channel_a_to_b_);
 230   RegisterSendCodec('A', codec_amrwb, 16000, 12000, 960, 8);
 231   Run(channel_a_to_b_);
 232   RegisterSendCodec('A', codec_amrwb, 16000, 14000, 320, 2);
 233   Run(channel_a_to_b_);
 234   RegisterSendCodec('A', codec_amrwb, 16000, 14000, 640, 4);
 235   Run(channel_a_to_b_);
 236   RegisterSendCodec('A', codec_amrwb, 16000, 14000, 960, 5);
 237   Run(channel_a_to_b_);
 238   RegisterSendCodec('A', codec_amrwb, 16000, 16000, 320, 1);
 239   Run(channel_a_to_b_);
 240   RegisterSendCodec('A', codec_amrwb, 16000, 16000, 640, 2);
 241   Run(channel_a_to_b_);
 242   RegisterSendCodec('A', codec_amrwb, 16000, 16000, 960, 2);
 243   Run(channel_a_to_b_);
 244   RegisterSendCodec('A', codec_amrwb, 16000, 18000, 320, 2);
 245   Run(channel_a_to_b_);
 246   RegisterSendCodec('A', codec_amrwb, 16000, 18000, 640, 4);
 247   Run(channel_a_to_b_);
 248   RegisterSendCodec('A', codec_amrwb, 16000, 18000, 960, 5);
 249   Run(channel_a_to_b_);
 250   RegisterSendCodec('A', codec_amrwb, 16000, 20000, 320, 1);
 251   Run(channel_a_to_b_);
 252   RegisterSendCodec('A', codec_amrwb, 16000, 20000, 640, 2);
 253   Run(channel_a_to_b_);
 254   RegisterSendCodec('A', codec_amrwb, 16000, 20000, 960, 2);
 255   Run(channel_a_to_b_);
 256   RegisterSendCodec('A', codec_amrwb, 16000, 23000, 320, 1);
 257   Run(channel_a_to_b_);
 258   RegisterSendCodec('A', codec_amrwb, 16000, 23000, 640, 3);
 259   Run(channel_a_to_b_);
 260   RegisterSendCodec('A', codec_amrwb, 16000, 23000, 960, 3);
 261   Run(channel_a_to_b_);
 262   RegisterSendCodec('A', codec_amrwb, 16000, 24000, 320, 1);
 263   Run(channel_a_to_b_);
 264   RegisterSendCodec('A', codec_amrwb, 16000, 24000, 640, 2);
 265   Run(channel_a_to_b_);
 266   RegisterSendCodec('A', codec_amrwb, 16000, 24000, 960, 2);
 267   Run(channel_a_to_b_);
 268   outfile_b_.Close();
 269 #endif
 270 #ifdef WEBRTC_CODEC_G722
 271   if (test_mode_ != 0) {
 272     printf("===============================================================\n");
 273   }
 274   test_count_++;
 275   OpenOutFile(test_count_);
 276   char codec_g722[] = "G722";
 277   RegisterSendCodec('A', codec_g722, 16000, 64000, 160, 0);
 278   Run(channel_a_to_b_);
 279   RegisterSendCodec('A', codec_g722, 16000, 64000, 320, 0);
 280   Run(channel_a_to_b_);
 281   RegisterSendCodec('A', codec_g722, 16000, 64000, 480, 0);
 282   Run(channel_a_to_b_);
 283   RegisterSendCodec('A', codec_g722, 16000, 64000, 640, 0);
 284   Run(channel_a_to_b_);
 285   RegisterSendCodec('A', codec_g722, 16000, 64000, 800, 0);
 286   Run(channel_a_to_b_);
 287   RegisterSendCodec('A', codec_g722, 16000, 64000, 960, 0);
 288   Run(channel_a_to_b_);
 289   outfile_b_.Close();
 290 #endif
 291 #ifdef WEBRTC_CODEC_G722_1
 292   if (test_mode_ != 0) {
 293     printf("===============================================================\n");
 294   }
 295   test_count_++;
 296   OpenOutFile(test_count_);
 297   char codec_g722_1[] = "G7221";
 298   RegisterSendCodec('A', codec_g722_1, 16000, 32000, 320, 0);
 299   Run(channel_a_to_b_);
 300   RegisterSendCodec('A', codec_g722_1, 16000, 24000, 320, 0);
 301   Run(channel_a_to_b_);
 302   RegisterSendCodec('A', codec_g722_1, 16000, 16000, 320, 0);
 303   Run(channel_a_to_b_);
 304   outfile_b_.Close();
 305 #endif
 306 #ifdef WEBRTC_CODEC_G722_1C
 307   if (test_mode_ != 0) {
 308     printf("===============================================================\n");
 309   }
 310   test_count_++;
 311   OpenOutFile(test_count_);
 312   char codec_g722_1c[] = "G7221";
 313   RegisterSendCodec('A', codec_g722_1c, 32000, 48000, 640, 0);
 314   Run(channel_a_to_b_);
 315   RegisterSendCodec('A', codec_g722_1c, 32000, 32000, 640, 0);
 316   Run(channel_a_to_b_);
 317   RegisterSendCodec('A', codec_g722_1c, 32000, 24000, 640, 0);
 318   Run(channel_a_to_b_);
 319   outfile_b_.Close();
 320 #endif
 321 #ifdef WEBRTC_CODEC_G729
 322   if (test_mode_ != 0) {
 323     printf("===============================================================\n");
 324   }
 325   test_count_++;
 326   OpenOutFile(test_count_);
 327   char codec_g729[] = "G729";
 328   RegisterSendCodec('A', codec_g729, 8000, 8000, 80, 0);
 329   Run(channel_a_to_b_);
 330   RegisterSendCodec('A', codec_g729, 8000, 8000, 160, 0);
 331   Run(channel_a_to_b_);
 332   RegisterSendCodec('A', codec_g729, 8000, 8000, 240, 0);
 333   Run(channel_a_to_b_);
 334   RegisterSendCodec('A', codec_g729, 8000, 8000, 320, 0);
 335   Run(channel_a_to_b_);
 336   RegisterSendCodec('A', codec_g729, 8000, 8000, 400, 0);
 337   Run(channel_a_to_b_);
 338   RegisterSendCodec('A', codec_g729, 8000, 8000, 480, 0);
 339   Run(channel_a_to_b_);
 340   outfile_b_.Close();
 341 #endif
 342 #ifdef WEBRTC_CODEC_G729_1
 343   if (test_mode_ != 0) {
 344     printf("===============================================================\n");
 345   }
 346   test_count_++;
 347   OpenOutFile(test_count_);
 348   char codec_g729_1[] = "G7291";
 349   RegisterSendCodec('A', codec_g729_1, 16000, 8000, 320, 1);
 350   Run(channel_a_to_b_);
 351   RegisterSendCodec('A', codec_g729_1, 16000, 8000, 640, 1);
 352   Run(channel_a_to_b_);
 353   RegisterSendCodec('A', codec_g729_1, 16000, 8000, 960, 1);
 354   Run(channel_a_to_b_);
 355   RegisterSendCodec('A', codec_g729_1, 16000, 12000, 320, 1);
 356   Run(channel_a_to_b_);
 357   RegisterSendCodec('A', codec_g729_1, 16000, 12000, 640, 1);
 358   Run(channel_a_to_b_);
 359   RegisterSendCodec('A', codec_g729_1, 16000, 12000, 960, 1);
 360   Run(channel_a_to_b_);
 361   RegisterSendCodec('A', codec_g729_1, 16000, 14000, 320, 1);
 362   Run(channel_a_to_b_);
 363   RegisterSendCodec('A', codec_g729_1, 16000, 14000, 640, 1);
 364   Run(channel_a_to_b_);
 365   RegisterSendCodec('A', codec_g729_1, 16000, 14000, 960, 1);
 366   Run(channel_a_to_b_);
 367   RegisterSendCodec('A', codec_g729_1, 16000, 16000, 320, 1);
 368   Run(channel_a_to_b_);
 369   RegisterSendCodec('A', codec_g729_1, 16000, 16000, 640, 1);
 370   Run(channel_a_to_b_);
 371   RegisterSendCodec('A', codec_g729_1, 16000, 16000, 960, 1);
 372   Run(channel_a_to_b_);
 373   RegisterSendCodec('A', codec_g729_1, 16000, 18000, 320, 1);
 374   Run(channel_a_to_b_);
 375   RegisterSendCodec('A', codec_g729_1, 16000, 18000, 640, 1);
 376   Run(channel_a_to_b_);
 377   RegisterSendCodec('A', codec_g729_1, 16000, 18000, 960, 1);
 378   Run(channel_a_to_b_);
 379   RegisterSendCodec('A', codec_g729_1, 16000, 20000, 320, 1);
 380   Run(channel_a_to_b_);
 381   RegisterSendCodec('A', codec_g729_1, 16000, 20000, 640, 1);
 382   Run(channel_a_to_b_);
 383   RegisterSendCodec('A', codec_g729_1, 16000, 20000, 960, 1);
 384   Run(channel_a_to_b_);
 385   RegisterSendCodec('A', codec_g729_1, 16000, 22000, 320, 1);
 386   Run(channel_a_to_b_);
 387   RegisterSendCodec('A', codec_g729_1, 16000, 22000, 640, 1);
 388   Run(channel_a_to_b_);
 389   RegisterSendCodec('A', codec_g729_1, 16000, 22000, 960, 1);
 390   Run(channel_a_to_b_);
 391   RegisterSendCodec('A', codec_g729_1, 16000, 24000, 320, 1);
 392   Run(channel_a_to_b_);
 393   RegisterSendCodec('A', codec_g729_1, 16000, 24000, 640, 1);
 394   Run(channel_a_to_b_);
 395   RegisterSendCodec('A', codec_g729_1, 16000, 24000, 960, 1);
 396   Run(channel_a_to_b_);
 397   RegisterSendCodec('A', codec_g729_1, 16000, 26000, 320, 1);
 398   Run(channel_a_to_b_);
 399   RegisterSendCodec('A', codec_g729_1, 16000, 26000, 640, 1);
 400   Run(channel_a_to_b_);
 401   RegisterSendCodec('A', codec_g729_1, 16000, 26000, 960, 1);
 402   Run(channel_a_to_b_);
 403   RegisterSendCodec('A', codec_g729_1, 16000, 28000, 320, 1);
 404   Run(channel_a_to_b_);
 405   RegisterSendCodec('A', codec_g729_1, 16000, 28000, 640, 1);
 406   Run(channel_a_to_b_);
 407   RegisterSendCodec('A', codec_g729_1, 16000, 28000, 960, 1);
 408   Run(channel_a_to_b_);
 409   RegisterSendCodec('A', codec_g729_1, 16000, 30000, 320, 1);
 410   Run(channel_a_to_b_);
 411   RegisterSendCodec('A', codec_g729_1, 16000, 30000, 640, 1);
 412   Run(channel_a_to_b_);
 413   RegisterSendCodec('A', codec_g729_1, 16000, 30000, 960, 1);
 414   Run(channel_a_to_b_);
 415   RegisterSendCodec('A', codec_g729_1, 16000, 32000, 320, 1);
 416   Run(channel_a_to_b_);
 417   RegisterSendCodec('A', codec_g729_1, 16000, 32000, 640, 1);
 418   Run(channel_a_to_b_);
 419   RegisterSendCodec('A', codec_g729_1, 16000, 32000, 960, 1);
 420   Run(channel_a_to_b_);
 421   outfile_b_.Close();
 422 #endif
 423 #ifdef WEBRTC_CODEC_GSMFR
 424   if (test_mode_ != 0) {
 425     printf("===============================================================\n");
 426   }
 427   test_count_++;
 428   OpenOutFile(test_count_);
 429   char codec_gsmfr[] = "GSM";
 430   RegisterSendCodec('A', codec_gsmfr, 8000, 13200, 160, 0);
 431   Run(channel_a_to_b_);
 432   RegisterSendCodec('A', codec_gsmfr, 8000, 13200, 320, 0);
 433   Run(channel_a_to_b_);
 434   RegisterSendCodec('A', codec_gsmfr, 8000, 13200, 480, 0);
 435   Run(channel_a_to_b_);
 436   outfile_b_.Close();
 437 #endif
 438 #ifdef WEBRTC_CODEC_ILBC
 439   if (test_mode_ != 0) {
 440     printf("===============================================================\n");
 441   }
 442   test_count_++;
 443   OpenOutFile(test_count_);
 444   char codec_ilbc[] = "ILBC";
 445   RegisterSendCodec('A', codec_ilbc, 8000, 13300, 240, 0);
 446   Run(channel_a_to_b_);
 447   RegisterSendCodec('A', codec_ilbc, 8000, 13300, 480, 0);
 448   Run(channel_a_to_b_);
 449   RegisterSendCodec('A', codec_ilbc, 8000, 15200, 160, 0);
 450   Run(channel_a_to_b_);
 451   RegisterSendCodec('A', codec_ilbc, 8000, 15200, 320, 0);
 452   Run(channel_a_to_b_);
 453   outfile_b_.Close();
 454 #endif
 455 #if (defined(WEBRTC_CODEC_ISAC) || defined(WEBRTC_CODEC_ISACFX))
 456   if (test_mode_ != 0) {
 457     printf("===============================================================\n");
 458   }
 459   test_count_++;
 460   OpenOutFile(test_count_);
 461   char codec_isac[] = "ISAC";
 462   RegisterSendCodec('A', codec_isac, 16000, -1, 480, -1);
 463   Run(channel_a_to_b_);
 464   RegisterSendCodec('A', codec_isac, 16000, -1, 960, -1);
 465   Run(channel_a_to_b_);
 466   RegisterSendCodec('A', codec_isac, 16000, 15000, 480, -1);
 467   Run(channel_a_to_b_);
 468   RegisterSendCodec('A', codec_isac, 16000, 32000, 960, -1);
 469   Run(channel_a_to_b_);
 470   outfile_b_.Close();
 471 #endif
 472 #ifdef WEBRTC_CODEC_ISAC
 473   if (test_mode_ != 0) {
 474     printf("===============================================================\n");
 475   }
 476   test_count_++;
 477   OpenOutFile(test_count_);
 478   RegisterSendCodec('A', codec_isac, 32000, -1, 960, -1);
 479   Run(channel_a_to_b_);
 480   RegisterSendCodec('A', codec_isac, 32000, 56000, 960, -1);
 481   Run(channel_a_to_b_);
 482   RegisterSendCodec('A', codec_isac, 32000, 37000, 960, -1);
 483   Run(channel_a_to_b_);
 484   RegisterSendCodec('A', codec_isac, 32000, 32000, 960, -1);
 485   Run(channel_a_to_b_);
 486   outfile_b_.Close();
 487 #endif
 488 #ifdef WEBRTC_CODEC_PCM16
 489   if (test_mode_ != 0) {
 490     printf("===============================================================\n");
 491   }
 492   test_count_++;
 493   OpenOutFile(test_count_);
 494   char codec_l16[] = "L16";
 495   RegisterSendCodec('A', codec_l16, 8000, 128000, 80, 0);
 496   Run(channel_a_to_b_);
 497   RegisterSendCodec('A', codec_l16, 8000, 128000, 160, 0);
 498   Run(channel_a_to_b_);
 499   RegisterSendCodec('A', codec_l16, 8000, 128000, 240, 0);
 500   Run(channel_a_to_b_);
 501   RegisterSendCodec('A', codec_l16, 8000, 128000, 320, 0);
 502   Run(channel_a_to_b_);
 503   outfile_b_.Close();
 504   if (test_mode_ != 0) {
 505     printf("===============================================================\n");
 506   }
 507   test_count_++;
 508   OpenOutFile(test_count_);
 509   RegisterSendCodec('A', codec_l16, 16000, 256000, 160, 0);
 510   Run(channel_a_to_b_);
 511   RegisterSendCodec('A', codec_l16, 16000, 256000, 320, 0);
 512   Run(channel_a_to_b_);
 513   RegisterSendCodec('A', codec_l16, 16000, 256000, 480, 0);
 514   Run(channel_a_to_b_);
 515   RegisterSendCodec('A', codec_l16, 16000, 256000, 640, 0);
 516   Run(channel_a_to_b_);
 517   outfile_b_.Close();
 518   if (test_mode_ != 0) {
 519     printf("===============================================================\n");
 520   }
 521   test_count_++;
 522   OpenOutFile(test_count_);
 523   RegisterSendCodec('A', codec_l16, 32000, 512000, 320, 0);
 524   Run(channel_a_to_b_);
 525   RegisterSendCodec('A', codec_l16, 32000, 512000, 640, 0);
 526   Run(channel_a_to_b_);
 527   outfile_b_.Close();
 528 #endif
 529   if (test_mode_ != 0) {
 530     printf("===============================================================\n");
 531   }
 532   test_count_++;
 533   OpenOutFile(test_count_);
 534   char codec_pcma[] = "PCMA";
 535   RegisterSendCodec('A', codec_pcma, 8000, 64000, 80, 0);
 536   Run(channel_a_to_b_);
 537   RegisterSendCodec('A', codec_pcma, 8000, 64000, 160, 0);
 538   Run(channel_a_to_b_);
 539   RegisterSendCodec('A', codec_pcma, 8000, 64000, 240, 0);
 540   Run(channel_a_to_b_);
 541   RegisterSendCodec('A', codec_pcma, 8000, 64000, 320, 0);
 542   Run(channel_a_to_b_);
 543   RegisterSendCodec('A', codec_pcma, 8000, 64000, 400, 0);
 544   Run(channel_a_to_b_);
 545   RegisterSendCodec('A', codec_pcma, 8000, 64000, 480, 0);
 546   Run(channel_a_to_b_);
 547   if (test_mode_ != 0) {
 548     printf("===============================================================\n");
 549   }
 550   char codec_pcmu[] = "PCMU";
 551   RegisterSendCodec('A', codec_pcmu, 8000, 64000, 80, 0);
 552   Run(channel_a_to_b_);
 553   RegisterSendCodec('A', codec_pcmu, 8000, 64000, 160, 0);
 554   Run(channel_a_to_b_);
 555   RegisterSendCodec('A', codec_pcmu, 8000, 64000, 240, 0);
 556   Run(channel_a_to_b_);
 557   RegisterSendCodec('A', codec_pcmu, 8000, 64000, 320, 0);
 558   Run(channel_a_to_b_);
 559   RegisterSendCodec('A', codec_pcmu, 8000, 64000, 400, 0);
 560   Run(channel_a_to_b_);
 561   RegisterSendCodec('A', codec_pcmu, 8000, 64000, 480, 0);
 562   Run(channel_a_to_b_);
 563   outfile_b_.Close();
 564 #ifdef WEBRTC_CODEC_SPEEX
 565   if (test_mode_ != 0) {
 566     printf("===============================================================\n");
 567   }
 568   test_count_++;
 569   OpenOutFile(test_count_);
 570   char codec_speex[] = "SPEEX";
 571   RegisterSendCodec('A', codec_speex, 8000, 2400, 160, 0);
 572   Run(channel_a_to_b_);
 573   RegisterSendCodec('A', codec_speex, 8000, 8000, 320, 0);
 574   Run(channel_a_to_b_);
 575   RegisterSendCodec('A', codec_speex, 8000, 18200, 480, 0);
 576   Run(channel_a_to_b_);
 577   outfile_b_.Close();
 578
 579   if (test_mode_ != 0) {
 580     printf("===============================================================\n");
 581   }
 582   test_count_++;
 583   OpenOutFile(test_count_);
 584   RegisterSendCodec('A', codec_speex, 16000, 4000, 320, 0);
 585   Run(channel_a_to_b_);
 586   RegisterSendCodec('A', codec_speex, 16000, 12800, 640, 0);
 587   Run(channel_a_to_b_);
 588   RegisterSendCodec('A', codec_speex, 16000, 34200, 960, 0);
 589   Run(channel_a_to_b_);
 590   outfile_b_.Close();
 591 #endif
 592 #ifdef WEBRTC_CODEC_CELT
 593   if (test_mode_ != 0) {
 594     printf("===============================================================\n");
 595   }
 596   test_count_++;
 597   OpenOutFile(test_count_);
 598   char codec_celt[] = "CELT";
 599   RegisterSendCodec('A', codec_celt, 32000, 48000, 640, 0);
 600   Run(channel_a_to_b_);
 601   RegisterSendCodec('A', codec_celt, 32000, 64000, 640, 0);
 602   Run(channel_a_to_b_);
 603   RegisterSendCodec('A', codec_celt, 32000, 128000, 640, 0);
 604   Run(channel_a_to_b_);
 605   outfile_b_.Close();
 606 #endif
 607 #ifdef WEBRTC_CODEC_OPUS
 608   if (test_mode_ != 0) {
 609     printf("===============================================================\n");
 610   }
 611   test_count_++;
 612   OpenOutFile(test_count_);
 613   char codec_opus[] = "OPUS";
 614   RegisterSendCodec('A', codec_opus, 48000, 6000, 480, -1);
 615   Run(channel_a_to_b_);
 616   RegisterSendCodec('A', codec_opus, 48000, 20000, 480*2, -1);
 617   Run(channel_a_to_b_);
 618   RegisterSendCodec('A', codec_opus, 48000, 32000, 480*4, -1);
 619   Run(channel_a_to_b_);
 620   RegisterSendCodec('A', codec_opus, 48000, 48000, 480, -1);
 621   Run(channel_a_to_b_);
 622   RegisterSendCodec('A', codec_opus, 48000, 64000, 480*4, -1);
 623   Run(channel_a_to_b_);
 624   RegisterSendCodec('A', codec_opus, 48000, 96000, 480*6, -1);
 625   Run(channel_a_to_b_);
 626   RegisterSendCodec('A', codec_opus, 48000, 500000, 480*2, -1);
 627   Run(channel_a_to_b_);
 628   outfile_b_.Close();
 629 #endif
 630   if (test_mode_ != 0) {
 631     printf("===============================================================\n");
 632
 633     /* Print out all codecs that were not tested in the run */
 634     printf("The following codecs was not included in the test:\n");
 635 #ifndef WEBRTC_CODEC_AMR
 636     printf("   GSMAMR\n");
 637 #endif
 638 #ifndef WEBRTC_CODEC_AMRWB
 639     printf("   GSMAMR-wb\n");
 640 #endif
 641 #ifndef WEBRTC_CODEC_G722
 642     printf("   G.722\n");
 643 #endif
 644 #ifndef WEBRTC_CODEC_G722_1
 645     printf("   G.722.1\n");
 646 #endif
 647 #ifndef WEBRTC_CODEC_G722_1C
 648     printf("   G.722.1C\n");
 649 #endif
 650 #ifndef WEBRTC_CODEC_G729
 651     printf("   G.729\n");
 652 #endif
 653 #ifndef WEBRTC_CODEC_G729_1
 654     printf("   G.729.1\n");
 655 #endif
 656 #ifndef WEBRTC_CODEC_GSMFR
 657     printf("   GSMFR\n");
 658 #endif
 659 #ifndef WEBRTC_CODEC_ILBC
 660     printf("   iLBC\n");
 661 #endif
 662 #ifndef WEBRTC_CODEC_ISAC
 663     printf("   ISAC float\n");
 664 #endif
 665 #ifndef WEBRTC_CODEC_ISACFX
 666     printf("   ISAC fix\n");
 667 #endif
 668 #ifndef WEBRTC_CODEC_PCM16
 669     printf("   PCM16\n");
 670 #endif
 671 #ifndef WEBRTC_CODEC_SPEEX
 672     printf("   Speex\n");
 673 #endif
 674
 675     printf("\nTo complete the test, listen to the %d number of output files.\n",
 676            test_count_);
 677   }
 678 }
 679
 680 // Register Codec to use in the test
 681 //
 682 // Input:  side             - which ACM to use, 'A' or 'B'
 683 //         codec_name       - name to use when register the codec
 684 //         sampling_freq_hz - sampling frequency in Herz
 685 //         rate             - bitrate in bytes
 686 //         packet_size      - packet size in samples
 687 //         extra_byte       - if extra bytes needed compared to the bitrate
 688 //                            used when registering, can be an internal header
 689 //                            set to -1 if the codec is a variable rate codec
 690 void TestAllCodecs::RegisterSendCodec(char side, char* codec_name,
 691                                       int32_t sampling_freq_hz, int rate,
 692                                       int packet_size, int extra_byte) {
 693   if (test_mode_ != 0) {
 694     // Print out codec and settings.
 695     printf("codec: %s Freq: %d Rate: %d PackSize: %d\n", codec_name,
 696            sampling_freq_hz, rate, packet_size);
 697   }
 698
 699   // Store packet-size in samples, used to validate the received packet.
 700   // If G.722, store half the size to compensate for the timestamp bug in the
 701   // RFC for G.722.
 702   // If iSAC runs in adaptive mode, packet size in samples can change on the
 703   // fly, so we exclude this test by setting |packet_size_samples_| to -1.
 704   if (!strcmp(codec_name, "G722")) {
 705     packet_size_samples_ = packet_size / 2;
 706   } else if (!strcmp(codec_name, "ISAC") && (rate == -1)) {
 707     packet_size_samples_ = -1;
 708   } else {
 709     packet_size_samples_ = packet_size;
 710   }
 711
 712   // Store the expected packet size in bytes, used to validate the received
 713   // packet. If variable rate codec (extra_byte == -1), set to -1.
 714   if (extra_byte != -1) {
 715     // Add 0.875 to always round up to a whole byte
 716     packet_size_bytes_ = static_cast<int>(static_cast<float>(packet_size
 717         * rate) / static_cast<float>(sampling_freq_hz * 8) + 0.875)
 718         + extra_byte;
 719   } else {
 720     // Packets will have a variable size.
 721     packet_size_bytes_ = -1;
 722   }
 723
 724   // Set pointer to the ACM where to register the codec.
 725   AudioCodingModule* my_acm = NULL;
 726   switch (side) {
 727     case 'A': {
 728       my_acm = acm_a_.get();
 729       break;
 730     }
 731     case 'B': {
 732       my_acm = acm_b_.get();
 733       break;
 734     }
 735     default: {
 736       break;
 737     }
 738   }
 739   ASSERT_TRUE(my_acm != NULL);
 740
 741   // Get all codec parameters before registering
 742   CodecInst my_codec_param;
 743   CHECK_ERROR(AudioCodingModule::Codec(codec_name, &my_codec_param,
 744                                        sampling_freq_hz, 1));
 745   my_codec_param.rate = rate;
 746   my_codec_param.pacsize = packet_size;
 747   CHECK_ERROR(my_acm->RegisterSendCodec(my_codec_param));
 748 }
 749
 750 void TestAllCodecs::Run(TestPack* channel) {
 751   AudioFrame audio_frame;
 752
 753   int32_t out_freq_hz = outfile_b_.SamplingFrequency();
 754   uint16_t receive_size;
 755   uint32_t timestamp_diff;
 756   channel->reset_payload_size();
 757   int error_count = 0;
 758
 759   int counter = 0;
 760   while (!infile_a_.EndOfFile()) {
 761     // Add 10 msec to ACM.
 762     infile_a_.Read10MsData(audio_frame);
 763     CHECK_ERROR(acm_a_->Add10MsData(audio_frame));
 764
 765     // Run sender side of ACM.
 766     CHECK_ERROR(acm_a_->Process());
 767
 768     // Verify that the received packet size matches the settings.
 769     receive_size = channel->payload_size();
 770     if (receive_size) {
 771       if ((static_cast<int>(receive_size) != packet_size_bytes_) &&
 772           (packet_size_bytes_ > -1)) {
 773         error_count++;
 774       }
 775
 776       // Verify that the timestamp is updated with expected length. The counter
 777       // is used to avoid problems when switching codec or frame size in the
 778       // test.
 779       timestamp_diff = channel->timestamp_diff();
 780       if ((counter > 10) &&
 781           (static_cast<int>(timestamp_diff) != packet_size_samples_) &&
 782           (packet_size_samples_ > -1))
 783         error_count++;
 784     }
 785
 786     // Run received side of ACM.
 787     CHECK_ERROR(acm_b_->PlayoutData10Ms(out_freq_hz, &audio_frame));
 788
 789     // Write output speech to file.
 790     outfile_b_.Write10MsData(audio_frame.data_,
 791                              audio_frame.samples_per_channel_);
 792
 793     // Update loop counter
 794     counter++;
 795   }
 796
 797   EXPECT_EQ(0, error_count);
 798
 799   if (infile_a_.EndOfFile()) {
 800     infile_a_.Rewind();
 801   }
 802 }
 803
 804 void TestAllCodecs::OpenOutFile(int test_number) {
 805   std::string filename = webrtc::test::OutputPath();
 806   std::ostringstream test_number_str;
 807   test_number_str << test_number;
 808   filename += "testallcodecs_out_";
 809   filename += test_number_str.str();
 810   filename += ".pcm";
 811   outfile_b_.Open(filename, 32000, "wb");
 812 }
 813
 814 void TestAllCodecs::DisplaySendReceiveCodec() {
 815   CodecInst my_codec_param;
 816   acm_a_->SendCodec(&my_codec_param);
 817   printf("%s -> ", my_codec_param.plname);
 818   acm_b_->ReceiveCodec(&my_codec_param);
 819   printf("%s\n", my_codec_param.plname);
 820 }
 821
 822 }  // namespace webrtc