Lint enabled for webrtc/modules/video_coding folder.

webrtc/modules/video_coding/jitter_buffer.cc

 /*
  *  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"
@@ skipping 75 matching lines @@
     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) {
+                                        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);
     }
@@ skipping 168 matching lines @@
   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_);
+                           num_discarded_packets_ * 100 / num_packets_);
   RTC_HISTOGRAM_PERCENTAGE("WebRTC.Video.DuplicatedPacketsInPercent",
-      num_duplicated_packets_ * 100 / num_packets_);
+                           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",
+    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_);
@@ skipping 120 matching lines @@
     // (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));
+      *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
@@ skipping 20 matching lines @@
     }
   } 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) {
+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;
+    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));
+          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() ||
@@ skipping 37 matching lines @@
     oldest_frame = incomplete_frames_.Front();
     // Frame will only be removed from buffer if it is complete (or decodable).
     if (oldest_frame->GetState() < kStateComplete) {
       return false;
     }
   } else {
     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) {
+    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_);
@@ skipping 18 matching lines @@
   } 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_.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.
@@ skipping 132 matching lines @@
 
   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());
+    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);
+      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);
@@ skipping 12 matching lines @@
     }
     // 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);
         // If NACKs are enabled, keyframes are triggered by |GetNackList|.
-        if (nack_mode_ == kNoNack && NonContinuousOrIncompleteDuration() >
-            90 * kMaxDiscontinuousFramesTime) {
+        if (nack_mode_ == kNoNack &&
+            NonContinuousOrIncompleteDuration() >
+                90 * kMaxDiscontinuousFramesTime) {
           return kFlushIndicator;
         }
       }
       break;
     }
     case kIncomplete: {
       if (frame->GetState() == kStateEmpty &&
           last_decoded_state_.UpdateEmptyFrame(frame)) {
         free_frames_.push_back(frame);
         return kNoError;
       } else {
         incomplete_frames_.InsertFrame(frame);
         // If NACKs are enabled, keyframes are triggered by |GetNackList|.
-        if (nack_mode_ == kNoNack && NonContinuousOrIncompleteDuration() >
-            90 * kMaxDiscontinuousFramesTime) {
+        if (nack_mode_ == kNoNack &&
+            NonContinuousOrIncompleteDuration() >
+                90 * kMaxDiscontinuousFramesTime) {
           return kFlushIndicator;
         }
       }
       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);
+    default:
+      assert(false);
   }
   return buffer_state;
 }
 
-bool VCMJitterBuffer::IsContinuousInState(const VCMFrameBuffer& frame,
+bool VCMJitterBuffer::IsContinuousInState(
+    const VCMFrameBuffer& frame,
     const VCMDecodingState& decoding_state) const {
   // 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)  {
+       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;
@@ skipping 12 matching lines @@
   // 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();)  {
+       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);
@@ skipping 89 matching lines @@
 
 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();
+                                    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);
+      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);
+        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);
+      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();
@@ skipping 19 matching lines @@
   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());
+        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);
     }
@@ skipping 29 matching lines @@
     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();
+  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();
+  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));
+  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_);
@@ skipping 63 matching lines @@
     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");
+    TRACE_EVENT_ASYNC_STEP0("webrtc", "Video", frame.TimeStamp(),
+                            "KeyComplete");
   } else {
-    TRACE_EVENT_ASYNC_STEP0("webrtc", "Video",
-                            frame.TimeStamp(), "DeltaComplete");
+    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;
+    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;
+    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();
+         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;
   }
@@ skipping 11 matching lines @@
   }
   // 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) {
+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);
+  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