| /* |
| * Copyright (c) 2013 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 <string> |
| |
| #include "testing/gtest/include/gtest/gtest.h" |
| #include "webrtc/modules/audio_coding/codecs/opus/interface/opus_interface.h" |
| #include "webrtc/modules/audio_coding/codecs/opus/opus_inst.h" |
| #include "webrtc/modules/audio_coding/neteq/tools/audio_loop.h" |
| #include "webrtc/test/testsupport/fileutils.h" |
| |
| namespace webrtc { |
| |
| using test::AudioLoop; |
| |
| // Maximum number of bytes in output bitstream. |
| const size_t kMaxBytes = 1000; |
| // Sample rate of Opus. |
| const int kOpusRateKhz = 48; |
| // Number of samples-per-channel in a 20 ms frame, sampled at 48 kHz. |
| const int kOpus20msFrameSamples = kOpusRateKhz * 20; |
| // Number of samples-per-channel in a 10 ms frame, sampled at 48 kHz. |
| const int kOpus10msFrameSamples = kOpusRateKhz * 10; |
| |
| class OpusTest : public ::testing::Test { |
| protected: |
| OpusTest(); |
| |
| void TestSetMaxPlaybackRate(opus_int32 expect, int32_t set); |
| void TestDtxEffect(bool dtx); |
| |
| // Prepare |speech_data_| for encoding, read from a hard-coded file. |
| // After preparation, |speech_data_.GetNextBlock()| returns a pointer to a |
| // block of |block_length_ms| milliseconds. The data is looped every |
| // |loop_length_ms| milliseconds. |
| void PrepareSpeechData(int channel, int block_length_ms, int loop_length_ms); |
| |
| int EncodeDecode(WebRtcOpusEncInst* encoder, |
| const int16_t* input_audio, |
| const int input_samples, |
| WebRtcOpusDecInst* decoder, |
| int16_t* output_audio, |
| int16_t* audio_type); |
| |
| WebRtcOpusEncInst* opus_mono_encoder_; |
| WebRtcOpusEncInst* opus_stereo_encoder_; |
| WebRtcOpusDecInst* opus_mono_decoder_; |
| WebRtcOpusDecInst* opus_stereo_decoder_; |
| |
| AudioLoop speech_data_; |
| uint8_t bitstream_[kMaxBytes]; |
| int encoded_bytes_; |
| }; |
| |
| OpusTest::OpusTest() |
| : opus_mono_encoder_(NULL), |
| opus_stereo_encoder_(NULL), |
| opus_mono_decoder_(NULL), |
| opus_stereo_decoder_(NULL) { |
| } |
| |
| void OpusTest::PrepareSpeechData(int channel, int block_length_ms, |
| int loop_length_ms) { |
| const std::string file_name = |
| webrtc::test::ResourcePath("audio_coding/speech_mono_32_48kHz", "pcm"); |
| if (loop_length_ms < block_length_ms) { |
| loop_length_ms = block_length_ms; |
| } |
| EXPECT_TRUE(speech_data_.Init(file_name, |
| loop_length_ms * kOpusRateKhz * channel, |
| block_length_ms * kOpusRateKhz * channel)); |
| } |
| |
| void OpusTest::TestSetMaxPlaybackRate(opus_int32 expect, int32_t set) { |
| opus_int32 bandwidth; |
| // Test mono encoder. |
| EXPECT_EQ(0, WebRtcOpus_SetMaxPlaybackRate(opus_mono_encoder_, set)); |
| opus_encoder_ctl(opus_mono_encoder_->encoder, |
| OPUS_GET_MAX_BANDWIDTH(&bandwidth)); |
| EXPECT_EQ(expect, bandwidth); |
| // Test stereo encoder. |
| EXPECT_EQ(0, WebRtcOpus_SetMaxPlaybackRate(opus_stereo_encoder_, set)); |
| opus_encoder_ctl(opus_stereo_encoder_->encoder, |
| OPUS_GET_MAX_BANDWIDTH(&bandwidth)); |
| EXPECT_EQ(expect, bandwidth); |
| } |
| |
| int OpusTest::EncodeDecode(WebRtcOpusEncInst* encoder, |
| const int16_t* input_audio, |
| const int input_samples, |
| WebRtcOpusDecInst* decoder, |
| int16_t* output_audio, |
| int16_t* audio_type) { |
| encoded_bytes_ = WebRtcOpus_Encode(encoder, |
| input_audio, |
| input_samples, kMaxBytes, |
| bitstream_); |
| return WebRtcOpus_Decode(decoder, bitstream_, |
| encoded_bytes_, output_audio, |
| audio_type); |
| } |
| |
| // Test if encoder/decoder can enter DTX mode properly and do not enter DTX when |
| // they should not. This test is signal dependent. |
| void OpusTest::TestDtxEffect(bool dtx) { |
| PrepareSpeechData(1, 20, 2000); |
| |
| // Create encoder memory. |
| EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 1)); |
| EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_mono_decoder_, 1)); |
| |
| // Set bitrate. |
| EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_mono_encoder_, 32000)); |
| |
| // Set input audio as silence. |
| int16_t silence[kOpus20msFrameSamples] = {0}; |
| |
| // Setting DTX. |
| EXPECT_EQ(0, dtx ? WebRtcOpus_EnableDtx(opus_mono_encoder_) : |
| WebRtcOpus_DisableDtx(opus_mono_encoder_)); |
| |
| int16_t audio_type; |
| int16_t output_data_decode[kOpus20msFrameSamples]; |
| |
| for (int i = 0; i < 100; ++i) { |
| EXPECT_EQ(kOpus20msFrameSamples, |
| EncodeDecode(opus_mono_encoder_, speech_data_.GetNextBlock(), |
| kOpus20msFrameSamples, opus_mono_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) { |
| EXPECT_GT(encoded_bytes_, 1); |
| EXPECT_EQ(0, opus_mono_encoder_->in_dtx_mode); |
| EXPECT_EQ(0, opus_mono_decoder_->in_dtx_mode); |
| EXPECT_EQ(0, audio_type); // Speech. |
| } |
| } |
| |
| // 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 < 21; ++i) { |
| EXPECT_EQ(kOpus20msFrameSamples, |
| EncodeDecode(opus_mono_encoder_, silence, |
| kOpus20msFrameSamples, opus_mono_decoder_, |
| output_data_decode, &audio_type)); |
| if (!dtx) { |
| EXPECT_GT(encoded_bytes_, 1); |
| EXPECT_EQ(0, opus_mono_encoder_->in_dtx_mode); |
| EXPECT_EQ(0, opus_mono_decoder_->in_dtx_mode); |
| EXPECT_EQ(0, audio_type); // Speech. |
| } |
| } |
| |
| // For this input signal, DTX happens now. |
| EXPECT_EQ(kOpus20msFrameSamples, |
| EncodeDecode(opus_mono_encoder_, silence, |
| kOpus20msFrameSamples, opus_mono_decoder_, |
| output_data_decode, &audio_type)); |
| if (dtx) { |
| EXPECT_EQ(1, encoded_bytes_); // Send 1 byte. |
| EXPECT_EQ(1, opus_mono_encoder_->in_dtx_mode); |
| EXPECT_EQ(1, opus_mono_decoder_->in_dtx_mode); |
| EXPECT_EQ(2, audio_type); // Comfort noise. |
| } else { |
| EXPECT_GT(encoded_bytes_, 1); |
| EXPECT_EQ(0, opus_mono_encoder_->in_dtx_mode); |
| EXPECT_EQ(0, opus_mono_decoder_->in_dtx_mode); |
| EXPECT_EQ(0, audio_type); // Speech. |
| } |
| |
| // DTX mode is maintained 400 ms. |
| for (int i = 0; i < 20; ++i) { |
| EXPECT_EQ(kOpus20msFrameSamples, |
| EncodeDecode(opus_mono_encoder_, silence, |
| kOpus20msFrameSamples, opus_mono_decoder_, |
| output_data_decode, &audio_type)); |
| if (dtx) { |
| EXPECT_EQ(0, encoded_bytes_); // Send 0 byte. |
| EXPECT_EQ(1, opus_mono_encoder_->in_dtx_mode); |
| EXPECT_EQ(1, opus_mono_decoder_->in_dtx_mode); |
| EXPECT_EQ(2, audio_type); // Comfort noise. |
| } else { |
| EXPECT_GT(encoded_bytes_, 1); |
| EXPECT_EQ(0, opus_mono_encoder_->in_dtx_mode); |
| EXPECT_EQ(0, opus_mono_decoder_->in_dtx_mode); |
| EXPECT_EQ(0, audio_type); // Speech. |
| } |
| } |
| |
| // Quit DTX after 400 ms |
| EXPECT_EQ(kOpus20msFrameSamples, |
| EncodeDecode(opus_mono_encoder_, silence, |
| kOpus20msFrameSamples, opus_mono_decoder_, |
| output_data_decode, &audio_type)); |
| |
| EXPECT_GT(encoded_bytes_, 1); |
| EXPECT_EQ(0, opus_mono_encoder_->in_dtx_mode); |
| EXPECT_EQ(0, opus_mono_decoder_->in_dtx_mode); |
| EXPECT_EQ(0, audio_type); // Speech. |
| |
| // Enters DTX again immediately. |
| EXPECT_EQ(kOpus20msFrameSamples, |
| EncodeDecode(opus_mono_encoder_, silence, |
| kOpus20msFrameSamples, opus_mono_decoder_, |
| output_data_decode, &audio_type)); |
| if (dtx) { |
| EXPECT_EQ(1, encoded_bytes_); // Send 1 byte. |
| EXPECT_EQ(1, opus_mono_encoder_->in_dtx_mode); |
| EXPECT_EQ(1, opus_mono_decoder_->in_dtx_mode); |
| EXPECT_EQ(2, audio_type); // Comfort noise. |
| } else { |
| EXPECT_GT(encoded_bytes_, 1); |
| EXPECT_EQ(0, opus_mono_encoder_->in_dtx_mode); |
| EXPECT_EQ(0, opus_mono_decoder_->in_dtx_mode); |
| EXPECT_EQ(0, audio_type); // Speech. |
| } |
| |
| silence[0] = 10000; |
| if (dtx) { |
| // Verify that encoder/decoder can jump out from DTX mode. |
| EXPECT_EQ(kOpus20msFrameSamples, |
| EncodeDecode(opus_mono_encoder_, silence, |
| kOpus20msFrameSamples, opus_mono_decoder_, |
| output_data_decode, &audio_type)); |
| EXPECT_GT(encoded_bytes_, 1); |
| EXPECT_EQ(0, opus_mono_encoder_->in_dtx_mode); |
| EXPECT_EQ(0, opus_mono_decoder_->in_dtx_mode); |
| EXPECT_EQ(0, audio_type); // Speech. |
| } |
| |
| // Free memory. |
| EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_mono_encoder_)); |
| EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_mono_decoder_)); |
| } |
| |
| // Test failing Create. |
| TEST_F(OpusTest, OpusCreateFail) { |
| // Test to see that an invalid pointer is caught. |
| EXPECT_EQ(-1, WebRtcOpus_EncoderCreate(NULL, 1)); |
| EXPECT_EQ(-1, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 3)); |
| EXPECT_EQ(-1, WebRtcOpus_DecoderCreate(NULL, 1)); |
| EXPECT_EQ(-1, WebRtcOpus_DecoderCreate(&opus_mono_decoder_, 3)); |
| } |
| |
| // Test failing Free. |
| TEST_F(OpusTest, OpusFreeFail) { |
| // Test to see that an invalid pointer is caught. |
| EXPECT_EQ(-1, WebRtcOpus_EncoderFree(NULL)); |
| EXPECT_EQ(-1, WebRtcOpus_DecoderFree(NULL)); |
| } |
| |
| // Test normal Create and Free. |
| TEST_F(OpusTest, OpusCreateFree) { |
| EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 1)); |
| EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_mono_decoder_, 1)); |
| EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2)); |
| EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_stereo_decoder_, 2)); |
| EXPECT_TRUE(opus_mono_encoder_ != NULL); |
| EXPECT_TRUE(opus_mono_decoder_ != NULL); |
| EXPECT_TRUE(opus_stereo_encoder_ != NULL); |
| EXPECT_TRUE(opus_stereo_decoder_ != NULL); |
| // Free encoder and decoder memory. |
| EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_mono_encoder_)); |
| EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_mono_decoder_)); |
| EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_)); |
| EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_stereo_decoder_)); |
| } |
| |
| TEST_F(OpusTest, OpusEncodeDecodeMono) { |
| PrepareSpeechData(1, 20, 20); |
| |
| // Create encoder memory. |
| EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 1)); |
| EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_mono_decoder_, 1)); |
| |
| // Set bitrate. |
| EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_mono_encoder_, 32000)); |
| |
| // Check number of channels for decoder. |
| EXPECT_EQ(1, WebRtcOpus_DecoderChannels(opus_mono_decoder_)); |
| |
| // Encode & decode. |
| int16_t audio_type; |
| int16_t output_data_decode[kOpus20msFrameSamples]; |
| EXPECT_EQ(kOpus20msFrameSamples, |
| EncodeDecode(opus_mono_encoder_, speech_data_.GetNextBlock(), |
| kOpus20msFrameSamples, opus_mono_decoder_, |
| output_data_decode, &audio_type)); |
| |
| // Free memory. |
| EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_mono_encoder_)); |
| EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_mono_decoder_)); |
| } |
| |
| TEST_F(OpusTest, OpusEncodeDecodeStereo) { |
| PrepareSpeechData(2, 20, 20); |
| |
| // Create encoder memory. |
| EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2)); |
| EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_stereo_decoder_, 2)); |
| |
| // Set bitrate. |
| EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_stereo_encoder_, 64000)); |
| |
| // Check number of channels for decoder. |
| EXPECT_EQ(2, WebRtcOpus_DecoderChannels(opus_stereo_decoder_)); |
| |
| // Encode & decode. |
| int16_t audio_type; |
| int16_t output_data_decode[kOpus20msFrameSamples * 2]; |
| EXPECT_EQ(kOpus20msFrameSamples, |
| EncodeDecode(opus_stereo_encoder_, speech_data_.GetNextBlock(), |
| kOpus20msFrameSamples, opus_stereo_decoder_, |
| output_data_decode, &audio_type)); |
| |
| // Free memory. |
| EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_)); |
| EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_stereo_decoder_)); |
| } |
| |
| TEST_F(OpusTest, OpusSetBitRate) { |
| // Test without creating encoder memory. |
| EXPECT_EQ(-1, WebRtcOpus_SetBitRate(opus_mono_encoder_, 60000)); |
| EXPECT_EQ(-1, WebRtcOpus_SetBitRate(opus_stereo_encoder_, 60000)); |
| |
| // Create encoder memory, try with different bitrates. |
| EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 1)); |
| EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2)); |
| EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_mono_encoder_, 30000)); |
| EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_stereo_encoder_, 60000)); |
| EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_mono_encoder_, 300000)); |
| EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_stereo_encoder_, 600000)); |
| |
| // Free memory. |
| EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_mono_encoder_)); |
| EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_)); |
| } |
| |
| TEST_F(OpusTest, OpusSetComplexity) { |
| // Test without creating encoder memory. |
| EXPECT_EQ(-1, WebRtcOpus_SetComplexity(opus_mono_encoder_, 9)); |
| EXPECT_EQ(-1, WebRtcOpus_SetComplexity(opus_stereo_encoder_, 9)); |
| |
| // Create encoder memory, try with different complexities. |
| EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 1)); |
| EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2)); |
| |
| EXPECT_EQ(0, WebRtcOpus_SetComplexity(opus_mono_encoder_, 0)); |
| EXPECT_EQ(0, WebRtcOpus_SetComplexity(opus_stereo_encoder_, 0)); |
| EXPECT_EQ(0, WebRtcOpus_SetComplexity(opus_mono_encoder_, 10)); |
| EXPECT_EQ(0, WebRtcOpus_SetComplexity(opus_stereo_encoder_, 10)); |
| EXPECT_EQ(-1, WebRtcOpus_SetComplexity(opus_mono_encoder_, 11)); |
| EXPECT_EQ(-1, WebRtcOpus_SetComplexity(opus_stereo_encoder_, 11)); |
| |
| // Free memory. |
| EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_mono_encoder_)); |
| EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_)); |
| } |
| |
| // Encode and decode one frame (stereo), initialize the decoder and |
| // decode once more. |
| TEST_F(OpusTest, OpusDecodeInit) { |
| PrepareSpeechData(2, 20, 20); |
| |
| // Create encoder memory. |
| EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2)); |
| EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_stereo_decoder_, 2)); |
| |
| // Encode & decode. |
| int16_t audio_type; |
| int16_t output_data_decode[kOpus20msFrameSamples * 2]; |
| EXPECT_EQ(kOpus20msFrameSamples, |
| EncodeDecode(opus_stereo_encoder_, speech_data_.GetNextBlock(), |
| kOpus20msFrameSamples, opus_stereo_decoder_, |
| output_data_decode, &audio_type)); |
| |
| EXPECT_EQ(0, WebRtcOpus_DecoderInit(opus_stereo_decoder_)); |
| |
| EXPECT_EQ(kOpus20msFrameSamples, |
| WebRtcOpus_Decode(opus_stereo_decoder_, bitstream_, |
| encoded_bytes_, output_data_decode, |
| &audio_type)); |
| |
| // Free memory. |
| EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_)); |
| EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_stereo_decoder_)); |
| } |
| |
| TEST_F(OpusTest, OpusEnableDisableFec) { |
| // Test without creating encoder memory. |
| EXPECT_EQ(-1, WebRtcOpus_EnableFec(opus_mono_encoder_)); |
| EXPECT_EQ(-1, WebRtcOpus_DisableFec(opus_stereo_encoder_)); |
| |
| // Create encoder memory, try with different bitrates. |
| EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 1)); |
| EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2)); |
| |
| EXPECT_EQ(0, WebRtcOpus_EnableFec(opus_mono_encoder_)); |
| EXPECT_EQ(0, WebRtcOpus_EnableFec(opus_stereo_encoder_)); |
| EXPECT_EQ(0, WebRtcOpus_DisableFec(opus_mono_encoder_)); |
| EXPECT_EQ(0, WebRtcOpus_DisableFec(opus_stereo_encoder_)); |
| |
| // Free memory. |
| EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_mono_encoder_)); |
| EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_)); |
| } |
| |
| TEST_F(OpusTest, OpusEnableDisableDtx) { |
| // Test without creating encoder memory. |
| EXPECT_EQ(-1, WebRtcOpus_EnableDtx(opus_mono_encoder_)); |
| EXPECT_EQ(-1, WebRtcOpus_DisableDtx(opus_stereo_encoder_)); |
| |
| // Create encoder memory, try with different bitrates. |
| EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 1)); |
| EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2)); |
| |
| opus_int32 dtx; |
| |
| // DTX is off by default. |
| opus_encoder_ctl(opus_mono_encoder_->encoder, |
| OPUS_GET_DTX(&dtx)); |
| EXPECT_EQ(0, dtx); |
| |
| opus_encoder_ctl(opus_stereo_encoder_->encoder, |
| OPUS_GET_DTX(&dtx)); |
| EXPECT_EQ(0, dtx); |
| |
| // Test to enable DTX. |
| EXPECT_EQ(0, WebRtcOpus_EnableDtx(opus_mono_encoder_)); |
| opus_encoder_ctl(opus_mono_encoder_->encoder, |
| OPUS_GET_DTX(&dtx)); |
| EXPECT_EQ(1, dtx); |
| |
| EXPECT_EQ(0, WebRtcOpus_EnableDtx(opus_stereo_encoder_)); |
| opus_encoder_ctl(opus_stereo_encoder_->encoder, |
| OPUS_GET_DTX(&dtx)); |
| EXPECT_EQ(1, dtx); |
| |
| // Test to disable DTX. |
| EXPECT_EQ(0, WebRtcOpus_DisableDtx(opus_mono_encoder_)); |
| opus_encoder_ctl(opus_mono_encoder_->encoder, |
| OPUS_GET_DTX(&dtx)); |
| EXPECT_EQ(0, dtx); |
| |
| EXPECT_EQ(0, WebRtcOpus_DisableDtx(opus_stereo_encoder_)); |
| opus_encoder_ctl(opus_stereo_encoder_->encoder, |
| OPUS_GET_DTX(&dtx)); |
| EXPECT_EQ(0, dtx); |
| |
| // Free memory. |
| EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_mono_encoder_)); |
| EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_)); |
| } |
| |
| TEST_F(OpusTest, OpusDtxOff) { |
| TestDtxEffect(false); |
| } |
| |
| TEST_F(OpusTest, OpusDtxOn) { |
| TestDtxEffect(true); |
| } |
| |
| TEST_F(OpusTest, OpusSetPacketLossRate) { |
| // Test without creating encoder memory. |
| EXPECT_EQ(-1, WebRtcOpus_SetPacketLossRate(opus_mono_encoder_, 50)); |
| EXPECT_EQ(-1, WebRtcOpus_SetPacketLossRate(opus_stereo_encoder_, 50)); |
| |
| // Create encoder memory, try with different bitrates. |
| EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 1)); |
| EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2)); |
| |
| EXPECT_EQ(0, WebRtcOpus_SetPacketLossRate(opus_mono_encoder_, 50)); |
| EXPECT_EQ(0, WebRtcOpus_SetPacketLossRate(opus_stereo_encoder_, 50)); |
| EXPECT_EQ(-1, WebRtcOpus_SetPacketLossRate(opus_mono_encoder_, -1)); |
| EXPECT_EQ(-1, WebRtcOpus_SetPacketLossRate(opus_stereo_encoder_, -1)); |
| EXPECT_EQ(-1, WebRtcOpus_SetPacketLossRate(opus_mono_encoder_, 101)); |
| EXPECT_EQ(-1, WebRtcOpus_SetPacketLossRate(opus_stereo_encoder_, 101)); |
| |
| // Free memory. |
| EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_mono_encoder_)); |
| EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_)); |
| } |
| |
| TEST_F(OpusTest, OpusSetMaxPlaybackRate) { |
| // Test without creating encoder memory. |
| EXPECT_EQ(-1, WebRtcOpus_SetMaxPlaybackRate(opus_mono_encoder_, 20000)); |
| EXPECT_EQ(-1, WebRtcOpus_SetMaxPlaybackRate(opus_stereo_encoder_, 20000)); |
| |
| // Create encoder memory, try with different bitrates. |
| EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 1)); |
| EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2)); |
| |
| TestSetMaxPlaybackRate(OPUS_BANDWIDTH_FULLBAND, 48000); |
| TestSetMaxPlaybackRate(OPUS_BANDWIDTH_FULLBAND, 24001); |
| TestSetMaxPlaybackRate(OPUS_BANDWIDTH_SUPERWIDEBAND, 24000); |
| TestSetMaxPlaybackRate(OPUS_BANDWIDTH_SUPERWIDEBAND, 16001); |
| TestSetMaxPlaybackRate(OPUS_BANDWIDTH_WIDEBAND, 16000); |
| TestSetMaxPlaybackRate(OPUS_BANDWIDTH_WIDEBAND, 12001); |
| TestSetMaxPlaybackRate(OPUS_BANDWIDTH_MEDIUMBAND, 12000); |
| TestSetMaxPlaybackRate(OPUS_BANDWIDTH_MEDIUMBAND, 8001); |
| TestSetMaxPlaybackRate(OPUS_BANDWIDTH_NARROWBAND, 8000); |
| TestSetMaxPlaybackRate(OPUS_BANDWIDTH_NARROWBAND, 4000); |
| |
| // Free memory. |
| EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_mono_encoder_)); |
| EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_)); |
| } |
| |
| // PLC in mono mode. |
| TEST_F(OpusTest, OpusDecodePlcMono) { |
| PrepareSpeechData(1, 20, 20); |
| |
| // Create encoder memory. |
| EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_mono_encoder_, 1)); |
| EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_mono_decoder_, 1)); |
| |
| // Set bitrate. |
| EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_mono_encoder_, 32000)); |
| |
| // Check number of channels for decoder. |
| EXPECT_EQ(1, WebRtcOpus_DecoderChannels(opus_mono_decoder_)); |
| |
| // Encode & decode. |
| int16_t audio_type; |
| int16_t output_data_decode[kOpus20msFrameSamples]; |
| EXPECT_EQ(kOpus20msFrameSamples, |
| EncodeDecode(opus_mono_encoder_, speech_data_.GetNextBlock(), |
| kOpus20msFrameSamples, opus_mono_decoder_, |
| output_data_decode, &audio_type)); |
| |
| // Call decoder PLC. |
| int16_t plc_buffer[kOpus20msFrameSamples]; |
| EXPECT_EQ(kOpus20msFrameSamples, |
| WebRtcOpus_DecodePlc(opus_mono_decoder_, plc_buffer, 1)); |
| |
| // Free memory. |
| EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_mono_encoder_)); |
| EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_mono_decoder_)); |
| } |
| |
| // PLC in stereo mode. |
| TEST_F(OpusTest, OpusDecodePlcStereo) { |
| PrepareSpeechData(2, 20, 20); |
| |
| // Create encoder memory. |
| EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2)); |
| EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_stereo_decoder_, 2)); |
| |
| // Set bitrate. |
| EXPECT_EQ(0, WebRtcOpus_SetBitRate(opus_stereo_encoder_, 64000)); |
| |
| // Check number of channels for decoder. |
| EXPECT_EQ(2, WebRtcOpus_DecoderChannels(opus_stereo_decoder_)); |
| |
| // Encode & decode. |
| int16_t audio_type; |
| int16_t output_data_decode[kOpus20msFrameSamples * 2]; |
| EXPECT_EQ(kOpus20msFrameSamples, |
| EncodeDecode(opus_stereo_encoder_, speech_data_.GetNextBlock(), |
| kOpus20msFrameSamples, opus_stereo_decoder_, |
| output_data_decode, &audio_type)); |
| |
| // Call decoder PLC. |
| int16_t plc_buffer[kOpus20msFrameSamples * 2]; |
| EXPECT_EQ(kOpus20msFrameSamples, |
| WebRtcOpus_DecodePlc(opus_stereo_decoder_, plc_buffer, 1)); |
| |
| // Free memory. |
| EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_)); |
| EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_stereo_decoder_)); |
| } |
| |
| // Duration estimation. |
| TEST_F(OpusTest, OpusDurationEstimation) { |
| PrepareSpeechData(2, 20, 20); |
| |
| // Create. |
| EXPECT_EQ(0, WebRtcOpus_EncoderCreate(&opus_stereo_encoder_, 2)); |
| EXPECT_EQ(0, WebRtcOpus_DecoderCreate(&opus_stereo_decoder_, 2)); |
| |
| // 10 ms. We use only first 10 ms of a 20 ms block. |
| encoded_bytes_ = WebRtcOpus_Encode(opus_stereo_encoder_, |
| speech_data_.GetNextBlock(), |
| kOpus10msFrameSamples, kMaxBytes, |
| bitstream_); |
| EXPECT_EQ(kOpus10msFrameSamples, |
| WebRtcOpus_DurationEst(opus_stereo_decoder_, bitstream_, |
| encoded_bytes_)); |
| |
| // 20 ms |
| encoded_bytes_ = WebRtcOpus_Encode(opus_stereo_encoder_, |
| speech_data_.GetNextBlock(), |
| kOpus20msFrameSamples, kMaxBytes, |
| bitstream_); |
| EXPECT_EQ(kOpus20msFrameSamples, |
| WebRtcOpus_DurationEst(opus_stereo_decoder_, bitstream_, |
| encoded_bytes_)); |
| |
| // Free memory. |
| EXPECT_EQ(0, WebRtcOpus_EncoderFree(opus_stereo_encoder_)); |
| EXPECT_EQ(0, WebRtcOpus_DecoderFree(opus_stereo_decoder_)); |
| } |
| |
| } // namespace webrtc |