diff --git a/webrtc/modules/video_coding/main/source/frame_buffer.cc b/webrtc/modules/video_coding/main/source/frame_buffer.cc index 69ef0a2127..5226ecbd52 100644 --- a/webrtc/modules/video_coding/main/source/frame_buffer.cc +++ b/webrtc/modules/video_coding/main/source/frame_buffer.cc @@ -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, diff --git a/webrtc/modules/video_coding/main/source/jitter_buffer.cc b/webrtc/modules/video_coding/main/source/jitter_buffer.cc index bef7bb59e6..a27dfc9827 100644 --- a/webrtc/modules/video_coding/main/source/jitter_buffer.cc +++ b/webrtc/modules/video_coding/main/source/jitter_buffer.cc @@ -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(frame)->GetNackCount() > 0); - return static_cast(frame)->LatestPacketTimeMs(); + const VCMFrameBuffer* frame_buffer = + static_cast(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(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; diff --git a/webrtc/modules/video_coding/main/source/jitter_buffer.h b/webrtc/modules/video_coding/main/source/jitter_buffer.h index 8cd1616181..05f2939dbb 100644 --- a/webrtc/modules/video_coding/main/source/jitter_buffer.h +++ b/webrtc/modules/video_coding/main/source/jitter_buffer.h @@ -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 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_; diff --git a/webrtc/modules/video_coding/main/source/jitter_buffer_common.h b/webrtc/modules/video_coding/main/source/jitter_buffer_common.h index e935c32f0a..9ecd9273cd 100644 --- a/webrtc/modules/video_coding/main/source/jitter_buffer_common.h +++ b/webrtc/modules/video_coding/main/source/jitter_buffer_common.h @@ -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, diff --git a/webrtc/modules/video_coding/main/source/jitter_buffer_unittest.cc b/webrtc/modules/video_coding/main/source/jitter_buffer_unittest.cc index e1fa12f4f4..5521093854 100644 --- a/webrtc/modules/video_coding/main/source/jitter_buffer_unittest.cc +++ b/webrtc/modules/video_coding/main/source/jitter_buffer_unittest.cc @@ -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()); diff --git a/webrtc/modules/video_coding/main/source/packet.cc b/webrtc/modules/video_coding/main/source/packet.cc index 10eba70fed..4604572f7b 100644 --- a/webrtc/modules/video_coding/main/source/packet.cc +++ b/webrtc/modules/video_coding/main/source/packet.cc @@ -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)); } diff --git a/webrtc/modules/video_coding/main/source/packet.h b/webrtc/modules/video_coding/main/source/packet.h index 91c446534d..54cd00f9c3 100644 --- a/webrtc/modules/video_coding/main/source/packet.h +++ b/webrtc/modules/video_coding/main/source/packet.h @@ -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: diff --git a/webrtc/modules/video_coding/main/source/receiver.cc b/webrtc/modules/video_coding/main/source/receiver.cc index 41ccf5f9a9..89383ea870 100644 --- a/webrtc/modules/video_coding/main/source/receiver.cc +++ b/webrtc/modules/video_coding/main/source/receiver.cc @@ -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(frame_width), - static_cast(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; } diff --git a/webrtc/modules/video_coding/main/source/receiver_unittest.cc b/webrtc/modules/video_coding/main/source/receiver_unittest.cc index 62b7a99caf..fee1f8e834 100644 --- a/webrtc/modules/video_coding/main/source/receiver_unittest.cc +++ b/webrtc/modules/video_coding/main/source/receiver_unittest.cc @@ -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); }