Request keyframe if too many packets are missing and NACK is disabled.

webrtc/modules/video_coding/main/source/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/main/source/jitter_buffer.h"
@@ skipping 922 matching lines @@
 
 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_)) {
+    if (nack_mode_ == kNoNack) {
+      // Packets missing but NACK disabled, request key frame.

[pbos-webrtc, 2015/06/26 05:01:02]

Should we request a keyframe even though the sequence is decodable? That might
make sense, since quality will start to deteriorate.

Also should this be called UpdateNackList if it's not related to NACK? Should
this check be plugged in elsewhere, or method renamed?

[joachim, 2015/06/26 07:46:01]

I'm not sure how to check if the sequence is decodable at that point. Isn't that
something only the codec knows?
I renamed the method to "CoverSequenceUpTo" and updated the comment in the
header file.

+      return false;
+    }
     // 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 {
+  } else if (nack_mode_ != kNoNack) {
     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_;
 }
@@ skipping 234 matching lines @@
   }
   // 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