generic-library/webrtc
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Consolidate GetFrame and InsertPacket and move NACK list processing to after a packet has been successfully inserted.

Browse Source 
TEST=trybots
BUG=1799
R=mikhal@webrtc.org

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

git-svn-id: http://webrtc.googlecode.com/svn/trunk@4080 4adac7df-926f-26a2-2b94-8c16560cd09d
This commit is contained in:
stefan@webrtc.org 2013-05-21 15:25:53 +00:00
parent 956aa7e087
commit 3417eb49f6
9 changed files with 311 additions and 394 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
webrtc/modules/video_coding/main/source/frame_buffer.cc
View File

@ -104,7 +104,7 @@ VCMFrameBuffer::InsertPacket(const VCMPacket& packet, int64_t timeInMs,
// Sanity to check if the frame has been freed. (Too old for example)
if (_state == kStateFree)
{
return kStateError;
return kGeneralError;
}
// is this packet part of this frame
@ -164,6 +164,11 @@ VCMFrameBuffer::InsertPacket(const VCMPacket& packet, int64_t timeInMs,
_sessionInfo.UpdateDataPointers(prevBuffer, _buffer);
}
if (packet.width > 0 && packet.height > 0) {
_encodedWidth = packet.width;
_encodedHeight = packet.height;
}
CopyCodecSpecific(&packet.codecSpecificHeader);
int retVal = _sessionInfo.InsertPacket(packet, _buffer,

131
webrtc/modules/video_coding/main/source/jitter_buffer.cc
View File

@ -90,7 +90,7 @@ VCMJitterBuffer::VCMJitterBuffer(Clock* clock,
frame_buffers_(),
frame_list_(),
last_decoded_state_(),
first_packet_(true),
first_packet_since_reset_(true),
num_not_decodable_packets_(0),
receive_statistics_(),
incoming_frame_rate_(0),
@ -154,7 +154,7 @@ void VCMJitterBuffer::CopyFrom(const VCMJitterBuffer& rhs) {
inter_frame_delay_ = rhs.inter_frame_delay_;
waiting_for_completion_ = rhs.waiting_for_completion_;
rtt_ms_ = rhs.rtt_ms_;
first_packet_ = rhs.first_packet_;
first_packet_since_reset_ = rhs.first_packet_since_reset_;
last_decoded_state_ = rhs.last_decoded_state_;
num_not_decodable_packets_ = rhs.num_not_decodable_packets_;
decode_with_errors_ = rhs.decode_with_errors_;
@ -207,7 +207,7 @@ void VCMJitterBuffer::Start() {
waiting_for_completion_.frame_size = 0;
waiting_for_completion_.timestamp = 0;
waiting_for_completion_.latest_packet_time = -1;
first_packet_ = true;
first_packet_since_reset_ = true;
rtt_ms_ = kDefaultRtt;
num_not_decodable_packets_ = 0;
last_decoded_state_.Reset();
@ -264,7 +264,7 @@ void VCMJitterBuffer::Flush() {
waiting_for_completion_.frame_size = 0;
waiting_for_completion_.timestamp = 0;
waiting_for_completion_.latest_packet_time = -1;
first_packet_ = true;
first_packet_since_reset_ = true;
missing_sequence_numbers_.clear();
WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVideoCoding,
VCMId(vcm_id_, receiver_id_), "JB(0x%x): Jitter buffer: flush",
@ -558,13 +558,8 @@ void VCMJitterBuffer::ReleaseFrame(VCMEncodedFrame* frame) {
}
// Gets frame to use for this timestamp. If no match, get empty frame.
int VCMJitterBuffer::GetFrame(const VCMPacket& packet,
VCMEncodedFrame*& frame) {
if (!running_) { // Don't accept incoming packets until we are started.
return VCM_UNINITIALIZED;
}
crit_sect_->Enter();
VCMFrameBufferEnum VCMJitterBuffer::GetFrame(const VCMPacket& packet,
VCMFrameBuffer** frame) {
// Does this packet belong to an old frame?
if (last_decoded_state_.IsOldPacket(&packet)) {
// Account only for media packets.
@ -584,11 +579,9 @@ int VCMJitterBuffer::GetFrame(const VCMPacket& packet,
if (num_consecutive_old_packets_ > kMaxConsecutiveOldPackets) {
Flush();
crit_sect_->Leave();
return VCM_FLUSH_INDICATOR;
return kFlushIndicator;
}
crit_sect_->Leave();
return VCM_OLD_PACKET_ERROR;
return kOldPacket;
}
num_consecutive_old_packets_ = 0;
@ -598,79 +591,54 @@ int VCMJitterBuffer::GetFrame(const VCMPacket& packet,
FrameEqualTimestamp(packet.timestamp));
if (it != frame_list_.end()) {
frame = *it;
crit_sect_->Leave();
return VCM_OK;
*frame = *it;
return kNoError;
}
crit_sect_->Leave();
// No match, return empty frame.
frame = GetEmptyFrame();
if (frame != NULL) {
return VCM_OK;
*frame = GetEmptyFrame();
if (*frame != NULL) {
return kNoError;
}
// No free frame! Try to reclaim some...
crit_sect_->Enter();
RecycleFramesUntilKeyFrame();
crit_sect_->Leave();
frame = GetEmptyFrame();
if (frame != NULL) {
return VCM_OK;
*frame = GetEmptyFrame();
if (*frame != NULL) {
return kNoError;
}
return VCM_JITTER_BUFFER_ERROR;
return kGeneralError;
}
// Deprecated! Kept for testing purposes.
VCMEncodedFrame* VCMJitterBuffer::GetFrame(const VCMPacket& packet) {
VCMEncodedFrame* frame = NULL;
if (GetFrame(packet, frame) < 0) {
return NULL;
}
return frame;
}
int64_t VCMJitterBuffer::LastPacketTime(VCMEncodedFrame* frame,
int64_t VCMJitterBuffer::LastPacketTime(const VCMEncodedFrame* frame,
bool* retransmitted) const {
assert(retransmitted);
CriticalSectionScoped cs(crit_sect_);
*retransmitted = (static_cast<VCMFrameBuffer*>(frame)->GetNackCount() > 0);
return static_cast<VCMFrameBuffer*>(frame)->LatestPacketTimeMs();
const VCMFrameBuffer* frame_buffer =
static_cast<const VCMFrameBuffer*>(frame);
*retransmitted = (frame_buffer->GetNackCount() > 0);
return frame_buffer->LatestPacketTimeMs();
}
VCMFrameBufferEnum VCMJitterBuffer::InsertPacket(VCMEncodedFrame* encoded_frame,
const VCMPacket& packet) {
assert(encoded_frame);
bool request_key_frame = false;
VCMFrameBufferEnum VCMJitterBuffer::InsertPacket(const VCMPacket& packet,
bool* retransmitted) {
CriticalSectionScoped cs(crit_sect_);
int64_t now_ms = clock_->TimeInMilliseconds();
VCMFrameBufferEnum buffer_return = kSizeError;
VCMFrameBufferEnum ret = kSizeError;
VCMFrameBuffer* frame = static_cast<VCMFrameBuffer*>(encoded_frame);
// If this packet belongs to an old, already decoded frame, we want to update
// the last decoded sequence number.
last_decoded_state_.UpdateOldPacket(&packet);
VCMFrameBuffer* frame = NULL;
const VCMFrameBufferEnum error = GetFrame(packet, &frame);
if (error != kNoError) {
return error;
}
// We are keeping track of the first seq num, the latest seq num and
// the number of wraps to be able to calculate how many packets we expect.
if (first_packet_) {
if (first_packet_since_reset_) {
// Now it's time to start estimating jitter
// reset the delay estimate.
inter_frame_delay_.Reset(clock_->TimeInMilliseconds());
first_packet_ = false;
latest_received_sequence_number_ = packet.seqNum;
} else {
if (IsPacketRetransmitted(packet)) {
frame->IncrementNackCount();
}
if (!UpdateNackList(packet.seqNum)) {
LOG_F(LS_INFO) << "Requesting key frame due to flushed NACK list.";
request_key_frame = true;
}
latest_received_sequence_number_ = LatestSequenceNumber(
latest_received_sequence_number_, packet.seqNum);
}
// Empty packets may bias the jitter estimate (lacking size component),
@ -692,10 +660,9 @@ VCMFrameBufferEnum VCMJitterBuffer::InsertPacket(VCMEncodedFrame* encoded_frame,
}
VCMFrameBufferStateEnum state = frame->GetState();
// Insert packet
// Check for first packet
// High sequence number will be -1 if neither an empty packet nor
// a media packet has been inserted.
// Insert packet.
// Check for first packet. High sequence number will be -1 if neither an empty
// packet nor a media packet has been inserted.
bool first = (frame->GetHighSeqNum() == -1);
// When in Hybrid mode, we allow for a decodable state
// Note: Under current version, a decodable frame will never be
@ -718,9 +685,23 @@ VCMFrameBufferEnum VCMJitterBuffer::InsertPacket(VCMEncodedFrame* encoded_frame,
FrameSmallerTimestamp(frame->TimeStamp()));
frame_list_.insert(rit.base(), frame);
}
if (first_packet_since_reset_) {
latest_received_sequence_number_ = packet.seqNum;
first_packet_since_reset_ = false;
} else {
if (IsPacketRetransmitted(packet)) {
frame->IncrementNackCount();
}
if (!UpdateNackList(packet.seqNum)) {
LOG_F(LS_INFO) << "Requesting key frame due to flushed NACK list.";
buffer_return = kFlushIndicator;
}
latest_received_sequence_number_ = LatestSequenceNumber(
latest_received_sequence_number_, packet.seqNum);
}
}
switch (buffer_return) {
case kStateError:
case kGeneralError:
case kTimeStampError:
case kSizeError: {
if (frame != NULL) {
@ -736,6 +717,7 @@ VCMFrameBufferEnum VCMJitterBuffer::InsertPacket(VCMEncodedFrame* encoded_frame,
// Only update return value for a JB flush indicator.
if (UpdateFrameState(frame) == kFlushIndicator)
ret = kFlushIndicator;
*retransmitted = (frame->GetNackCount() > 0);
// Signal that we have a received packet.
packet_event_->Set();
break;
@ -750,13 +732,13 @@ VCMFrameBufferEnum VCMJitterBuffer::InsertPacket(VCMEncodedFrame* encoded_frame,
case kDuplicatePacket: {
break;
}
case kFlushIndicator:
ret = kFlushIndicator;
break;
default: {
assert(false && "JitterBuffer::InsertPacket: Undefined value");
}
}
if (request_key_frame) {
ret = kFlushIndicator;
}
return ret;
}
@ -1080,17 +1062,10 @@ void VCMJitterBuffer::ReleaseFrameIfNotDecoding(VCMFrameBuffer* frame) {
}
VCMFrameBuffer* VCMJitterBuffer::GetEmptyFrame() {
if (!running_) {
return NULL;
}
crit_sect_->Enter();
for (int i = 0; i < max_number_of_frames_; ++i) {
if (kStateFree == frame_buffers_[i]->GetState()) {
// found a free buffer
frame_buffers_[i]->SetState(kStateEmpty);
crit_sect_->Leave();
return frame_buffers_[i];
}
}
@ -1102,7 +1077,6 @@ VCMFrameBuffer* VCMJitterBuffer::GetEmptyFrame() {
frame_buffers_[max_number_of_frames_] = ptr_new_buffer;
max_number_of_frames_++;
crit_sect_->Leave();
WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVideoCoding,
VCMId(vcm_id_, receiver_id_),
"JB(0x%x) FB(0x%x): Jitter buffer increased to:%d frames",
@ -1110,7 +1084,6 @@ VCMFrameBuffer* VCMJitterBuffer::GetEmptyFrame() {
TRACE_COUNTER1("webrtc", "JBMaxFrames", max_number_of_frames_);
return ptr_new_buffer;
}
crit_sect_->Leave();
// We have reached max size, cannot increase JB size
return NULL;

17
webrtc/modules/video_coding/main/source/jitter_buffer.h
View File

@ -113,18 +113,15 @@ class VCMJitterBuffer {
// done with decoding.
void ReleaseFrame(VCMEncodedFrame* frame);
// Returns the frame assigned to this timestamp.
int GetFrame(const VCMPacket& packet, VCMEncodedFrame*&);
VCMEncodedFrame* GetFrame(const VCMPacket& packet); // Deprecated.
// Returns the time in ms when the latest packet was inserted into the frame.
// Retransmitted is set to true if any of the packets belonging to the frame
// has been retransmitted.
int64_t LastPacketTime(VCMEncodedFrame* frame, bool* retransmitted) const;
int64_t LastPacketTime(const VCMEncodedFrame* frame,
bool* retransmitted) const;
// Inserts a packet into a frame returned from GetFrame().
VCMFrameBufferEnum InsertPacket(VCMEncodedFrame* frame,
const VCMPacket& packet);
VCMFrameBufferEnum InsertPacket(const VCMPacket& packet,
bool* retransmitted);
// Enable a max filter on the jitter estimate by setting an initial
// non-zero delay.
@ -174,6 +171,10 @@ class VCMJitterBuffer {
};
typedef std::set<uint16_t, SequenceNumberLessThan> SequenceNumberSet;
// Gets the frame assigned to the timestamp of the packet. May recycle
// existing frames if no free frames are available. Returns an error code if
// failing, or kNoError on success.
VCMFrameBufferEnum GetFrame(const VCMPacket& packet, VCMFrameBuffer** frame);
// Returns true if the NACK list was updated to cover sequence numbers up to
// |sequence_number|. If false a key frame is needed to get into a state where
// we can continue decoding.
@ -264,7 +265,7 @@ class VCMJitterBuffer {
VCMFrameBuffer* frame_buffers_[kMaxNumberOfFrames];
FrameList frame_list_;
VCMDecodingState last_decoded_state_;
bool first_packet_;
bool first_packet_since_reset_;
// Statistics.
int num_not_decodable_packets_;

4
webrtc/modules/video_coding/main/source/jitter_buffer_common.h
View File

@ -28,7 +28,9 @@ enum VCMJitterBufferEnum {
};
enum VCMFrameBufferEnum {
kStateError = -4,
kNotInitialized = -6,
kOldPacket = -5,
kGeneralError = -4,
kFlushIndicator = -3, // Indicator that a flush has occurred.
kTimeStampError = -2,
kSizeError = -1,

442
webrtc/modules/video_coding/main/source/jitter_buffer_unittest.cc
View File

@ -143,28 +143,24 @@ class TestRunningJitterBuffer : public ::testing::Test {
VCMFrameBufferEnum InsertPacketAndPop(int index) {
VCMPacket packet;
VCMEncodedFrame* frame;
packet.dataPtr = data_buffer_;
bool packet_available = stream_generator_->PopPacket(&packet, index);
EXPECT_TRUE(packet_available);
if (!packet_available)
return kStateError; // Return here to avoid crashes below.
EXPECT_EQ(VCM_OK, jitter_buffer_->GetFrame(packet, frame));
return jitter_buffer_->InsertPacket(frame, packet);
return kGeneralError; // Return here to avoid crashes below.
bool retransmitted = false;
return jitter_buffer_->InsertPacket(packet, &retransmitted);
}
VCMFrameBufferEnum InsertPacket(int index) {
VCMPacket packet;
VCMEncodedFrame* frame;
packet.dataPtr = data_buffer_;
bool packet_available = stream_generator_->GetPacket(&packet, index);
EXPECT_TRUE(packet_available);
if (!packet_available)
return kStateError; // Return here to avoid crashes below.
EXPECT_EQ(VCM_OK, jitter_buffer_->GetFrame(packet, frame));
return jitter_buffer_->InsertPacket(frame, packet);
return kGeneralError; // Return here to avoid crashes below.
bool retransmitted = false;
return jitter_buffer_->InsertPacket(packet, &retransmitted);
}
VCMFrameBufferEnum InsertFrame(FrameType frame_type) {
@ -242,15 +238,12 @@ class TestJitterBufferNack : public TestRunningJitterBuffer {
TEST_F(TestBasicJitterBuffer, StopRunning) {
jitter_buffer_->Stop();
EXPECT_EQ(0, jitter_buffer_->GetFrame(*packet_));
EXPECT_TRUE(NULL == DecodeCompleteFrame());
EXPECT_TRUE(NULL == DecodeIncompleteFrame());
jitter_buffer_->Start();
// Allow decoding with errors.
jitter_buffer_->DecodeWithErrors(true);
VCMEncodedFrame* frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
// No packets inserted.
EXPECT_TRUE(NULL == DecodeCompleteFrame());
EXPECT_TRUE(NULL == DecodeIncompleteFrame());
@ -264,8 +257,9 @@ TEST_F(TestBasicJitterBuffer, SinglePacketFrame) {
packet_->timestamp += 123*90;
// Insert the packet to the jitter buffer and get a frame.
VCMEncodedFrame* frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(frame_in, *packet_));
bool retransmitted = false;
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
VCMEncodedFrame* frame_out = DecodeCompleteFrame();
EXPECT_EQ(0, CheckOutFrame(frame_out, size_, false));
EXPECT_EQ(kVideoFrameKey, frame_out->FrameType());
@ -276,9 +270,9 @@ TEST_F(TestBasicJitterBuffer, DualPacketFrame) {
packet_->isFirstPacket = true;
packet_->markerBit = false;
VCMEncodedFrame* frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(frame_in, *packet_));
bool retransmitted = false;
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
VCMEncodedFrame* frame_out = DecodeCompleteFrame();
// Should not be complete.
EXPECT_TRUE(frame_out == NULL);
@ -288,10 +282,8 @@ TEST_F(TestBasicJitterBuffer, DualPacketFrame) {
packet_->markerBit = true;
packet_->seqNum = seq_num_;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_FALSE(frame_in == NULL);
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
frame_out = DecodeCompleteFrame();
EXPECT_EQ(0, CheckOutFrame(frame_out, 2 * size_, false));
@ -303,10 +295,10 @@ TEST_F(TestBasicJitterBuffer, 100PacketKeyFrame) {
packet_->frameType = kVideoFrameKey;
packet_->isFirstPacket = true;
packet_->markerBit = false;
VCMEncodedFrame* frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(frame_in, *packet_));
bool retransmitted = false;
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
VCMEncodedFrame* frame_out = DecodeCompleteFrame();
@ -320,10 +312,9 @@ TEST_F(TestBasicJitterBuffer, 100PacketKeyFrame) {
packet_->isFirstPacket = false;
packet_->markerBit = false;
packet_->seqNum = seq_num_;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_FALSE(frame_in == NULL);
EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
loop++;
} while (loop < 98);
@ -333,10 +324,8 @@ TEST_F(TestBasicJitterBuffer, 100PacketKeyFrame) {
packet_->markerBit = true;
packet_->seqNum = seq_num_;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_FALSE(frame_in == NULL);
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
frame_out = DecodeCompleteFrame();
@ -350,8 +339,9 @@ TEST_F(TestBasicJitterBuffer, 100PacketDeltaFrame) {
packet_->isFirstPacket = true;
packet_->markerBit = true;
VCMEncodedFrame* frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(frame_in, *packet_));
bool retransmitted = false;
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
VCMEncodedFrame* frame_out = DecodeCompleteFrame();
EXPECT_FALSE(frame_out == NULL);
@ -361,10 +351,8 @@ TEST_F(TestBasicJitterBuffer, 100PacketDeltaFrame) {
packet_->frameType = kVideoFrameDelta;
packet_->timestamp += 33 * 90;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_FALSE(frame_in == NULL);
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
frame_out = DecodeCompleteFrame();
@ -377,10 +365,10 @@ TEST_F(TestBasicJitterBuffer, 100PacketDeltaFrame) {
do {
++seq_num_;
packet_->seqNum = seq_num_;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_FALSE(frame_in == NULL);
// Insert a packet into a frame.
EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
loop++;
} while (loop < 98);
@ -390,10 +378,8 @@ TEST_F(TestBasicJitterBuffer, 100PacketDeltaFrame) {
packet_->markerBit = true;
packet_->seqNum = seq_num_;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_FALSE(frame_in == NULL);
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
frame_out = DecodeCompleteFrame();
@ -410,10 +396,9 @@ TEST_F(TestBasicJitterBuffer, PacketReorderingReverseOrder) {
packet_->seqNum = seq_num_;
packet_->timestamp = timestamp_;
VCMEncodedFrame* frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(frame_in, *packet_));
bool retransmitted = false;
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
VCMEncodedFrame* frame_out = DecodeCompleteFrame();
@ -427,10 +412,8 @@ TEST_F(TestBasicJitterBuffer, PacketReorderingReverseOrder) {
packet_->markerBit = false;
packet_->seqNum = seq_num_;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
loop++;
} while (loop < 98);
@ -440,10 +423,8 @@ TEST_F(TestBasicJitterBuffer, PacketReorderingReverseOrder) {
packet_->markerBit = false;
packet_->seqNum = seq_num_;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
frame_out = DecodeCompleteFrame();;
@ -457,10 +438,9 @@ TEST_F(TestBasicJitterBuffer, FrameReordering2Frames2PacketsEach) {
packet_->isFirstPacket = true;
packet_->markerBit = false;
VCMEncodedFrame* frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(frame_in, *packet_));
bool retransmitted = false;
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
VCMEncodedFrame* frame_out = DecodeCompleteFrame();
@ -471,10 +451,8 @@ TEST_F(TestBasicJitterBuffer, FrameReordering2Frames2PacketsEach) {
packet_->markerBit = true;
packet_->seqNum = seq_num_;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
// check that we fail to get frame since seqnum is not continuous
frame_out = DecodeCompleteFrame();
@ -488,10 +466,8 @@ TEST_F(TestBasicJitterBuffer, FrameReordering2Frames2PacketsEach) {
packet_->seqNum = seq_num_;
packet_->timestamp = timestamp_;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
frame_out = DecodeCompleteFrame();
@ -503,10 +479,8 @@ TEST_F(TestBasicJitterBuffer, FrameReordering2Frames2PacketsEach) {
packet_->markerBit = true;
packet_->seqNum = seq_num_;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
frame_out = DecodeCompleteFrame();
@ -530,10 +504,9 @@ TEST_F(TestBasicJitterBuffer, DuplicatePackets) {
packet_->seqNum = seq_num_;
packet_->timestamp = timestamp_;
VCMEncodedFrame* frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(frame_in, *packet_));
bool retransmitted = false;
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
VCMEncodedFrame* frame_out = DecodeCompleteFrame();
@ -542,16 +515,15 @@ TEST_F(TestBasicJitterBuffer, DuplicatePackets) {
packet_->isFirstPacket = false;
packet_->markerBit = true;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
// Insert a packet into a frame.
EXPECT_EQ(kDuplicatePacket, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kDuplicatePacket, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
seq_num_++;
packet_->seqNum = seq_num_;
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
frame_out = DecodeCompleteFrame();
@ -568,10 +540,9 @@ TEST_F(TestBasicJitterBuffer, H264InsertStartCode) {
packet_->timestamp = timestamp_;
packet_->insertStartCode = true;
VCMEncodedFrame* frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(frame_in, *packet_));
bool retransmitted = false;
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
VCMEncodedFrame* frame_out = DecodeCompleteFrame();
@ -583,10 +554,8 @@ TEST_F(TestBasicJitterBuffer, H264InsertStartCode) {
packet_->markerBit = true;
packet_->seqNum = seq_num_;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
frame_out = DecodeCompleteFrame();
@ -612,9 +581,10 @@ TEST_F(TestBasicJitterBuffer, PacketLoss) {
packet_->seqNum = seq_num_;
packet_->timestamp = timestamp_;
packet_->completeNALU = kNaluStart;
VCMEncodedFrame* frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(frame_in, *packet_));
bool retransmitted = false;
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
for (int i = 0; i < 11; ++i) {
webrtc::FrameType frametype = kVideoFrameDelta;
@ -627,10 +597,8 @@ TEST_F(TestBasicJitterBuffer, PacketLoss) {
packet_->timestamp = timestamp_;
packet_->completeNALU = kNaluStart;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
VCMEncodedFrame* frame_out = DecodeCompleteFrame();
@ -643,10 +611,8 @@ TEST_F(TestBasicJitterBuffer, PacketLoss) {
packet_->seqNum = seq_num_;
packet_->completeNALU = kNaluEnd;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
// Insert an empty (non-media) packet.
@ -657,10 +623,8 @@ TEST_F(TestBasicJitterBuffer, PacketLoss) {
packet_->completeNALU = kNaluEnd;
packet_->frameType = kFrameEmpty;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
frame_out = DecodeIncompleteFrame();
@ -687,16 +651,19 @@ TEST_F(TestBasicJitterBuffer, PacketLoss) {
// Match value to actual latest timestamp decoded.
timestamp_ -= 33 * 90;
packet_->timestamp = timestamp_ - 1000;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in == NULL);
EXPECT_EQ(kOldPacket, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
packet_->timestamp = timestamp_ - 500;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in == NULL);
EXPECT_EQ(kOldPacket, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
packet_->timestamp = timestamp_ - 100;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in == NULL);
EXPECT_EQ(kOldPacket, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
EXPECT_EQ(3, jitter_buffer_->num_discarded_packets());
@ -714,10 +681,9 @@ TEST_F(TestBasicJitterBuffer, DeltaFrame100PacketsWithSeqNumWrap) {
packet_->seqNum = seq_num_;
packet_->timestamp = timestamp_;
VCMEncodedFrame* frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(frame_in, *packet_));
bool retransmitted = false;
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
VCMEncodedFrame* frame_out = DecodeCompleteFrame();
@ -730,10 +696,8 @@ TEST_F(TestBasicJitterBuffer, DeltaFrame100PacketsWithSeqNumWrap) {
packet_->markerBit = false;
packet_->seqNum = seq_num_;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
frame_out = DecodeCompleteFrame();
@ -747,10 +711,8 @@ TEST_F(TestBasicJitterBuffer, DeltaFrame100PacketsWithSeqNumWrap) {
packet_->markerBit = true;
packet_->seqNum = seq_num_;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
frame_out = DecodeCompleteFrame();
@ -767,10 +729,9 @@ TEST_F(TestBasicJitterBuffer, PacketReorderingReverseWithNegSeqNumWrap) {
packet_->markerBit = true;
packet_->seqNum = seq_num_;
VCMEncodedFrame* frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(frame_in, *packet_));
bool retransmitted = false;
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
VCMEncodedFrame* frame_out = DecodeCompleteFrame();
// Should not be complete.
@ -784,10 +745,8 @@ TEST_F(TestBasicJitterBuffer, PacketReorderingReverseWithNegSeqNumWrap) {
packet_->markerBit = false;
packet_->seqNum = seq_num_;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
frame_out = DecodeCompleteFrame();
@ -802,10 +761,8 @@ TEST_F(TestBasicJitterBuffer, PacketReorderingReverseWithNegSeqNumWrap) {
packet_->markerBit = false;
packet_->seqNum = seq_num_;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
frame_out = DecodeCompleteFrame();
EXPECT_EQ(0, CheckOutFrame(frame_out, 100 * size_, false));
@ -825,10 +782,9 @@ TEST_F(TestBasicJitterBuffer, TestInsertOldFrame) {
packet_->timestamp = timestamp_;
packet_->seqNum = seq_num_;
VCMEncodedFrame* frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(frame_in, *packet_));
bool retransmitted = false;
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
VCMEncodedFrame* frame_out = DecodeCompleteFrame();
EXPECT_EQ(3000u, frame_out->TimeStamp());
@ -847,10 +803,8 @@ TEST_F(TestBasicJitterBuffer, TestInsertOldFrame) {
packet_->seqNum = seq_num_;
packet_->timestamp = timestamp_;
frame_in = jitter_buffer_->GetFrame(*packet_);
// Changed behavior, never insert packets into frames older than the
// last decoded frame.
EXPECT_TRUE(frame_in == NULL);
EXPECT_EQ(kOldPacket, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
}
TEST_F(TestBasicJitterBuffer, TestInsertOldFrameWithSeqNumWrap) {
@ -867,10 +821,9 @@ TEST_F(TestBasicJitterBuffer, TestInsertOldFrameWithSeqNumWrap) {
packet_->seqNum = seq_num_;
packet_->timestamp = timestamp_;
VCMEncodedFrame* frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(frame_in, *packet_));
bool retransmitted = false;
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
VCMEncodedFrame* frame_out = DecodeCompleteFrame();
EXPECT_EQ(timestamp_, frame_out->TimeStamp());
@ -889,9 +842,10 @@ TEST_F(TestBasicJitterBuffer, TestInsertOldFrameWithSeqNumWrap) {
packet_->seqNum = seq_num_;
packet_->timestamp = timestamp_;
frame_in = jitter_buffer_->GetFrame(*packet_);
// This timestamp is old.
EXPECT_TRUE(frame_in == NULL);
EXPECT_EQ(kOldPacket, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
}
TEST_F(TestBasicJitterBuffer, TimestampWrap) {
@ -907,10 +861,9 @@ TEST_F(TestBasicJitterBuffer, TimestampWrap) {
packet_->seqNum = seq_num_;
packet_->timestamp = timestamp_;
VCMEncodedFrame* frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(frame_in, *packet_));
bool retransmitted = false;
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
VCMEncodedFrame* frame_out = DecodeCompleteFrame();
@ -921,10 +874,8 @@ TEST_F(TestBasicJitterBuffer, TimestampWrap) {
packet_->markerBit = true;
packet_->seqNum = seq_num_;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
frame_out = DecodeCompleteFrame();
@ -940,10 +891,8 @@ TEST_F(TestBasicJitterBuffer, TimestampWrap) {
packet_->seqNum = seq_num_;
packet_->timestamp = timestamp_;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
frame_out = DecodeCompleteFrame();
@ -954,10 +903,8 @@ TEST_F(TestBasicJitterBuffer, TimestampWrap) {
packet_->markerBit = true;
packet_->seqNum = seq_num_;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
frame_out = DecodeCompleteFrame();
@ -978,11 +925,10 @@ TEST_F(TestBasicJitterBuffer, 2FrameWithTimestampWrap) {
packet_->markerBit = true;
packet_->timestamp = timestamp_;
VCMEncodedFrame* frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
bool retransmitted = false;
// Insert first frame (session will be complete).
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
// Insert next frame.
seq_num_++;
@ -993,10 +939,8 @@ TEST_F(TestBasicJitterBuffer, 2FrameWithTimestampWrap) {
packet_->seqNum = seq_num_;
packet_->timestamp = timestamp_;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
VCMEncodedFrame* frame_out = DecodeCompleteFrame();
EXPECT_EQ(0xffffff00, frame_out->TimeStamp());
@ -1027,10 +971,9 @@ TEST_F(TestBasicJitterBuffer, Insert2FramesReOrderedWithTimestampWrap) {
packet_->seqNum = seq_num_;
packet_->timestamp = timestamp_;
VCMEncodedFrame* frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(frame_in, *packet_));
bool retransmitted = false;
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
// Insert second frame
seq_num_--;
@ -1041,10 +984,8 @@ TEST_F(TestBasicJitterBuffer, Insert2FramesReOrderedWithTimestampWrap) {
packet_->seqNum = seq_num_;
packet_->timestamp = timestamp_;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
VCMEncodedFrame* frame_out = DecodeCompleteFrame();
EXPECT_EQ(0xffffff00, frame_out->TimeStamp());
@ -1064,7 +1005,7 @@ TEST_F(TestBasicJitterBuffer, Insert2FramesReOrderedWithTimestampWrap) {
TEST_F(TestBasicJitterBuffer, DeltaFrameWithMoreThanMaxNumberOfPackets) {
int loop = 0;
bool firstPacket = true;
VCMEncodedFrame* frame_in;
bool retransmitted = false;
// Insert kMaxPacketsInJitterBuffer into frame.
do {
seq_num_++;
@ -1072,14 +1013,13 @@ TEST_F(TestBasicJitterBuffer, DeltaFrameWithMoreThanMaxNumberOfPackets) {
packet_->markerBit = false;
packet_->seqNum = seq_num_;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
if (firstPacket) {
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
firstPacket = false;
} else {
EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
}
loop++;
@ -1092,10 +1032,9 @@ TEST_F(TestBasicJitterBuffer, DeltaFrameWithMoreThanMaxNumberOfPackets) {
packet_->markerBit = true;
packet_->seqNum = seq_num_;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
// Insert the packet -> frame recycled.
EXPECT_EQ(kSizeError, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kSizeError, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
EXPECT_TRUE(NULL == DecodeCompleteFrame());
}
@ -1111,9 +1050,8 @@ TEST_F(TestBasicJitterBuffer, ExceedNumOfFrameWithSeqNumWrap) {
int loop = 0;
seq_num_ = 65485;
VCMEncodedFrame* ptrLastDeltaFrame = NULL;
VCMEncodedFrame* ptrFirstKeyFrame = NULL;
VCMEncodedFrame* frame_in;
uint32_t first_key_frame_timestamp = 0;
bool retransmitted = false;
// Insert MAX_NUMBER_OF_FRAMES frames.
do {
timestamp_ += 33*90;
@ -1123,20 +1061,14 @@ TEST_F(TestBasicJitterBuffer, ExceedNumOfFrameWithSeqNumWrap) {
packet_->seqNum = seq_num_;
packet_->timestamp = timestamp_;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_TRUE(frame_in != NULL);
if (loop == 49) { // last delta
ptrLastDeltaFrame = frame_in;
}
if (loop == 50) { // first key
ptrFirstKeyFrame = frame_in;
if (loop == 50) {
first_key_frame_timestamp = packet_->timestamp;
packet_->frameType = kVideoFrameKey;
}
// Insert frame.
EXPECT_EQ(kCompleteSession,
jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
loop++;
} while (loop < kMaxNumberOfFrames);
@ -1152,14 +1084,11 @@ TEST_F(TestBasicJitterBuffer, ExceedNumOfFrameWithSeqNumWrap) {
packet_->timestamp = timestamp_;
// Now, no free frame - frames will be recycled until first key frame.
frame_in = jitter_buffer_->GetFrame(*packet_);
// Pointer to last inserted delta frame should be returned.
EXPECT_TRUE(frame_in != NULL && frame_in && ptrLastDeltaFrame);
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(frame_in, *packet_));
VCMEncodedFrame* frame_out = DecodeCompleteFrame();;
EXPECT_EQ(ptrFirstKeyFrame, frame_out);
VCMEncodedFrame* frame_out = DecodeCompleteFrame();
EXPECT_EQ(first_key_frame_timestamp, frame_out->TimeStamp());
EXPECT_EQ(0, CheckOutFrame(frame_out, size_, false));
@ -1172,6 +1101,7 @@ TEST_F(TestBasicJitterBuffer, EmptyLastFrame) {
// Insert one empty packet per frame, should never return the last timestamp
// inserted. Only return empty frames in the presence of subsequent frames.
int maxSize = 1000;
bool retransmitted = false;
for (int i = 0; i < maxSize + 10; i++) {
timestamp_ += 33 * 90;
seq_num_++;
@ -1180,8 +1110,9 @@ TEST_F(TestBasicJitterBuffer, EmptyLastFrame) {
packet_->seqNum = seq_num_;
packet_->timestamp = timestamp_;
packet_->frameType = kFrameEmpty;
VCMEncodedFrame* frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
VCMEncodedFrame* testFrame = DecodeIncompleteFrame();
// Timestamp should never be the last TS inserted.
if (testFrame != NULL) {
@ -1202,10 +1133,10 @@ TEST_F(TestBasicJitterBuffer, H264IncompleteNalu) {
packet_->isFirstPacket = true;
packet_->completeNALU = kNaluStart;
packet_->markerBit = false;
bool retransmitted = false;
VCMEncodedFrame* frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
seq_num_ += 2; // Skip one packet
packet_->seqNum = seq_num_;
@ -1214,7 +1145,8 @@ TEST_F(TestBasicJitterBuffer, H264IncompleteNalu) {
packet_->completeNALU = kNaluIncomplete;
packet_->markerBit = false;
EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
seq_num_++;
packet_->seqNum = seq_num_;
@ -1223,13 +1155,15 @@ TEST_F(TestBasicJitterBuffer, H264IncompleteNalu) {
packet_->completeNALU = kNaluEnd;
packet_->markerBit = false;
EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
seq_num_++;
packet_->seqNum = seq_num_;
packet_->completeNALU = kNaluComplete;
packet_->markerBit = true; // Last packet
EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
// The JB will only output (incomplete) frames if a packet belonging to a
// subsequent frame was already inserted. Insert one packet of a subsequent
// frame. place high timestamp so the JB would always have a next frame
@ -1241,8 +1175,9 @@ TEST_F(TestBasicJitterBuffer, H264IncompleteNalu) {
packet_->isFirstPacket = false;
packet_->completeNALU = kNaluStart;
packet_->markerBit = false;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
VCMEncodedFrame* frame_out = DecodeIncompleteFrame();
@ -1264,8 +1199,9 @@ TEST_F(TestBasicJitterBuffer, H264IncompleteNalu) {
packet_->completeNALU = kNaluEnd;
packet_->markerBit = false;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
insertedLength += packet_->sizeBytes; // This packet should be decoded.
seq_num_--;
@ -1275,7 +1211,8 @@ TEST_F(TestBasicJitterBuffer, H264IncompleteNalu) {
packet_->isFirstPacket = true;
packet_->completeNALU = kNaluStart;
packet_->markerBit = false;
EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
insertedLength += packet_->sizeBytes; // This packet should be decoded.
seq_num_ += 3; // One packet drop
@ -1285,7 +1222,8 @@ TEST_F(TestBasicJitterBuffer, H264IncompleteNalu) {
packet_->isFirstPacket = false;
packet_->completeNALU = kNaluComplete;
packet_->markerBit = false;
EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
insertedLength += packet_->sizeBytes; // This packet should be decoded.
seq_num_ += 1;
@ -1295,7 +1233,8 @@ TEST_F(TestBasicJitterBuffer, H264IncompleteNalu) {
packet_->isFirstPacket = false;
packet_->completeNALU = kNaluStart;
packet_->markerBit = false;
EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
// This packet should be decoded since it's the beginning of a NAL.
insertedLength += packet_->sizeBytes;
@ -1306,7 +1245,8 @@ TEST_F(TestBasicJitterBuffer, H264IncompleteNalu) {
packet_->isFirstPacket = false;
packet_->completeNALU = kNaluEnd;
packet_->markerBit = true;
EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kIncomplete, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
// This packet should not be decoded because it is an incomplete NAL if it
// is the last.
frame_out = DecodeIncompleteFrame();
@ -1325,9 +1265,8 @@ TEST_F(TestBasicJitterBuffer, H264IncompleteNalu) {
emptypacket.isFirstPacket = true;
emptypacket.completeNALU = kNaluComplete;
emptypacket.markerBit = true;
frame_in = jitter_buffer_->GetFrame(emptypacket);
EXPECT_EQ(kCompleteSession,
jitter_buffer_->InsertPacket(frame_in, emptypacket));
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(emptypacket,
&retransmitted));
// This packet should not be decoded because it is an incomplete NAL if it
// is the last.
insertedLength += 0;
@ -1347,8 +1286,9 @@ TEST_F(TestBasicJitterBuffer, H264IncompleteNalu) {
packet_->isFirstPacket = true;
packet_->completeNALU = kNaluComplete;
packet_->markerBit = false;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
seq_num_ += 1;
emptypacket.seqNum = seq_num_;
@ -1357,8 +1297,8 @@ TEST_F(TestBasicJitterBuffer, H264IncompleteNalu) {
emptypacket.isFirstPacket = true;
emptypacket.completeNALU = kNaluComplete;
emptypacket.markerBit = true;
EXPECT_EQ(kCompleteSession,
jitter_buffer_->InsertPacket(frame_in, emptypacket));
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(emptypacket,
&retransmitted));
frame_out = DecodeCompleteFrame();
// Only last NALU is complete
@ -1374,8 +1314,10 @@ TEST_F(TestBasicJitterBuffer, NextFrameWhenIncomplete) {
packet_->frameType = kVideoFrameKey;
packet_->isFirstPacket = true;
packet_->markerBit = true;
VCMEncodedFrame* frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(frame_in, *packet_));
bool retransmitted = false;
EXPECT_EQ(kCompleteSession, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
VCMEncodedFrame* frame_out = DecodeCompleteFrame();
EXPECT_TRUE(frame_out != NULL);
@ -1385,8 +1327,9 @@ TEST_F(TestBasicJitterBuffer, NextFrameWhenIncomplete) {
packet_->isFirstPacket = false;
packet_->markerBit = false;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
frame_out = DecodeIncompleteFrame();
EXPECT_TRUE(frame_out == NULL);
@ -1395,8 +1338,9 @@ TEST_F(TestBasicJitterBuffer, NextFrameWhenIncomplete) {
packet_->timestamp += 33 * 90;
packet_->isFirstPacket = true;
frame_in = jitter_buffer_->GetFrame(*packet_);
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(frame_in, *packet_));
EXPECT_EQ(kFirstPacket, jitter_buffer_->InsertPacket(*packet_,
&retransmitted));
frame_out = DecodeIncompleteFrame();
@ -1563,12 +1507,17 @@ TEST_F(TestJitterBufferNack, NackTooOldPackets) {
bool request_key_frame = false;
uint16_t* nack_list = jitter_buffer_->GetNackList(&nack_list_length,
&request_key_frame);
// Verify that the jitter buffer requests a key frame.
EXPECT_TRUE(request_key_frame);
// No key frame will be requested since the jitter buffer is empty.
EXPECT_FALSE(request_key_frame);
EXPECT_TRUE(nack_list == NULL);
EXPECT_EQ(0, nack_list_length);
EXPECT_GE(InsertFrame(kVideoFrameDelta), kNoError);
// Verify that the jitter buffer requests a key frame since we need one to
// start decoding.
EXPECT_FALSE(request_key_frame);
EXPECT_TRUE(nack_list == NULL);
EXPECT_EQ(0, nack_list_length);
// Waiting for a key frame.
EXPECT_FALSE(DecodeCompleteFrame());
EXPECT_FALSE(DecodeIncompleteFrame());
@ -1614,10 +1563,17 @@ TEST_F(TestJitterBufferNack, NackListFull) {
uint16_t nack_list_length = max_nack_list_size_;
bool request_key_frame = false;
jitter_buffer_->GetNackList(&nack_list_length, &request_key_frame);
// Verify that the jitter buffer requests a key frame.
EXPECT_TRUE(request_key_frame);
// The jitter buffer is empty, so we won't request key frames until we get a
// packet.
EXPECT_FALSE(request_key_frame);
EXPECT_GE(InsertFrame(kVideoFrameDelta), kNoError);
// Now we have a packet in the jitter buffer, a key frame will be requested
// since it's not a key frame.
jitter_buffer_->GetNackList(&nack_list_length, &request_key_frame);
// The jitter buffer is empty, so we won't request key frames until we get a
// packet.
EXPECT_TRUE(request_key_frame);
// The next complete continuous frame isn't a key frame, but we're waiting
// for one.
EXPECT_FALSE(DecodeCompleteFrame());

12
webrtc/modules/video_coding/main/source/packet.cc
View File

@ -28,12 +28,14 @@ VCMPacket::VCMPacket()
isFirstPacket(false),
completeNALU(kNaluUnset),
insertStartCode(false),
width(0),
height(0),
codecSpecificHeader() {
}
VCMPacket::VCMPacket(const uint8_t* ptr,
const uint32_t size,
const WebRtcRTPHeader& rtpHeader) :
const uint32_t size,
const WebRtcRTPHeader& rtpHeader) :
payloadType(rtpHeader.header.payloadType),
timestamp(rtpHeader.header.timestamp),
seqNum(rtpHeader.header.sequenceNumber),
@ -46,6 +48,8 @@ VCMPacket::VCMPacket(const uint8_t* ptr,
isFirstPacket(rtpHeader.type.Video.isFirstPacket),
completeNALU(kNaluComplete),
insertStartCode(false),
width(rtpHeader.type.Video.width),
height(rtpHeader.type.Video.height),
codecSpecificHeader(rtpHeader.type.Video)
{
CopyCodecSpecifics(rtpHeader.type.Video);
@ -64,6 +68,8 @@ VCMPacket::VCMPacket(const uint8_t* ptr, uint32_t size, uint16_t seq, uint32_t t
isFirstPacket(false),
completeNALU(kNaluComplete),
insertStartCode(false),
width(0),
height(0),
codecSpecificHeader()
{}
@ -79,6 +85,8 @@ void VCMPacket::Reset() {
isFirstPacket = false;
completeNALU = kNaluUnset;
insertStartCode = false;
width = 0;
height = 0;
memset(&codecSpecificHeader, 0, sizeof(RTPVideoHeader));
}

2
webrtc/modules/video_coding/main/source/packet.h
View File

@ -45,6 +45,8 @@ public:
VCMNaluCompleteness completeNALU; // Default is kNaluIncomplete.
bool insertStartCode; // True if a start code should be inserted before this
// packet.
int width;
int height;
RTPVideoHeader codecSpecificHeader;
protected:

86
webrtc/modules/video_coding/main/source/receiver.cc
View File

@ -77,66 +77,36 @@ void VCMReceiver::UpdateRtt(uint32_t rtt) {
int32_t VCMReceiver::InsertPacket(const VCMPacket& packet,
uint16_t frame_width,
uint16_t frame_height) {
// Find an empty frame.
VCMEncodedFrame* buffer = NULL;
const int32_t error = jitter_buffer_.GetFrame(packet, buffer);
if (error == VCM_OLD_PACKET_ERROR) {
// Insert the packet into the jitter buffer. The packet can either be empty or
// contain media at this point.
bool retransmitted = false;
const VCMFrameBufferEnum ret = jitter_buffer_.InsertPacket(packet,
&retransmitted);
if (ret == kOldPacket) {
return VCM_OK;
} else if (error != VCM_OK) {
return error;
} else if (ret == kFlushIndicator) {
return VCM_FLUSH_INDICATOR;
} else if (ret < 0) {
WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCoding,
VCMId(vcm_id_, receiver_id_),
"Error inserting packet seqnum=%u, timestamp=%u",
packet.seqNum, packet.timestamp);
return VCM_JITTER_BUFFER_ERROR;
}
assert(buffer);
{
CriticalSectionScoped cs(crit_sect_);
if (frame_width && frame_height) {
buffer->SetEncodedSize(static_cast<uint32_t>(frame_width),
static_cast<uint32_t>(frame_height));
}
if (master_) {
// Only trace the primary receiver to make it possible to parse and plot
// the trace file.
WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVideoCoding,
VCMId(vcm_id_, receiver_id_),
"Packet seq_no %u of frame %u at %u",
packet.seqNum, packet.timestamp,
MaskWord64ToUWord32(clock_->TimeInMilliseconds()));
}
// First packet received belonging to this frame.
if (buffer->Length() == 0 && master_) {
const int64_t now_ms = clock_->TimeInMilliseconds();
// Only trace the primary receiver to make it possible to parse and plot
// the trace file.
WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVideoCoding,
VCMId(vcm_id_, receiver_id_),
"First packet of frame %u at %u", packet.timestamp,
MaskWord64ToUWord32(now_ms));
}
// Insert packet into the jitter buffer both media and empty packets.
const VCMFrameBufferEnum
ret = jitter_buffer_.InsertPacket(buffer, packet);
if (ret == kCompleteSession) {
bool retransmitted = false;
const int64_t last_packet_time_ms =
jitter_buffer_.LastPacketTime(buffer, &retransmitted);
if (last_packet_time_ms >= 0 && !retransmitted) {
// We don't want to include timestamps which have suffered from
// retransmission here, since we compensate with extra retransmission
// delay within the jitter estimate.
timing_->IncomingTimestamp(packet.timestamp, last_packet_time_ms);
}
}
if (ret == kFlushIndicator) {
return VCM_FLUSH_INDICATOR;
} else if (ret < 0) {
WEBRTC_TRACE(webrtc::kTraceError, webrtc::kTraceVideoCoding,
VCMId(vcm_id_, receiver_id_),
"Error inserting packet seq_no=%u, time_stamp=%u",
packet.seqNum, packet.timestamp);
return VCM_JITTER_BUFFER_ERROR;
}
if (ret == kCompleteSession && !retransmitted) {
// We don't want to include timestamps which have suffered from
// retransmission here, since we compensate with extra retransmission
// delay within the jitter estimate.
timing_->IncomingTimestamp(packet.timestamp, clock_->TimeInMilliseconds());
}
if (master_) {
// Only trace the primary receiver to make it possible to parse and plot
// the trace file.
WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVideoCoding,
VCMId(vcm_id_, receiver_id_),
"Packet seqnum=%u timestamp=%u inserted at %u",
packet.seqNum, packet.timestamp,
MaskWord64ToUWord32(clock_->TimeInMilliseconds()));
}
return VCM_OK;
}

4
webrtc/modules/video_coding/main/source/receiver_unittest.cc
View File

@ -47,7 +47,7 @@ class TestVCMReceiver : public ::testing::Test {
bool packet_available = stream_generator_->GetPacket(&packet, index);
EXPECT_TRUE(packet_available);
if (!packet_available)
return kStateError; // Return here to avoid crashes below.
return kGeneralError; // Return here to avoid crashes below.
// Arbitrary width and height.
return receiver_.InsertPacket(packet, 640, 480);
}
@ -58,7 +58,7 @@ class TestVCMReceiver : public ::testing::Test {
bool packet_available = stream_generator_->PopPacket(&packet, index);
EXPECT_TRUE(packet_available);
if (!packet_available)
return kStateError; // Return here to avoid crashes below.
return kGeneralError; // Return here to avoid crashes below.
return receiver_.InsertPacket(packet, kWidth, kHeight);
}