Frame continuity is now tested as soon as a frame is inserted into the FrameBuffer.

webrtc/modules/video_coding/frame_buffer2.h

Index: webrtc/modules/video_coding/frame_buffer2.h
diff --git a/webrtc/modules/video_coding/frame_buffer2.h b/webrtc/modules/video_coding/frame_buffer2.h
index d0f896133f116cecef7491070c1ebd6508ae28ff..7ae4cc35912f34b24db8dad49d54780bc319ead1 100644
--- a/webrtc/modules/video_coding/frame_buffer2.h
+++ b/webrtc/modules/video_coding/frame_buffer2.h
@@ -14,15 +14,16 @@
 #include <array>
 #include <map>
 #include <memory>
-#include <set>
 #include <utility>
 
 #include "webrtc/base/constructormagic.h"
 #include "webrtc/base/criticalsection.h"
 #include "webrtc/base/event.h"
 #include "webrtc/base/thread_annotations.h"
+#include "webrtc/modules/video_coding/frame_object.h"
 #include "webrtc/modules/video_coding/include/video_coding_defines.h"
 #include "webrtc/modules/video_coding/inter_frame_delay.h"
+#include "webrtc/modules/video_coding/sequence_number_util.h"
 
 namespace webrtc {
 
@@ -32,8 +33,6 @@ class VCMTiming;
 
 namespace video_coding {
 
-class FrameObject;
-
 class FrameBuffer {
  public:
   enum ReturnReason { kFrameFound, kTimeout, kStopped };
@@ -42,12 +41,13 @@ class FrameBuffer {
               VCMJitterEstimator* jitter_estimator,
               VCMTiming* timing);
 
-  // Insert a frame into the frame buffer.
-  void InsertFrame(std::unique_ptr<FrameObject> frame);
+  // Insert a frame into the frame buffer. Returns the picture id
+  // of the last continuous frame or -1 if there is no continuous frame.
+  int InsertFrame(std::unique_ptr<FrameObject> frame);
 
   // Get the next frame for decoding. Will return at latest after
   // |max_wait_time_ms|.
-  //  - If a frame is availiable within |max_wait_time_ms| it will return
+  //  - If a frame is available within |max_wait_time_ms| it will return
   //    kFrameFound and set |frame_out| to the resulting frame.
   //  - If no frame is available after |max_wait_time_ms| it will return
   //    kTimeout.
@@ -70,21 +70,55 @@ class FrameBuffer {
   void Stop();
 
  private:
-  // FrameKey is a pair of (picture id, spatial layer).
-  using FrameKey = std::pair<uint16_t, uint8_t>;
+  struct FrameKey {
+    FrameKey() : picture_id(0), spatial_layer(0) {}
+    FrameKey(uint16_t picture_id, uint8_t spatial_layer)
+        : picture_id(picture_id), spatial_layer(spatial_layer) {}
+    uint16_t picture_id;
+    uint8_t spatial_layer;
+  };
+
+  struct FrameInfo {
+    static constexpr size_t kMaxNumDependentFrames = 5;
+
+    // Which other frames that have unfulfilled dependencies on this frame.
+    FrameKey dependent_frames[kMaxNumDependentFrames];
+    size_t num_dependent_frames = 0;
+
+    // How many unfulfilled frames this frame have to become continuous.
+    size_t num_missing_continuous = 0;
+
+    // How many unfulfilled frames this frame have to become decodable.
+    size_t num_missing_decodable = 0;
+
+    // If this frame is continuous or not.
+    bool continuous = false;
+
+    // If this frame has been handed off for decoding or not.
+    bool decoded = false;
+  };
 
   // Comparator used to sort frames, first on their picture id, and second
   // on their spatial layer.
   struct FrameComp {
-    bool operator()(const FrameKey& f1, const FrameKey& f2) const;
+    bool operator()(const FrameKey& f1, const FrameKey& f2) const {

[danilchap, 2016/09/12 12:20:14]

If you add this operator as a bool operator<(const FrameKey& other) const into
FrameKey
you will have one helper structure less.

[philipel, 2016/09/16 14:01:20]

Done.

+      if (f1.picture_id == f2.picture_id)

[danilchap, 2016/09/12 12:20:14]

what is the reason for moving implementation into .h from .cc?

[philipel, 2016/09/16 14:01:20]

The idea was to make it clearer how |frames_| and |frame_history_| works by just
reading the .h file.

[danilchap, 2016/09/19 12:21:50]

Acknowledged.

+        return f1.spatial_layer < f2.spatial_layer;
+      return AheadOf(f2.picture_id, f1.picture_id);
+    }
   };
 
-  // Determines whether a frame is continuous.
-  bool IsContinuous(const FrameObject& frame) const
+  // Update all directly dependent and indirectly dependent frames and mark
+  // them as continuous if all their references has been fulfilled.
+  void PropagateContinuity(const FrameKey& key)
+      EXCLUSIVE_LOCKS_REQUIRED(crit_);
+
+  // Mark the frame as decoded and updates all directly dependent frames.
+  void PropagateDecodability(const FrameKey& key)
       EXCLUSIVE_LOCKS_REQUIRED(crit_);
 
-  // Keep track of decoded frames.
-  std::set<FrameKey, FrameComp> decoded_frames_ GUARDED_BY(crit_);
+  // Keep track of recent frame history.
+  std::map<FrameKey, FrameInfo, FrameComp> frame_history_ GUARDED_BY(crit_);
 
   // The actual buffer that holds the FrameObjects.
   std::map<FrameKey, std::unique_ptr<FrameObject>, FrameComp> frames_
@@ -97,6 +131,8 @@ class FrameBuffer {
   VCMTiming* const timing_ GUARDED_BY(crit_);
   VCMInterFrameDelay inter_frame_delay_ GUARDED_BY(crit_);
   int newest_picture_id_ GUARDED_BY(crit_);
+  int last_continuous_picture_id_ GUARDED_BY(crit_);
+  int last_decoded_picture_id_ GUARDED_BY(crit_);
   bool stopped_ GUARDED_BY(crit_);
   VCMVideoProtection protection_mode_ GUARDED_BY(crit_);