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;
+
+  auto it = stashed_frames_.begin();
+  while (it != stashed_frames_.end()) {
+    if (AheadOf<uint16_t>(cleared_to_seq_num_, (*it)->first_seq_num())) {
+      it = stashed_frames_.erase(it);
+    } else {
+      ++it;
+    }
+  }
+}
+
 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 11 matching lines @@
     ++next_seq_num_with_padding;
     padding_seq_num_it = stashed_padding_.erase(padding_seq_num_it);
   }
 }
 
 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();
+    stashed_frames_.pop_front();
 
   // 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();
+    stashed_frames_.pop_front();
     ManageFrame(std::move(frame));
   }
 }
 
 void RtpFrameReferenceFinder::ManageFrameGeneric(
     std::unique_ptr<RtpFrameObject> frame,
     int picture_id) {
   // If |picture_id| is specified then we use that to set the frame references,
   // otherwise we use sequence number.
   if (picture_id != kNoPictureId) {
     if (last_unwrap_ == -1)
       last_unwrap_ = picture_id;
 
     frame->picture_id = UnwrapPictureId(picture_id % kPicIdLength);
     frame->num_references = frame->frame_type() == kVideoFrameKey ? 0 : 1;
     frame->references[0] = frame->picture_id - 1;
     frame_callback_->OnCompleteFrame(std::move(frame));
     return;
   }
 
   if (frame->frame_type() == kVideoFrameKey) {
     last_seq_num_gop_.insert(std::make_pair(
         frame->last_seq_num(),
         std::make_pair(frame->last_seq_num(), frame->last_seq_num())));
   }
 
   // We have received a frame but not yet a keyframe, stash this frame.
   if (last_seq_num_gop_.empty()) {
-    stashed_frames_.emplace(std::move(frame));
+    stashed_frames_.push_back(std::move(frame));
     return;
   }
 
   // Clean up info for old keyframes but make sure to keep info
   // for the last keyframe.
   auto clean_to = last_seq_num_gop_.lower_bound(frame->last_seq_num() - 100);
   if (clean_to != last_seq_num_gop_.end())
     last_seq_num_gop_.erase(last_seq_num_gop_.begin(), clean_to);
 
   // Find the last sequence number of the last frame for the keyframe
   // that this frame indirectly references.
   auto seq_num_it = last_seq_num_gop_.upper_bound(frame->last_seq_num());
   if (seq_num_it == last_seq_num_gop_.begin()) {
     LOG(LS_WARNING) << "Generic frame with packet range ["
                     << frame->first_seq_num() << ", " << frame->last_seq_num()
                     << "] has no Gop, dropping frame.";
     return;
   }
   seq_num_it--;
 
   // Make sure the packet sequence numbers are continuous, otherwise stash
   // this frame.
   uint16_t last_picture_id_gop = seq_num_it->second.first;
   uint16_t last_picture_id_with_padding_gop = seq_num_it->second.second;
   if (frame->frame_type() == kVideoFrameDelta) {
     uint16_t prev_seq_num = frame->first_seq_num() - 1;
     if (prev_seq_num != last_picture_id_with_padding_gop) {
-      stashed_frames_.emplace(std::move(frame));
+      stashed_frames_.push_back(std::move(frame));
       return;
     }
   }
 
   RTC_DCHECK(AheadOrAt(frame->last_seq_num(), seq_num_it->first));
 
   // Since keyframes can cause reordering we can't simply assign the
   // picture id according to some incrementing counter.
   frame->picture_id = frame->last_seq_num();
   frame->num_references = frame->frame_type() == kVideoFrameDelta;
@@ skipping 60 matching lines @@
     CompletedFrameVp8(std::move(frame));
     return;
   }
 
   auto layer_info_it = layer_info_.find(codec_header.temporalIdx == 0
                                             ? codec_header.tl0PicIdx - 1
                                             : codec_header.tl0PicIdx);
 
   // If we don't have the base layer frame yet, stash this frame.
   if (layer_info_it == layer_info_.end()) {
-    stashed_frames_.emplace(std::move(frame));
+    stashed_frames_.push_back(std::move(frame));
     return;
   }
 
   // A non keyframe base layer frame has been received, copy the layer info
   // from the previous base layer frame and set a reference to the previous
   // base layer frame.
   if (codec_header.temporalIdx == 0) {
     layer_info_it =
         layer_info_
             .insert(make_pair(codec_header.tl0PicIdx, layer_info_it->second))
@@ skipping 18 matching lines @@
   for (uint8_t layer = 0; layer <= codec_header.temporalIdx; ++layer) {
     RTC_DCHECK_NE(-1, layer_info_it->second[layer]);
 
     // If we have not yet received a frame between this frame and the referenced
     // frame then we have to wait for that frame to be completed first.
     auto not_received_frame_it =
         not_yet_received_frames_.upper_bound(layer_info_it->second[layer]);
     if (not_received_frame_it != not_yet_received_frames_.end() &&
         AheadOf<uint16_t, kPicIdLength>(frame->picture_id,
                                         *not_received_frame_it)) {
-      stashed_frames_.emplace(std::move(frame));
+      stashed_frames_.push_back(std::move(frame));
       return;
     }
 
     ++frame->num_references;
     frame->references[layer] = layer_info_it->second[layer];
   }
 
   CompletedFrameVp8(std::move(frame));
 }
 
@@ skipping 101 matching lines @@
     return;
   }
 
   auto gof_info_it = gof_info_.find(
       (codec_header.temporal_idx == 0 && !codec_header.ss_data_available)
           ? codec_header.tl0_pic_idx - 1
           : codec_header.tl0_pic_idx);
 
   // Gof info for this frame is not available yet, stash this frame.
   if (gof_info_it == gof_info_.end()) {
-    stashed_frames_.emplace(std::move(frame));
+    stashed_frames_.push_back(std::move(frame));
     return;
   }
 
   GofInfo* info = &gof_info_it->second;
   FrameReceivedVp9(frame->picture_id, info);
 
   // Make sure we don't miss any frame that could potentially have the
   // up switch flag set.
   if (MissingRequiredFrameVp9(frame->picture_id, *info)) {
-    stashed_frames_.emplace(std::move(frame));
+    stashed_frames_.push_back(std::move(frame));
     return;
   }
 
   if (codec_header.temporal_up_switch) {
     auto pid_tidx =
         std::make_pair(frame->picture_id, codec_header.temporal_idx);
     up_switch_.insert(pid_tidx);
   }
 
   // If this is a base layer frame that contains a scalability structure
@@ skipping 118 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