Added ClearTo(seq_num) to RtpFrameReferenceFinder.

webrtc/modules/video_coding/rtp_frame_reference_finder.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.
  */
 
 #include "webrtc/modules/video_coding/rtp_frame_reference_finder.h"
 
 #include <algorithm>
 #include <limits>
 
 #include "webrtc/base/checks.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/modules/video_coding/frame_object.h"
 #include "webrtc/modules/video_coding/packet_buffer.h"
 
 namespace webrtc {
 namespace video_coding {
 
 RtpFrameReferenceFinder::RtpFrameReferenceFinder(
     OnCompleteFrameCallback* frame_callback)
     : last_picture_id_(-1),
       last_unwrap_(-1),
       current_ss_idx_(0),
+      cleared_to_seq_num_(-1),
       frame_callback_(frame_callback) {}
 
 void RtpFrameReferenceFinder::ManageFrame(
     std::unique_ptr<RtpFrameObject> frame) {
   rtc::CritScope lock(&crit_);
+
+  // If we have cleared past this frame, drop it.
+  if (cleared_to_seq_num_ != -1 &&
+      AheadOf<uint16_t>(cleared_to_seq_num_, frame->first_seq_num())) {
+    return;
+  }
+
   switch (frame->codec_type()) {
     case kVideoCodecULPFEC:
     case kVideoCodecRED:
     case kVideoCodecUnknown:
       RTC_NOTREACHED();
       break;
     case kVideoCodecVP8:
       ManageFrameVp8(std::move(frame));
       break;
     case kVideoCodecVP9:
@@ skipping 10 matching lines @@
 void RtpFrameReferenceFinder::PaddingReceived(uint16_t seq_num) {
   rtc::CritScope lock(&crit_);
   auto clean_padding_to =
       stashed_padding_.lower_bound(seq_num - kMaxPaddingAge);
   stashed_padding_.erase(stashed_padding_.begin(), clean_padding_to);
   stashed_padding_.insert(seq_num);
   UpdateLastPictureIdWithPadding(seq_num);
   RetryStashedFrames();
 }
 
+void RtpFrameReferenceFinder::ClearTo(uint16_t seq_num) {
+  rtc::CritScope lock(&crit_);
+  cleared_to_seq_num_ = seq_num;
+  size_t num_stashed_frames = stashed_frames_.size();
+
+  for (size_t i = 0; i < num_stashed_frames; ++i) {

[stefan-webrtc, 2016/09/07 13:29:57]

Isn't it simpler to write this:

while (AheadOf<uint16_t>(cleared_to_seq_num_,
stashed_frames_.front()->first_seq_num()) {
  stashed_frames_.pop();
}

[philipel, 2016/09/08 11:27:19]

Frames might be inserted out of order, so we don't know if the oldest frames are
first in the queue, and even if they were inserted in order I'm not 100% sure
that order would be maintained.

[stefan-webrtc, 2016/09/08 11:51:30]

Ok, but what about:

for (it = stashed_frames_.begin(); ... ; ++it) {
  if (AheadOf<uint16_t>(cleared_to_seq_num_, it->first_seq_num()))
    stashed_frames_.erase(it++);

}

My main point is that it seems unnecessarily complicated to first pop the frame
and then insert it back if it wasn't too old. I guess that'd mean you have to a
list instead, but maybe that makes sense?

[philipel, 2016/09/08 12:16:03]

Changed to deque

+    std::unique_ptr<RtpFrameObject> frame = std::move(stashed_frames_.front());
+    stashed_frames_.pop();
+
+    if (AheadOf<uint16_t>(cleared_to_seq_num_, frame->first_seq_num()))
+      continue;
+
+    stashed_frames_.emplace(std::move(frame));
+  }
+}
+
 void RtpFrameReferenceFinder::UpdateLastPictureIdWithPadding(uint16_t seq_num) {
   auto gop_seq_num_it = last_seq_num_gop_.upper_bound(seq_num);
 
   // If this padding packet "belongs" to a group of pictures that we don't track
   // anymore, do nothing.
   if (gop_seq_num_it == last_seq_num_gop_.begin())
     return;
   --gop_seq_num_it;
 
   // Calculate the next contiuous sequence number and search for it in
@@ skipping 16 matching lines @@
 void RtpFrameReferenceFinder::RetryStashedFrames() {
   size_t num_stashed_frames = stashed_frames_.size();
 
   // Clean up stashed frames if there are too many.
   while (stashed_frames_.size() > kMaxStashedFrames)
     stashed_frames_.pop();
 
   // Since frames are stashed if there is not enough data to determine their
   // frame references we should at most check |stashed_frames_.size()| in
   // order to not pop and push frames in and endless loop.
+  // NOTE! This function may be called recursively, hence the
+  //       "!stashed_frames_.empty()" condition.
   for (size_t i = 0; i < num_stashed_frames && !stashed_frames_.empty(); ++i) {
     std::unique_ptr<RtpFrameObject> frame = std::move(stashed_frames_.front());
     stashed_frames_.pop();
     ManageFrame(std::move(frame));
   }
 }
 
 void RtpFrameReferenceFinder::ManageFrameGeneric(
     std::unique_ptr<RtpFrameObject> frame,
     int picture_id) {
@@ skipping 430 matching lines @@
   if (AheadOf<uint16_t, kPicIdLength>(picture_id, unwrap_truncated))
     last_unwrap_ = Add<1 << 16>(last_unwrap_, diff);
   else
     last_unwrap_ = Subtract<1 << 16>(last_unwrap_, diff);
 
   return last_unwrap_;
 }
 
 }  // namespace video_coding
 }  // namespace webrtc