admin/webrtc_m130
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Remove old WebRTC-NewVideoJitterBuffer used for testing the NackModule.

Browse Source 
This experiment was used to test the NackModule but will soon (tm) be used to
test the completly new video jitter buffer.

BUG=webrtc:5514
R=stefan@webrtc.org

Review URL: https://codereview.webrtc.org/2123913002 .

Cr-Commit-Position: refs/heads/master@{#13395}
This commit is contained in:
philipel 2016-07-06 16:10:31 +02:00
parent 262ba77d78
commit 8513029e1f
6 changed files with 61 additions and 176 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

48
webrtc/modules/video_coding/jitter_buffer.cc
View File

@ -215,20 +215,6 @@ void Vp9SsMap::UpdateFrames(FrameList* frames) {
}
}
static NackModule*
MaybeCreateNackModule(Clock* clock,
NackSender* nack_sender,
KeyFrameRequestSender* keyframe_request_sender) {
if (field_trial::FindFullName("WebRTC-NewVideoJitterBuffer") == "Enabled") {
// Only create a nack module if a nack sender is available.
if (nack_sender) {
RTC_DCHECK(keyframe_request_sender);
return new NackModule(clock, nack_sender, keyframe_request_sender);
}
}
return nullptr;
}
VCMJitterBuffer::VCMJitterBuffer(Clock* clock,
std::unique_ptr<EventWrapper> event,
NackSender* nack_sender,
@ -266,10 +252,7 @@ VCMJitterBuffer::VCMJitterBuffer(Clock* clock,
max_incomplete_time_ms_(0),
decode_error_mode_(kNoErrors),
average_packets_per_frame_(0.0f),
frame_counter_(0),
nack_module_(MaybeCreateNackModule(clock,
nack_sender,
keyframe_request_sender)) {
frame_counter_(0) {
for (int i = 0; i < kStartNumberOfFrames; i++)
free_frames_.push_back(new VCMFrameBuffer());
}
@ -349,8 +332,6 @@ void VCMJitterBuffer::Stop() {
UpdateHistograms();
running_ = false;
last_decoded_state_.Reset();
if (nack_module_)
nack_module_->Stop();
// Make sure all frames are free and reset.
for (FrameList::iterator it = decodable_frames_.begin();
@ -391,8 +372,6 @@ void VCMJitterBuffer::Flush() {
waiting_for_completion_.latest_packet_time = -1;
first_packet_since_reset_ = true;
missing_sequence_numbers_.clear();
if (nack_module_)
nack_module_->Clear();
}
// Get received key and delta frames
@ -609,8 +588,6 @@ VCMEncodedFrame* VCMJitterBuffer::ExtractAndSetDecode(uint32_t timestamp) {
if ((*frame).IsSessionComplete())
UpdateAveragePacketsPerFrame(frame->NumPackets());
if (nack_module_)
nack_module_->ClearUpTo(frame->GetHighSeqNum());
return frame;
}
@ -671,9 +648,6 @@ VCMFrameBufferEnum VCMJitterBuffer::InsertPacket(const VCMPacket& packet,
bool* retransmitted) {
CriticalSectionScoped cs(crit_sect_);
if (nack_module_)
nack_module_->OnReceivedPacket(packet);
++num_packets_;
if (num_packets_ == 1) {
time_first_packet_ms_ = clock_->TimeInMilliseconds();
@ -936,8 +910,6 @@ void VCMJitterBuffer::UpdateRtt(int64_t rtt_ms) {
CriticalSectionScoped cs(crit_sect_);
rtt_ms_ = rtt_ms;
jitter_estimate_.UpdateRtt(rtt_ms);
if (nack_module_)
nack_module_->UpdateRtt(rtt_ms);
if (!WaitForRetransmissions())
jitter_estimate_.ResetNackCount();
}
@ -1059,14 +1031,6 @@ std::vector<uint16_t> VCMJitterBuffer::GetNackList(bool* request_key_frame) {
}
}
}
// The experiment is running, the nack module will send Nacks.
// The reason we allow the major part of the GetNackList function to
// run even if we are running the experiment is because this
// function is also used to signal that the jitter buffer wants to
// request a keyframe.
if (nack_module_)
return std::vector<uint16_t>();
std::vector<uint16_t> nack_list(missing_sequence_numbers_.begin(),
missing_sequence_numbers_.end());
return nack_list;
@ -1351,14 +1315,4 @@ bool VCMJitterBuffer::WaitForRetransmissions() {
return true;
}
int64_t VCMJitterBuffer::TimeUntilNextProcess() {
if (nack_module_)
return nack_module_->TimeUntilNextProcess();
return std::numeric_limits<int64_t>::max();
}
void VCMJitterBuffer::Process() {
if (nack_module_)
nack_module_->Process();
}
} // namespace webrtc

5
webrtc/modules/video_coding/jitter_buffer.h
View File

@ -202,9 +202,6 @@ class VCMJitterBuffer {
void RegisterStatsCallback(VCMReceiveStatisticsCallback* callback);
int64_t TimeUntilNextProcess();
void Process();
private:
class SequenceNumberLessThan {
public:
@ -376,8 +373,6 @@ class VCMJitterBuffer {
// frames.
int frame_counter_;
std::unique_ptr<NackModule> nack_module_;
RTC_DISALLOW_COPY_AND_ASSIGN(VCMJitterBuffer);
};
} // namespace webrtc

167
webrtc/modules/video_coding/jitter_buffer_unittest.cc
View File

@ -218,7 +218,7 @@ class TestBasicJitterBuffer : public ::testing::TestWithParam<std::string>,
int keyframe_requests_;
protected:
TestBasicJitterBuffer() : scoped_field_trial_(GetParam()) {}
TestBasicJitterBuffer() {}
void SetUp() override {
clock_.reset(new SimulatedClock(0));
jitter_buffer_.reset(new VCMJitterBuffer(
@ -316,15 +316,8 @@ class TestBasicJitterBuffer : public ::testing::TestWithParam<std::string>,
std::unique_ptr<SimulatedClock> clock_;
NullEventFactory event_factory_;
std::unique_ptr<VCMJitterBuffer> jitter_buffer_;
test::ScopedFieldTrials scoped_field_trial_;
};
INSTANTIATE_TEST_CASE_P(
TestWithNackModule,
TestBasicJitterBuffer,
::testing::Values("WebRTC-NewVideoJitterBuffer/Enabled/",
"WebRTC-NewVideoJitterBuffer/Disabled/"));
class TestRunningJitterBuffer : public ::testing::TestWithParam<std::string>,
public NackSender,
public KeyFrameRequestSender {
@ -450,24 +443,16 @@ class TestRunningJitterBuffer : public ::testing::TestWithParam<std::string>,
class TestJitterBufferNack : public TestRunningJitterBuffer {
protected:
TestJitterBufferNack() : scoped_field_trial_(GetParam()) {}
TestJitterBufferNack() {}
virtual void SetUp() {
TestRunningJitterBuffer::SetUp();
jitter_buffer_->SetNackMode(kNack, -1, -1);
}
virtual void TearDown() { TestRunningJitterBuffer::TearDown(); }
test::ScopedFieldTrials scoped_field_trial_;
};
INSTANTIATE_TEST_CASE_P(
TestWithNackModule,
TestJitterBufferNack,
::testing::Values("WebRTC-NewVideoJitterBuffer/Enabled/",
"WebRTC-NewVideoJitterBuffer/Disabled/"));
TEST_P(TestBasicJitterBuffer, StopRunning) {
TEST_F(TestBasicJitterBuffer, StopRunning) {
jitter_buffer_->Stop();
EXPECT_TRUE(NULL == DecodeCompleteFrame());
EXPECT_TRUE(NULL == DecodeIncompleteFrame());
@ -487,7 +472,7 @@ TEST_P(TestBasicJitterBuffer, StopRunning) {
EXPECT_TRUE(NULL == DecodeIncompleteFrame());
}
TEST_P(TestBasicJitterBuffer, SinglePacketFrame) {
TEST_F(TestBasicJitterBuffer, SinglePacketFrame) {
// Always start with a complete key frame when not allowing errors.
jitter_buffer_->SetDecodeErrorMode(kNoErrors);
packet_->frameType = kVideoFrameKey;
@ -505,7 +490,7 @@ TEST_P(TestBasicJitterBuffer, SinglePacketFrame) {
jitter_buffer_->ReleaseFrame(frame_out);
}
TEST_P(TestBasicJitterBuffer, VerifyHistogramStats) {
TEST_F(TestBasicJitterBuffer, VerifyHistogramStats) {
metrics::Reset();
// Always start with a complete key frame when not allowing errors.
jitter_buffer_->SetDecodeErrorMode(kNoErrors);
@ -543,7 +528,7 @@ TEST_P(TestBasicJitterBuffer, VerifyHistogramStats) {
EXPECT_EQ(1, metrics::NumSamples("WebRTC.Video.KeyFramesReceivedInPermille"));
}
TEST_P(TestBasicJitterBuffer, DualPacketFrame) {
TEST_F(TestBasicJitterBuffer, DualPacketFrame) {
packet_->frameType = kVideoFrameKey;
packet_->isFirstPacket = true;
packet_->markerBit = false;
@ -570,7 +555,7 @@ TEST_P(TestBasicJitterBuffer, DualPacketFrame) {
jitter_buffer_->ReleaseFrame(frame_out);
}
TEST_P(TestBasicJitterBuffer, 100PacketKeyFrame) {
TEST_F(TestBasicJitterBuffer, 100PacketKeyFrame) {
packet_->frameType = kVideoFrameKey;
packet_->isFirstPacket = true;
packet_->markerBit = false;
@ -613,7 +598,7 @@ TEST_P(TestBasicJitterBuffer, 100PacketKeyFrame) {
jitter_buffer_->ReleaseFrame(frame_out);
}
TEST_P(TestBasicJitterBuffer, 100PacketDeltaFrame) {
TEST_F(TestBasicJitterBuffer, 100PacketDeltaFrame) {
// Always start with a complete key frame.
packet_->frameType = kVideoFrameKey;
packet_->isFirstPacket = true;
@ -669,7 +654,7 @@ TEST_P(TestBasicJitterBuffer, 100PacketDeltaFrame) {
jitter_buffer_->ReleaseFrame(frame_out);
}
TEST_P(TestBasicJitterBuffer, PacketReorderingReverseOrder) {
TEST_F(TestBasicJitterBuffer, PacketReorderingReverseOrder) {
// Insert the "first" packet last.
seq_num_ += 100;
packet_->frameType = kVideoFrameKey;
@ -716,7 +701,7 @@ TEST_P(TestBasicJitterBuffer, PacketReorderingReverseOrder) {
jitter_buffer_->ReleaseFrame(frame_out);
}
TEST_P(TestBasicJitterBuffer, FrameReordering2Frames2PacketsEach) {
TEST_F(TestBasicJitterBuffer, FrameReordering2Frames2PacketsEach) {
packet_->frameType = kVideoFrameDelta;
packet_->isFirstPacket = true;
packet_->markerBit = false;
@ -776,7 +761,7 @@ TEST_P(TestBasicJitterBuffer, FrameReordering2Frames2PacketsEach) {
jitter_buffer_->ReleaseFrame(frame_out);
}
TEST_P(TestBasicJitterBuffer, TestReorderingWithPadding) {
TEST_F(TestBasicJitterBuffer, TestReorderingWithPadding) {
packet_->frameType = kVideoFrameKey;
packet_->isFirstPacket = true;
packet_->markerBit = true;
@ -838,7 +823,7 @@ TEST_P(TestBasicJitterBuffer, TestReorderingWithPadding) {
jitter_buffer_->ReleaseFrame(frame_out);
}
TEST_P(TestBasicJitterBuffer, DuplicatePackets) {
TEST_F(TestBasicJitterBuffer, DuplicatePackets) {
packet_->frameType = kVideoFrameKey;
packet_->isFirstPacket = true;
packet_->markerBit = false;
@ -881,7 +866,7 @@ TEST_P(TestBasicJitterBuffer, DuplicatePackets) {
jitter_buffer_->ReleaseFrame(frame_out);
}
TEST_P(TestBasicJitterBuffer, DuplicatePreviousDeltaFramePacket) {
TEST_F(TestBasicJitterBuffer, DuplicatePreviousDeltaFramePacket) {
packet_->frameType = kVideoFrameKey;
packet_->isFirstPacket = true;
packet_->markerBit = true;
@ -933,7 +918,7 @@ TEST_P(TestBasicJitterBuffer, DuplicatePreviousDeltaFramePacket) {
}
}
TEST_P(TestBasicJitterBuffer, TestSkipForwardVp9) {
TEST_F(TestBasicJitterBuffer, TestSkipForwardVp9) {
// Verify that JB skips forward to next base layer frame.
// -------------------------------------------------
// | 65485 | 65486 | 65487 | 65488 | 65489 | ...
@ -986,7 +971,7 @@ TEST_P(TestBasicJitterBuffer, TestSkipForwardVp9) {
jitter_buffer_->ReleaseFrame(frame_out);
}
TEST_P(TestBasicJitterBuffer, ReorderedVp9SsData_3TlLayers) {
TEST_F(TestBasicJitterBuffer, ReorderedVp9SsData_3TlLayers) {
// Verify that frames are updated with SS data when SS packet is reordered.
// --------------------------------
// | 65486 | 65487 | 65485 |...
@ -1060,7 +1045,7 @@ TEST_P(TestBasicJitterBuffer, ReorderedVp9SsData_3TlLayers) {
jitter_buffer_->ReleaseFrame(frame_out);
}
TEST_P(TestBasicJitterBuffer, ReorderedVp9SsData_2Tl2SLayers) {
TEST_F(TestBasicJitterBuffer, ReorderedVp9SsData_2Tl2SLayers) {
// Verify that frames are updated with SS data when SS packet is reordered.
// -----------------------------------------
// | 65486 | 65487 | 65485 | 65484 |...
@ -1144,7 +1129,7 @@ TEST_P(TestBasicJitterBuffer, ReorderedVp9SsData_2Tl2SLayers) {
jitter_buffer_->ReleaseFrame(frame_out);
}
TEST_P(TestBasicJitterBuffer, H264InsertStartCode) {
TEST_F(TestBasicJitterBuffer, H264InsertStartCode) {
packet_->frameType = kVideoFrameKey;
packet_->isFirstPacket = true;
packet_->markerBit = false;
@ -1176,7 +1161,7 @@ TEST_P(TestBasicJitterBuffer, H264InsertStartCode) {
}
// Test threshold conditions of decodable state.
TEST_P(TestBasicJitterBuffer, PacketLossWithSelectiveErrorsThresholdCheck) {
TEST_F(TestBasicJitterBuffer, PacketLossWithSelectiveErrorsThresholdCheck) {
jitter_buffer_->SetDecodeErrorMode(kSelectiveErrors);
// Always start with a key frame. Use 10 packets to test Decodable State
// boundaries.
@ -1262,7 +1247,7 @@ TEST_P(TestBasicJitterBuffer, PacketLossWithSelectiveErrorsThresholdCheck) {
}
// Make sure first packet is present before a frame can be decoded.
TEST_P(TestBasicJitterBuffer, PacketLossWithSelectiveErrorsIncompleteKey) {
TEST_F(TestBasicJitterBuffer, PacketLossWithSelectiveErrorsIncompleteKey) {
jitter_buffer_->SetDecodeErrorMode(kSelectiveErrors);
// Always start with a key frame.
packet_->frameType = kVideoFrameKey;
@ -1326,7 +1311,7 @@ TEST_P(TestBasicJitterBuffer, PacketLossWithSelectiveErrorsIncompleteKey) {
}
// Make sure first packet is present before a frame can be decoded.
TEST_P(TestBasicJitterBuffer, PacketLossWithSelectiveErrorsMissingFirstPacket) {
TEST_F(TestBasicJitterBuffer, PacketLossWithSelectiveErrorsMissingFirstPacket) {
jitter_buffer_->SetDecodeErrorMode(kSelectiveErrors);
// Always start with a key frame.
packet_->frameType = kVideoFrameKey;
@ -1388,7 +1373,7 @@ TEST_P(TestBasicJitterBuffer, PacketLossWithSelectiveErrorsMissingFirstPacket) {
jitter_buffer_->ReleaseFrame(frame_out);
}
TEST_P(TestBasicJitterBuffer, DiscontinuousStreamWhenDecodingWithErrors) {
TEST_F(TestBasicJitterBuffer, DiscontinuousStreamWhenDecodingWithErrors) {
// Will use one packet per frame.
jitter_buffer_->SetDecodeErrorMode(kWithErrors);
packet_->frameType = kVideoFrameKey;
@ -1432,7 +1417,7 @@ TEST_P(TestBasicJitterBuffer, DiscontinuousStreamWhenDecodingWithErrors) {
EXPECT_EQ(packet_->timestamp - 33 * 90, next_timestamp);
}
TEST_P(TestBasicJitterBuffer, PacketLoss) {
TEST_F(TestBasicJitterBuffer, PacketLoss) {
// Verify missing packets statistics and not decodable packets statistics.
// Insert 10 frames consisting of 4 packets and remove one from all of them.
// The last packet is an empty (non-media) packet.
@ -1533,7 +1518,7 @@ TEST_P(TestBasicJitterBuffer, PacketLoss) {
EXPECT_EQ(3, jitter_buffer_->num_discarded_packets());
}
TEST_P(TestBasicJitterBuffer, DeltaFrame100PacketsWithSeqNumWrap) {
TEST_F(TestBasicJitterBuffer, DeltaFrame100PacketsWithSeqNumWrap) {
seq_num_ = 0xfff0;
packet_->frameType = kVideoFrameKey;
packet_->isFirstPacket = true;
@ -1582,7 +1567,7 @@ TEST_P(TestBasicJitterBuffer, DeltaFrame100PacketsWithSeqNumWrap) {
jitter_buffer_->ReleaseFrame(frame_out);
}
TEST_P(TestBasicJitterBuffer, PacketReorderingReverseWithNegSeqNumWrap) {
TEST_F(TestBasicJitterBuffer, PacketReorderingReverseWithNegSeqNumWrap) {
// Insert "first" packet last seqnum.
seq_num_ = 10;
packet_->frameType = kVideoFrameKey;
@ -1631,7 +1616,7 @@ TEST_P(TestBasicJitterBuffer, PacketReorderingReverseWithNegSeqNumWrap) {
jitter_buffer_->ReleaseFrame(frame_out);
}
TEST_P(TestBasicJitterBuffer, TestInsertOldFrame) {
TEST_F(TestBasicJitterBuffer, TestInsertOldFrame) {
// ------- -------
// | 2 | | 1 |
// ------- -------
@ -1665,7 +1650,7 @@ TEST_P(TestBasicJitterBuffer, TestInsertOldFrame) {
EXPECT_EQ(kOldPacket, jitter_buffer_->InsertPacket(*packet_, &retransmitted));
}
TEST_P(TestBasicJitterBuffer, TestInsertOldFrameWithSeqNumWrap) {
TEST_F(TestBasicJitterBuffer, TestInsertOldFrameWithSeqNumWrap) {
// ------- -------
// | 2 | | 1 |
// ------- -------
@ -1704,7 +1689,7 @@ TEST_P(TestBasicJitterBuffer, TestInsertOldFrameWithSeqNumWrap) {
EXPECT_EQ(kOldPacket, jitter_buffer_->InsertPacket(*packet_, &retransmitted));
}
TEST_P(TestBasicJitterBuffer, TimestampWrap) {
TEST_F(TestBasicJitterBuffer, TimestampWrap) {
// --------------- ---------------
// | 1 | 2 | | 3 | 4 |
// --------------- ---------------
@ -1764,7 +1749,7 @@ TEST_P(TestBasicJitterBuffer, TimestampWrap) {
jitter_buffer_->ReleaseFrame(frame_out);
}
TEST_P(TestBasicJitterBuffer, 2FrameWithTimestampWrap) {
TEST_F(TestBasicJitterBuffer, 2FrameWithTimestampWrap) {
// ------- -------
// | 1 | | 2 |
// ------- -------
@ -1806,7 +1791,7 @@ TEST_P(TestBasicJitterBuffer, 2FrameWithTimestampWrap) {
jitter_buffer_->ReleaseFrame(frame_out2);
}
TEST_P(TestBasicJitterBuffer, Insert2FramesReOrderedWithTimestampWrap) {
TEST_F(TestBasicJitterBuffer, Insert2FramesReOrderedWithTimestampWrap) {
// ------- -------
// | 2 | | 1 |
// ------- -------
@ -1849,7 +1834,7 @@ TEST_P(TestBasicJitterBuffer, Insert2FramesReOrderedWithTimestampWrap) {
jitter_buffer_->ReleaseFrame(frame_out2);
}
TEST_P(TestBasicJitterBuffer, DeltaFrameWithMoreThanMaxNumberOfPackets) {
TEST_F(TestBasicJitterBuffer, DeltaFrameWithMoreThanMaxNumberOfPackets) {
int loop = 0;
bool firstPacket = true;
bool retransmitted = false;
@ -1884,7 +1869,7 @@ TEST_P(TestBasicJitterBuffer, DeltaFrameWithMoreThanMaxNumberOfPackets) {
EXPECT_TRUE(NULL == DecodeCompleteFrame());
}
TEST_P(TestBasicJitterBuffer, ExceedNumOfFrameWithSeqNumWrap) {
TEST_F(TestBasicJitterBuffer, ExceedNumOfFrameWithSeqNumWrap) {
// TEST fill JB with more than max number of frame (50 delta frames +
// 51 key frames) with wrap in seq_num_
//
@ -1944,7 +1929,7 @@ TEST_P(TestBasicJitterBuffer, ExceedNumOfFrameWithSeqNumWrap) {
jitter_buffer_->ReleaseFrame(frame_out);
}
TEST_P(TestBasicJitterBuffer, EmptyLastFrame) {
TEST_F(TestBasicJitterBuffer, EmptyLastFrame) {
jitter_buffer_->SetDecodeErrorMode(kWithErrors);
seq_num_ = 3;
// Insert one empty packet per frame, should never return the last timestamp
@ -1970,7 +1955,7 @@ TEST_P(TestBasicJitterBuffer, EmptyLastFrame) {
}
}
TEST_P(TestBasicJitterBuffer, H264IncompleteNalu) {
TEST_F(TestBasicJitterBuffer, H264IncompleteNalu) {
jitter_buffer_->SetNackMode(kNoNack, -1, -1);
jitter_buffer_->SetDecodeErrorMode(kWithErrors);
++seq_num_;
@ -2153,7 +2138,7 @@ TEST_P(TestBasicJitterBuffer, H264IncompleteNalu) {
jitter_buffer_->ReleaseFrame(frame_out);
}
TEST_P(TestBasicJitterBuffer, NextFrameWhenIncomplete) {
TEST_F(TestBasicJitterBuffer, NextFrameWhenIncomplete) {
// Test that a we cannot get incomplete frames from the JB if we haven't
// received the marker bit, unless we have received a packet from a later
// timestamp.
@ -2330,7 +2315,7 @@ TEST_F(TestRunningJitterBuffer, TwoPacketsNonContinuous) {
EXPECT_TRUE(DecodeCompleteFrame());
}
TEST_P(TestJitterBufferNack, EmptyPackets) {
TEST_F(TestJitterBufferNack, EmptyPackets) {
// Make sure empty packets doesn't clog the jitter buffer.
jitter_buffer_->SetNackMode(kNack, media_optimization::kLowRttNackMs, -1);
EXPECT_GE(InsertFrames(kMaxNumberOfFrames, kEmptyFrame), kNoError);
@ -2338,7 +2323,7 @@ TEST_P(TestJitterBufferNack, EmptyPackets) {
EXPECT_TRUE(DecodeCompleteFrame());
}
TEST_P(TestJitterBufferNack, NackTooOldPackets) {
TEST_F(TestJitterBufferNack, NackTooOldPackets) {
// Insert a key frame and decode it.
EXPECT_GE(InsertFrame(kVideoFrameKey), kNoError);
EXPECT_TRUE(DecodeCompleteFrame());
@ -2371,7 +2356,7 @@ TEST_P(TestJitterBufferNack, NackTooOldPackets) {
EXPECT_TRUE(DecodeCompleteFrame());
}
TEST_P(TestJitterBufferNack, NackLargeJitterBuffer) {
TEST_F(TestJitterBufferNack, NackLargeJitterBuffer) {
// Insert a key frame and decode it.
EXPECT_GE(InsertFrame(kVideoFrameKey), kNoError);
EXPECT_TRUE(DecodeCompleteFrame());
@ -2390,7 +2375,7 @@ TEST_P(TestJitterBufferNack, NackLargeJitterBuffer) {
EXPECT_TRUE(DecodeCompleteFrame());
}
TEST_P(TestJitterBufferNack, NackListFull) {
TEST_F(TestJitterBufferNack, NackListFull) {
// Insert a key frame and decode it.
EXPECT_GE(InsertFrame(kVideoFrameKey), kNoError);
EXPECT_TRUE(DecodeCompleteFrame());
@ -2423,7 +2408,7 @@ TEST_P(TestJitterBufferNack, NackListFull) {
EXPECT_TRUE(DecodeCompleteFrame());
}
TEST_P(TestJitterBufferNack, NoNackListReturnedBeforeFirstDecode) {
TEST_F(TestJitterBufferNack, NoNackListReturnedBeforeFirstDecode) {
DropFrame(10);
// Insert a frame and try to generate a NACK list. Shouldn't get one.
EXPECT_GE(InsertFrame(kVideoFrameDelta), kNoError);
@ -2435,7 +2420,7 @@ TEST_P(TestJitterBufferNack, NoNackListReturnedBeforeFirstDecode) {
EXPECT_TRUE(request_key_frame);
}
TEST_P(TestJitterBufferNack, NackListBuiltBeforeFirstDecode) {
TEST_F(TestJitterBufferNack, NackListBuiltBeforeFirstDecode) {
stream_generator_->Init(0, clock_->TimeInMilliseconds());
InsertFrame(kVideoFrameKey);
stream_generator_->GenerateFrame(kVideoFrameDelta, 2, 0,
@ -2445,13 +2430,10 @@ TEST_P(TestJitterBufferNack, NackListBuiltBeforeFirstDecode) {
EXPECT_TRUE(DecodeCompleteFrame());
bool extended = false;
std::vector<uint16_t> nack_list = jitter_buffer_->GetNackList(&extended);
if (field_trial::FindFullName("WebRTC-NewVideoJitterBuffer") == "Enabled")
EXPECT_EQ(1u, nack_sent_.size());
else
EXPECT_EQ(1u, nack_list.size());
EXPECT_EQ(1u, nack_list.size());
}
TEST_P(TestJitterBufferNack, VerifyRetransmittedFlag) {
TEST_F(TestJitterBufferNack, VerifyRetransmittedFlag) {
stream_generator_->Init(0, clock_->TimeInMilliseconds());
stream_generator_->GenerateFrame(kVideoFrameKey, 3, 0,
clock_->TimeInMilliseconds());
@ -2468,13 +2450,8 @@ TEST_P(TestJitterBufferNack, VerifyRetransmittedFlag) {
bool extended = false;
std::vector<uint16_t> nack_list = jitter_buffer_->GetNackList(&extended);
uint16_t seq_num;
if (field_trial::FindFullName("WebRTC-NewVideoJitterBuffer") == "Enabled") {
EXPECT_EQ(1u, nack_sent_.size());
seq_num = nack_sent_[0];
} else {
EXPECT_EQ(1u, nack_list.size());
seq_num = nack_list[0];
}
EXPECT_EQ(1u, nack_list.size());
seq_num = nack_list[0];
stream_generator_->PopPacket(&packet, 0);
EXPECT_EQ(packet.seqNum, seq_num);
EXPECT_EQ(kCompleteSession,
@ -2483,7 +2460,7 @@ TEST_P(TestJitterBufferNack, VerifyRetransmittedFlag) {
EXPECT_TRUE(DecodeCompleteFrame());
}
TEST_P(TestJitterBufferNack, UseNackToRecoverFirstKeyFrame) {
TEST_F(TestJitterBufferNack, UseNackToRecoverFirstKeyFrame) {
stream_generator_->Init(0, clock_->TimeInMilliseconds());
stream_generator_->GenerateFrame(kVideoFrameKey, 3, 0,
clock_->TimeInMilliseconds());
@ -2494,19 +2471,14 @@ TEST_P(TestJitterBufferNack, UseNackToRecoverFirstKeyFrame) {
bool extended = false;
std::vector<uint16_t> nack_list = jitter_buffer_->GetNackList(&extended);
uint16_t seq_num;
if (field_trial::FindFullName("WebRTC-NewVideoJitterBuffer") == "Enabled") {
ASSERT_EQ(1u, nack_sent_.size());
seq_num = nack_sent_[0];
} else {
ASSERT_EQ(1u, nack_list.size());
seq_num = nack_list[0];
}
ASSERT_EQ(1u, nack_list.size());
seq_num = nack_list[0];
VCMPacket packet;
stream_generator_->GetPacket(&packet, 0);
EXPECT_EQ(packet.seqNum, seq_num);
}
TEST_P(TestJitterBufferNack, UseNackToRecoverFirstKeyFrameSecondInQueue) {
TEST_F(TestJitterBufferNack, UseNackToRecoverFirstKeyFrameSecondInQueue) {
VCMPacket packet;
stream_generator_->Init(0, clock_->TimeInMilliseconds());
// First frame is delta.
@ -2526,18 +2498,13 @@ TEST_P(TestJitterBufferNack, UseNackToRecoverFirstKeyFrameSecondInQueue) {
bool extended = false;
std::vector<uint16_t> nack_list = jitter_buffer_->GetNackList(&extended);
uint16_t seq_num;
if (field_trial::FindFullName("WebRTC-NewVideoJitterBuffer") == "Enabled") {
ASSERT_EQ(2u, nack_sent_.size());
seq_num = nack_sent_[1];
} else {
ASSERT_EQ(1u, nack_list.size());
seq_num = nack_list[0];
}
ASSERT_EQ(1u, nack_list.size());
seq_num = nack_list[0];
stream_generator_->GetPacket(&packet, 0);
EXPECT_EQ(packet.seqNum, seq_num);
}
TEST_P(TestJitterBufferNack, NormalOperation) {
TEST_F(TestJitterBufferNack, NormalOperation) {
EXPECT_EQ(kNack, jitter_buffer_->nack_mode());
jitter_buffer_->SetDecodeErrorMode(kWithErrors);
@ -2570,15 +2537,12 @@ TEST_P(TestJitterBufferNack, NormalOperation) {
std::vector<uint16_t> nack_list =
jitter_buffer_->GetNackList(&request_key_frame);
const size_t kExpectedNackSize = 9;
if (field_trial::FindFullName("WebRTC-NewVideoJitterBuffer") == "Enabled")
ASSERT_EQ(kExpectedNackSize, nack_sent_.size());
else
ASSERT_EQ(kExpectedNackSize, nack_list.size());
ASSERT_EQ(kExpectedNackSize, nack_list.size());
for (size_t i = 0; i < nack_list.size(); ++i)
EXPECT_EQ((1 + i) * 10, nack_list[i]);
}
TEST_P(TestJitterBufferNack, NormalOperationWrap) {
TEST_F(TestJitterBufferNack, NormalOperationWrap) {
bool request_key_frame = false;
// ------- ------------------------------------------------------------
// | 65532 | | 65533 | 65534 | 65535 | x | 1 | .. | 9 | x | 11 |.....| 96 |
@ -2607,18 +2571,12 @@ TEST_P(TestJitterBufferNack, NormalOperationWrap) {
std::vector<uint16_t> nack_list = jitter_buffer_->GetNackList(&extended);
// Verify the NACK list.
const size_t kExpectedNackSize = 10;
if (field_trial::FindFullName("WebRTC-NewVideoJitterBuffer") == "Enabled") {
ASSERT_EQ(kExpectedNackSize, nack_sent_.size());
for (size_t i = 0; i < nack_sent_.size(); ++i)
EXPECT_EQ(i * 10, nack_sent_[i]);
} else {
ASSERT_EQ(kExpectedNackSize, nack_list.size());
for (size_t i = 0; i < nack_list.size(); ++i)
EXPECT_EQ(i * 10, nack_list[i]);
}
ASSERT_EQ(kExpectedNackSize, nack_list.size());
for (size_t i = 0; i < nack_list.size(); ++i)
EXPECT_EQ(i * 10, nack_list[i]);
}
TEST_P(TestJitterBufferNack, NormalOperationWrap2) {
TEST_F(TestJitterBufferNack, NormalOperationWrap2) {
bool request_key_frame = false;
// -----------------------------------
// | 65532 | 65533 | 65534 | x | 0 | 1 |
@ -2646,16 +2604,11 @@ TEST_P(TestJitterBufferNack, NormalOperationWrap2) {
bool extended = false;
std::vector<uint16_t> nack_list = jitter_buffer_->GetNackList(&extended);
// Verify the NACK list.
if (field_trial::FindFullName("WebRTC-NewVideoJitterBuffer") == "Enabled") {
ASSERT_EQ(1u, nack_sent_.size());
EXPECT_EQ(65535, nack_sent_[0]);
} else {
ASSERT_EQ(1u, nack_list.size());
EXPECT_EQ(65535, nack_list[0]);
}
ASSERT_EQ(1u, nack_list.size());
EXPECT_EQ(65535, nack_list[0]);
}
TEST_P(TestJitterBufferNack, ResetByFutureKeyFrameDoesntError) {
TEST_F(TestJitterBufferNack, ResetByFutureKeyFrameDoesntError) {
stream_generator_->Init(0, clock_->TimeInMilliseconds());
InsertFrame(kVideoFrameKey);
EXPECT_TRUE(DecodeCompleteFrame());

8
webrtc/modules/video_coding/receiver.cc
View File

@ -102,14 +102,6 @@ void VCMReceiver::UpdateRtt(int64_t rtt) {
jitter_buffer_.UpdateRtt(rtt);
}
int64_t VCMReceiver::TimeUntilNextProcess() {
return jitter_buffer_.TimeUntilNextProcess();
}
void VCMReceiver::Process() {
jitter_buffer_.Process();
}
int32_t VCMReceiver::InsertPacket(const VCMPacket& packet) {
// Insert the packet into the jitter buffer. The packet can either be empty or
// contain media at this point.

3
webrtc/modules/video_coding/receiver.h
View File

@ -91,9 +91,6 @@ class VCMReceiver {
void TriggerDecoderShutdown();
int64_t TimeUntilNextProcess();
void Process();
private:
CriticalSectionWrapper* crit_sect_;
Clock* const clock_;

6
webrtc/modules/video_coding/video_receiver.cc
View File

@ -94,10 +94,6 @@ void VideoReceiver::Process() {
RequestKeyFrame();
}
if (_receiver.TimeUntilNextProcess() == 0) {
_receiver.Process();
}
// Packet retransmission requests
// TODO(holmer): Add API for changing Process interval and make sure it's
// disabled when NACK is off.
@ -138,8 +134,6 @@ int64_t VideoReceiver::TimeUntilNextProcess() {
}
timeUntilNextProcess =
VCM_MIN(timeUntilNextProcess, _keyRequestTimer.TimeUntilProcess());
timeUntilNextProcess =
VCM_MIN(timeUntilNextProcess, _receiver.TimeUntilNextProcess());
return timeUntilNextProcess;
}