modules/video_coding refactorings
The main purpose was the interface-> include rename, but other files
were also moved, eliminating the "main" dir.
To avoid breaking downstream, the "interface" directories were copied
into a new "video_coding/include" dir. The old headers got pragma
warnings added about deprecation (a very short deprecation since I plan
to remove them as soon downstream is updated).
Other files also moved:
video_coding/main/source -> video_coding
video_coding/main/test -> video_coding/test
BUG=webrtc:5095
TESTED=Passing compile-trybots with --clobber flag:
git cl try --clobber --bot=win_compile_rel --bot=linux_compile_rel --bot=android_compile_rel --bot=mac_compile_rel --bot=ios_rel --bot=linux_gn_rel --bot=win_x64_gn_rel --bot=mac_x64_gn_rel --bot=android_gn_rel -m tryserver.webrtc
R=stefan@webrtc.org, tommi@webrtc.org
Review URL: https://codereview.webrtc.org/1417283007 .
Cr-Commit-Position: refs/heads/master@{#10694}
diff --git a/webrtc/modules/video_coding/jitter_buffer.cc b/webrtc/modules/video_coding/jitter_buffer.cc
new file mode 100644
index 0000000..15195db
--- /dev/null
+++ b/webrtc/modules/video_coding/jitter_buffer.cc
@@ -0,0 +1,1322 @@
+/*
+ * Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
+ *
+ * Use of this source code is governed by a BSD-style license
+ * that can be found in the LICENSE file in the root of the source
+ * tree. An additional intellectual property rights grant can be found
+ * in the file PATENTS. All contributing project authors may
+ * be found in the AUTHORS file in the root of the source tree.
+ */
+#include "webrtc/modules/video_coding/jitter_buffer.h"
+
+#include <assert.h>
+
+#include <algorithm>
+#include <utility>
+
+#include "webrtc/base/checks.h"
+#include "webrtc/base/logging.h"
+#include "webrtc/base/trace_event.h"
+#include "webrtc/modules/rtp_rtcp/include/rtp_rtcp_defines.h"
+#include "webrtc/modules/video_coding/include/video_coding.h"
+#include "webrtc/modules/video_coding/frame_buffer.h"
+#include "webrtc/modules/video_coding/inter_frame_delay.h"
+#include "webrtc/modules/video_coding/internal_defines.h"
+#include "webrtc/modules/video_coding/jitter_buffer_common.h"
+#include "webrtc/modules/video_coding/jitter_estimator.h"
+#include "webrtc/modules/video_coding/packet.h"
+#include "webrtc/system_wrappers/include/clock.h"
+#include "webrtc/system_wrappers/include/critical_section_wrapper.h"
+#include "webrtc/system_wrappers/include/event_wrapper.h"
+#include "webrtc/system_wrappers/include/metrics.h"
+
+namespace webrtc {
+
+// Interval for updating SS data.
+static const uint32_t kSsCleanupIntervalSec = 60;
+
+// Use this rtt if no value has been reported.
+static const int64_t kDefaultRtt = 200;
+
+typedef std::pair<uint32_t, VCMFrameBuffer*> FrameListPair;
+
+bool IsKeyFrame(FrameListPair pair) {
+ return pair.second->FrameType() == kVideoFrameKey;
+}
+
+bool HasNonEmptyState(FrameListPair pair) {
+ return pair.second->GetState() != kStateEmpty;
+}
+
+void FrameList::InsertFrame(VCMFrameBuffer* frame) {
+ insert(rbegin().base(), FrameListPair(frame->TimeStamp(), frame));
+}
+
+VCMFrameBuffer* FrameList::PopFrame(uint32_t timestamp) {
+ FrameList::iterator it = find(timestamp);
+ if (it == end())
+ return NULL;
+ VCMFrameBuffer* frame = it->second;
+ erase(it);
+ return frame;
+}
+
+VCMFrameBuffer* FrameList::Front() const {
+ return begin()->second;
+}
+
+VCMFrameBuffer* FrameList::Back() const {
+ return rbegin()->second;
+}
+
+int FrameList::RecycleFramesUntilKeyFrame(FrameList::iterator* key_frame_it,
+ UnorderedFrameList* free_frames) {
+ int drop_count = 0;
+ FrameList::iterator it = begin();
+ while (!empty()) {
+ // Throw at least one frame.
+ it->second->Reset();
+ free_frames->push_back(it->second);
+ erase(it++);
+ ++drop_count;
+ if (it != end() && it->second->FrameType() == kVideoFrameKey) {
+ *key_frame_it = it;
+ return drop_count;
+ }
+ }
+ *key_frame_it = end();
+ return drop_count;
+}
+
+void FrameList::CleanUpOldOrEmptyFrames(VCMDecodingState* decoding_state,
+ UnorderedFrameList* free_frames) {
+ while (!empty()) {
+ VCMFrameBuffer* oldest_frame = Front();
+ bool remove_frame = false;
+ if (oldest_frame->GetState() == kStateEmpty && size() > 1) {
+ // This frame is empty, try to update the last decoded state and drop it
+ // if successful.
+ remove_frame = decoding_state->UpdateEmptyFrame(oldest_frame);
+ } else {
+ remove_frame = decoding_state->IsOldFrame(oldest_frame);
+ }
+ if (!remove_frame) {
+ break;
+ }
+ free_frames->push_back(oldest_frame);
+ TRACE_EVENT_INSTANT1("webrtc", "JB::OldOrEmptyFrameDropped", "timestamp",
+ oldest_frame->TimeStamp());
+ erase(begin());
+ }
+}
+
+void FrameList::Reset(UnorderedFrameList* free_frames) {
+ while (!empty()) {
+ begin()->second->Reset();
+ free_frames->push_back(begin()->second);
+ erase(begin());
+ }
+}
+
+bool Vp9SsMap::Insert(const VCMPacket& packet) {
+ if (!packet.codecSpecificHeader.codecHeader.VP9.ss_data_available)
+ return false;
+
+ ss_map_[packet.timestamp] = packet.codecSpecificHeader.codecHeader.VP9.gof;
+ return true;
+}
+
+void Vp9SsMap::Reset() {
+ ss_map_.clear();
+}
+
+bool Vp9SsMap::Find(uint32_t timestamp, SsMap::iterator* it_out) {
+ bool found = false;
+ for (SsMap::iterator it = ss_map_.begin(); it != ss_map_.end(); ++it) {
+ if (it->first == timestamp || IsNewerTimestamp(timestamp, it->first)) {
+ *it_out = it;
+ found = true;
+ }
+ }
+ return found;
+}
+
+void Vp9SsMap::RemoveOld(uint32_t timestamp) {
+ if (!TimeForCleanup(timestamp))
+ return;
+
+ SsMap::iterator it;
+ if (!Find(timestamp, &it))
+ return;
+
+ ss_map_.erase(ss_map_.begin(), it);
+ AdvanceFront(timestamp);
+}
+
+bool Vp9SsMap::TimeForCleanup(uint32_t timestamp) const {
+ if (ss_map_.empty() || !IsNewerTimestamp(timestamp, ss_map_.begin()->first))
+ return false;
+
+ uint32_t diff = timestamp - ss_map_.begin()->first;
+ return diff / kVideoPayloadTypeFrequency >= kSsCleanupIntervalSec;
+}
+
+void Vp9SsMap::AdvanceFront(uint32_t timestamp) {
+ RTC_DCHECK(!ss_map_.empty());
+ GofInfoVP9 gof = ss_map_.begin()->second;
+ ss_map_.erase(ss_map_.begin());
+ ss_map_[timestamp] = gof;
+}
+
+// TODO(asapersson): Update according to updates in RTP payload profile.
+bool Vp9SsMap::UpdatePacket(VCMPacket* packet) {
+ uint8_t gof_idx = packet->codecSpecificHeader.codecHeader.VP9.gof_idx;
+ if (gof_idx == kNoGofIdx)
+ return false; // No update needed.
+
+ SsMap::iterator it;
+ if (!Find(packet->timestamp, &it))
+ return false; // Corresponding SS not yet received.
+
+ if (gof_idx >= it->second.num_frames_in_gof)
+ return false; // Assume corresponding SS not yet received.
+
+ RTPVideoHeaderVP9* vp9 = &packet->codecSpecificHeader.codecHeader.VP9;
+ vp9->temporal_idx = it->second.temporal_idx[gof_idx];
+ vp9->temporal_up_switch = it->second.temporal_up_switch[gof_idx];
+
+ // TODO(asapersson): Set vp9.ref_picture_id[i] and add usage.
+ vp9->num_ref_pics = it->second.num_ref_pics[gof_idx];
+ for (uint8_t i = 0; i < it->second.num_ref_pics[gof_idx]; ++i) {
+ vp9->pid_diff[i] = it->second.pid_diff[gof_idx][i];
+ }
+ return true;
+}
+
+void Vp9SsMap::UpdateFrames(FrameList* frames) {
+ for (const auto& frame_it : *frames) {
+ uint8_t gof_idx =
+ frame_it.second->CodecSpecific()->codecSpecific.VP9.gof_idx;
+ if (gof_idx == kNoGofIdx) {
+ continue;
+ }
+ SsMap::iterator ss_it;
+ if (Find(frame_it.second->TimeStamp(), &ss_it)) {
+ if (gof_idx >= ss_it->second.num_frames_in_gof) {
+ continue; // Assume corresponding SS not yet received.
+ }
+ frame_it.second->SetGofInfo(ss_it->second, gof_idx);
+ }
+ }
+}
+
+VCMJitterBuffer::VCMJitterBuffer(Clock* clock,
+ rtc::scoped_ptr<EventWrapper> event)
+ : clock_(clock),
+ running_(false),
+ crit_sect_(CriticalSectionWrapper::CreateCriticalSection()),
+ frame_event_(event.Pass()),
+ max_number_of_frames_(kStartNumberOfFrames),
+ free_frames_(),
+ decodable_frames_(),
+ incomplete_frames_(),
+ last_decoded_state_(),
+ first_packet_since_reset_(true),
+ stats_callback_(NULL),
+ incoming_frame_rate_(0),
+ incoming_frame_count_(0),
+ time_last_incoming_frame_count_(0),
+ incoming_bit_count_(0),
+ incoming_bit_rate_(0),
+ num_consecutive_old_packets_(0),
+ num_packets_(0),
+ num_duplicated_packets_(0),
+ num_discarded_packets_(0),
+ time_first_packet_ms_(0),
+ jitter_estimate_(clock),
+ inter_frame_delay_(clock_->TimeInMilliseconds()),
+ rtt_ms_(kDefaultRtt),
+ nack_mode_(kNoNack),
+ low_rtt_nack_threshold_ms_(-1),
+ high_rtt_nack_threshold_ms_(-1),
+ missing_sequence_numbers_(SequenceNumberLessThan()),
+ max_nack_list_size_(0),
+ max_packet_age_to_nack_(0),
+ max_incomplete_time_ms_(0),
+ decode_error_mode_(kNoErrors),
+ average_packets_per_frame_(0.0f),
+ frame_counter_(0) {
+ for (int i = 0; i < kStartNumberOfFrames; i++)
+ free_frames_.push_back(new VCMFrameBuffer());
+}
+
+VCMJitterBuffer::~VCMJitterBuffer() {
+ Stop();
+ for (UnorderedFrameList::iterator it = free_frames_.begin();
+ it != free_frames_.end(); ++it) {
+ delete *it;
+ }
+ for (FrameList::iterator it = incomplete_frames_.begin();
+ it != incomplete_frames_.end(); ++it) {
+ delete it->second;
+ }
+ for (FrameList::iterator it = decodable_frames_.begin();
+ it != decodable_frames_.end(); ++it) {
+ delete it->second;
+ }
+ delete crit_sect_;
+}
+
+void VCMJitterBuffer::UpdateHistograms() {
+ if (num_packets_ <= 0 || !running_) {
+ return;
+ }
+ int64_t elapsed_sec =
+ (clock_->TimeInMilliseconds() - time_first_packet_ms_) / 1000;
+ if (elapsed_sec < metrics::kMinRunTimeInSeconds) {
+ return;
+ }
+
+ RTC_HISTOGRAM_PERCENTAGE("WebRTC.Video.DiscardedPacketsInPercent",
+ num_discarded_packets_ * 100 / num_packets_);
+ RTC_HISTOGRAM_PERCENTAGE("WebRTC.Video.DuplicatedPacketsInPercent",
+ num_duplicated_packets_ * 100 / num_packets_);
+
+ int total_frames =
+ receive_statistics_.key_frames + receive_statistics_.delta_frames;
+ if (total_frames > 0) {
+ RTC_HISTOGRAM_COUNTS_100("WebRTC.Video.CompleteFramesReceivedPerSecond",
+ static_cast<int>((total_frames / elapsed_sec) + 0.5f));
+ RTC_HISTOGRAM_COUNTS_1000(
+ "WebRTC.Video.KeyFramesReceivedInPermille",
+ static_cast<int>(
+ (receive_statistics_.key_frames * 1000.0f / total_frames) + 0.5f));
+ }
+}
+
+void VCMJitterBuffer::Start() {
+ CriticalSectionScoped cs(crit_sect_);
+ running_ = true;
+ incoming_frame_count_ = 0;
+ incoming_frame_rate_ = 0;
+ incoming_bit_count_ = 0;
+ incoming_bit_rate_ = 0;
+ time_last_incoming_frame_count_ = clock_->TimeInMilliseconds();
+ receive_statistics_ = FrameCounts();
+
+ num_consecutive_old_packets_ = 0;
+ num_packets_ = 0;
+ num_duplicated_packets_ = 0;
+ num_discarded_packets_ = 0;
+ time_first_packet_ms_ = 0;
+
+ // Start in a non-signaled state.
+ waiting_for_completion_.frame_size = 0;
+ waiting_for_completion_.timestamp = 0;
+ waiting_for_completion_.latest_packet_time = -1;
+ first_packet_since_reset_ = true;
+ rtt_ms_ = kDefaultRtt;
+ last_decoded_state_.Reset();
+}
+
+void VCMJitterBuffer::Stop() {
+ crit_sect_->Enter();
+ UpdateHistograms();
+ running_ = false;
+ last_decoded_state_.Reset();
+
+ // Make sure all frames are free and reset.
+ for (FrameList::iterator it = decodable_frames_.begin();
+ it != decodable_frames_.end(); ++it) {
+ free_frames_.push_back(it->second);
+ }
+ for (FrameList::iterator it = incomplete_frames_.begin();
+ it != incomplete_frames_.end(); ++it) {
+ free_frames_.push_back(it->second);
+ }
+ for (UnorderedFrameList::iterator it = free_frames_.begin();
+ it != free_frames_.end(); ++it) {
+ (*it)->Reset();
+ }
+ decodable_frames_.clear();
+ incomplete_frames_.clear();
+ crit_sect_->Leave();
+ // Make sure we wake up any threads waiting on these events.
+ frame_event_->Set();
+}
+
+bool VCMJitterBuffer::Running() const {
+ CriticalSectionScoped cs(crit_sect_);
+ return running_;
+}
+
+void VCMJitterBuffer::Flush() {
+ CriticalSectionScoped cs(crit_sect_);
+ decodable_frames_.Reset(&free_frames_);
+ incomplete_frames_.Reset(&free_frames_);
+ last_decoded_state_.Reset(); // TODO(mikhal): sync reset.
+ num_consecutive_old_packets_ = 0;
+ // Also reset the jitter and delay estimates
+ jitter_estimate_.Reset();
+ inter_frame_delay_.Reset(clock_->TimeInMilliseconds());
+ waiting_for_completion_.frame_size = 0;
+ waiting_for_completion_.timestamp = 0;
+ waiting_for_completion_.latest_packet_time = -1;
+ first_packet_since_reset_ = true;
+ missing_sequence_numbers_.clear();
+}
+
+// Get received key and delta frames
+FrameCounts VCMJitterBuffer::FrameStatistics() const {
+ CriticalSectionScoped cs(crit_sect_);
+ return receive_statistics_;
+}
+
+int VCMJitterBuffer::num_packets() const {
+ CriticalSectionScoped cs(crit_sect_);
+ return num_packets_;
+}
+
+int VCMJitterBuffer::num_duplicated_packets() const {
+ CriticalSectionScoped cs(crit_sect_);
+ return num_duplicated_packets_;
+}
+
+int VCMJitterBuffer::num_discarded_packets() const {
+ CriticalSectionScoped cs(crit_sect_);
+ return num_discarded_packets_;
+}
+
+// Calculate framerate and bitrate.
+void VCMJitterBuffer::IncomingRateStatistics(unsigned int* framerate,
+ unsigned int* bitrate) {
+ assert(framerate);
+ assert(bitrate);
+ CriticalSectionScoped cs(crit_sect_);
+ const int64_t now = clock_->TimeInMilliseconds();
+ int64_t diff = now - time_last_incoming_frame_count_;
+ if (diff < 1000 && incoming_frame_rate_ > 0 && incoming_bit_rate_ > 0) {
+ // Make sure we report something even though less than
+ // 1 second has passed since last update.
+ *framerate = incoming_frame_rate_;
+ *bitrate = incoming_bit_rate_;
+ } else if (incoming_frame_count_ != 0) {
+ // We have received frame(s) since last call to this function
+
+ // Prepare calculations
+ if (diff <= 0) {
+ diff = 1;
+ }
+ // we add 0.5f for rounding
+ float rate = 0.5f + ((incoming_frame_count_ * 1000.0f) / diff);
+ if (rate < 1.0f) {
+ rate = 1.0f;
+ }
+
+ // Calculate frame rate
+ // Let r be rate.
+ // r(0) = 1000*framecount/delta_time.
+ // (I.e. frames per second since last calculation.)
+ // frame_rate = r(0)/2 + r(-1)/2
+ // (I.e. fr/s average this and the previous calculation.)
+ *framerate = (incoming_frame_rate_ + static_cast<unsigned int>(rate)) / 2;
+ incoming_frame_rate_ = static_cast<unsigned int>(rate);
+
+ // Calculate bit rate
+ if (incoming_bit_count_ == 0) {
+ *bitrate = 0;
+ } else {
+ *bitrate = 10 * ((100 * incoming_bit_count_) /
+ static_cast<unsigned int>(diff));
+ }
+ incoming_bit_rate_ = *bitrate;
+
+ // Reset count
+ incoming_frame_count_ = 0;
+ incoming_bit_count_ = 0;
+ time_last_incoming_frame_count_ = now;
+
+ } else {
+ // No frames since last call
+ time_last_incoming_frame_count_ = clock_->TimeInMilliseconds();
+ *framerate = 0;
+ *bitrate = 0;
+ incoming_frame_rate_ = 0;
+ incoming_bit_rate_ = 0;
+ }
+}
+
+// Answers the question:
+// Will the packet sequence be complete if the next frame is grabbed for
+// decoding right now? That is, have we lost a frame between the last decoded
+// frame and the next, or is the next
+// frame missing one or more packets?
+bool VCMJitterBuffer::CompleteSequenceWithNextFrame() {
+ CriticalSectionScoped cs(crit_sect_);
+ // Finding oldest frame ready for decoder, check sequence number and size
+ CleanUpOldOrEmptyFrames();
+ if (!decodable_frames_.empty()) {
+ if (decodable_frames_.Front()->GetState() == kStateComplete) {
+ return true;
+ }
+ } else if (incomplete_frames_.size() <= 1) {
+ // Frame not ready to be decoded.
+ return true;
+ }
+ return false;
+}
+
+// Returns immediately or a |max_wait_time_ms| ms event hang waiting for a
+// complete frame, |max_wait_time_ms| decided by caller.
+bool VCMJitterBuffer::NextCompleteTimestamp(
+ uint32_t max_wait_time_ms, uint32_t* timestamp) {
+ crit_sect_->Enter();
+ if (!running_) {
+ crit_sect_->Leave();
+ return false;
+ }
+ CleanUpOldOrEmptyFrames();
+
+ if (decodable_frames_.empty() ||
+ decodable_frames_.Front()->GetState() != kStateComplete) {
+ const int64_t end_wait_time_ms = clock_->TimeInMilliseconds() +
+ max_wait_time_ms;
+ int64_t wait_time_ms = max_wait_time_ms;
+ while (wait_time_ms > 0) {
+ crit_sect_->Leave();
+ const EventTypeWrapper ret =
+ frame_event_->Wait(static_cast<uint32_t>(wait_time_ms));
+ crit_sect_->Enter();
+ if (ret == kEventSignaled) {
+ // Are we shutting down the jitter buffer?
+ if (!running_) {
+ crit_sect_->Leave();
+ return false;
+ }
+ // Finding oldest frame ready for decoder.
+ CleanUpOldOrEmptyFrames();
+ if (decodable_frames_.empty() ||
+ decodable_frames_.Front()->GetState() != kStateComplete) {
+ wait_time_ms = end_wait_time_ms - clock_->TimeInMilliseconds();
+ } else {
+ break;
+ }
+ } else {
+ break;
+ }
+ }
+ }
+ if (decodable_frames_.empty() ||
+ decodable_frames_.Front()->GetState() != kStateComplete) {
+ crit_sect_->Leave();
+ return false;
+ }
+ *timestamp = decodable_frames_.Front()->TimeStamp();
+ crit_sect_->Leave();
+ return true;
+}
+
+bool VCMJitterBuffer::NextMaybeIncompleteTimestamp(uint32_t* timestamp) {
+ CriticalSectionScoped cs(crit_sect_);
+ if (!running_) {
+ return false;
+ }
+ if (decode_error_mode_ == kNoErrors) {
+ // No point to continue, as we are not decoding with errors.
+ return false;
+ }
+
+ CleanUpOldOrEmptyFrames();
+
+ if (decodable_frames_.empty()) {
+ return false;
+ }
+ VCMFrameBuffer* oldest_frame = decodable_frames_.Front();
+ // If we have exactly one frame in the buffer, release it only if it is
+ // complete. We know decodable_frames_ is not empty due to the previous
+ // check.
+ if (decodable_frames_.size() == 1 && incomplete_frames_.empty()
+ && oldest_frame->GetState() != kStateComplete) {
+ return false;
+ }
+
+ *timestamp = oldest_frame->TimeStamp();
+ return true;
+}
+
+VCMEncodedFrame* VCMJitterBuffer::ExtractAndSetDecode(uint32_t timestamp) {
+ CriticalSectionScoped cs(crit_sect_);
+ if (!running_) {
+ return NULL;
+ }
+ // Extract the frame with the desired timestamp.
+ VCMFrameBuffer* frame = decodable_frames_.PopFrame(timestamp);
+ bool continuous = true;
+ if (!frame) {
+ frame = incomplete_frames_.PopFrame(timestamp);
+ if (frame)
+ continuous = last_decoded_state_.ContinuousFrame(frame);
+ else
+ return NULL;
+ }
+ TRACE_EVENT_ASYNC_STEP0("webrtc", "Video", timestamp, "Extract");
+ // Frame pulled out from jitter buffer, update the jitter estimate.
+ const bool retransmitted = (frame->GetNackCount() > 0);
+ if (retransmitted) {
+ jitter_estimate_.FrameNacked();
+ } else if (frame->Length() > 0) {
+ // Ignore retransmitted and empty frames.
+ if (waiting_for_completion_.latest_packet_time >= 0) {
+ UpdateJitterEstimate(waiting_for_completion_, true);
+ }
+ if (frame->GetState() == kStateComplete) {
+ UpdateJitterEstimate(*frame, false);
+ } else {
+ // Wait for this one to get complete.
+ waiting_for_completion_.frame_size = frame->Length();
+ waiting_for_completion_.latest_packet_time =
+ frame->LatestPacketTimeMs();
+ waiting_for_completion_.timestamp = frame->TimeStamp();
+ }
+ }
+
+ // The state must be changed to decoding before cleaning up zero sized
+ // frames to avoid empty frames being cleaned up and then given to the
+ // decoder. Propagates the missing_frame bit.
+ frame->PrepareForDecode(continuous);
+
+ // We have a frame - update the last decoded state and nack list.
+ last_decoded_state_.SetState(frame);
+ DropPacketsFromNackList(last_decoded_state_.sequence_num());
+
+ if ((*frame).IsSessionComplete())
+ UpdateAveragePacketsPerFrame(frame->NumPackets());
+
+ return frame;
+}
+
+// Release frame when done with decoding. Should never be used to release
+// frames from within the jitter buffer.
+void VCMJitterBuffer::ReleaseFrame(VCMEncodedFrame* frame) {
+ CriticalSectionScoped cs(crit_sect_);
+ VCMFrameBuffer* frame_buffer = static_cast<VCMFrameBuffer*>(frame);
+ if (frame_buffer) {
+ free_frames_.push_back(frame_buffer);
+ }
+}
+
+// Gets frame to use for this timestamp. If no match, get empty frame.
+VCMFrameBufferEnum VCMJitterBuffer::GetFrame(const VCMPacket& packet,
+ VCMFrameBuffer** frame,
+ FrameList** frame_list) {
+ *frame = incomplete_frames_.PopFrame(packet.timestamp);
+ if (*frame != NULL) {
+ *frame_list = &incomplete_frames_;
+ return kNoError;
+ }
+ *frame = decodable_frames_.PopFrame(packet.timestamp);
+ if (*frame != NULL) {
+ *frame_list = &decodable_frames_;
+ return kNoError;
+ }
+
+ *frame_list = NULL;
+ // No match, return empty frame.
+ *frame = GetEmptyFrame();
+ if (*frame == NULL) {
+ // No free frame! Try to reclaim some...
+ LOG(LS_WARNING) << "Unable to get empty frame; Recycling.";
+ bool found_key_frame = RecycleFramesUntilKeyFrame();
+ *frame = GetEmptyFrame();
+ assert(*frame);
+ if (!found_key_frame) {
+ free_frames_.push_back(*frame);
+ return kFlushIndicator;
+ }
+ }
+ (*frame)->Reset();
+ return kNoError;
+}
+
+int64_t VCMJitterBuffer::LastPacketTime(const VCMEncodedFrame* frame,
+ bool* retransmitted) const {
+ assert(retransmitted);
+ CriticalSectionScoped cs(crit_sect_);
+ const VCMFrameBuffer* frame_buffer =
+ static_cast<const VCMFrameBuffer*>(frame);
+ *retransmitted = (frame_buffer->GetNackCount() > 0);
+ return frame_buffer->LatestPacketTimeMs();
+}
+
+VCMFrameBufferEnum VCMJitterBuffer::InsertPacket(const VCMPacket& packet,
+ bool* retransmitted) {
+ CriticalSectionScoped cs(crit_sect_);
+
+ ++num_packets_;
+ if (num_packets_ == 1) {
+ time_first_packet_ms_ = clock_->TimeInMilliseconds();
+ }
+ // Does this packet belong to an old frame?
+ if (last_decoded_state_.IsOldPacket(&packet)) {
+ // Account only for media packets.
+ if (packet.sizeBytes > 0) {
+ num_discarded_packets_++;
+ num_consecutive_old_packets_++;
+ if (stats_callback_ != NULL)
+ stats_callback_->OnDiscardedPacketsUpdated(num_discarded_packets_);
+ }
+ // Update last decoded sequence number if the packet arrived late and
+ // belongs to a frame with a timestamp equal to the last decoded
+ // timestamp.
+ last_decoded_state_.UpdateOldPacket(&packet);
+ DropPacketsFromNackList(last_decoded_state_.sequence_num());
+
+ // Also see if this old packet made more incomplete frames continuous.
+ FindAndInsertContinuousFramesWithState(last_decoded_state_);
+
+ if (num_consecutive_old_packets_ > kMaxConsecutiveOldPackets) {
+ LOG(LS_WARNING)
+ << num_consecutive_old_packets_
+ << " consecutive old packets received. Flushing the jitter buffer.";
+ Flush();
+ return kFlushIndicator;
+ }
+ return kOldPacket;
+ }
+
+ num_consecutive_old_packets_ = 0;
+
+ VCMFrameBuffer* frame;
+ FrameList* frame_list;
+ const VCMFrameBufferEnum error = GetFrame(packet, &frame, &frame_list);
+ if (error != kNoError)
+ return error;
+
+ int64_t now_ms = clock_->TimeInMilliseconds();
+ // We are keeping track of the first and latest seq numbers, and
+ // the number of wraps to be able to calculate how many packets we expect.
+ if (first_packet_since_reset_) {
+ // Now it's time to start estimating jitter
+ // reset the delay estimate.
+ inter_frame_delay_.Reset(now_ms);
+ }
+
+ // Empty packets may bias the jitter estimate (lacking size component),
+ // therefore don't let empty packet trigger the following updates:
+ if (packet.frameType != kEmptyFrame) {
+ if (waiting_for_completion_.timestamp == packet.timestamp) {
+ // This can get bad if we have a lot of duplicate packets,
+ // we will then count some packet multiple times.
+ waiting_for_completion_.frame_size += packet.sizeBytes;
+ waiting_for_completion_.latest_packet_time = now_ms;
+ } else if (waiting_for_completion_.latest_packet_time >= 0 &&
+ waiting_for_completion_.latest_packet_time + 2000 <= now_ms) {
+ // A packet should never be more than two seconds late
+ UpdateJitterEstimate(waiting_for_completion_, true);
+ waiting_for_completion_.latest_packet_time = -1;
+ waiting_for_completion_.frame_size = 0;
+ waiting_for_completion_.timestamp = 0;
+ }
+ }
+
+ VCMFrameBufferStateEnum previous_state = frame->GetState();
+ // Insert packet.
+ FrameData frame_data;
+ frame_data.rtt_ms = rtt_ms_;
+ frame_data.rolling_average_packets_per_frame = average_packets_per_frame_;
+ VCMFrameBufferEnum buffer_state =
+ frame->InsertPacket(packet, now_ms, decode_error_mode_, frame_data);
+
+ if (previous_state != kStateComplete) {
+ TRACE_EVENT_ASYNC_BEGIN1("webrtc", "Video", frame->TimeStamp(),
+ "timestamp", frame->TimeStamp());
+ }
+
+ if (buffer_state > 0) {
+ incoming_bit_count_ += packet.sizeBytes << 3;
+ 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) &&
+ packet.frameType != kVideoFrameKey) {
+ buffer_state = kFlushIndicator;
+ }
+
+ latest_received_sequence_number_ = LatestSequenceNumber(
+ latest_received_sequence_number_, packet.seqNum);
+ }
+ }
+
+ // Is the frame already in the decodable list?
+ bool continuous = IsContinuous(*frame);
+ switch (buffer_state) {
+ case kGeneralError:
+ case kTimeStampError:
+ case kSizeError: {
+ free_frames_.push_back(frame);
+ break;
+ }
+ case kCompleteSession: {
+ if (previous_state != kStateDecodable &&
+ previous_state != kStateComplete) {
+ CountFrame(*frame);
+ if (continuous) {
+ // Signal that we have a complete session.
+ frame_event_->Set();
+ }
+ }
+ FALLTHROUGH();
+ }
+ // Note: There is no break here - continuing to kDecodableSession.
+ case kDecodableSession: {
+ *retransmitted = (frame->GetNackCount() > 0);
+ if (continuous) {
+ decodable_frames_.InsertFrame(frame);
+ FindAndInsertContinuousFrames(*frame);
+ } else {
+ incomplete_frames_.InsertFrame(frame);
+ }
+ break;
+ }
+ case kIncomplete: {
+ if (frame->GetState() == kStateEmpty &&
+ last_decoded_state_.UpdateEmptyFrame(frame)) {
+ free_frames_.push_back(frame);
+ return kNoError;
+ } else {
+ incomplete_frames_.InsertFrame(frame);
+ }
+ break;
+ }
+ case kNoError:
+ case kOutOfBoundsPacket:
+ case kDuplicatePacket: {
+ // Put back the frame where it came from.
+ if (frame_list != NULL) {
+ frame_list->InsertFrame(frame);
+ } else {
+ free_frames_.push_back(frame);
+ }
+ ++num_duplicated_packets_;
+ break;
+ }
+ case kFlushIndicator:
+ free_frames_.push_back(frame);
+ return kFlushIndicator;
+ default: assert(false);
+ }
+ return buffer_state;
+}
+
+bool VCMJitterBuffer::IsContinuousInState(const VCMFrameBuffer& frame,
+ const VCMDecodingState& decoding_state) const {
+ if (decode_error_mode_ == kWithErrors)
+ return true;
+ // Is this frame (complete or decodable) and continuous?
+ // kStateDecodable will never be set when decode_error_mode_ is false
+ // as SessionInfo determines this state based on the error mode (and frame
+ // completeness).
+ return (frame.GetState() == kStateComplete ||
+ frame.GetState() == kStateDecodable) &&
+ decoding_state.ContinuousFrame(&frame);
+}
+
+bool VCMJitterBuffer::IsContinuous(const VCMFrameBuffer& frame) const {
+ if (IsContinuousInState(frame, last_decoded_state_)) {
+ return true;
+ }
+ VCMDecodingState decoding_state;
+ decoding_state.CopyFrom(last_decoded_state_);
+ for (FrameList::const_iterator it = decodable_frames_.begin();
+ it != decodable_frames_.end(); ++it) {
+ VCMFrameBuffer* decodable_frame = it->second;
+ if (IsNewerTimestamp(decodable_frame->TimeStamp(), frame.TimeStamp())) {
+ break;
+ }
+ decoding_state.SetState(decodable_frame);
+ if (IsContinuousInState(frame, decoding_state)) {
+ return true;
+ }
+ }
+ return false;
+}
+
+void VCMJitterBuffer::FindAndInsertContinuousFrames(
+ const VCMFrameBuffer& new_frame) {
+ VCMDecodingState decoding_state;
+ decoding_state.CopyFrom(last_decoded_state_);
+ decoding_state.SetState(&new_frame);
+ FindAndInsertContinuousFramesWithState(decoding_state);
+}
+
+void VCMJitterBuffer::FindAndInsertContinuousFramesWithState(
+ const VCMDecodingState& original_decoded_state) {
+ // Copy original_decoded_state so we can move the state forward with each
+ // decodable frame we find.
+ VCMDecodingState decoding_state;
+ decoding_state.CopyFrom(original_decoded_state);
+
+ // When temporal layers are available, we search for a complete or decodable
+ // frame until we hit one of the following:
+ // 1. Continuous base or sync layer.
+ // 2. The end of the list was reached.
+ for (FrameList::iterator it = incomplete_frames_.begin();
+ it != incomplete_frames_.end();) {
+ VCMFrameBuffer* frame = it->second;
+ if (IsNewerTimestamp(original_decoded_state.time_stamp(),
+ frame->TimeStamp())) {
+ ++it;
+ continue;
+ }
+ if (IsContinuousInState(*frame, decoding_state)) {
+ decodable_frames_.InsertFrame(frame);
+ incomplete_frames_.erase(it++);
+ decoding_state.SetState(frame);
+ } else if (frame->TemporalId() <= 0) {
+ break;
+ } else {
+ ++it;
+ }
+ }
+}
+
+uint32_t VCMJitterBuffer::EstimatedJitterMs() {
+ CriticalSectionScoped cs(crit_sect_);
+ // Compute RTT multiplier for estimation.
+ // low_rtt_nackThresholdMs_ == -1 means no FEC.
+ double rtt_mult = 1.0f;
+ if (low_rtt_nack_threshold_ms_ >= 0 &&
+ rtt_ms_ >= low_rtt_nack_threshold_ms_) {
+ // For RTTs above low_rtt_nack_threshold_ms_ we don't apply extra delay
+ // when waiting for retransmissions.
+ rtt_mult = 0.0f;
+ }
+ return jitter_estimate_.GetJitterEstimate(rtt_mult);
+}
+
+void VCMJitterBuffer::UpdateRtt(int64_t rtt_ms) {
+ CriticalSectionScoped cs(crit_sect_);
+ rtt_ms_ = rtt_ms;
+ jitter_estimate_.UpdateRtt(rtt_ms);
+}
+
+void VCMJitterBuffer::SetNackMode(VCMNackMode mode,
+ int64_t low_rtt_nack_threshold_ms,
+ int64_t high_rtt_nack_threshold_ms) {
+ CriticalSectionScoped cs(crit_sect_);
+ nack_mode_ = mode;
+ if (mode == kNoNack) {
+ missing_sequence_numbers_.clear();
+ }
+ assert(low_rtt_nack_threshold_ms >= -1 && high_rtt_nack_threshold_ms >= -1);
+ assert(high_rtt_nack_threshold_ms == -1 ||
+ low_rtt_nack_threshold_ms <= high_rtt_nack_threshold_ms);
+ assert(low_rtt_nack_threshold_ms > -1 || high_rtt_nack_threshold_ms == -1);
+ low_rtt_nack_threshold_ms_ = low_rtt_nack_threshold_ms;
+ high_rtt_nack_threshold_ms_ = high_rtt_nack_threshold_ms;
+ // Don't set a high start rtt if high_rtt_nack_threshold_ms_ is used, to not
+ // disable NACK in |kNack| mode.
+ if (rtt_ms_ == kDefaultRtt && high_rtt_nack_threshold_ms_ != -1) {
+ rtt_ms_ = 0;
+ }
+ if (!WaitForRetransmissions()) {
+ jitter_estimate_.ResetNackCount();
+ }
+}
+
+void VCMJitterBuffer::SetNackSettings(size_t max_nack_list_size,
+ int max_packet_age_to_nack,
+ int max_incomplete_time_ms) {
+ CriticalSectionScoped cs(crit_sect_);
+ assert(max_packet_age_to_nack >= 0);
+ assert(max_incomplete_time_ms_ >= 0);
+ max_nack_list_size_ = max_nack_list_size;
+ max_packet_age_to_nack_ = max_packet_age_to_nack;
+ max_incomplete_time_ms_ = max_incomplete_time_ms;
+}
+
+VCMNackMode VCMJitterBuffer::nack_mode() const {
+ CriticalSectionScoped cs(crit_sect_);
+ return nack_mode_;
+}
+
+int VCMJitterBuffer::NonContinuousOrIncompleteDuration() {
+ if (incomplete_frames_.empty()) {
+ return 0;
+ }
+ uint32_t start_timestamp = incomplete_frames_.Front()->TimeStamp();
+ if (!decodable_frames_.empty()) {
+ start_timestamp = decodable_frames_.Back()->TimeStamp();
+ }
+ return incomplete_frames_.Back()->TimeStamp() - start_timestamp;
+}
+
+uint16_t VCMJitterBuffer::EstimatedLowSequenceNumber(
+ const VCMFrameBuffer& frame) const {
+ assert(frame.GetLowSeqNum() >= 0);
+ if (frame.HaveFirstPacket())
+ return frame.GetLowSeqNum();
+
+ // This estimate is not accurate if more than one packet with lower sequence
+ // number is lost.
+ return frame.GetLowSeqNum() - 1;
+}
+
+std::vector<uint16_t> VCMJitterBuffer::GetNackList(bool* request_key_frame) {
+ CriticalSectionScoped cs(crit_sect_);
+ *request_key_frame = false;
+ if (nack_mode_ == kNoNack) {
+ return std::vector<uint16_t>();
+ }
+ if (last_decoded_state_.in_initial_state()) {
+ VCMFrameBuffer* next_frame = NextFrame();
+ const bool first_frame_is_key = next_frame &&
+ next_frame->FrameType() == kVideoFrameKey &&
+ next_frame->HaveFirstPacket();
+ if (!first_frame_is_key) {
+ bool have_non_empty_frame = decodable_frames_.end() != find_if(
+ decodable_frames_.begin(), decodable_frames_.end(),
+ HasNonEmptyState);
+ if (!have_non_empty_frame) {
+ have_non_empty_frame = incomplete_frames_.end() != find_if(
+ incomplete_frames_.begin(), incomplete_frames_.end(),
+ HasNonEmptyState);
+ }
+ bool found_key_frame = RecycleFramesUntilKeyFrame();
+ if (!found_key_frame) {
+ *request_key_frame = have_non_empty_frame;
+ return std::vector<uint16_t>();
+ }
+ }
+ }
+ if (TooLargeNackList()) {
+ *request_key_frame = !HandleTooLargeNackList();
+ }
+ if (max_incomplete_time_ms_ > 0) {
+ int non_continuous_incomplete_duration =
+ NonContinuousOrIncompleteDuration();
+ if (non_continuous_incomplete_duration > 90 * max_incomplete_time_ms_) {
+ LOG_F(LS_WARNING) << "Too long non-decodable duration: "
+ << non_continuous_incomplete_duration << " > "
+ << 90 * max_incomplete_time_ms_;
+ FrameList::reverse_iterator rit = find_if(incomplete_frames_.rbegin(),
+ incomplete_frames_.rend(), IsKeyFrame);
+ if (rit == incomplete_frames_.rend()) {
+ // Request a key frame if we don't have one already.
+ *request_key_frame = true;
+ return std::vector<uint16_t>();
+ } else {
+ // Skip to the last key frame. If it's incomplete we will start
+ // NACKing it.
+ // Note that the estimated low sequence number is correct for VP8
+ // streams because only the first packet of a key frame is marked.
+ last_decoded_state_.Reset();
+ DropPacketsFromNackList(EstimatedLowSequenceNumber(*rit->second));
+ }
+ }
+ }
+ std::vector<uint16_t> nack_list(missing_sequence_numbers_.begin(),
+ missing_sequence_numbers_.end());
+ return nack_list;
+}
+
+void VCMJitterBuffer::SetDecodeErrorMode(VCMDecodeErrorMode error_mode) {
+ CriticalSectionScoped cs(crit_sect_);
+ decode_error_mode_ = error_mode;
+}
+
+VCMFrameBuffer* VCMJitterBuffer::NextFrame() const {
+ if (!decodable_frames_.empty())
+ return decodable_frames_.Front();
+ if (!incomplete_frames_.empty())
+ return incomplete_frames_.Front();
+ return NULL;
+}
+
+bool VCMJitterBuffer::UpdateNackList(uint16_t sequence_number) {
+ if (nack_mode_ == kNoNack) {
+ return true;
+ }
+ // Make sure we don't add packets which are already too old to be decoded.
+ if (!last_decoded_state_.in_initial_state()) {
+ latest_received_sequence_number_ = LatestSequenceNumber(
+ latest_received_sequence_number_,
+ last_decoded_state_.sequence_num());
+ }
+ if (IsNewerSequenceNumber(sequence_number,
+ latest_received_sequence_number_)) {
+ // Push any missing sequence numbers to the NACK list.
+ for (uint16_t i = latest_received_sequence_number_ + 1;
+ IsNewerSequenceNumber(sequence_number, i); ++i) {
+ missing_sequence_numbers_.insert(missing_sequence_numbers_.end(), i);
+ TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "AddNack",
+ "seqnum", i);
+ }
+ if (TooLargeNackList() && !HandleTooLargeNackList()) {
+ LOG(LS_WARNING) << "Requesting key frame due to too large NACK list.";
+ return false;
+ }
+ if (MissingTooOldPacket(sequence_number) &&
+ !HandleTooOldPackets(sequence_number)) {
+ LOG(LS_WARNING) << "Requesting key frame due to missing too old packets";
+ return false;
+ }
+ } else {
+ missing_sequence_numbers_.erase(sequence_number);
+ TRACE_EVENT_INSTANT1(TRACE_DISABLED_BY_DEFAULT("webrtc_rtp"), "RemoveNack",
+ "seqnum", sequence_number);
+ }
+ return true;
+}
+
+bool VCMJitterBuffer::TooLargeNackList() const {
+ return missing_sequence_numbers_.size() > max_nack_list_size_;
+}
+
+bool VCMJitterBuffer::HandleTooLargeNackList() {
+ // Recycle frames until the NACK list is small enough. It is likely cheaper to
+ // request a key frame than to retransmit this many missing packets.
+ LOG_F(LS_WARNING) << "NACK list has grown too large: "
+ << missing_sequence_numbers_.size() << " > "
+ << max_nack_list_size_;
+ bool key_frame_found = false;
+ while (TooLargeNackList()) {
+ key_frame_found = RecycleFramesUntilKeyFrame();
+ }
+ return key_frame_found;
+}
+
+bool VCMJitterBuffer::MissingTooOldPacket(
+ uint16_t latest_sequence_number) const {
+ if (missing_sequence_numbers_.empty()) {
+ return false;
+ }
+ const uint16_t age_of_oldest_missing_packet = latest_sequence_number -
+ *missing_sequence_numbers_.begin();
+ // Recycle frames if the NACK list contains too old sequence numbers as
+ // the packets may have already been dropped by the sender.
+ return age_of_oldest_missing_packet > max_packet_age_to_nack_;
+}
+
+bool VCMJitterBuffer::HandleTooOldPackets(uint16_t latest_sequence_number) {
+ bool key_frame_found = false;
+ const uint16_t age_of_oldest_missing_packet = latest_sequence_number -
+ *missing_sequence_numbers_.begin();
+ LOG_F(LS_WARNING) << "NACK list contains too old sequence numbers: "
+ << age_of_oldest_missing_packet << " > "
+ << max_packet_age_to_nack_;
+ while (MissingTooOldPacket(latest_sequence_number)) {
+ key_frame_found = RecycleFramesUntilKeyFrame();
+ }
+ return key_frame_found;
+}
+
+void VCMJitterBuffer::DropPacketsFromNackList(
+ uint16_t last_decoded_sequence_number) {
+ // Erase all sequence numbers from the NACK list which we won't need any
+ // longer.
+ missing_sequence_numbers_.erase(missing_sequence_numbers_.begin(),
+ missing_sequence_numbers_.upper_bound(
+ last_decoded_sequence_number));
+}
+
+int64_t VCMJitterBuffer::LastDecodedTimestamp() const {
+ CriticalSectionScoped cs(crit_sect_);
+ return last_decoded_state_.time_stamp();
+}
+
+void VCMJitterBuffer::RenderBufferSize(uint32_t* timestamp_start,
+ uint32_t* timestamp_end) {
+ CriticalSectionScoped cs(crit_sect_);
+ CleanUpOldOrEmptyFrames();
+ *timestamp_start = 0;
+ *timestamp_end = 0;
+ if (decodable_frames_.empty()) {
+ return;
+ }
+ *timestamp_start = decodable_frames_.Front()->TimeStamp();
+ *timestamp_end = decodable_frames_.Back()->TimeStamp();
+}
+
+void VCMJitterBuffer::RegisterStatsCallback(
+ VCMReceiveStatisticsCallback* callback) {
+ CriticalSectionScoped cs(crit_sect_);
+ stats_callback_ = callback;
+}
+
+VCMFrameBuffer* VCMJitterBuffer::GetEmptyFrame() {
+ if (free_frames_.empty()) {
+ if (!TryToIncreaseJitterBufferSize()) {
+ return NULL;
+ }
+ }
+ VCMFrameBuffer* frame = free_frames_.front();
+ free_frames_.pop_front();
+ return frame;
+}
+
+bool VCMJitterBuffer::TryToIncreaseJitterBufferSize() {
+ if (max_number_of_frames_ >= kMaxNumberOfFrames)
+ return false;
+ free_frames_.push_back(new VCMFrameBuffer());
+ ++max_number_of_frames_;
+ TRACE_COUNTER1("webrtc", "JBMaxFrames", max_number_of_frames_);
+ return true;
+}
+
+// Recycle oldest frames up to a key frame, used if jitter buffer is completely
+// full.
+bool VCMJitterBuffer::RecycleFramesUntilKeyFrame() {
+ // First release incomplete frames, and only release decodable frames if there
+ // are no incomplete ones.
+ FrameList::iterator key_frame_it;
+ bool key_frame_found = false;
+ int dropped_frames = 0;
+ dropped_frames += incomplete_frames_.RecycleFramesUntilKeyFrame(
+ &key_frame_it, &free_frames_);
+ key_frame_found = key_frame_it != incomplete_frames_.end();
+ if (dropped_frames == 0) {
+ dropped_frames += decodable_frames_.RecycleFramesUntilKeyFrame(
+ &key_frame_it, &free_frames_);
+ key_frame_found = key_frame_it != decodable_frames_.end();
+ }
+ TRACE_EVENT_INSTANT0("webrtc", "JB::RecycleFramesUntilKeyFrame");
+ if (key_frame_found) {
+ LOG(LS_INFO) << "Found key frame while dropping frames.";
+ // Reset last decoded state to make sure the next frame decoded is a key
+ // frame, and start NACKing from here.
+ last_decoded_state_.Reset();
+ DropPacketsFromNackList(EstimatedLowSequenceNumber(*key_frame_it->second));
+ } else if (decodable_frames_.empty()) {
+ // All frames dropped. Reset the decoding state and clear missing sequence
+ // numbers as we're starting fresh.
+ last_decoded_state_.Reset();
+ missing_sequence_numbers_.clear();
+ }
+ return key_frame_found;
+}
+
+// Must be called under the critical section |crit_sect_|.
+void VCMJitterBuffer::CountFrame(const VCMFrameBuffer& frame) {
+ incoming_frame_count_++;
+
+ if (frame.FrameType() == kVideoFrameKey) {
+ TRACE_EVENT_ASYNC_STEP0("webrtc", "Video",
+ frame.TimeStamp(), "KeyComplete");
+ } else {
+ TRACE_EVENT_ASYNC_STEP0("webrtc", "Video",
+ frame.TimeStamp(), "DeltaComplete");
+ }
+
+ // Update receive statistics. We count all layers, thus when you use layers
+ // adding all key and delta frames might differ from frame count.
+ if (frame.IsSessionComplete()) {
+ if (frame.FrameType() == kVideoFrameKey) {
+ ++receive_statistics_.key_frames;
+ } else {
+ ++receive_statistics_.delta_frames;
+ }
+ if (stats_callback_ != NULL)
+ stats_callback_->OnFrameCountsUpdated(receive_statistics_);
+ }
+}
+
+void VCMJitterBuffer::UpdateAveragePacketsPerFrame(int current_number_packets) {
+ if (frame_counter_ > kFastConvergeThreshold) {
+ average_packets_per_frame_ = average_packets_per_frame_
+ * (1 - kNormalConvergeMultiplier)
+ + current_number_packets * kNormalConvergeMultiplier;
+ } else if (frame_counter_ > 0) {
+ average_packets_per_frame_ = average_packets_per_frame_
+ * (1 - kFastConvergeMultiplier)
+ + current_number_packets * kFastConvergeMultiplier;
+ frame_counter_++;
+ } else {
+ average_packets_per_frame_ = current_number_packets;
+ frame_counter_++;
+ }
+}
+
+// Must be called under the critical section |crit_sect_|.
+void VCMJitterBuffer::CleanUpOldOrEmptyFrames() {
+ decodable_frames_.CleanUpOldOrEmptyFrames(&last_decoded_state_,
+ &free_frames_);
+ incomplete_frames_.CleanUpOldOrEmptyFrames(&last_decoded_state_,
+ &free_frames_);
+ if (!last_decoded_state_.in_initial_state()) {
+ DropPacketsFromNackList(last_decoded_state_.sequence_num());
+ }
+}
+
+// Must be called from within |crit_sect_|.
+bool VCMJitterBuffer::IsPacketRetransmitted(const VCMPacket& packet) const {
+ return missing_sequence_numbers_.find(packet.seqNum) !=
+ missing_sequence_numbers_.end();
+}
+
+// Must be called under the critical section |crit_sect_|. Should never be
+// called with retransmitted frames, they must be filtered out before this
+// function is called.
+void VCMJitterBuffer::UpdateJitterEstimate(const VCMJitterSample& sample,
+ bool incomplete_frame) {
+ if (sample.latest_packet_time == -1) {
+ return;
+ }
+ UpdateJitterEstimate(sample.latest_packet_time, sample.timestamp,
+ sample.frame_size, incomplete_frame);
+}
+
+// Must be called under the critical section crit_sect_. Should never be
+// called with retransmitted frames, they must be filtered out before this
+// function is called.
+void VCMJitterBuffer::UpdateJitterEstimate(const VCMFrameBuffer& frame,
+ bool incomplete_frame) {
+ if (frame.LatestPacketTimeMs() == -1) {
+ return;
+ }
+ // No retransmitted frames should be a part of the jitter
+ // estimate.
+ UpdateJitterEstimate(frame.LatestPacketTimeMs(), frame.TimeStamp(),
+ frame.Length(), incomplete_frame);
+}
+
+// Must be called under the critical section |crit_sect_|. Should never be
+// called with retransmitted frames, they must be filtered out before this
+// function is called.
+void VCMJitterBuffer::UpdateJitterEstimate(
+ int64_t latest_packet_time_ms,
+ uint32_t timestamp,
+ unsigned int frame_size,
+ bool incomplete_frame) {
+ if (latest_packet_time_ms == -1) {
+ return;
+ }
+ int64_t frame_delay;
+ bool not_reordered = inter_frame_delay_.CalculateDelay(timestamp,
+ &frame_delay,
+ latest_packet_time_ms);
+ // Filter out frames which have been reordered in time by the network
+ if (not_reordered) {
+ // Update the jitter estimate with the new samples
+ jitter_estimate_.UpdateEstimate(frame_delay, frame_size, incomplete_frame);
+ }
+}
+
+bool VCMJitterBuffer::WaitForRetransmissions() {
+ if (nack_mode_ == kNoNack) {
+ // NACK disabled -> don't wait for retransmissions.
+ return false;
+ }
+ // Evaluate if the RTT is higher than |high_rtt_nack_threshold_ms_|, and in
+ // that case we don't wait for retransmissions.
+ if (high_rtt_nack_threshold_ms_ >= 0 &&
+ rtt_ms_ >= high_rtt_nack_threshold_ms_) {
+ return false;
+ }
+ return true;
+}
+} // namespace webrtc