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

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 20 matching lines @@
 #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;
 
+// Request a keyframe if no continuous frame has been received for this
+// number of milliseconds and NACKs are disabled.
+static const int64_t kMaxDiscontinuousFramesTime = 1000;
+
 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;
 }
 
@@ skipping 470 matching lines @@
   if (!running_) {
     return false;
   }
   if (decode_error_mode_ == kNoErrors) {
     // No point to continue, as we are not decoding with errors.
     return false;
   }
 
   CleanUpOldOrEmptyFrames();
 
+  VCMFrameBuffer* oldest_frame;
   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;
+    if (nack_mode_ != kNoNack || incomplete_frames_.size() <= 1) {
+      return false;
+    }
+    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) {
+      return false;
+    }
   }
 
   *timestamp = oldest_frame->TimeStamp();
   return true;
 }
 
 VCMEncodedFrame* VCMJitterBuffer::ExtractAndSetDecode(uint32_t timestamp) {
   CriticalSectionScoped cs(crit_sect_);
   if (!running_) {
     return NULL;
@@ skipping 221 matching lines @@
       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);
+        // If NACKs are enabled, keyframes are triggered by |GetNackList|.
+        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) {
+          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);
   }
   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 {
@@ skipping 484 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