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

/*
 *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

#include "TestStereo.h"

#include <cassert>
#include <iostream>

#include "audio_coding_module_typedefs.h"
#include "common_types.h"
#include "engine_configurations.h"
#include "testsupport/fileutils.h"
#include "trace.h"
#include "utility.h"

namespace webrtc {

// Class for simulating packet handling
TestPackStereo::TestPackStereo()
    : receiver_acm_(NULL),
      seq_no_(0),
      timestamp_diff_(0),
      last_in_timestamp_(0),
      total_bytes_(0),
      payload_size_(0),
      codec_mode_(kNotSet),
      lost_packet_(false) {}

TestPackStereo::~TestPackStereo() {}

void TestPackStereo::RegisterReceiverACM(AudioCodingModule* acm) {
  receiver_acm_ = acm;
  return;
}

WebRtc_Word32 TestPackStereo::SendData(
    const FrameType frame_type,
    const WebRtc_UWord8 payload_type,
    const WebRtc_UWord32 timestamp,
    const WebRtc_UWord8* payload_data,
    const WebRtc_UWord16 payload_size,
    const RTPFragmentationHeader* fragmentation) {
  WebRtcRTPHeader rtp_info;
  WebRtc_Word32 status = 0;

  rtp_info.header.markerBit = false;
  rtp_info.header.ssrc = 0;
  rtp_info.header.sequenceNumber = seq_no_++;
  rtp_info.header.payloadType = payload_type;
  rtp_info.header.timestamp = timestamp;
  if (frame_type == kFrameEmpty) {
    // Skip this frame
    return 0;
  }

  if (lost_packet_ == false) {
    if (frame_type != kAudioFrameCN) {
      rtp_info.type.Audio.isCNG = false;
      rtp_info.type.Audio.channel = (int) codec_mode_;
    } else {
      rtp_info.type.Audio.isCNG = true;
      rtp_info.type.Audio.channel = (int) kMono;
    }
    status = receiver_acm_->IncomingPacket(payload_data, payload_size,
                                          rtp_info);

    if (frame_type != kAudioFrameCN) {
      payload_size_ = payload_size;
    } else {
      payload_size_ = -1;
    }

    timestamp_diff_ = timestamp - last_in_timestamp_;
    last_in_timestamp_ = timestamp;
    total_bytes_ += payload_size;
  }
  return status;
}

WebRtc_UWord16 TestPackStereo::payload_size() {
  return payload_size_;
}

WebRtc_UWord32 TestPackStereo::timestamp_diff() {
  return timestamp_diff_;
}

void TestPackStereo::reset_payload_size() {
  payload_size_ = 0;
}

void TestPackStereo::set_codec_mode(enum StereoMonoMode mode) {
  codec_mode_ = mode;
}

void TestPackStereo::set_lost_packet(bool lost) {
  lost_packet_ = lost;
}

TestStereo::TestStereo(int test_mode)
    : acm_a_(NULL),
      acm_b_(NULL),
      channel_a2b_(NULL),
      test_cntr_(0),
      pack_size_samp_(0),
      pack_size_bytes_(0),
      counter_(0),
      g722_pltype_(0),
      l16_8khz_pltype_(-1),
      l16_16khz_pltype_(-1),
      l16_32khz_pltype_(-1),
      pcma_pltype_(-1),
      pcmu_pltype_(-1),
      celt_pltype_(-1),
      cn_8khz_pltype_(-1),
      cn_16khz_pltype_(-1),
      cn_32khz_pltype_(-1) {
  // testMode = 0 for silent test (auto test)
  test_mode_ = test_mode;
}

TestStereo::~TestStereo() {
  if (acm_a_ != NULL) {
    AudioCodingModule::Destroy(acm_a_);
    acm_a_ = NULL;
  }
  if (acm_b_ != NULL) {
    AudioCodingModule::Destroy(acm_b_);
    acm_b_ = NULL;
  }
  if (channel_a2b_ != NULL) {
    delete channel_a2b_;
    channel_a2b_ = NULL;
  }
}

void TestStereo::Perform() {
  char file_name_stereo[500];
  char file_name_mono[500];
  WebRtc_UWord16 frequency_hz;
  int audio_channels;
  int codec_channels;
  int status;

  if (test_mode_ == 0) {
    printf("Running Stereo Test");
    WEBRTC_TRACE(kTraceStateInfo, kTraceAudioCoding, -1,
                 "---------- TestStereo ----------");
  }

  strcpy(file_name_stereo, "./test/data/audio_coding/teststereo32kHz.pcm");
  strcpy(file_name_mono, "./test/data/audio_coding/testfile32kHz.pcm");
  frequency_hz = 32000;

  in_file_stereo_ = new PCMFile();
  in_file_mono_ = new PCMFile();

  in_file_stereo_->Open(file_name_stereo, frequency_hz, "rb");
  in_file_stereo_->ReadStereo(true);
  in_file_mono_->Open(file_name_mono, frequency_hz, "rb");
  in_file_mono_->ReadStereo(false);

  acm_a_ = AudioCodingModule::Create(0);
  acm_b_ = AudioCodingModule::Create(1);

  acm_a_->InitializeReceiver();
  acm_b_->InitializeReceiver();

  WebRtc_UWord8 num_encoders = acm_a_->NumberOfCodecs();
  CodecInst my_codec_param;

  // Register receiving codecs, some of them as stereo.
  for (WebRtc_UWord8 n = 0; n < num_encoders; n++) {
    acm_b_->Codec(n, my_codec_param);
    if (!strcmp(my_codec_param.plname, "L16")) {
      if (my_codec_param.plfreq == 8000) {
        l16_8khz_pltype_ = my_codec_param.pltype;
      } else if (my_codec_param.plfreq == 16000) {
        l16_16khz_pltype_ = my_codec_param.pltype;
      } else if (my_codec_param.plfreq == 32000) {
        l16_32khz_pltype_ = my_codec_param.pltype;
      }
      my_codec_param.channels = 2;
    } else if (!strcmp(my_codec_param.plname, "PCMA")) {
      pcma_pltype_ = my_codec_param.pltype;
      my_codec_param.channels = 2;
    } else if (!strcmp(my_codec_param.plname, "PCMU")) {
      pcmu_pltype_ = my_codec_param.pltype;
      my_codec_param.channels = 2;
    } else if (!strcmp(my_codec_param.plname, "G722")) {
      g722_pltype_ = my_codec_param.pltype;
      my_codec_param.channels = 2;
    } else if (!strcmp(my_codec_param.plname, "CELT")) {
      celt_pltype_ = my_codec_param.pltype;
      my_codec_param.channels = 2;
    }

    acm_b_->RegisterReceiveCodec(my_codec_param);
  }

  // Test that unregister all receive codecs works for stereo.
  for (WebRtc_UWord8 n = 0; n < num_encoders; n++) {
    status = acm_b_->Codec(n, my_codec_param);
    if (status < 0) {
      printf("Error in Codec(), no matching codec found");
    }
    status = acm_b_->UnregisterReceiveCodec(my_codec_param.pltype);
    if (status < 0) {
      printf("Error in UnregisterReceiveCodec() for payload type %d",
             my_codec_param.pltype);
    }
  }

  // Register receiving mono codecs, except comfort noise.
  for (WebRtc_UWord8 n = 0; n < num_encoders; n++) {
    status = acm_b_->Codec(n, my_codec_param);
    if (status < 0) {
      printf("Error in Codec(), no matching codec found");
    }
    if (!strcmp(my_codec_param.plname, "L16")
        || !strcmp(my_codec_param.plname, "PCMA")
        || !strcmp(my_codec_param.plname, "PCMU")
        || !strcmp(my_codec_param.plname, "G722")
        || !strcmp(my_codec_param.plname, "CELT")
        || !strcmp(my_codec_param.plname, "CN")) {
    } else {
      status = acm_b_->RegisterReceiveCodec(my_codec_param);
      if (status < 0) {
        printf("Error in UnregisterReceiveCodec() for codec number %d", n);
      }
    }
  }

  // TODO(tlegrand): Take care of return values of all function calls.
  // Re-register all stereo codecs needed in the test, with new payload
  // numbers.
  g722_pltype_ = 117;
  l16_8khz_pltype_ = 120;
  l16_16khz_pltype_ = 121;
  l16_32khz_pltype_ = 122;
  pcma_pltype_ = 110;
  pcmu_pltype_ = 118;
  celt_pltype_ = 119;
  cn_8khz_pltype_ = 123;
  cn_16khz_pltype_ = 124;
  cn_32khz_pltype_ = 125;

  // Register all stereo codecs with new payload types.
#ifdef WEBRTC_CODEC_G722
  // G722
  acm_b_->Codec("G722", my_codec_param, 16000);
  my_codec_param.pltype = g722_pltype_;
  my_codec_param.channels = 2;
  acm_b_->RegisterReceiveCodec(my_codec_param);
#endif
#ifdef WEBRTC_CODEC_PCM16
  // L16
  acm_b_->Codec("L16", my_codec_param, 8000);
  my_codec_param.pltype = l16_8khz_pltype_;
  my_codec_param.channels = 2;
  acm_b_->RegisterReceiveCodec(my_codec_param);
  acm_b_->Codec("L16", my_codec_param, 16000);
  my_codec_param.pltype = l16_16khz_pltype_;
  my_codec_param.channels = 2;
  acm_b_->RegisterReceiveCodec(my_codec_param);
  acm_b_->Codec("L16", my_codec_param, 32000);
  my_codec_param.pltype = l16_32khz_pltype_;
  my_codec_param.channels = 2;
  acm_b_->RegisterReceiveCodec(my_codec_param);
#endif
  // PCM Alaw and u-law
  acm_b_->Codec("PCMA", my_codec_param, 8000);
  my_codec_param.pltype = pcma_pltype_;
  my_codec_param.channels = 2;
  acm_b_->RegisterReceiveCodec(my_codec_param);
  acm_b_->Codec("PCMU", my_codec_param, 8000);
  my_codec_param.pltype = pcmu_pltype_;
  my_codec_param.channels = 2;
  acm_b_->RegisterReceiveCodec(my_codec_param);
#ifdef WEBRTC_CODEC_CELT
  // Celt
  acm_b_->Codec("CELT", my_codec_param, 32000);
  my_codec_param.pltype = celt_pltype_;
  my_codec_param.channels = 2;
  acm_b_->RegisterReceiveCodec(my_codec_param);
#endif

  // Register CNG with new payload type on both send and receive side.
  acm_b_->Codec("CN", my_codec_param, 8000);
  my_codec_param.pltype = cn_8khz_pltype_;
  acm_a_->RegisterSendCodec(my_codec_param);
  acm_b_->RegisterReceiveCodec(my_codec_param);
  acm_b_->Codec("CN", my_codec_param, 16000);
  my_codec_param.pltype = cn_16khz_pltype_;
  acm_a_->RegisterSendCodec(my_codec_param);
  acm_b_->RegisterReceiveCodec(my_codec_param);
  acm_b_->Codec("CN", my_codec_param, 32000);
  my_codec_param.pltype = cn_32khz_pltype_;
  acm_a_->RegisterSendCodec(my_codec_param);
  acm_b_->RegisterReceiveCodec(my_codec_param);

  // Create and connect the channel.
  channel_a2b_ = new TestPackStereo;
  acm_a_->RegisterTransportCallback(channel_a2b_);
  channel_a2b_->RegisterReceiverACM(acm_b_);

  //
  // Test Stereo-To-Stereo for all codecs.
  //
  audio_channels = 2;
  codec_channels = 2;

  // All codecs are tested for all allowed sampling frequencies, rates and
  // packet sizes.
#ifdef WEBRTC_CODEC_G722
  if(test_mode_ != 0) {
    printf("===========================================================\n");
    printf("Test number: %d\n",test_cntr_ + 1);
    printf("Test type: Stereo-to-stereo\n");
  } else {
    printf(".");
  }
  channel_a2b_->set_codec_mode(kStereo);
  test_cntr_++;
  OpenOutFile(test_cntr_);
  char codec_g722[] = "G722";
  RegisterSendCodec('A', codec_g722, 16000, 64000, 160, codec_channels,
      g722_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  RegisterSendCodec('A', codec_g722, 16000, 64000, 320, codec_channels,
      g722_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  RegisterSendCodec('A', codec_g722, 16000, 64000, 480, codec_channels,
      g722_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  RegisterSendCodec('A', codec_g722, 16000, 64000, 640, codec_channels,
      g722_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  RegisterSendCodec('A', codec_g722, 16000, 64000, 800, codec_channels,
      g722_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  RegisterSendCodec('A', codec_g722, 16000, 64000, 960, codec_channels,
      g722_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  acm_a_->SetVAD(true, true, VADNormal);
  RegisterSendCodec('A', codec_g722, 16000, 64000, 320, codec_channels,
      g722_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  acm_a_->SetVAD(false, false, VADNormal);
  out_file_.Close();
#endif
#ifdef WEBRTC_CODEC_PCM16
  if(test_mode_ != 0) {
    printf("===========================================================\n");
    printf("Test number: %d\n",test_cntr_ + 1);
    printf("Test type: Stereo-to-stereo\n");
  } else {
    printf(".");
  }
  channel_a2b_->set_codec_mode(kStereo);
  test_cntr_++;
  OpenOutFile(test_cntr_);
  char codec_l16[] = "L16";
  RegisterSendCodec('A', codec_l16, 8000, 128000, 80, codec_channels,
      l16_8khz_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  RegisterSendCodec('A', codec_l16, 8000, 128000, 160, codec_channels,
      l16_8khz_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  RegisterSendCodec('A', codec_l16, 8000, 128000, 240, codec_channels,
      l16_8khz_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  RegisterSendCodec('A', codec_l16, 8000, 128000, 320, codec_channels,
      l16_8khz_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  acm_a_->SetVAD(true, true, VADNormal);
  RegisterSendCodec('A', codec_l16, 8000, 128000, 80, codec_channels,
      l16_8khz_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  acm_a_->SetVAD(false, false, VADNormal);
  out_file_.Close();

  if(test_mode_ != 0) {
    printf("===========================================================\n");
    printf("Test number: %d\n",test_cntr_ + 1);
    printf("Test type: Stereo-to-stereo\n");
  } else {
    printf(".");
  }
  test_cntr_++;
  OpenOutFile(test_cntr_);
  RegisterSendCodec('A', codec_l16, 16000, 256000, 160, codec_channels,
      l16_16khz_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  RegisterSendCodec('A', codec_l16, 16000, 256000, 320, codec_channels,
      l16_16khz_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  RegisterSendCodec('A', codec_l16, 16000, 256000, 480, codec_channels,
      l16_16khz_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  RegisterSendCodec('A', codec_l16, 16000, 256000, 640, codec_channels,
      l16_16khz_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  acm_a_->SetVAD(true, true, VADNormal);
  RegisterSendCodec('A', codec_l16, 16000, 256000, 160, codec_channels,
      l16_16khz_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  acm_a_->SetVAD(false, false, VADNormal);
  out_file_.Close();

  if(test_mode_ != 0) {
    printf("===========================================================\n");
    printf("Test number: %d\n",test_cntr_ + 1);
    printf("Test type: Stereo-to-stereo\n");
  } else {
    printf(".");
  }
  test_cntr_++;
  OpenOutFile(test_cntr_);
  RegisterSendCodec('A', codec_l16, 32000, 512000, 320, codec_channels,
      l16_32khz_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  RegisterSendCodec('A', codec_l16, 32000, 512000, 640, codec_channels,
      l16_32khz_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  acm_a_->SetVAD(true, true, VADNormal);
  RegisterSendCodec('A', codec_l16, 32000, 512000, 320, codec_channels,
      l16_32khz_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  acm_a_->SetVAD(false, false, VADNormal);
  out_file_.Close();
#endif
#define PCMA_AND_PCMU
#ifdef PCMA_AND_PCMU
  if (test_mode_ != 0) {
    printf("===========================================================\n");
    printf("Test number: %d\n", test_cntr_ + 1);
    printf("Test type: Stereo-to-stereo\n");
  } else {
    printf(".");
  }
  channel_a2b_->set_codec_mode(kStereo);
  audio_channels = 2;
  codec_channels = 2;
  test_cntr_++;
  OpenOutFile(test_cntr_);
  char codec_pcma[] = "PCMA";
  RegisterSendCodec('A', codec_pcma, 8000, 64000, 80, codec_channels,
                    pcma_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  RegisterSendCodec('A', codec_pcma, 8000, 64000, 160, codec_channels,
                    pcma_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  RegisterSendCodec('A', codec_pcma, 8000, 64000, 240, codec_channels,
                    pcma_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  RegisterSendCodec('A', codec_pcma, 8000, 64000, 320, codec_channels,
                    pcma_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  RegisterSendCodec('A', codec_pcma, 8000, 64000, 400, codec_channels,
                    pcma_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  RegisterSendCodec('A', codec_pcma, 8000, 64000, 480, codec_channels,
                    pcma_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  acm_a_->SetVAD(true, true, VADNormal);
  RegisterSendCodec('A', codec_pcma, 8000, 64000, 80, codec_channels,
                    pcma_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  acm_a_->SetVAD(false, false, VADNormal);
  out_file_.Close();
  if (test_mode_ != 0) {
    printf("===========================================================\n");
    printf("Test number: %d\n", test_cntr_ + 1);
    printf("Test type: Stereo-to-stereo\n");
  } else {
    printf(".");
  }
  test_cntr_++;
  OpenOutFile(test_cntr_);
  char codec_pcmu[] = "PCMU";
  RegisterSendCodec('A', codec_pcmu, 8000, 64000, 80, codec_channels,
                    pcmu_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  RegisterSendCodec('A', codec_pcmu, 8000, 64000, 160, codec_channels,
                    pcmu_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  RegisterSendCodec('A', codec_pcmu, 8000, 64000, 240, codec_channels,
                    pcmu_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  RegisterSendCodec('A', codec_pcmu, 8000, 64000, 320, codec_channels,
                    pcmu_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  RegisterSendCodec('A', codec_pcmu, 8000, 64000, 400, codec_channels,
                    pcmu_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  RegisterSendCodec('A', codec_pcmu, 8000, 64000, 480, codec_channels,
                    pcmu_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  acm_a_->SetVAD(true, true, VADNormal);
  RegisterSendCodec('A', codec_pcmu, 8000, 64000, 80, codec_channels,
                    pcmu_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  acm_a_->SetVAD(false, false, VADNormal);
  out_file_.Close();
#endif
#ifdef WEBRTC_CODEC_CELT
  if(test_mode_ != 0) {
    printf("===========================================================\n");
    printf("Test number: %d\n",test_cntr_ + 1);
    printf("Test type: Stereo-to-stereo\n");
  } else {
    printf(".");
  }
  channel_a2b_->set_codec_mode(kStereo);
  audio_channels = 2;
  codec_channels = 2;
  test_cntr_++;
  OpenOutFile(test_cntr_);
  char codec_celt[] = "CELT";
  RegisterSendCodec('A', codec_celt, 32000, 48000, 320, codec_channels,
      celt_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  RegisterSendCodec('A', codec_celt, 32000, 64000, 320, codec_channels,
      celt_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  RegisterSendCodec('A', codec_celt, 32000, 128000, 320, codec_channels,
      celt_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  acm_a_->SetVAD(true, true, VADNormal);
  RegisterSendCodec('A', codec_celt, 32000, 48000, 320, codec_channels,
      celt_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  acm_a_->SetVAD(false, false, VADNormal);
  out_file_.Close();
#endif
  //
  // Test Mono-To-Stereo for all codecs.
  //
  audio_channels = 1;
  codec_channels = 2;

#ifdef WEBRTC_CODEC_G722
  if(test_mode_ != 0) {
    printf("===============================================================\n");
    printf("Test number: %d\n",test_cntr_ + 1);
    printf("Test type: Mono-to-stereo\n");
  }
  test_cntr_++;
  channel_a2b_->set_codec_mode(kStereo);
  OpenOutFile(test_cntr_);
  RegisterSendCodec('A', codec_g722, 16000, 64000, 160, codec_channels,
                    g722_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  out_file_.Close();
#endif
#ifdef WEBRTC_CODEC_PCM16
  if(test_mode_ != 0) {
    printf("===============================================================\n");
    printf("Test number: %d\n",test_cntr_ + 1);
    printf("Test type: Mono-to-stereo\n");
  }
  test_cntr_++;
  channel_a2b_->set_codec_mode(kStereo);
  OpenOutFile(test_cntr_);
  RegisterSendCodec('A', codec_l16, 8000, 128000, 80, codec_channels,
                    l16_8khz_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  out_file_.Close();
  if(test_mode_ != 0) {
    printf("===============================================================\n");
    printf("Test number: %d\n",test_cntr_ + 1);
    printf("Test type: Mono-to-stereo\n");
  }
  test_cntr_++;
  OpenOutFile(test_cntr_);
  RegisterSendCodec('A', codec_l16, 16000, 256000, 160, codec_channels,
                    l16_16khz_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  out_file_.Close();
  if(test_mode_ != 0) {
    printf("===============================================================\n");
    printf("Test number: %d\n",test_cntr_ + 1);
    printf("Test type: Mono-to-stereo\n");
  }
  test_cntr_++;
  OpenOutFile(test_cntr_);
  RegisterSendCodec('A', codec_l16, 32000, 512000, 320, codec_channels,
                    l16_32khz_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  out_file_.Close();
#endif
#ifdef PCMA_AND_PCMU
  if(test_mode_ != 0) {
    printf("===============================================================\n");
    printf("Test number: %d\n",test_cntr_ + 1);
    printf("Test type: Mono-to-stereo\n");
  }
  test_cntr_++;
  channel_a2b_->set_codec_mode(kStereo);
  OpenOutFile(test_cntr_);
  RegisterSendCodec('A', codec_pcmu, 8000, 64000, 80, codec_channels,
                    pcmu_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  RegisterSendCodec('A', codec_pcma, 8000, 64000, 80, codec_channels,
                    pcma_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  out_file_.Close();
#endif
#ifdef WEBRTC_CODEC_CELT
  if(test_mode_ != 0) {
    printf("===============================================================\n");
    printf("Test number: %d\n",test_cntr_ + 1);
    printf("Test type: Mono-to-stereo\n");
  }
  test_cntr_++;
  channel_a2b_->set_codec_mode(kStereo);
  OpenOutFile(test_cntr_);
  RegisterSendCodec('A', codec_celt, 32000, 64000, 320, codec_channels,
                    celt_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  out_file_.Close();
#endif

  //
  // Test Stereo-To-Mono for all codecs.
  //
  audio_channels = 2;
  codec_channels = 1;
  channel_a2b_->set_codec_mode(kMono);

  // Register receivers as mono.
  for (WebRtc_UWord8 n = 0; n < num_encoders; n++) {
    acm_b_->Codec(n, my_codec_param);
    if (!strcmp(my_codec_param.plname, "L16")) {
      if (my_codec_param.plfreq == 8000) {
        my_codec_param.pltype = l16_8khz_pltype_;
      } else if (my_codec_param.plfreq == 16000) {
        my_codec_param.pltype = l16_16khz_pltype_;
      } else if (my_codec_param.plfreq == 32000) {
        my_codec_param.pltype = l16_32khz_pltype_;
      }
    } else if (!strcmp(my_codec_param.plname, "PCMA")) {
      my_codec_param.pltype = pcma_pltype_;
    } else if (!strcmp(my_codec_param.plname, "PCMU")) {
      my_codec_param.pltype = pcmu_pltype_;
    } else if (!strcmp(my_codec_param.plname, "G722")) {
      my_codec_param.pltype = g722_pltype_;
    } else if (!strcmp(my_codec_param.plname, "CELT")) {
      my_codec_param.pltype = celt_pltype_;
      my_codec_param.channels = 1;
    }
    acm_b_->RegisterReceiveCodec(my_codec_param);
  }
#ifdef WEBRTC_CODEC_G722
  // Run stereo audio and mono codec.
  if(test_mode_ != 0) {
    printf("===============================================================\n");
    printf("Test number: %d\n",test_cntr_ + 1);
    printf("Test type: Stereo-to-mono\n");
  }
  test_cntr_++;
  OpenOutFile(test_cntr_);
  RegisterSendCodec('A', codec_g722, 16000, 64000, 160, codec_channels,
                    g722_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  out_file_.Close();
#endif
#ifdef WEBRTC_CODEC_PCM16
  if(test_mode_ != 0) {
    printf("===============================================================\n");
    printf("Test number: %d\n",test_cntr_ + 1);
    printf("Test type: Stereo-to-mono\n");
  }
  test_cntr_++;
  OpenOutFile(test_cntr_);
  RegisterSendCodec('A', codec_l16, 8000, 128000, 80, codec_channels,
                    l16_8khz_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  out_file_.Close();
  if(test_mode_ != 0) {
    printf("===============================================================\n");
    printf("Test number: %d\n",test_cntr_ + 1);
    printf("Test type: Stereo-to-mono\n");
   }
  test_cntr_++;
  OpenOutFile(test_cntr_);
  RegisterSendCodec('A', codec_l16, 16000, 256000, 160, codec_channels,
                    l16_16khz_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  out_file_.Close();
  if(test_mode_ != 0) {
     printf("==============================================================\n");
     printf("Test number: %d\n",test_cntr_ + 1);
     printf("Test type: Stereo-to-mono\n");
   }
   test_cntr_++;
   OpenOutFile(test_cntr_);
   RegisterSendCodec('A', codec_l16, 32000, 512000, 320, codec_channels,
                     l16_32khz_pltype_);
   Run(channel_a2b_, audio_channels, codec_channels);
   out_file_.Close();
#endif
#ifdef PCMA_AND_PCMU
  if(test_mode_ != 0) {
    printf("===============================================================\n");
    printf("Test number: %d\n",test_cntr_ + 1);
    printf("Test type: Stereo-to-mono\n");
  }
  test_cntr_++;
  OpenOutFile(test_cntr_);
  RegisterSendCodec('A', codec_pcmu, 8000, 64000, 80, codec_channels,
                    pcmu_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  RegisterSendCodec('A', codec_pcma, 8000, 64000, 80, codec_channels,
                    pcma_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  out_file_.Close();
#endif
#ifdef WEBRTC_CODEC_CELT
  if(test_mode_ != 0) {
    printf("===============================================================\n");
    printf("Test number: %d\n",test_cntr_ + 1);
    printf("Test type: Stereo-to-mono\n");
  }
  test_cntr_++;
  OpenOutFile(test_cntr_);
  RegisterSendCodec('A', codec_celt, 32000, 64000, 320, codec_channels,
                    celt_pltype_);
  Run(channel_a2b_, audio_channels, codec_channels);
  out_file_.Close();
#endif

  // Print out which codecs were tested, and which were not, in the run.
  if (test_mode_ != 0) {
    printf("\nThe following codecs was INCLUDED in the test:\n");
#ifdef WEBRTC_CODEC_G722
    printf("   G.722\n");
#endif
#ifdef WEBRTC_CODEC_PCM16
    printf("   PCM16\n");
#endif
    printf("   G.711\n");

    printf("\nTo complete the test, listen to the %d number of output "
           "files.\n",
           test_cntr_);
  } else {
    printf("Done!\n");
  }

  // Delete the file pointers.
  delete in_file_stereo_;
  delete in_file_mono_;
}

// Register Codec to use in the test
//
// Input:   side             - which ACM to use, 'A' or 'B'
//          codec_name       - name to use when register the codec
//          sampling_freq_hz - sampling frequency in Herz
//          rate             - bitrate in bytes
//          pack_size        - packet size in samples
//          channels         - number of channels; 1 for mono, 2 for stereo
//          payload_type     - payload type for the codec
WebRtc_Word16 TestStereo::RegisterSendCodec(char side, char* codec_name,
                                            WebRtc_Word32 sampling_freq_hz,
                                            int rate, int pack_size,
                                            int channels, int payload_type) {
  if (test_mode_ != 0) {
    // Print out codec and settings
    printf("Codec: %s Freq: %d Rate: %d PackSize: %d", codec_name,
           sampling_freq_hz, rate, pack_size);
  }

  // Store packet size in samples, used to validate the received packet
  pack_size_samp_ = pack_size;

  // Store the expected packet size in bytes, used to validate the received
  // packet. Add 0.875 to always round up to a whole byte.
  // For Celt the packet size in bytes is already counting the stereo part.
  if (!strcmp(codec_name, "CELT")) {
    pack_size_bytes_ = (WebRtc_UWord16)(
        (float) (pack_size * rate) / (float) (sampling_freq_hz * 8) + 0.875)
        / channels;
  } else {
    pack_size_bytes_ = (WebRtc_UWord16)(
        (float) (pack_size * rate) / (float) (sampling_freq_hz * 8) + 0.875);
  }

  // Set pointer to the ACM where to register the codec
  AudioCodingModule* my_acm;
  switch (side) {
    case 'A': {
      my_acm = acm_a_;
      break;
    }
    case 'B': {
      my_acm = acm_b_;
      break;
    }
    default:
      return -1;
  }

  if (my_acm == NULL) {
    assert(false);
    return -1;
  }

  CodecInst my_codec_param;
  // Get all codec parameters before registering
  CHECK_ERROR(AudioCodingModule::Codec(codec_name, my_codec_param,
                                       sampling_freq_hz));
  my_codec_param.rate = rate;
  my_codec_param.pacsize = pack_size;
  my_codec_param.pltype = payload_type;
  my_codec_param.channels = channels;
  CHECK_ERROR(my_acm->RegisterSendCodec(my_codec_param));

  // Initialization was successful.
  return 0;
}

void TestStereo::Run(TestPackStereo* channel, int in_channels, int out_channels,
                     int percent_loss) {
  AudioFrame audio_frame;

  WebRtc_Word32 out_freq_hz_b = out_file_.SamplingFrequency();
  WebRtc_UWord16 rec_size;
  WebRtc_UWord32 time_stamp_diff;
  channel->reset_payload_size();
  int error_count = 0;

  // Only run 1 second for each test case
  // TODO(tlegrand): either remove |counter_| or start using it as the comment
  // above says. Now |counter_| is always 0.
  while (1) {
    // Simulate packet loss by setting |packet_loss_| to "true" in
    // |percent_loss| percent of the loops.
    if (percent_loss > 0) {
      if (counter_ == floor((100 / percent_loss) + 0.5)) {
        counter_ = 0;
        channel->set_lost_packet(true);
      } else {
        channel->set_lost_packet(false);
      }
      counter_++;
    }

    // Add 10 msec to ACM
    if (in_channels == 1) {
      if (in_file_mono_->EndOfFile()) {
        break;
      }
      in_file_mono_->Read10MsData(audio_frame);
    } else {
      if (in_file_stereo_->EndOfFile()) {
        break;
      }
      in_file_stereo_->Read10MsData(audio_frame);
    }
    CHECK_ERROR(acm_a_->Add10MsData(audio_frame));

    // Run sender side of ACM
    CHECK_ERROR(acm_a_->Process());

    // Verify that the received packet size matches the settings
    rec_size = channel->payload_size();
    if ((0 < rec_size) & (rec_size < 65535)) {
      if ((rec_size != pack_size_bytes_ * out_channels)
          && (pack_size_bytes_ < 65535)) {
        error_count++;
      }

      // Verify that the timestamp is updated with expected length
      time_stamp_diff = channel->timestamp_diff();
      if ((counter_ > 10) && (time_stamp_diff != pack_size_samp_)) {
        error_count++;
      }
    }

    // Run received side of ACM
    CHECK_ERROR(acm_b_->PlayoutData10Ms(out_freq_hz_b, audio_frame));

    // Write output speech to file
    out_file_.Write10MsData(
        audio_frame._payloadData,
        audio_frame._payloadDataLengthInSamples * audio_frame._audioChannel);
  }

  if (error_count) {
    printf(" - test FAILED\n");
  } else if (test_mode_ != 0) {
    printf(" - test PASSED\n");
  }

  // Reset counter_
  if (counter_ == 1000) {
    counter_ = 0;
  }
  if (in_file_mono_->EndOfFile()) {
    in_file_mono_->Rewind();
  }
  if (in_file_stereo_->EndOfFile()) {
    in_file_stereo_->Rewind();
  }
  // Reset in case we ended with a lost packet
  channel->set_lost_packet(false);
}

void TestStereo::OpenOutFile(WebRtc_Word16 test_number) {
  char file_name[500];
  sprintf(file_name, "%s/teststereo_out_%02d.pcm",
          webrtc::test::OutputPath().c_str(), test_number);
  out_file_.Open(file_name, 32000, "wb");
}

void TestStereo::DisplaySendReceiveCodec() {
  CodecInst my_codec_param;
  acm_a_->SendCodec(my_codec_param);
  if (test_mode_ != 0) {
    printf("%s -> ", my_codec_param.plname);
  }
  acm_b_->ReceiveCodec(my_codec_param);
  if (test_mode_ != 0) {
    printf("%s\n", my_codec_param.plname);
  }
}

}  // namespace webrtc