Skip non-continuous FrameInfos when finding the next frame to return from FrameBuffer::NextFrame.

webrtc/modules/video_coding/frame_buffer2.cc

 /*
  *  Copyright (c) 2016 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.
  */
 
@@ skipping 67 matching lines @@
         ++frame_it;
       }
 
       // |continuous_end_it| points to the first frame after the
       // |last_continuous_frame_it_|.
       auto continuous_end_it = last_continuous_frame_it_;
       if (continuous_end_it != frames_.end())
         ++continuous_end_it;
 
       for (; frame_it != continuous_end_it; ++frame_it) {
-        if (frame_it->second.num_missing_decodable > 0)
+        if (!frame_it->second.continuous ||
+            frame_it->second.num_missing_decodable > 0) {
           continue;
+        }
 
         FrameObject* frame = frame_it->second.frame.get();
         next_frame_it = frame_it;
         if (frame->RenderTime() == -1)
           frame->SetRenderTime(timing_->RenderTimeMs(frame->timestamp, now_ms));
         wait_ms = timing_->MaxWaitingTime(frame->RenderTime(), now_ms);
 
         // This will cause the frame buffer to prefer high framerate rather
         // than high resolution in the case of the decoder not decoding fast
         // enough and the stream has multiple spatial and temporal layers.
@@ skipping 44 matching lines @@
 }
 
 void FrameBuffer::Stop() {
   rtc::CritScope lock(&crit_);
   stopped_ = true;
   new_countinuous_frame_event_.Set();
 }
 
 int FrameBuffer::InsertFrame(std::unique_ptr<FrameObject> frame) {
   rtc::CritScope lock(&crit_);
+  RTC_DCHECK(frame);
+
   FrameKey key(frame->picture_id, frame->spatial_layer);
   int last_continuous_picture_id =
       last_continuous_frame_it_ == frames_.end()
           ? -1
           : last_continuous_frame_it_->first.picture_id;
 
   if (num_frames_buffered_ >= kMaxFramesBuffered) {
     LOG(LS_WARNING) << "Frame with (picture_id:spatial_id) (" << key.picture_id
                     << ":" << static_cast<int>(key.spatial_layer)
                     << ") could not be inserted due to the frame "
@@ skipping 15 matching lines @@
                     << ") inserted after frame ("
                     << last_decoded_frame_it_->first.picture_id << ":"
                     << static_cast<int>(
                            last_decoded_frame_it_->first.spatial_layer)
                     << ") was handed off for decoding, dropping frame.";
     return last_continuous_picture_id;
   }
 
   auto info = frames_.insert(std::make_pair(key, FrameInfo())).first;
 
-  if (!UpdateFrameInfoWithIncomingFrame(*frame, info)) {
-    frames_.erase(info);
+  if (info->second.frame) {
+    LOG(LS_WARNING) << "Frame with (picture_id:spatial_id) (" << key.picture_id
+                    << ":" << static_cast<int>(key.spatial_layer)
+                    << ") already inserted, dropping frame.";
     return last_continuous_picture_id;
   }
 
+  if (!UpdateFrameInfoWithIncomingFrame(*frame, info))
+    return last_continuous_picture_id;
+
   info->second.frame = std::move(frame);
   ++num_frames_buffered_;
 
   if (info->second.num_missing_continuous == 0) {
     info->second.continuous = true;
     PropagateContinuity(info);
     last_continuous_picture_id = last_continuous_frame_it_->first.picture_id;
 
     // Since we now have new continuous frames there might be a better frame
     // to return from NextFrame. Signal that thread so that it again can choose
@@ skipping 30 matching lines @@
         frame_ref->second.continuous = true;
         continuous_frames.push(frame_ref);
       }
     }
   }
 }
 
 void FrameBuffer::PropagateDecodability(const FrameInfo& info) {
   for (size_t d = 0; d < info.num_dependent_frames; ++d) {
     auto ref_info = frames_.find(info.dependent_frames[d]);
+    RTC_DCHECK(ref_info != frames_.end());

[stefan-webrtc, 2016/10/05 14:02:49]

NE?

[philipel, 2016/10/05 14:30:01]

Sorry, comparing iterators don't work with the DCHECK macros.

     RTC_DCHECK_GT(ref_info->second.num_missing_decodable, 0U);
     --ref_info->second.num_missing_decodable;
   }
 }
 
 void FrameBuffer::AdvanceLastDecodedFrame(FrameMap::iterator decoded) {
   if (last_decoded_frame_it_ == frames_.end()) {
     last_decoded_frame_it_ = frames_.begin();
   } else {
     RTC_DCHECK(last_decoded_frame_it_->first < decoded->first);
@@ skipping 50 matching lines @@
 
       if (ref_info->second.continuous)
         --info->second.num_missing_continuous;
 
       // Add backwards reference so |frame| can be updated when new
       // frames are inserted or decoded.
       ref_info->second.dependent_frames[ref_info->second.num_dependent_frames] =
           key;
       ++ref_info->second.num_dependent_frames;
     }
+    RTC_DCHECK_LE(ref_info->second.num_missing_continuous,
+                  ref_info->second.num_missing_decodable);
   }
 
   // Check if we have the lower spatial layer frame.
   if (frame.inter_layer_predicted) {
     ++info->second.num_missing_continuous;
     ++info->second.num_missing_decodable;
 
     FrameKey ref_key(frame.picture_id, frame.spatial_layer - 1);
     // Gets or create the FrameInfo for the referenced frame.
     auto ref_info = frames_.insert(std::make_pair(ref_key, FrameInfo())).first;
     if (ref_info->second.continuous)
       --info->second.num_missing_continuous;
 
     if (ref_info == last_decoded_frame_it_) {
       --info->second.num_missing_decodable;
     } else {
       ref_info->second.dependent_frames[ref_info->second.num_dependent_frames] =
           key;
       ++ref_info->second.num_dependent_frames;
     }
+    RTC_DCHECK_LE(ref_info->second.num_missing_continuous,
+                  ref_info->second.num_missing_decodable);
   }
 
+  RTC_DCHECK_LE(info->second.num_missing_continuous,
+                info->second.num_missing_decodable);
+
   return true;
 }
 
 }  // namespace video_coding
 }  // namespace webrtc