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

Delete left-over tests NetEqExternalDecoderUnitTest

Browse Source 
Related code was deleted in
https://webrtc-review.googlesource.com/c/112081.

Bug: webrtc:10080
Change-Id: I3adc1238df6e80380cae3403c108403a59fd4a05
Reviewed-on: https://webrtc-review.googlesource.com/c/src/+/135740
Reviewed-by: Ivo Creusen <ivoc@webrtc.org>
Commit-Queue: Niels Moller <nisse@webrtc.org>
Cr-Commit-Position: refs/heads/master@{#27890}
This commit is contained in:
Niels Möller
2019-05-09 09:09:48 +02:00
committed by Commit Bot
parent d61f2a726e
commit 035ee11f78
1 changed files with 0 additions and 451 deletions
Download Patch File Download Diff File Expand all files Collapse all files

451
modules/audio_coding/neteq/neteq_external_decoder_unittest.cc
View File

@ -1,451 +0,0 @@
/*
* 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.
*/
// Test to verify correct operation for externally created decoders.
#include <memory>
#include "api/audio/audio_frame.h"
#include "api/audio_codecs/builtin_audio_decoder_factory.h"
#include "modules/audio_coding/neteq/mock/mock_external_decoder_pcm16b.h"
#include "modules/audio_coding/neteq/tools/input_audio_file.h"
#include "modules/audio_coding/neteq/tools/neteq_external_decoder_test.h"
#include "modules/audio_coding/neteq/tools/rtp_generator.h"
#include "rtc_base/strings/string_builder.h"
#include "test/gmock.h"
#include "test/testsupport/file_utils.h"
namespace webrtc {
using ::testing::_;
using ::testing::Return;
class NetEqExternalDecoderUnitTest : public test::NetEqExternalDecoderTest {
protected:
static const int kFrameSizeMs = 10; // Frame size of Pcm16B.
NetEqExternalDecoderUnitTest(NetEqDecoder codec,
int sample_rate_hz,
MockExternalPcm16B* decoder)
: NetEqExternalDecoderTest(codec, sample_rate_hz, decoder),
external_decoder_(decoder),
samples_per_ms_(sample_rate_hz / 1000),
frame_size_samples_(kFrameSizeMs * samples_per_ms_),
rtp_generator_(new test::RtpGenerator(samples_per_ms_)),
input_(new int16_t[frame_size_samples_]),
// Payload should be no larger than input.
encoded_(new uint8_t[2 * frame_size_samples_]),
payload_size_bytes_(0),
last_send_time_(0),
last_arrival_time_(0) {
// NetEq is not allowed to delete the external decoder (hence Times(0)).
EXPECT_CALL(*external_decoder_, Die()).Times(0);
Init();
const std::string file_name =
webrtc::test::ResourcePath("audio_coding/testfile32kHz", "pcm");
input_file_.reset(new test::InputAudioFile(file_name));
}
virtual ~NetEqExternalDecoderUnitTest() {
delete[] input_;
delete[] encoded_;
// ~NetEqExternalDecoderTest() will delete |external_decoder_|, so expecting
// Die() to be called.
EXPECT_CALL(*external_decoder_, Die()).Times(1);
}
// Method to draw kFrameSizeMs audio and verify the output.
// Use gTest methods. e.g. ASSERT_EQ() inside to trigger errors.
virtual void GetAndVerifyOutput() = 0;
// Method to get the number of calls to the Decode() method of the external
// decoder.
virtual int NumExpectedDecodeCalls(int num_loops) = 0;
// Method to generate packets and return the send time of the packet.
int GetNewPacket() {
if (!input_file_->Read(frame_size_samples_, input_)) {
return -1;
}
payload_size_bytes_ =
WebRtcPcm16b_Encode(input_, frame_size_samples_, encoded_);
int next_send_time = rtp_generator_->GetRtpHeader(
kPayloadType, frame_size_samples_, &rtp_header_);
return next_send_time;
}
// Method to decide packet losses.
virtual bool Lost() { return false; }
// Method to calculate packet arrival time.
int GetArrivalTime(int send_time) {
int arrival_time = last_arrival_time_ + (send_time - last_send_time_);
last_send_time_ = send_time;
last_arrival_time_ = arrival_time;
return arrival_time;
}
void RunTest(int num_loops) {
// Get next input packets (mono and multi-channel).
uint32_t next_send_time;
uint32_t next_arrival_time;
do {
next_send_time = GetNewPacket();
next_arrival_time = GetArrivalTime(next_send_time);
} while (Lost()); // If lost, immediately read the next packet.
EXPECT_CALL(
*external_decoder_,
DecodeInternal(_, payload_size_bytes_, 1000 * samples_per_ms_, _, _))
.Times(NumExpectedDecodeCalls(num_loops));
uint32_t time_now = 0;
for (int k = 0; k < num_loops; ++k) {
while (time_now >= next_arrival_time) {
InsertPacket(
rtp_header_,
rtc::ArrayView<const uint8_t>(encoded_, payload_size_bytes_),
next_arrival_time);
// Get next input packet.
do {
next_send_time = GetNewPacket();
next_arrival_time = GetArrivalTime(next_send_time);
} while (Lost()); // If lost, immediately read the next packet.
}
rtc::StringBuilder ss;
ss << "Lap number " << k << ".";
SCOPED_TRACE(ss.str()); // Print out the parameter values on failure.
// Compare mono and multi-channel.
ASSERT_NO_FATAL_FAILURE(GetAndVerifyOutput());
time_now += kOutputLengthMs;
}
}
void InsertPacket(RTPHeader rtp_header,
rtc::ArrayView<const uint8_t> payload,
uint32_t receive_timestamp) override {
EXPECT_CALL(*external_decoder_,
IncomingPacket(_, payload.size(), rtp_header.sequenceNumber,
rtp_header.timestamp, receive_timestamp));
NetEqExternalDecoderTest::InsertPacket(rtp_header, payload,
receive_timestamp);
}
MockExternalPcm16B* external_decoder() { return external_decoder_.get(); }
void ResetRtpGenerator(test::RtpGenerator* rtp_generator) {
rtp_generator_.reset(rtp_generator);
}
int samples_per_ms() const { return samples_per_ms_; }
private:
std::unique_ptr<MockExternalPcm16B> external_decoder_;
int samples_per_ms_;
size_t frame_size_samples_;
std::unique_ptr<test::RtpGenerator> rtp_generator_;
int16_t* input_;
uint8_t* encoded_;
size_t payload_size_bytes_;
uint32_t last_send_time_;
uint32_t last_arrival_time_;
std::unique_ptr<test::InputAudioFile> input_file_;
RTPHeader rtp_header_;
};
// This test encodes a few packets of PCM16b 32 kHz data and inserts it into two
// different NetEq instances. The first instance uses the internal version of
// the decoder object, while the second one uses an externally created decoder
// object (ExternalPcm16B wrapped in MockExternalPcm16B, both defined above).
// The test verifies that the output from both instances match.
class NetEqExternalVsInternalDecoderTest : public NetEqExternalDecoderUnitTest,
public ::testing::Test {
protected:
static const size_t kMaxBlockSize = 480; // 10 ms @ 48 kHz.
NetEqExternalVsInternalDecoderTest()
: NetEqExternalDecoderUnitTest(NetEqDecoder::kDecoderPCM16Bswb32kHz,
32000,
new MockExternalPcm16B(32000)),
sample_rate_hz_(32000) {
NetEq::Config config;
config.sample_rate_hz = sample_rate_hz_;
neteq_internal_.reset(
NetEq::Create(config, CreateBuiltinAudioDecoderFactory()));
}
void SetUp() override {
ASSERT_EQ(true, neteq_internal_->RegisterPayloadType(
kPayloadType, SdpAudioFormat("L16", 32000, 1)));
}
void GetAndVerifyOutput() override {
// Get audio from internal decoder instance.
bool muted;
EXPECT_EQ(NetEq::kOK, neteq_internal_->GetAudio(&output_internal_, &muted));
ASSERT_FALSE(muted);
EXPECT_EQ(1u, output_internal_.num_channels_);
EXPECT_EQ(static_cast<size_t>(kOutputLengthMs * sample_rate_hz_ / 1000),
output_internal_.samples_per_channel_);
// Get audio from external decoder instance.
GetOutputAudio(&output_);
const int16_t* output_data = output_.data();
const int16_t* output_internal_data = output_internal_.data();
for (size_t i = 0; i < output_.samples_per_channel_; ++i) {
ASSERT_EQ(output_data[i], output_internal_data[i])
<< "Diff in sample " << i << ".";
}
}
void InsertPacket(RTPHeader rtp_header,
rtc::ArrayView<const uint8_t> payload,
uint32_t receive_timestamp) override {
// Insert packet in internal decoder.
ASSERT_EQ(NetEq::kOK, neteq_internal_->InsertPacket(rtp_header, payload,
receive_timestamp));
// Insert packet in external decoder instance.
NetEqExternalDecoderUnitTest::InsertPacket(rtp_header, payload,
receive_timestamp);
}
int NumExpectedDecodeCalls(int num_loops) override { return num_loops; }
private:
int sample_rate_hz_;
std::unique_ptr<NetEq> neteq_internal_;
AudioFrame output_internal_;
AudioFrame output_;
};
TEST_F(NetEqExternalVsInternalDecoderTest, RunTest) {
RunTest(100); // Run 100 laps @ 10 ms each in the test loop.
}
class LargeTimestampJumpTest : public NetEqExternalDecoderUnitTest,
public ::testing::Test {
protected:
static const size_t kMaxBlockSize = 480; // 10 ms @ 48 kHz.
enum TestStates {
kInitialPhase,
kNormalPhase,
kExpandPhase,
kFadedExpandPhase,
kRecovered
};
LargeTimestampJumpTest()
: NetEqExternalDecoderUnitTest(NetEqDecoder::kDecoderPCM16B,
8000,
new MockExternalPcm16B(8000)),
test_state_(kInitialPhase) {
EXPECT_CALL(*external_decoder(), HasDecodePlc())
.WillRepeatedly(Return(false));
}
virtual void UpdateState(AudioFrame::SpeechType output_type) {
switch (test_state_) {
case kInitialPhase: {
if (output_type == AudioFrame::kNormalSpeech) {
test_state_ = kNormalPhase;
}
break;
}
case kNormalPhase: {
if (output_type == AudioFrame::kPLC) {
test_state_ = kExpandPhase;
}
break;
}
case kExpandPhase: {
if (output_type == AudioFrame::kPLCCNG) {
test_state_ = kFadedExpandPhase;
} else if (output_type == AudioFrame::kNormalSpeech) {
test_state_ = kRecovered;
}
break;
}
case kFadedExpandPhase: {
if (output_type == AudioFrame::kNormalSpeech) {
test_state_ = kRecovered;
}
break;
}
case kRecovered: {
break;
}
}
}
void GetAndVerifyOutput() override {
AudioFrame output;
GetOutputAudio(&output);
UpdateState(output.speech_type_);
if (test_state_ == kExpandPhase || test_state_ == kFadedExpandPhase) {
// Don't verify the output in this phase of the test.
return;
}
ASSERT_EQ(1u, output.num_channels_);
const int16_t* output_data = output.data();
for (size_t i = 0; i < output.samples_per_channel_; ++i) {
if (output_data[i] != 0)
return;
}
EXPECT_TRUE(false)
<< "Expected at least one non-zero sample in each output block.";
}
int NumExpectedDecodeCalls(int num_loops) override {
// Some packets at the end of the stream won't be decoded. When the jump in
// timestamp happens, NetEq will do Expand during one GetAudio call. In the
// next call it will decode the packet after the jump, but the net result is
// that the delay increased by 1 packet. In another call, a Pre-emptive
// Expand operation is performed, leading to delay increase by 1 packet. In
// total, the test will end with a 2-packet delay, which results in the 2
// last packets not being decoded.
return num_loops - 2;
}
TestStates test_state_;
};
TEST_F(LargeTimestampJumpTest, JumpLongerThanHalfRange) {
// Set the timestamp series to start at 2880, increase to 7200, then jump to
// 2869342376. The sequence numbers start at 42076 and increase by 1 for each
// packet, also when the timestamp jumps.
static const uint16_t kStartSeqeunceNumber = 42076;
static const uint32_t kStartTimestamp = 2880;
static const uint32_t kJumpFromTimestamp = 7200;
static const uint32_t kJumpToTimestamp = 2869342376;
static_assert(kJumpFromTimestamp < kJumpToTimestamp,
"timestamp jump should not result in wrap");
static_assert(
static_cast<uint32_t>(kJumpToTimestamp - kJumpFromTimestamp) > 0x7FFFFFFF,
"jump should be larger than half range");
// Replace the default RTP generator with one that jumps in timestamp.
ResetRtpGenerator(new test::TimestampJumpRtpGenerator(
samples_per_ms(), kStartSeqeunceNumber, kStartTimestamp,
kJumpFromTimestamp, kJumpToTimestamp));
RunTest(130); // Run 130 laps @ 10 ms each in the test loop.
EXPECT_EQ(kRecovered, test_state_);
}
TEST_F(LargeTimestampJumpTest, JumpLongerThanHalfRangeAndWrap) {
// Make a jump larger than half the 32-bit timestamp range. Set the start
// timestamp such that the jump will result in a wrap around.
static const uint16_t kStartSeqeunceNumber = 42076;
// Set the jump length slightly larger than 2^31.
static const uint32_t kStartTimestamp = 3221223116;
static const uint32_t kJumpFromTimestamp = 3221223216;
static const uint32_t kJumpToTimestamp = 1073744278;
static_assert(kJumpToTimestamp < kJumpFromTimestamp,
"timestamp jump should result in wrap");
static_assert(
static_cast<uint32_t>(kJumpToTimestamp - kJumpFromTimestamp) > 0x7FFFFFFF,
"jump should be larger than half range");
// Replace the default RTP generator with one that jumps in timestamp.
ResetRtpGenerator(new test::TimestampJumpRtpGenerator(
samples_per_ms(), kStartSeqeunceNumber, kStartTimestamp,
kJumpFromTimestamp, kJumpToTimestamp));
RunTest(130); // Run 130 laps @ 10 ms each in the test loop.
EXPECT_EQ(kRecovered, test_state_);
}
class ShortTimestampJumpTest : public LargeTimestampJumpTest {
protected:
void UpdateState(AudioFrame::SpeechType output_type) override {
switch (test_state_) {
case kInitialPhase: {
if (output_type == AudioFrame::kNormalSpeech) {
test_state_ = kNormalPhase;
}
break;
}
case kNormalPhase: {
if (output_type == AudioFrame::kPLC) {
test_state_ = kExpandPhase;
}
break;
}
case kExpandPhase: {
if (output_type == AudioFrame::kNormalSpeech) {
test_state_ = kRecovered;
}
break;
}
case kRecovered: {
break;
}
default: { FAIL(); }
}
}
int NumExpectedDecodeCalls(int num_loops) override {
// Some packets won't be decoded because of the timestamp jump.
return num_loops - 2;
}
};
TEST_F(ShortTimestampJumpTest, JumpShorterThanHalfRange) {
// Make a jump shorter than half the 32-bit timestamp range. Set the start
// timestamp such that the jump will not result in a wrap around.
static const uint16_t kStartSeqeunceNumber = 42076;
// Set the jump length slightly smaller than 2^31.
static const uint32_t kStartTimestamp = 4711;
static const uint32_t kJumpFromTimestamp = 4811;
static const uint32_t kJumpToTimestamp = 2147483747;
static_assert(kJumpFromTimestamp < kJumpToTimestamp,
"timestamp jump should not result in wrap");
static_assert(
static_cast<uint32_t>(kJumpToTimestamp - kJumpFromTimestamp) < 0x7FFFFFFF,
"jump should be smaller than half range");
// Replace the default RTP generator with one that jumps in timestamp.
ResetRtpGenerator(new test::TimestampJumpRtpGenerator(
samples_per_ms(), kStartSeqeunceNumber, kStartTimestamp,
kJumpFromTimestamp, kJumpToTimestamp));
RunTest(130); // Run 130 laps @ 10 ms each in the test loop.
EXPECT_EQ(kRecovered, test_state_);
}
TEST_F(ShortTimestampJumpTest, JumpShorterThanHalfRangeAndWrap) {
// Make a jump shorter than half the 32-bit timestamp range. Set the start
// timestamp such that the jump will result in a wrap around.
static const uint16_t kStartSeqeunceNumber = 42076;
// Set the jump length slightly smaller than 2^31.
static const uint32_t kStartTimestamp = 3221227827;
static const uint32_t kJumpFromTimestamp = 3221227927;
static const uint32_t kJumpToTimestamp = 1073739567;
static_assert(kJumpToTimestamp < kJumpFromTimestamp,
"timestamp jump should result in wrap");
static_assert(
static_cast<uint32_t>(kJumpToTimestamp - kJumpFromTimestamp) < 0x7FFFFFFF,
"jump should be smaller than half range");
// Replace the default RTP generator with one that jumps in timestamp.
ResetRtpGenerator(new test::TimestampJumpRtpGenerator(
samples_per_ms(), kStartSeqeunceNumber, kStartTimestamp,
kJumpFromTimestamp, kJumpToTimestamp));
RunTest(130); // Run 130 laps @ 10 ms each in the test loop.
EXPECT_EQ(kRecovered, test_state_);
}
} // namespace webrtc