generic-library/webrtc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Refactoring one of the ACM tests: TestStereo, to follow the style guide.

Browse Source 
(First patch: formatting the test file)

TEST=audio_coding_module_test

Review URL: https://webrtc-codereview.appspot.com/507001

git-svn-id: http://webrtc.googlecode.com/svn/trunk@2124 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
tina.legrand@webrtc.org 2012-04-26 07:54:30 +00:00
parent 61331137b6
commit a6ecd1ebb5
4 changed files with 1043 additions and 1149 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

436
src/modules/audio_coding/main/test/PCMFile.cc
View File

@ -21,282 +21,212 @@ namespace webrtc {
#define MAX_FILE_NAME_LENGTH_BYTE 500
PCMFile::PCMFile():
_pcmFile(NULL),
_nSamples10Ms(160),
_frequency(16000),
_endOfFile(false),
_autoRewind(false),
_rewinded(false),
_timestamp(0),
_readStereo(false),
_saveStereo(false)
{
_timestamp = (((WebRtc_UWord32)rand() & 0x0000FFFF) << 16) |
((WebRtc_UWord32)rand() & 0x0000FFFF);
PCMFile::PCMFile()
: pcm_file_(NULL),
samples_10ms_(160),
frequency_(16000),
end_of_file_(false),
auto_rewind_(false),
rewinded_(false),
read_stereo_(false),
save_stereo_(false) {
timestamp_ = (((WebRtc_UWord32)rand() & 0x0000FFFF) << 16) |
((WebRtc_UWord32)rand() & 0x0000FFFF);
}
/*
PCMFile::~PCMFile()
{
if(_pcmFile != NULL)
{
fclose(_pcmFile);
_pcmFile = NULL;
}
}
*/
WebRtc_Word16
PCMFile::ChooseFile(
char* fileName,
WebRtc_Word16 maxLen)
{
char tmpName[MAX_FILE_NAME_LENGTH_BYTE];
//strcpy(_fileName, "in.pcm");
//printf("\n\nPlease enter the input file: ");
EXPECT_TRUE(fgets(tmpName, MAX_FILE_NAME_LENGTH_BYTE, stdin) != NULL);
tmpName[MAX_FILE_NAME_LENGTH_BYTE-1] = '\0';
WebRtc_Word16 n = 0;
// removing leading spaces
while((isspace(tmpName[n]) || iscntrl(tmpName[n])) &&
(tmpName[n] != 0) &&
(n < MAX_FILE_NAME_LENGTH_BYTE))
{
n++;
}
if(n > 0)
{
memmove(tmpName, &tmpName[n], MAX_FILE_NAME_LENGTH_BYTE - n);
}
//removing trailing spaces
n = (WebRtc_Word16)(strlen(tmpName) - 1);
if(n >= 0)
{
while((isspace(tmpName[n]) || iscntrl(tmpName[n])) &&
(n >= 0))
{
n--;
}
}
if(n >= 0)
{
tmpName[n + 1] = '\0';
}
WebRtc_Word16 len = (WebRtc_Word16)strlen(tmpName);
if(len > maxLen)
{
return -1;
}
if(len > 0)
{
strncpy(fileName, tmpName, len+1);
}
return 0;
PCMFile::PCMFile(WebRtc_UWord32 timestamp)
: pcm_file_(NULL),
samples_10ms_(160),
frequency_(16000),
end_of_file_(false),
auto_rewind_(false),
rewinded_(false),
read_stereo_(false),
save_stereo_(false) {
timestamp_ = timestamp;
}
WebRtc_Word16
PCMFile::ChooseFile(
char* fileName,
WebRtc_Word16 maxLen,
WebRtc_UWord16* frequencyHz)
{
char tmpName[MAX_FILE_NAME_LENGTH_BYTE];
//strcpy(_fileName, "in.pcm");
//printf("\n\nPlease enter the input file: ");
EXPECT_TRUE(fgets(tmpName, MAX_FILE_NAME_LENGTH_BYTE, stdin) != NULL);
tmpName[MAX_FILE_NAME_LENGTH_BYTE-1] = '\0';
WebRtc_Word16 n = 0;
WebRtc_Word16 PCMFile::ChooseFile(char* filename, WebRtc_Word16 max_len) {
char tmp_name[MAX_FILE_NAME_LENGTH_BYTE];
// removing leading spaces
while((isspace(tmpName[n]) || iscntrl(tmpName[n])) &&
(tmpName[n] != 0) &&
(n < MAX_FILE_NAME_LENGTH_BYTE))
{
n++;
EXPECT_TRUE(fgets(tmp_name, MAX_FILE_NAME_LENGTH_BYTE, stdin) != NULL);
tmp_name[MAX_FILE_NAME_LENGTH_BYTE - 1] = '\0';
WebRtc_Word16 n = 0;
// Removing leading spaces.
while ((isspace(tmp_name[n]) || iscntrl(tmp_name[n])) && (tmp_name[n] != 0)
&& (n < MAX_FILE_NAME_LENGTH_BYTE)) {
n++;
}
if (n > 0) {
memmove(tmp_name, &tmp_name[n], MAX_FILE_NAME_LENGTH_BYTE - n);
}
// Removing trailing spaces.
n = (WebRtc_Word16)(strlen(tmp_name) - 1);
if (n >= 0) {
while ((isspace(tmp_name[n]) || iscntrl(tmp_name[n])) && (n >= 0)) {
n--;
}
if(n > 0)
{
memmove(tmpName, &tmpName[n], MAX_FILE_NAME_LENGTH_BYTE - n);
}
if (n >= 0) {
tmp_name[n + 1] = '\0';
}
WebRtc_Word16 len = (WebRtc_Word16) strlen(tmp_name);
if (len > max_len) {
return -1;
}
if (len > 0) {
strncpy(filename, tmp_name, len + 1);
}
return 0;
}
WebRtc_Word16 PCMFile::ChooseFile(char* filename, WebRtc_Word16 max_len,
WebRtc_UWord16* frequency_hz) {
char tmp_name[MAX_FILE_NAME_LENGTH_BYTE];
EXPECT_TRUE(fgets(tmp_name, MAX_FILE_NAME_LENGTH_BYTE, stdin) != NULL);
tmp_name[MAX_FILE_NAME_LENGTH_BYTE - 1] = '\0';
WebRtc_Word16 n = 0;
// Removing trailing spaces.
while ((isspace(tmp_name[n]) || iscntrl(tmp_name[n])) && (tmp_name[n] != 0)
&& (n < MAX_FILE_NAME_LENGTH_BYTE)) {
n++;
}
if (n > 0) {
memmove(tmp_name, &tmp_name[n], MAX_FILE_NAME_LENGTH_BYTE - n);
}
// Removing trailing spaces.
n = (WebRtc_Word16)(strlen(tmp_name) - 1);
if (n >= 0) {
while ((isspace(tmp_name[n]) || iscntrl(tmp_name[n])) && (n >= 0)) {
n--;
}
}
if (n >= 0) {
tmp_name[n + 1] = '\0';
}
//removing trailing spaces
n = (WebRtc_Word16)(strlen(tmpName) - 1);
if(n >= 0)
{
while((isspace(tmpName[n]) || iscntrl(tmpName[n])) &&
(n >= 0))
{
n--;
}
WebRtc_Word16 len = (WebRtc_Word16) strlen(tmp_name);
if (len > max_len) {
return -1;
}
if (len > 0) {
strncpy(filename, tmp_name, len + 1);
}
printf("Enter the sampling frequency (in Hz) of the above file [%u]: ",
*frequency_hz);
EXPECT_TRUE(fgets(tmp_name, 10, stdin) != NULL);
WebRtc_UWord16 tmp_frequency = (WebRtc_UWord16) atoi(tmp_name);
if (tmp_frequency > 0) {
*frequency_hz = tmp_frequency;
}
return 0;
}
void PCMFile::Open(const char* filename, WebRtc_UWord16 frequency,
const char* mode, bool auto_rewind) {
if ((pcm_file_ = fopen(filename, mode)) == NULL) {
printf("Cannot open file %s.\n", filename);
ADD_FAILURE() << "Unable to read file";
}
frequency_ = frequency;
samples_10ms_ = (WebRtc_UWord16)(frequency_ / 100);
auto_rewind_ = auto_rewind;
end_of_file_ = false;
rewinded_ = false;
}
WebRtc_Word32 PCMFile::SamplingFrequency() const {
return frequency_;
}
WebRtc_UWord16 PCMFile::PayloadLength10Ms() const {
return samples_10ms_;
}
WebRtc_Word32 PCMFile::Read10MsData(AudioFrame& audio_frame) {
WebRtc_UWord16 channels = 1;
if (read_stereo_) {
channels = 2;
}
WebRtc_Word32 payload_size = (WebRtc_Word32) fread(audio_frame._payloadData,
sizeof(WebRtc_UWord16),
samples_10ms_ * channels,
pcm_file_);
if (payload_size < samples_10ms_ * channels) {
for (int k = payload_size; k < samples_10ms_ * channels; k++) {
audio_frame._payloadData[k] = 0;
}
if(n >= 0)
{
tmpName[n + 1] = '\0';
if (auto_rewind_) {
rewind(pcm_file_);
rewinded_ = true;
} else {
end_of_file_ = true;
}
}
audio_frame._payloadDataLengthInSamples = samples_10ms_;
audio_frame._frequencyInHz = frequency_;
audio_frame._audioChannel = channels;
audio_frame._timeStamp = timestamp_;
timestamp_ += samples_10ms_;
return samples_10ms_;
}
WebRtc_Word16 len = (WebRtc_Word16)strlen(tmpName);
if(len > maxLen)
{
return -1;
}
if(len > 0)
{
strncpy(fileName, tmpName, len+1);
void PCMFile::Write10MsData(AudioFrame& audio_frame) {
if (audio_frame._audioChannel == 1) {
if (!save_stereo_) {
fwrite(audio_frame._payloadData, sizeof(WebRtc_UWord16),
audio_frame._payloadDataLengthInSamples, pcm_file_);
} else {
WebRtc_Word16* stereo_audio =
new WebRtc_Word16[2 * audio_frame._payloadDataLengthInSamples];
int k;
for (k = 0; k < audio_frame._payloadDataLengthInSamples; k++) {
stereo_audio[k << 1] = audio_frame._payloadData[k];
stereo_audio[(k << 1) + 1] = audio_frame._payloadData[k];
}
fwrite(stereo_audio, sizeof(WebRtc_Word16),
2 * audio_frame._payloadDataLengthInSamples, pcm_file_);
delete[] stereo_audio;
}
printf("Enter the sampling frequency (in Hz) of the above file [%u]: ", *frequencyHz);
EXPECT_TRUE(fgets(tmpName, 10, stdin) != NULL);
WebRtc_UWord16 tmpFreq = (WebRtc_UWord16)atoi(tmpName);
if(tmpFreq > 0)
{
*frequencyHz = tmpFreq;
}
return 0;
} else {
fwrite(audio_frame._payloadData, sizeof(WebRtc_Word16),
audio_frame._audioChannel * audio_frame._payloadDataLengthInSamples,
pcm_file_);
}
}
void
PCMFile::Open(
const char* filename,
WebRtc_UWord16 frequency,
const char* mode,
bool autoRewind)
{
if ((_pcmFile = fopen(filename, mode)) == NULL)
{
printf("Cannot open file %s.\n", filename);
ADD_FAILURE() << "Unable to read file";
}
_frequency = frequency;
_nSamples10Ms = (WebRtc_UWord16)(_frequency / 100);
_autoRewind = autoRewind;
_endOfFile = false;
_rewinded = false;
void PCMFile::Write10MsData(WebRtc_Word16* playout_buffer,
WebRtc_UWord16 length_smpls) {
fwrite(playout_buffer, sizeof(WebRtc_UWord16), length_smpls, pcm_file_);
}
WebRtc_Word32
PCMFile::SamplingFrequency() const
{
return _frequency;
void PCMFile::Close() {
fclose(pcm_file_);
pcm_file_ = NULL;
}
WebRtc_UWord16
PCMFile::PayloadLength10Ms() const
{
return _nSamples10Ms;
void PCMFile::Rewind() {
rewind(pcm_file_);
end_of_file_ = false;
}
WebRtc_Word32
PCMFile::Read10MsData(
AudioFrame& audioFrame)
{
WebRtc_UWord16 noChannels = 1;
if (_readStereo)
{
noChannels = 2;
}
WebRtc_Word32 payloadSize = (WebRtc_Word32)fread(audioFrame._payloadData, sizeof(WebRtc_UWord16), _nSamples10Ms*noChannels, _pcmFile);
if (payloadSize < _nSamples10Ms*noChannels) {
for (int k = payloadSize; k < _nSamples10Ms*noChannels; k++)
{
audioFrame._payloadData[k] = 0;
}
if(_autoRewind)
{
rewind(_pcmFile);
_rewinded = true;
}
else
{
_endOfFile = true;
}
}
audioFrame._payloadDataLengthInSamples = _nSamples10Ms;
audioFrame._frequencyInHz = _frequency;
audioFrame._audioChannel = noChannels;
audioFrame._timeStamp = _timestamp;
_timestamp += _nSamples10Ms;
return _nSamples10Ms;
bool PCMFile::Rewinded() {
return rewinded_;
}
void
PCMFile::Write10MsData(
AudioFrame& audioFrame)
{
if(audioFrame._audioChannel == 1)
{
if(!_saveStereo)
{
fwrite(audioFrame._payloadData, sizeof(WebRtc_UWord16),
audioFrame._payloadDataLengthInSamples, _pcmFile);
}
else
{
WebRtc_Word16* stereoAudio = new WebRtc_Word16[2 *
audioFrame._payloadDataLengthInSamples];
int k;
for(k = 0; k < audioFrame._payloadDataLengthInSamples; k++)
{
stereoAudio[k<<1] = audioFrame._payloadData[k];
stereoAudio[(k<<1) + 1] = audioFrame._payloadData[k];
}
fwrite(stereoAudio, sizeof(WebRtc_Word16), 2*audioFrame._payloadDataLengthInSamples,
_pcmFile);
delete [] stereoAudio;
}
}
else
{
fwrite(audioFrame._payloadData, sizeof(WebRtc_Word16),
audioFrame._audioChannel * audioFrame._payloadDataLengthInSamples, _pcmFile);
}
void PCMFile::SaveStereo(bool is_stereo) {
save_stereo_ = is_stereo;
}
void
PCMFile::Write10MsData(
WebRtc_Word16* playoutBuffer,
WebRtc_UWord16 playoutLengthSmpls)
{
fwrite(playoutBuffer, sizeof(WebRtc_UWord16), playoutLengthSmpls, _pcmFile);
void PCMFile::ReadStereo(bool is_stereo) {
read_stereo_ = is_stereo;
}
void
PCMFile::Close()
{
fclose(_pcmFile);
_pcmFile = NULL;
}
void
PCMFile::Rewind()
{
rewind(_pcmFile);
_endOfFile = false;
}
bool
PCMFile::Rewinded()
{
return _rewinded;
}
void
PCMFile::SaveStereo(
bool saveStereo)
{
_saveStereo = saveStereo;
}
void
PCMFile::ReadStereo(
bool readStereo)
{
_readStereo = readStereo;
}
} // namespace webrtc
} // namespace webrtc

94
src/modules/audio_coding/main/test/PCMFile.h
View File

@ -1,5 +1,5 @@
/*
* Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
* 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
@ -8,60 +8,60 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef PCMFILE_H
#define PCMFILE_H
#ifndef WEBRTC_MODULES_AUDIO_CODING_MAIN_TEST_PCMFILE_H_
#define WEBRTC_MODULES_AUDIO_CODING_MAIN_TEST_PCMFILE_H_
#include "typedefs.h"
#include "module_common_types.h"
#include <cstdio>
#include <cstdlib>
#include "module_common_types.h"
#include "typedefs.h"
namespace webrtc {
class PCMFile
{
public:
PCMFile();
~PCMFile()
{
if(_pcmFile != NULL)
{
fclose(_pcmFile);
}
class PCMFile {
public:
PCMFile();
PCMFile(WebRtc_UWord32 timestamp);
~PCMFile() {
if (pcm_file_ != NULL) {
fclose(pcm_file_);
}
void Open(const char *filename, WebRtc_UWord16 frequency, const char *mode,
bool autoRewind = false);
WebRtc_Word32 Read10MsData(AudioFrame& audioFrame);
void Write10MsData(WebRtc_Word16 *playoutBuffer, WebRtc_UWord16 playoutLengthSmpls);
void Write10MsData(AudioFrame& audioFrame);
}
void Open(const char *filename, WebRtc_UWord16 frequency, const char *mode,
bool auto_rewind = false);
WebRtc_UWord16 PayloadLength10Ms() const;
WebRtc_Word32 SamplingFrequency() const;
void Close();
bool EndOfFile() const { return _endOfFile; }
void Rewind();
static WebRtc_Word16 ChooseFile(char* fileName, WebRtc_Word16 maxLen,
WebRtc_UWord16* frequencyHz);
static WebRtc_Word16 ChooseFile(char* fileName, WebRtc_Word16 maxLen);
bool Rewinded();
void SaveStereo(
bool saveStereo = true);
void ReadStereo(
bool readStereo = true);
private:
FILE* _pcmFile;
WebRtc_UWord16 _nSamples10Ms;
WebRtc_Word32 _frequency;
bool _endOfFile;
bool _autoRewind;
bool _rewinded;
WebRtc_UWord32 _timestamp;
bool _readStereo;
bool _saveStereo;
WebRtc_Word32 Read10MsData(AudioFrame& audio_frame);
void Write10MsData(WebRtc_Word16 *playout_buffer,
WebRtc_UWord16 length_smpls);
void Write10MsData(AudioFrame& audio_frame);
WebRtc_UWord16 PayloadLength10Ms() const;
WebRtc_Word32 SamplingFrequency() const;
void Close();
bool EndOfFile() const {
return end_of_file_;
}
void Rewind();
static WebRtc_Word16 ChooseFile(char* filename, WebRtc_Word16 max_len,
WebRtc_UWord16* frequency_hz);
static WebRtc_Word16 ChooseFile(char* filename, WebRtc_Word16 max_len);
bool Rewinded();
void SaveStereo(bool is_stereo = true);
void ReadStereo(bool is_stereo = true);
private:
FILE* pcm_file_;
WebRtc_UWord16 samples_10ms_;
WebRtc_Word32 frequency_;
bool end_of_file_;
bool auto_rewind_;
bool rewinded_;
WebRtc_UWord32 timestamp_;
bool read_stereo_;
bool save_stereo_;
};
} // namespace webrtc
} // namespace webrtc
#endif
#endif // WEBRTC_MODULES_AUDIO_CODING_MAIN_TEST_PCMFILE_H_

1493
src/modules/audio_coding/main/test/TestStereo.cc
View File

File diff suppressed because it is too large Load Diff

169
src/modules/audio_coding/main/test/TestStereo.h
View File

@ -8,8 +8,8 @@
* be found in the AUTHORS file in the root of the source tree.
*/
#ifndef TEST_STEREO_H
#define TEST_STEREO_H
#ifndef WEBRTC_MODULES_AUDIO_CODING_MAIN_TEST_TEST_STEREO_H_
#define WEBRTC_MODULES_AUDIO_CODING_MAIN_TEST_TEST_STEREO_H_
#include <math.h>
@ -20,106 +20,99 @@
namespace webrtc {
enum StereoMonoMode {
kNotSet,
kMono,
kStereo
kNotSet,
kMono,
kStereo
};
class TestPackStereo : public AudioPacketizationCallback
{
public:
TestPackStereo();
~TestPackStereo();
void RegisterReceiverACM(AudioCodingModule* acm);
virtual WebRtc_Word32 SendData(const FrameType frameType,
const WebRtc_UWord8 payloadType,
const WebRtc_UWord32 timeStamp,
const WebRtc_UWord8* payloadData,
const WebRtc_UWord16 payloadSize,
const RTPFragmentationHeader* fragmentation);
class TestPackStereo : public AudioPacketizationCallback {
public:
TestPackStereo();
~TestPackStereo();
WebRtc_UWord16 GetPayloadSize();
WebRtc_UWord32 GetTimeStampDiff();
void ResetPayloadSize();
void set_codec_mode(StereoMonoMode mode);
void set_lost_packet(bool lost);
void RegisterReceiverACM(AudioCodingModule* acm);
private:
AudioCodingModule* _receiverACM;
WebRtc_Word16 _seqNo;
WebRtc_UWord8 _payloadData[60 * 32 * 2 * 2];
WebRtc_UWord32 _timeStampDiff;
WebRtc_UWord32 _lastInTimestamp;
WebRtc_UWord64 _totalBytes;
WebRtc_UWord16 _payloadSize;
StereoMonoMode _codec_mode;
// Simulate packet losses
bool _lost_packet;
virtual WebRtc_Word32 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);
WebRtc_UWord16 payload_size();
WebRtc_UWord32 timestamp_diff();
void reset_payload_size();
void set_codec_mode(StereoMonoMode mode);
void set_lost_packet(bool lost);
private:
AudioCodingModule* receiver_acm_;
WebRtc_Word16 seq_no_;
WebRtc_UWord8 payload_data_[60 * 32 * 2 * 2];
WebRtc_UWord32 timestamp_diff_;
WebRtc_UWord32 last_in_timestamp_;
WebRtc_UWord64 total_bytes_;
WebRtc_UWord16 payload_size_;
StereoMonoMode codec_mode_;
// Simulate packet losses
bool lost_packet_;
};
class TestStereo : public ACMTest
{
public:
TestStereo(int testMode);
~TestStereo();
class TestStereo : public ACMTest {
public:
TestStereo(int test_mode);
~TestStereo();
void Perform();
private:
// The default value of '-1' indicates that the registration is based only on codec name
// and a sampling frequncy matching is not required. This is useful for codecs which support
// several sampling frequency.
WebRtc_Word16 RegisterSendCodec(char side,
char* codecName,
WebRtc_Word32 sampFreqHz,
int rate,
int packSize,
int channels,
int payload_type);
void Perform();
private:
// The default value of '-1' indicates that the registration is based only on
// codec name and a sampling frequncy matching is not required. This is useful
// for codecs which support several sampling frequency.
WebRtc_Word16 RegisterSendCodec(char side, char* codec_name,
WebRtc_Word32 samp_freq_hz, int rate,
int pack_size, int channels,
int payload_type);
void Run(TestPackStereo* channel, int in_channels, int out_channels,
int percent_loss = 0);
void OpenOutFile(WebRtc_Word16 testNumber);
void DisplaySendReceiveCodec();
void Run(TestPackStereo* channel, int in_channels, int out_channels,
int percent_loss = 0);
void OpenOutFile(WebRtc_Word16 test_number);
void DisplaySendReceiveCodec();
WebRtc_Word32 SendData(
const FrameType frameType,
const WebRtc_UWord8 payloadType,
const WebRtc_UWord32 timeStamp,
const WebRtc_UWord8* payloadData,
const WebRtc_UWord16 payloadSize,
const RTPFragmentationHeader* fragmentation);
WebRtc_Word32 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);
int _testMode;
int test_mode_;
AudioCodingModule* _acmA;
AudioCodingModule* _acmB;
AudioCodingModule* acm_a_;
AudioCodingModule* acm_b_;
TestPackStereo* _channelA2B;
TestPackStereo* channel_a2b_;
PCMFile _in_file_stereo;
PCMFile _in_file_mono;
PCMFile _outFileB;
WebRtc_Word16 _testCntr;
WebRtc_UWord16 _packSizeSamp;
WebRtc_UWord16 _packSizeBytes;
int _counter;
PCMFile* in_file_stereo_;
PCMFile* in_file_mono_;
PCMFile out_file_;
WebRtc_Word16 test_cntr_;
WebRtc_UWord16 pack_size_samp_;
WebRtc_UWord16 pack_size_bytes_;
int counter_;
// Payload types for stereo codecs and CNG
int g722_pltype_;
int l16_8khz_pltype_;
int l16_16khz_pltype_;
int l16_32khz_pltype_;
int pcma_pltype_;
int pcmu_pltype_;
int celt_pltype_;
int cn_8khz_pltype_;
int cn_16khz_pltype_;
int cn_32khz_pltype_;
// Payload types for stereo codecs and CNG
int g722_pltype_;
int l16_8khz_pltype_;
int l16_16khz_pltype_;
int l16_32khz_pltype_;
int pcma_pltype_;
int pcmu_pltype_;
int celt_pltype_;
int cn_8khz_pltype_;
int cn_16khz_pltype_;
int cn_32khz_pltype_;
};
} // namespace webrtc
#endif
} // namespace webrtc
#endif // WEBRTC_MODULES_AUDIO_CODING_MAIN_TEST_TEST_STEREO_H_