Padding is now used to check for continuity in the packet sequence.

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.
  */
 
@@ skipping 33 matching lines @@
       ManageFrameVp9(std::move(frame));
       break;
     case kVideoCodecH264:
     case kVideoCodecI420:
     case kVideoCodecGeneric:
       ManageFrameGeneric(std::move(frame), kNoPictureId);
       break;
   }
 }
 
+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::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
+  // the padding packets we have stashed.
+  uint16_t next_seq_num_with_padding = gop_seq_num_it->second.second + 1;
+  auto padding_seq_num_it =
+      stashed_padding_.lower_bound(next_seq_num_with_padding);
+
+  // While there still are padding packets and those padding packets are
+  // continuous, then advance the "last-picture-id-with-padding" and remove
+  // the stashed padding packet.
+  while (padding_seq_num_it != stashed_padding_.end() &&
+         *padding_seq_num_it == next_seq_num_with_padding) {
+    gop_seq_num_it->second.second = next_seq_num_with_padding;
+    ++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();
 
   // 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.
@@ skipping 13 matching lines @@
     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_[frame->last_seq_num()] = frame->last_seq_num();
+  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));
     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) {
-    if (seq_num_it->second !=
-        static_cast<uint16_t>(frame->first_seq_num() - 1)) {
+    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));
       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;
-  frame->references[0] = seq_num_it->second;
-  seq_num_it->second = frame->picture_id;
+  frame->references[0] = last_picture_id_gop;
+  if (AheadOf(frame->picture_id, last_picture_id_gop)) {
+    seq_num_it->second.first = frame->picture_id;
+    seq_num_it->second.second = frame->picture_id;
+  }
 
   last_picture_id_ = frame->picture_id;
+  UpdateLastPictureIdWithPadding(frame->picture_id);
   frame_callback_->OnCompleteFrame(std::move(frame));
   RetryStashedFrames();
 }
 
 void RtpFrameReferenceFinder::ManageFrameVp8(
     std::unique_ptr<RtpFrameObject> frame) {
   RTPVideoTypeHeader* rtp_codec_header = frame->GetCodecHeader();
   if (!rtp_codec_header)
     return;
 
@@ skipping 355 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