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

Reformat the WebRTC code base

Browse Source 
Running clang-format with chromium's style guide.

The goal is n-fold:
 * providing consistency and readability (that's what code guidelines are for)
 * preventing noise with presubmit checks and git cl format
 * building on the previous point: making it easier to automatically fix format issues
 * you name it

Please consider using git-hyper-blame to ignore this commit.

Bug: webrtc:9340
Change-Id: I694567c4cdf8cee2860958cfe82bfaf25848bb87
Reviewed-on: https://webrtc-review.googlesource.com/81185
Reviewed-by: Patrik Höglund <phoglund@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#23660}
This commit is contained in:
Yves Gerey
2018-06-19 15:03:05 +02:00
parent b602123a5a
commit 665174fdbb
1569 changed files with 30495 additions and 30309 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
modules/audio_coding/codecs/opus/audio_encoder_opus.cc
View File

@ -613,20 +613,17 @@ AudioEncoder::EncodedInfo AudioEncoderOpusImpl::EncodeImpl(
const size_t max_encoded_bytes = SufficientOutputBufferSize();
EncodedInfo info;
info.encoded_bytes =
encoded->AppendData(
max_encoded_bytes, [&] (rtc::ArrayView<uint8_t> encoded) {
int status = WebRtcOpus_Encode(
inst_, &input_buffer_[0],
rtc::CheckedDivExact(input_buffer_.size(),
config_.num_channels),
rtc::saturated_cast<int16_t>(max_encoded_bytes),
encoded.data());
info.encoded_bytes = encoded->AppendData(
max_encoded_bytes, [&](rtc::ArrayView<uint8_t> encoded) {
int status = WebRtcOpus_Encode(
inst_, &input_buffer_[0],
rtc::CheckedDivExact(input_buffer_.size(), config_.num_channels),
rtc::saturated_cast<int16_t>(max_encoded_bytes), encoded.data());
RTC_CHECK_GE(status, 0); // Fails only if fed invalid data.
RTC_CHECK_GE(status, 0); // Fails only if fed invalid data.
return static_cast<size_t>(status);
});
return static_cast<size_t>(status);
});
input_buffer_.clear();
bool dtx_frame = (info.encoded_bytes <= 2);

20
modules/audio_coding/codecs/opus/audio_encoder_opus_unittest.cc
View File

@ -753,8 +753,8 @@ TEST(AudioEncoderOpusTest, SetMaxPlaybackRateNb) {
EXPECT_EQ(8000, config.max_playback_rate_hz);
EXPECT_EQ(12000, config.bitrate_bps);
config = CreateConfigWithParameters({{"maxplaybackrate", "8000"},
{"stereo", "1"}});
config = CreateConfigWithParameters(
{{"maxplaybackrate", "8000"}, {"stereo", "1"}});
EXPECT_EQ(8000, config.max_playback_rate_hz);
EXPECT_EQ(24000, config.bitrate_bps);
}
@ -765,8 +765,8 @@ TEST(AudioEncoderOpusTest, SetMaxPlaybackRateMb) {
EXPECT_EQ(8001, config.max_playback_rate_hz);
EXPECT_EQ(20000, config.bitrate_bps);
config = CreateConfigWithParameters({{"maxplaybackrate", "8001"},
{"stereo", "1"}});
config = CreateConfigWithParameters(
{{"maxplaybackrate", "8001"}, {"stereo", "1"}});
EXPECT_EQ(8001, config.max_playback_rate_hz);
EXPECT_EQ(40000, config.bitrate_bps);
}
@ -777,8 +777,8 @@ TEST(AudioEncoderOpusTest, SetMaxPlaybackRateWb) {
EXPECT_EQ(12001, config.max_playback_rate_hz);
EXPECT_EQ(20000, config.bitrate_bps);
config = CreateConfigWithParameters({{"maxplaybackrate", "12001"},
{"stereo", "1"}});
config = CreateConfigWithParameters(
{{"maxplaybackrate", "12001"}, {"stereo", "1"}});
EXPECT_EQ(12001, config.max_playback_rate_hz);
EXPECT_EQ(40000, config.bitrate_bps);
}
@ -789,8 +789,8 @@ TEST(AudioEncoderOpusTest, SetMaxPlaybackRateSwb) {
EXPECT_EQ(16001, config.max_playback_rate_hz);
EXPECT_EQ(32000, config.bitrate_bps);
config = CreateConfigWithParameters({{"maxplaybackrate", "16001"},
{"stereo", "1"}});
config = CreateConfigWithParameters(
{{"maxplaybackrate", "16001"}, {"stereo", "1"}});
EXPECT_EQ(16001, config.max_playback_rate_hz);
EXPECT_EQ(64000, config.bitrate_bps);
}
@ -801,8 +801,8 @@ TEST(AudioEncoderOpusTest, SetMaxPlaybackRateFb) {
EXPECT_EQ(24001, config.max_playback_rate_hz);
EXPECT_EQ(32000, config.bitrate_bps);
config = CreateConfigWithParameters({{"maxplaybackrate", "24001"},
{"stereo", "1"}});
config = CreateConfigWithParameters(
{{"maxplaybackrate", "24001"}, {"stereo", "1"}});
EXPECT_EQ(24001, config.max_playback_rate_hz);
EXPECT_EQ(64000, config.bitrate_bps);
}

33
modules/audio_coding/codecs/opus/opus_fec_test.cc
View File

@ -83,8 +83,8 @@ void OpusFecTest::SetUp() {
rewind(fp);
// Allocate memory to contain the whole file.
in_data_.reset(new int16_t[loop_length_samples_ +
block_length_sample_ * channels_]);
in_data_.reset(
new int16_t[loop_length_samples_ + block_length_sample_ * channels_]);
// Copy the file into the buffer.
ASSERT_EQ(fread(&in_data_[0], sizeof(int16_t), loop_length_samples_, fp),
@ -130,14 +130,12 @@ OpusFecTest::OpusFecTest()
max_bytes_(0),
encoded_bytes_(0),
opus_encoder_(NULL),
opus_decoder_(NULL) {
}
opus_decoder_(NULL) {}
void OpusFecTest::EncodeABlock() {
int value = WebRtcOpus_Encode(opus_encoder_,
&in_data_[data_pointer_],
block_length_sample_,
max_bytes_, &bit_stream_[0]);
int value =
WebRtcOpus_Encode(opus_encoder_, &in_data_[data_pointer_],
block_length_sample_, max_bytes_, &bit_stream_[0]);
EXPECT_GT(value, 0);
encoded_bytes_ = static_cast<size_t>(value);
@ -151,9 +149,9 @@ void OpusFecTest::DecodeABlock(bool lost_previous, bool lost_current) {
// Decode previous frame.
if (!lost_current &&
WebRtcOpus_PacketHasFec(&bit_stream_[0], encoded_bytes_) == 1) {
value_1 = WebRtcOpus_DecodeFec(opus_decoder_, &bit_stream_[0],
encoded_bytes_, &out_data_[0],
&audio_type);
value_1 =
WebRtcOpus_DecodeFec(opus_decoder_, &bit_stream_[0], encoded_bytes_,
&out_data_[0], &audio_type);
} else {
value_1 = WebRtcOpus_DecodePlc(opus_decoder_, &out_data_[0], 1);
}
@ -173,16 +171,14 @@ TEST_P(OpusFecTest, RandomPacketLossTest) {
int time_now_ms, fec_frames;
int actual_packet_loss_rate;
bool lost_current, lost_previous;
mode mode_set[3] = {{true, 0},
{false, 0},
{true, 50}};
mode mode_set[3] = {{true, 0}, {false, 0}, {true, 50}};
lost_current = false;
for (int i = 0; i < 3; i++) {
if (mode_set[i].fec) {
EXPECT_EQ(0, WebRtcOpus_EnableFec(opus_encoder_));
EXPECT_EQ(0, WebRtcOpus_SetPacketLossRate(opus_encoder_,
mode_set[i].target_packet_loss_rate));
EXPECT_EQ(0, WebRtcOpus_SetPacketLossRate(
opus_encoder_, mode_set[i].target_packet_loss_rate));
printf("FEC is ON, target at packet loss rate %d percent.\n",
mode_set[i].target_packet_loss_rate);
} else {
@ -218,7 +214,7 @@ TEST_P(OpusFecTest, RandomPacketLossTest) {
// |data_pointer_| is incremented and wrapped across
// |loop_length_samples_|.
data_pointer_ = (data_pointer_ + block_length_sample_ * channels_) %
loop_length_samples_;
loop_length_samples_;
}
if (mode_set[i].fec) {
printf("%.2f percent frames has FEC.\n",
@ -242,7 +238,6 @@ const coding_param param_set[] = {
string("pcm"))};
// 64 kbps, stereo
INSTANTIATE_TEST_CASE_P(AllTest, OpusFecTest,
::testing::ValuesIn(param_set));
INSTANTIATE_TEST_CASE_P(AllTest, OpusFecTest, ::testing::ValuesIn(param_set));
} // namespace webrtc

1
modules/audio_coding/codecs/opus/opus_inst.h
View File

@ -32,5 +32,4 @@ struct WebRtcOpusDecInst {
int in_dtx_mode;
};
#endif // MODULES_AUDIO_CODING_CODECS_OPUS_OPUS_INST_H_

15
modules/audio_coding/codecs/opus/opus_interface.h
View File

@ -318,8 +318,10 @@ void WebRtcOpus_DecoderInit(OpusDecInst* inst);
* Return value : >0 - Samples per channel in decoded vector
* -1 - Error
*/
int WebRtcOpus_Decode(OpusDecInst* inst, const uint8_t* encoded,
size_t encoded_bytes, int16_t* decoded,
int WebRtcOpus_Decode(OpusDecInst* inst,
const uint8_t* encoded,
size_t encoded_bytes,
int16_t* decoded,
int16_t* audio_type);
/****************************************************************************
@ -336,7 +338,8 @@ int WebRtcOpus_Decode(OpusDecInst* inst, const uint8_t* encoded,
* Return value : >0 - number of samples in decoded PLC vector
* -1 - Error
*/
int WebRtcOpus_DecodePlc(OpusDecInst* inst, int16_t* decoded,
int WebRtcOpus_DecodePlc(OpusDecInst* inst,
int16_t* decoded,
int number_of_lost_frames);
/****************************************************************************
@ -357,8 +360,10 @@ int WebRtcOpus_DecodePlc(OpusDecInst* inst, int16_t* decoded,
* 0 - No FEC data in the packet
* -1 - Error
*/
int WebRtcOpus_DecodeFec(OpusDecInst* inst, const uint8_t* encoded,
size_t encoded_bytes, int16_t* decoded,
int WebRtcOpus_DecodeFec(OpusDecInst* inst,
const uint8_t* encoded,
size_t encoded_bytes,
int16_t* decoded,
int16_t* audio_type);
/****************************************************************************

43
modules/audio_coding/codecs/opus/opus_speed_test.cc
View File

@ -23,9 +23,12 @@ class OpusSpeedTest : public AudioCodecSpeedTest {
OpusSpeedTest();
void SetUp() override;
void TearDown() override;
float EncodeABlock(int16_t* in_data, uint8_t* bit_stream,
size_t max_bytes, size_t* encoded_bytes) override;
float DecodeABlock(const uint8_t* bit_stream, size_t encoded_bytes,
float EncodeABlock(int16_t* in_data,
uint8_t* bit_stream,
size_t max_bytes,
size_t* encoded_bytes) override;
float DecodeABlock(const uint8_t* bit_stream,
size_t encoded_bytes,
int16_t* out_data) override;
WebRtcOpusEncInst* opus_encoder_;
WebRtcOpusDecInst* opus_decoder_;
@ -36,8 +39,7 @@ OpusSpeedTest::OpusSpeedTest()
kOpusSamplingKhz,
kOpusSamplingKhz),
opus_encoder_(NULL),
opus_decoder_(NULL) {
}
opus_decoder_(NULL) {}
void OpusSpeedTest::SetUp() {
AudioCodecSpeedTest::SetUp();
@ -57,12 +59,13 @@ void OpusSpeedTest::TearDown() {
EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_decoder_));
}
float OpusSpeedTest::EncodeABlock(int16_t* in_data, uint8_t* bit_stream,
size_t max_bytes, size_t* encoded_bytes) {
float OpusSpeedTest::EncodeABlock(int16_t* in_data,
uint8_t* bit_stream,
size_t max_bytes,
size_t* encoded_bytes) {
clock_t clocks = clock();
int value = WebRtcOpus_Encode(opus_encoder_, in_data,
input_length_sample_, max_bytes,
bit_stream);
int value = WebRtcOpus_Encode(opus_encoder_, in_data, input_length_sample_,
max_bytes, bit_stream);
clocks = clock() - clocks;
EXPECT_GT(value, 0);
*encoded_bytes = static_cast<size_t>(value);
@ -70,7 +73,8 @@ float OpusSpeedTest::EncodeABlock(int16_t* in_data, uint8_t* bit_stream,
}
float OpusSpeedTest::DecodeABlock(const uint8_t* bit_stream,
size_t encoded_bytes, int16_t* out_data) {
size_t encoded_bytes,
int16_t* out_data) {
int value;
int16_t audio_type;
clock_t clocks = clock();
@ -84,13 +88,13 @@ float OpusSpeedTest::DecodeABlock(const uint8_t* bit_stream,
/* Test audio length in second. */
constexpr size_t kDurationSec = 400;
#define ADD_TEST(complexity) \
TEST_P(OpusSpeedTest, OpusSetComplexityTest##complexity) { \
/* Set complexity. */ \
printf("Setting complexity to %d ...\n", complexity); \
EXPECT_EQ(0, WebRtcOpus_SetComplexity(opus_encoder_, complexity)); \
EncodeDecode(kDurationSec); \
}
#define ADD_TEST(complexity) \
TEST_P(OpusSpeedTest, OpusSetComplexityTest##complexity) { \
/* Set complexity. */ \
printf("Setting complexity to %d ...\n", complexity); \
EXPECT_EQ(0, WebRtcOpus_SetComplexity(opus_encoder_, complexity)); \
EncodeDecode(kDurationSec); \
}
ADD_TEST(10);
ADD_TEST(9);
@ -136,7 +140,6 @@ const coding_param param_set[] = {
string("pcm"),
true)};
INSTANTIATE_TEST_CASE_P(AllTest, OpusSpeedTest,
::testing::ValuesIn(param_set));
INSTANTIATE_TEST_CASE_P(AllTest, OpusSpeedTest, ::testing::ValuesIn(param_set));
} // namespace webrtc

234
modules/audio_coding/codecs/opus/opus_unittest.cc
View File

@ -58,9 +58,12 @@ class OpusTest : public TestWithParam<::testing::tuple<int, int>> {
int16_t* audio_type);
void SetMaxPlaybackRate(WebRtcOpusEncInst* encoder,
opus_int32 expect, int32_t set);
opus_int32 expect,
int32_t set);
void CheckAudioBounded(const int16_t* audio, size_t samples, size_t channels,
void CheckAudioBounded(const int16_t* audio,
size_t samples,
size_t channels,
uint16_t bound) const;
WebRtcOpusEncInst* opus_encoder_;
@ -78,15 +81,15 @@ OpusTest::OpusTest()
opus_decoder_(NULL),
encoded_bytes_(0),
channels_(static_cast<size_t>(::testing::get<0>(GetParam()))),
application_(::testing::get<1>(GetParam())) {
}
application_(::testing::get<1>(GetParam())) {}
void OpusTest::PrepareSpeechData(size_t channel, int block_length_ms,
void OpusTest::PrepareSpeechData(size_t channel,
int block_length_ms,
int loop_length_ms) {
const std::string file_name =
webrtc::test::ResourcePath((channel == 1) ?
"audio_coding/testfile32kHz" :
"audio_coding/teststereo32kHz", "pcm");
const std::string file_name = webrtc::test::ResourcePath(
(channel == 1) ? "audio_coding/testfile32kHz"
: "audio_coding/teststereo32kHz",
"pcm");
if (loop_length_ms < block_length_ms) {
loop_length_ms = block_length_ms;
}
@ -100,13 +103,14 @@ void OpusTest::SetMaxPlaybackRate(WebRtcOpusEncInst* encoder,
int32_t set) {
opus_int32 bandwidth;
EXPECT_EQ(0, WebRtcOpus_SetMaxPlaybackRate(opus_encoder_, set));
opus_encoder_ctl(opus_encoder_->encoder,
OPUS_GET_MAX_BANDWIDTH(&bandwidth));
opus_encoder_ctl(opus_encoder_->encoder, OPUS_GET_MAX_BANDWIDTH(&bandwidth));
EXPECT_EQ(expect, bandwidth);
}
void OpusTest::CheckAudioBounded(const int16_t* audio, size_t samples,
size_t channels, uint16_t bound) const {
void OpusTest::CheckAudioBounded(const int16_t* audio,
size_t samples,
size_t channels,
uint16_t bound) const {
for (size_t i = 0; i < samples; ++i) {
for (size_t c = 0; c < channels; ++c) {
ASSERT_GE(audio[i * channels + c], -bound);
@ -120,16 +124,15 @@ int OpusTest::EncodeDecode(WebRtcOpusEncInst* encoder,
WebRtcOpusDecInst* decoder,
int16_t* output_audio,
int16_t* audio_type) {
int encoded_bytes_int = WebRtcOpus_Encode(
encoder, input_audio.data(),
rtc::CheckedDivExact(input_audio.size(), channels_),
kMaxBytes, bitstream_);
int encoded_bytes_int =
WebRtcOpus_Encode(encoder, input_audio.data(),
rtc::CheckedDivExact(input_audio.size(), channels_),
kMaxBytes, bitstream_);
EXPECT_GE(encoded_bytes_int, 0);
encoded_bytes_ = static_cast<size_t>(encoded_bytes_int);
int est_len = WebRtcOpus_DurationEst(decoder, bitstream_, encoded_bytes_);
int act_len = WebRtcOpus_Decode(decoder, bitstream_,
encoded_bytes_, output_audio,
audio_type);
int act_len = WebRtcOpus_Decode(decoder, bitstream_, encoded_bytes_,
output_audio, audio_type);
EXPECT_EQ(est_len, act_len);
return act_len;
}
@ -141,30 +144,28 @@ void OpusTest::TestDtxEffect(bool dtx, int block_length_ms) {
const size_t samples = kOpusRateKhz * block_length_ms;
// Create encoder memory.
EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_encoder_,
channels_,
application_));
EXPECT_EQ(0,
WebRtcOpus_EncoderCreate(&opus_encoder_, channels_, application_));
EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_decoder_, channels_));
// Set bitrate.
EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_encoder_,
channels_ == 1 ? 32000 : 64000));
EXPECT_EQ(
0, WebRtcOpus_SetBitRate(opus_encoder_, channels_ == 1 ? 32000 : 64000));
// Set input audio as silence.
std::vector<int16_t> silence(samples * channels_, 0);
// Setting DTX.
EXPECT_EQ(0, dtx ? WebRtcOpus_EnableDtx(opus_encoder_) :
WebRtcOpus_DisableDtx(opus_encoder_));
EXPECT_EQ(0, dtx ? WebRtcOpus_EnableDtx(opus_encoder_)
: WebRtcOpus_DisableDtx(opus_encoder_));
int16_t audio_type;
int16_t* output_data_decode = new int16_t[samples * channels_];
for (int i = 0; i < 100; ++i) {
EXPECT_EQ(samples,
static_cast<size_t>(EncodeDecode(
opus_encoder_, speech_data_.GetNextBlock(), opus_decoder_,
output_data_decode, &audio_type)));
EXPECT_EQ(samples, static_cast<size_t>(EncodeDecode(
opus_encoder_, speech_data_.GetNextBlock(),
opus_decoder_, output_data_decode, &audio_type)));
// If not DTX, it should never enter DTX mode. If DTX, we do not care since
// whether it enters DTX depends on the signal type.
if (!dtx) {
@ -178,10 +179,9 @@ void OpusTest::TestDtxEffect(bool dtx, int block_length_ms) {
// We input some silent segments. In DTX mode, the encoder will stop sending.
// However, DTX may happen after a while.
for (int i = 0; i < 30; ++i) {
EXPECT_EQ(samples,
static_cast<size_t>(EncodeDecode(
opus_encoder_, silence, opus_decoder_, output_data_decode,
&audio_type)));
EXPECT_EQ(samples, static_cast<size_t>(
EncodeDecode(opus_encoder_, silence, opus_decoder_,
output_data_decode, &audio_type)));
if (!dtx) {
EXPECT_GT(encoded_bytes_, 1U);
EXPECT_EQ(0, opus_encoder_->in_dtx_mode);
@ -227,10 +227,9 @@ void OpusTest::TestDtxEffect(bool dtx, int block_length_ms) {
int i = 0;
for (; i < max_dtx_frames; ++i) {
time += block_length_ms;
EXPECT_EQ(samples,
static_cast<size_t>(EncodeDecode(
opus_encoder_, silence, opus_decoder_, output_data_decode,
&audio_type)));
EXPECT_EQ(samples, static_cast<size_t>(
EncodeDecode(opus_encoder_, silence, opus_decoder_,
output_data_decode, &audio_type)));
if (dtx) {
if (encoded_bytes_ > 1)
break;
@ -263,10 +262,9 @@ void OpusTest::TestDtxEffect(bool dtx, int block_length_ms) {
// Enters DTX again immediately.
time += block_length_ms;
EXPECT_EQ(samples,
static_cast<size_t>(EncodeDecode(
opus_encoder_, silence, opus_decoder_, output_data_decode,
&audio_type)));
EXPECT_EQ(samples, static_cast<size_t>(
EncodeDecode(opus_encoder_, silence, opus_decoder_,
output_data_decode, &audio_type)));
if (dtx) {
EXPECT_EQ(1U, encoded_bytes_); // Send 1 byte.
EXPECT_EQ(1, opus_encoder_->in_dtx_mode);
@ -287,10 +285,9 @@ void OpusTest::TestDtxEffect(bool dtx, int block_length_ms) {
silence[0] = 10000;
if (dtx) {
// Verify that encoder/decoder can jump out from DTX mode.
EXPECT_EQ(samples,
static_cast<size_t>(EncodeDecode(
opus_encoder_, silence, opus_decoder_, output_data_decode,
&audio_type)));
EXPECT_EQ(samples, static_cast<size_t>(
EncodeDecode(opus_encoder_, silence, opus_decoder_,
output_data_decode, &audio_type)));
EXPECT_GT(encoded_bytes_, 1U);
EXPECT_EQ(0, opus_encoder_->in_dtx_mode);
EXPECT_EQ(0, opus_decoder_->in_dtx_mode);
@ -375,9 +372,8 @@ TEST(OpusTest, OpusFreeFail) {
// Test normal Create and Free.
TEST_P(OpusTest, OpusCreateFree) {
EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_encoder_,
channels_,
application_));
EXPECT_EQ(0,
WebRtcOpus_EncoderCreate(&opus_encoder_, channels_, application_));
EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_decoder_, channels_));
EXPECT_TRUE(opus_encoder_ != NULL);
EXPECT_TRUE(opus_decoder_ != NULL);
@ -390,23 +386,20 @@ TEST_P(OpusTest, OpusEncodeDecode) {
PrepareSpeechData(channels_, 20, 20);
// Create encoder memory.
EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_encoder_,
channels_,
application_));
EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_decoder_,
channels_));
EXPECT_EQ(0,
WebRtcOpus_EncoderCreate(&opus_encoder_, channels_, application_));
EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_decoder_, channels_));
// Set bitrate.
EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_encoder_,
channels_ == 1 ? 32000 : 64000));
EXPECT_EQ(
0, WebRtcOpus_SetBitRate(opus_encoder_, channels_ == 1 ? 32000 : 64000));
// Check number of channels for decoder.
EXPECT_EQ(channels_, WebRtcOpus_DecoderChannels(opus_decoder_));
// Check application mode.
opus_int32 app;
opus_encoder_ctl(opus_encoder_->encoder,
OPUS_GET_APPLICATION(&app));
opus_encoder_ctl(opus_encoder_->encoder, OPUS_GET_APPLICATION(&app));
EXPECT_EQ(application_ == 0 ? OPUS_APPLICATION_VOIP : OPUS_APPLICATION_AUDIO,
app);
@ -429,9 +422,8 @@ TEST_P(OpusTest, OpusSetBitRate) {
EXPECT_EQ(-1, WebRtcOpus_SetBitRate(opus_encoder_, 60000));
// Create encoder memory, try with different bitrates.
EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_encoder_,
channels_,
application_));
EXPECT_EQ(0,
WebRtcOpus_EncoderCreate(&opus_encoder_, channels_, application_));
EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_encoder_, 30000));
EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_encoder_, 60000));
EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_encoder_, 300000));
@ -446,9 +438,8 @@ TEST_P(OpusTest, OpusSetComplexity) {
EXPECT_EQ(-1, WebRtcOpus_SetComplexity(opus_encoder_, 9));
// Create encoder memory, try with different complexities.
EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_encoder_,
channels_,
application_));
EXPECT_EQ(0,
WebRtcOpus_EncoderCreate(&opus_encoder_, channels_, application_));
EXPECT_EQ(0, WebRtcOpus_SetComplexity(opus_encoder_, 0));
EXPECT_EQ(0, WebRtcOpus_SetComplexity(opus_encoder_, 10));
@ -524,9 +515,8 @@ TEST_P(OpusTest, OpusDecodeInit) {
PrepareSpeechData(channels_, 20, 20);
// Create encoder memory.
EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_encoder_,
channels_,
application_));
EXPECT_EQ(0,
WebRtcOpus_EncoderCreate(&opus_encoder_, channels_, application_));
EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_decoder_, channels_));
// Encode & decode.
@ -540,9 +530,9 @@ TEST_P(OpusTest, OpusDecodeInit) {
WebRtcOpus_DecoderInit(opus_decoder_);
EXPECT_EQ(kOpus20msFrameSamples,
static_cast<size_t>(WebRtcOpus_Decode(
opus_decoder_, bitstream_, encoded_bytes_, output_data_decode,
&audio_type)));
static_cast<size_t>(
WebRtcOpus_Decode(opus_decoder_, bitstream_, encoded_bytes_,
output_data_decode, &audio_type)));
// Free memory.
delete[] output_data_decode;
@ -556,9 +546,8 @@ TEST_P(OpusTest, OpusEnableDisableFec) {
EXPECT_EQ(-1, WebRtcOpus_DisableFec(opus_encoder_));
// Create encoder memory.
EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_encoder_,
channels_,
application_));
EXPECT_EQ(0,
WebRtcOpus_EncoderCreate(&opus_encoder_, channels_, application_));
EXPECT_EQ(0, WebRtcOpus_EnableFec(opus_encoder_));
EXPECT_EQ(0, WebRtcOpus_DisableFec(opus_encoder_));
@ -573,30 +562,25 @@ TEST_P(OpusTest, OpusEnableDisableDtx) {
EXPECT_EQ(-1, WebRtcOpus_DisableDtx(opus_encoder_));
// Create encoder memory.
EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_encoder_,
channels_,
application_));
EXPECT_EQ(0,
WebRtcOpus_EncoderCreate(&opus_encoder_, channels_, application_));
opus_int32 dtx;
// DTX is off by default.
opus_encoder_ctl(opus_encoder_->encoder,
OPUS_GET_DTX(&dtx));
opus_encoder_ctl(opus_encoder_->encoder, OPUS_GET_DTX(&dtx));
EXPECT_EQ(0, dtx);
// Test to enable DTX.
EXPECT_EQ(0, WebRtcOpus_EnableDtx(opus_encoder_));
opus_encoder_ctl(opus_encoder_->encoder,
OPUS_GET_DTX(&dtx));
opus_encoder_ctl(opus_encoder_->encoder, OPUS_GET_DTX(&dtx));
EXPECT_EQ(1, dtx);
// Test to disable DTX.
EXPECT_EQ(0, WebRtcOpus_DisableDtx(opus_encoder_));
opus_encoder_ctl(opus_encoder_->encoder,
OPUS_GET_DTX(&dtx));
opus_encoder_ctl(opus_encoder_->encoder, OPUS_GET_DTX(&dtx));
EXPECT_EQ(0, dtx);
// Free memory.
EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_encoder_));
}
@ -630,9 +614,8 @@ TEST_P(OpusTest, OpusSetPacketLossRate) {
EXPECT_EQ(-1, WebRtcOpus_SetPacketLossRate(opus_encoder_, 50));
// Create encoder memory.
EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_encoder_,
channels_,
application_));
EXPECT_EQ(0,
WebRtcOpus_EncoderCreate(&opus_encoder_, channels_, application_));
EXPECT_EQ(0, WebRtcOpus_SetPacketLossRate(opus_encoder_, 50));
EXPECT_EQ(-1, WebRtcOpus_SetPacketLossRate(opus_encoder_, -1));
@ -647,9 +630,8 @@ TEST_P(OpusTest, OpusSetMaxPlaybackRate) {
EXPECT_EQ(-1, WebRtcOpus_SetMaxPlaybackRate(opus_encoder_, 20000));
// Create encoder memory.
EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_encoder_,
channels_,
application_));
EXPECT_EQ(0,
WebRtcOpus_EncoderCreate(&opus_encoder_, channels_, application_));
SetMaxPlaybackRate(opus_encoder_, OPUS_BANDWIDTH_FULLBAND, 48000);
SetMaxPlaybackRate(opus_encoder_, OPUS_BANDWIDTH_FULLBAND, 24001);
@ -671,14 +653,13 @@ TEST_P(OpusTest, OpusDecodePlc) {
PrepareSpeechData(channels_, 20, 20);
// Create encoder memory.
EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_encoder_,
channels_,
application_));
EXPECT_EQ(0,
WebRtcOpus_EncoderCreate(&opus_encoder_, channels_, application_));
EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_decoder_, channels_));
// Set bitrate.
EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_encoder_,
channels_== 1 ? 32000 : 64000));
EXPECT_EQ(
0, WebRtcOpus_SetBitRate(opus_encoder_, channels_ == 1 ? 32000 : 64000));
// Check number of channels for decoder.
EXPECT_EQ(channels_, WebRtcOpus_DecoderChannels(opus_decoder_));
@ -693,9 +674,8 @@ TEST_P(OpusTest, OpusDecodePlc) {
// Call decoder PLC.
int16_t* plc_buffer = new int16_t[kOpus20msFrameSamples * channels_];
EXPECT_EQ(kOpus20msFrameSamples,
static_cast<size_t>(WebRtcOpus_DecodePlc(
opus_decoder_, plc_buffer, 1)));
EXPECT_EQ(kOpus20msFrameSamples, static_cast<size_t>(WebRtcOpus_DecodePlc(
opus_decoder_, plc_buffer, 1)));
// Free memory.
delete[] plc_buffer;
@ -709,34 +689,33 @@ TEST_P(OpusTest, OpusDurationEstimation) {
PrepareSpeechData(channels_, 20, 20);
// Create.
EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_encoder_,
channels_,
application_));
EXPECT_EQ(0,
WebRtcOpus_EncoderCreate(&opus_encoder_, channels_, application_));
EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_decoder_, channels_));
// 10 ms. We use only first 10 ms of a 20 ms block.
auto speech_block = speech_data_.GetNextBlock();
int encoded_bytes_int = WebRtcOpus_Encode(
opus_encoder_, speech_block.data(),
rtc::CheckedDivExact(speech_block.size(), 2 * channels_),
kMaxBytes, bitstream_);
rtc::CheckedDivExact(speech_block.size(), 2 * channels_), kMaxBytes,
bitstream_);
EXPECT_GE(encoded_bytes_int, 0);
EXPECT_EQ(kOpus10msFrameSamples,
static_cast<size_t>(WebRtcOpus_DurationEst(
opus_decoder_, bitstream_,
static_cast<size_t>(encoded_bytes_int))));
EXPECT_EQ(
kOpus10msFrameSamples,
static_cast<size_t>(WebRtcOpus_DurationEst(
opus_decoder_, bitstream_, static_cast<size_t>(encoded_bytes_int))));
// 20 ms
speech_block = speech_data_.GetNextBlock();
encoded_bytes_int = WebRtcOpus_Encode(
opus_encoder_, speech_block.data(),
rtc::CheckedDivExact(speech_block.size(), channels_),
kMaxBytes, bitstream_);
encoded_bytes_int =
WebRtcOpus_Encode(opus_encoder_, speech_block.data(),
rtc::CheckedDivExact(speech_block.size(), channels_),
kMaxBytes, bitstream_);
EXPECT_GE(encoded_bytes_int, 0);
EXPECT_EQ(kOpus20msFrameSamples,
static_cast<size_t>(WebRtcOpus_DurationEst(
opus_decoder_, bitstream_,
static_cast<size_t>(encoded_bytes_int))));
EXPECT_EQ(
kOpus20msFrameSamples,
static_cast<size_t>(WebRtcOpus_DurationEst(
opus_decoder_, bitstream_, static_cast<size_t>(encoded_bytes_int))));
// Free memory.
EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_encoder_));
@ -749,15 +728,13 @@ TEST_P(OpusTest, OpusDecodeRepacketized) {
PrepareSpeechData(channels_, 20, 20 * kPackets);
// Create encoder memory.
ASSERT_EQ(0, WebRtcOpus_EncoderCreate(&opus_encoder_,
channels_,
application_));
ASSERT_EQ(0, WebRtcOpus_DecoderCreate(&opus_decoder_,
channels_));
ASSERT_EQ(0,
WebRtcOpus_EncoderCreate(&opus_encoder_, channels_, application_));
ASSERT_EQ(0, WebRtcOpus_DecoderCreate(&opus_decoder_, channels_));
// Set bitrate.
EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_encoder_,
channels_ == 1 ? 32000 : 64000));
EXPECT_EQ(
0, WebRtcOpus_SetBitRate(opus_encoder_, channels_ == 1 ? 32000 : 64000));
// Check number of channels for decoder.
EXPECT_EQ(channels_, WebRtcOpus_DecoderChannels(opus_decoder_));
@ -776,9 +753,9 @@ TEST_P(OpusTest, OpusDecodeRepacketized) {
WebRtcOpus_Encode(opus_encoder_, speech_block.data(),
rtc::CheckedDivExact(speech_block.size(), channels_),
kMaxBytes, bitstream_);
if (opus_repacketizer_cat(
rp, bitstream_,
rtc::checked_cast<opus_int32>(encoded_bytes_)) == OPUS_OK) {
if (opus_repacketizer_cat(rp, bitstream_,
rtc::checked_cast<opus_int32>(encoded_bytes_)) ==
OPUS_OK) {
++num_packets;
if (num_packets == kPackets) {
break;
@ -798,9 +775,9 @@ TEST_P(OpusTest, OpusDecodeRepacketized) {
opus_decoder_, bitstream_, encoded_bytes_)));
EXPECT_EQ(kOpus20msFrameSamples * kPackets,
static_cast<size_t>(WebRtcOpus_Decode(
opus_decoder_, bitstream_, encoded_bytes_,
output_data_decode.get(), &audio_type)));
static_cast<size_t>(
WebRtcOpus_Decode(opus_decoder_, bitstream_, encoded_bytes_,
output_data_decode.get(), &audio_type)));
// Free memory.
opus_repacketizer_destroy(rp);
@ -812,5 +789,4 @@ INSTANTIATE_TEST_CASE_P(VariousMode,
OpusTest,
Combine(Values(1, 2), Values(0, 1)));
} // namespace webrtc