modules/video_coding refactorings

webrtc/modules/video_coding/main/source/jitter_buffer.cc

Index: webrtc/modules/video_coding/main/source/jitter_buffer.cc
diff --git a/webrtc/modules/video_coding/main/source/jitter_buffer.cc b/webrtc/modules/video_coding/main/source/jitter_buffer.cc
deleted file mode 100644
index b5314de885b2fe741fb434c2d5976ca9e2cbdd47..0000000000000000000000000000000000000000
--- a/webrtc/modules/video_coding/main/source/jitter_buffer.cc
+++ /dev/null
@@ -1,1322 +0,0 @@
-/*
- *  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/main/source/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/main/interface/video_coding.h"
-#include "webrtc/modules/video_coding/main/source/frame_buffer.h"
-#include "webrtc/modules/video_coding/main/source/inter_frame_delay.h"
-#include "webrtc/modules/video_coding/main/source/internal_defines.h"
-#include "webrtc/modules/video_coding/main/source/jitter_buffer_common.h"
-#include "webrtc/modules/video_coding/main/source/jitter_estimator.h"
-#include "webrtc/modules/video_coding/main/source/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