zqz/platform-external-webrtc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert 6458 "Since NetEq4 is ready to handle 48 kHz codec, it is..."

Browse Source 
> Since NetEq4 is ready to handle 48 kHz codec, it is good to remove the 48-to-32kHz downsampling of Opus output. This facilitates webrtc to make full use of Opus's bandwidth and eliminates unneeded computation in resampling.
> 
> TEST=passed_all_trybots
> R=henrik.lundin@webrtc.org, tina.legrand@webrtc.org
> 
> Review URL: https://webrtc-codereview.appspot.com/16619005

TBR=minyue@webrtc.org

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

git-svn-id: http://webrtc.googlecode.com/svn/trunk@6462 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
minyue@webrtc.org
2014-06-17 09:50:12 +00:00
parent 851a09e71a
commit d42da54768
12 changed files with 433 additions and 249 deletions
Download Patch File Download Diff File Expand all files Collapse all files

86
webrtc/modules/audio_coding/neteq/audio_decoder_unittest.cc
View File

@ -607,7 +607,7 @@ class AudioDecoderCeltStereoTest : public AudioDecoderTest {
class AudioDecoderOpusTest : public AudioDecoderTest {
protected:
AudioDecoderOpusTest() : AudioDecoderTest() {
frame_size_ = 480;
frame_size_ = 320;
data_length_ = 10 * frame_size_;
decoder_ = new AudioDecoderOpus(kDecoderOpus);
assert(decoder_);
@ -618,69 +618,75 @@ class AudioDecoderOpusTest : public AudioDecoderTest {
WebRtcOpus_EncoderFree(encoder_);
}
virtual void SetUp() OVERRIDE {
AudioDecoderTest::SetUp();
// Upsample from 32 to 48 kHz.
// Because Opus is 48 kHz codec but the input file is 32 kHz, so the data
// read in |AudioDecoderTest::SetUp| has to be upsampled.
// |AudioDecoderTest::SetUp| has read |data_length_| samples, which is more
// than necessary after upsampling, so the end of audio that has been read
// is unused and the end of the buffer is overwritten by the resampled data.
Resampler rs;
rs.Reset(32000, 48000, kResamplerSynchronous);
const int before_resamp_len_samples = static_cast<int>(data_length_) * 2
/ 3;
int16_t* before_resamp_input = new int16_t[before_resamp_len_samples];
memcpy(before_resamp_input, input_,
sizeof(int16_t) * before_resamp_len_samples);
int resamp_len_samples;
EXPECT_EQ(0, rs.Push(before_resamp_input, before_resamp_len_samples,
input_, static_cast<int>(data_length_),
resamp_len_samples));
EXPECT_EQ(static_cast<int>(data_length_), resamp_len_samples);
delete[] before_resamp_input;
}
virtual void InitEncoder() {}
virtual int EncodeFrame(const int16_t* input, size_t input_len_samples,
uint8_t* output) OVERRIDE {
int enc_len_bytes = WebRtcOpus_Encode(encoder_, const_cast<int16_t*>(input),
static_cast<int16_t>(input_len_samples),
static_cast<int16_t>(data_length_), output);
uint8_t* output) {
// Upsample from 32 to 48 kHz.
Resampler rs;
rs.Reset(32000, 48000, kResamplerSynchronous);
const int max_resamp_len_samples = static_cast<int>(input_len_samples) *
3 / 2;
int16_t* resamp_input = new int16_t[max_resamp_len_samples];
int resamp_len_samples;
EXPECT_EQ(0, rs.Push(input, static_cast<int>(input_len_samples),
resamp_input, max_resamp_len_samples,
resamp_len_samples));
EXPECT_EQ(max_resamp_len_samples, resamp_len_samples);
int enc_len_bytes =
WebRtcOpus_Encode(encoder_, resamp_input, resamp_len_samples,
static_cast<int>(data_length_), output);
EXPECT_GT(enc_len_bytes, 0);
delete [] resamp_input;
return enc_len_bytes;
}
OpusEncInst* encoder_;
};
class AudioDecoderOpusStereoTest : public AudioDecoderOpusTest {
class AudioDecoderOpusStereoTest : public AudioDecoderTest {
protected:
AudioDecoderOpusStereoTest() : AudioDecoderOpusTest() {
AudioDecoderOpusStereoTest() : AudioDecoderTest() {
channels_ = 2;
WebRtcOpus_EncoderFree(encoder_);
delete decoder_;
frame_size_ = 320;
data_length_ = 10 * frame_size_;
decoder_ = new AudioDecoderOpus(kDecoderOpus_2ch);
assert(decoder_);
WebRtcOpus_EncoderCreate(&encoder_, 2);
}
~AudioDecoderOpusStereoTest() {
WebRtcOpus_EncoderFree(encoder_);
}
virtual void InitEncoder() {}
virtual int EncodeFrame(const int16_t* input, size_t input_len_samples,
uint8_t* output) OVERRIDE {
uint8_t* output) {
// Create stereo by duplicating each sample in |input|.
const int input_stereo_samples = static_cast<int>(input_len_samples) * 2;
int16_t* input_stereo = new int16_t[input_stereo_samples];
for (size_t i = 0; i < input_len_samples; i++)
input_stereo[i * 2] = input_stereo[i * 2 + 1] = input[i];
int enc_len_bytes = WebRtcOpus_Encode(
encoder_, input_stereo, static_cast<int16_t>(input_len_samples),
static_cast<int16_t>(data_length_), output);
// Upsample from 32 to 48 kHz.
Resampler rs;
rs.Reset(32000, 48000, kResamplerSynchronousStereo);
const int max_resamp_len_samples = input_stereo_samples * 3 / 2;
int16_t* resamp_input = new int16_t[max_resamp_len_samples];
int resamp_len_samples;
EXPECT_EQ(0, rs.Push(input_stereo, input_stereo_samples, resamp_input,
max_resamp_len_samples, resamp_len_samples));
EXPECT_EQ(max_resamp_len_samples, resamp_len_samples);
int enc_len_bytes =
WebRtcOpus_Encode(encoder_, resamp_input, resamp_len_samples / 2,
static_cast<int16_t>(data_length_), output);
EXPECT_GT(enc_len_bytes, 0);
delete[] input_stereo;
delete [] resamp_input;
delete [] input_stereo;
return enc_len_bytes;
}
OpusEncInst* encoder_;
};
TEST_F(AudioDecoderPcmUTest, EncodeDecode) {
@ -870,11 +876,11 @@ TEST(AudioDecoder, CodecSampleRateHz) {
EXPECT_EQ(8000, AudioDecoder::CodecSampleRateHz(kDecoderCNGnb));
EXPECT_EQ(16000, AudioDecoder::CodecSampleRateHz(kDecoderCNGwb));
EXPECT_EQ(32000, AudioDecoder::CodecSampleRateHz(kDecoderCNGswb32kHz));
EXPECT_EQ(48000, AudioDecoder::CodecSampleRateHz(kDecoderOpus));
EXPECT_EQ(48000, AudioDecoder::CodecSampleRateHz(kDecoderOpus_2ch));
// TODO(tlegrand): Change 32000 to 48000 below once ACM has 48 kHz support.
EXPECT_EQ(32000, AudioDecoder::CodecSampleRateHz(kDecoderCNGswb48kHz));
EXPECT_EQ(-1, AudioDecoder::CodecSampleRateHz(kDecoderArbitrary));
EXPECT_EQ(32000, AudioDecoder::CodecSampleRateHz(kDecoderOpus));
EXPECT_EQ(32000, AudioDecoder::CodecSampleRateHz(kDecoderOpus_2ch));
#ifdef WEBRTC_CODEC_CELT
EXPECT_EQ(32000, AudioDecoder::CodecSampleRateHz(kDecoderCELT_32));
EXPECT_EQ(32000, AudioDecoder::CodecSampleRateHz(kDecoderCELT_32_2ch));