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

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

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

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

@ -28,12 +28,14 @@ VCMPacket::VCMPacket()
isFirstPacket(false), isFirstPacket(false),
completeNALU(kNaluUnset), completeNALU(kNaluUnset),
insertStartCode(false), insertStartCode(false),
width(0),
height(0),
codecSpecificHeader() { codecSpecificHeader() {
} }
VCMPacket::VCMPacket(const uint8_t* ptr, VCMPacket::VCMPacket(const uint8_t* ptr,
const uint32_t size, const uint32_t size,
const WebRtcRTPHeader& rtpHeader) : const WebRtcRTPHeader& rtpHeader) :
payloadType(rtpHeader.header.payloadType), payloadType(rtpHeader.header.payloadType),
timestamp(rtpHeader.header.timestamp), timestamp(rtpHeader.header.timestamp),
seqNum(rtpHeader.header.sequenceNumber), seqNum(rtpHeader.header.sequenceNumber),
@ -46,6 +48,8 @@ VCMPacket::VCMPacket(const uint8_t* ptr,
isFirstPacket(rtpHeader.type.Video.isFirstPacket), isFirstPacket(rtpHeader.type.Video.isFirstPacket),
completeNALU(kNaluComplete), completeNALU(kNaluComplete),
insertStartCode(false), insertStartCode(false),
width(rtpHeader.type.Video.width),
height(rtpHeader.type.Video.height),
codecSpecificHeader(rtpHeader.type.Video) codecSpecificHeader(rtpHeader.type.Video)
{ {
CopyCodecSpecifics(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), isFirstPacket(false),
completeNALU(kNaluComplete), completeNALU(kNaluComplete),
insertStartCode(false), insertStartCode(false),
width(0),
height(0),
codecSpecificHeader() codecSpecificHeader()
{} {}
@ -79,6 +85,8 @@ void VCMPacket::Reset() {
isFirstPacket = false; isFirstPacket = false;
completeNALU = kNaluUnset; completeNALU = kNaluUnset;
insertStartCode = false; insertStartCode = false;
width = 0;
height = 0;
memset(&codecSpecificHeader, 0, sizeof(RTPVideoHeader)); 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. VCMNaluCompleteness completeNALU; // Default is kNaluIncomplete.
bool insertStartCode; // True if a start code should be inserted before this bool insertStartCode; // True if a start code should be inserted before this
// packet. // packet.
int width;
int height;
RTPVideoHeader codecSpecificHeader; RTPVideoHeader codecSpecificHeader;
protected: 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, int32_t VCMReceiver::InsertPacket(const VCMPacket& packet,
uint16_t frame_width, uint16_t frame_width,
uint16_t frame_height) { uint16_t frame_height) {
// Find an empty frame. // Insert the packet into the jitter buffer. The packet can either be empty or
VCMEncodedFrame* buffer = NULL; // contain media at this point.
const int32_t error = jitter_buffer_.GetFrame(packet, buffer); bool retransmitted = false;
if (error == VCM_OLD_PACKET_ERROR) { const VCMFrameBufferEnum ret = jitter_buffer_.InsertPacket(packet,
&retransmitted);
if (ret == kOldPacket) {
return VCM_OK; return VCM_OK;
} else if (error != VCM_OK) { } else if (ret == kFlushIndicator) {
return error; 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); if (ret == kCompleteSession && !retransmitted) {
{ // We don't want to include timestamps which have suffered from
CriticalSectionScoped cs(crit_sect_); // retransmission here, since we compensate with extra retransmission
// delay within the jitter estimate.
if (frame_width && frame_height) { timing_->IncomingTimestamp(packet.timestamp, clock_->TimeInMilliseconds());
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.
if (master_) { WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVideoCoding,
// Only trace the primary receiver to make it possible to parse and plot VCMId(vcm_id_, receiver_id_),
// the trace file. "Packet seqnum=%u timestamp=%u inserted at %u",
WEBRTC_TRACE(webrtc::kTraceDebug, webrtc::kTraceVideoCoding, packet.seqNum, packet.timestamp,
VCMId(vcm_id_, receiver_id_), MaskWord64ToUWord32(clock_->TimeInMilliseconds()));
"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;
}
} }
return VCM_OK; 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); bool packet_available = stream_generator_->GetPacket(&packet, index);
EXPECT_TRUE(packet_available); EXPECT_TRUE(packet_available);
if (!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. // Arbitrary width and height.
return receiver_.InsertPacket(packet, 640, 480); return receiver_.InsertPacket(packet, 640, 480);
} }
@ -58,7 +58,7 @@ class TestVCMReceiver : public ::testing::Test {
bool packet_available = stream_generator_->PopPacket(&packet, index); bool packet_available = stream_generator_->PopPacket(&packet, index);
EXPECT_TRUE(packet_available); EXPECT_TRUE(packet_available);
if (!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); return receiver_.InsertPacket(packet, kWidth, kHeight);
} }