Use picture id to check continuity between frames.

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 28 matching lines @@
       break;
     case kVideoCodecVP8:
       ManageFrameVp8(std::move(frame));
       break;
     case kVideoCodecVP9:
       ManageFrameVp9(std::move(frame));
       break;
     case kVideoCodecH264:
     case kVideoCodecI420:
     case kVideoCodecGeneric:
-      ManageFrameGeneric(std::move(frame));
+      ManageFrameGeneric(std::move(frame), kNoPictureId);
       break;
   }
 }
 
 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.
   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) {
+    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_[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
@@ skipping 35 matching lines @@
     std::unique_ptr<RtpFrameObject> frame) {
   RTPVideoTypeHeader* rtp_codec_header = frame->GetCodecHeader();
   if (!rtp_codec_header)
     return;
 
   const RTPVideoHeaderVP8& codec_header = rtp_codec_header->VP8;
 
   if (codec_header.pictureId == kNoPictureId ||
       codec_header.temporalIdx == kNoTemporalIdx ||
       codec_header.tl0PicIdx == kNoTl0PicIdx) {
-    ManageFrameGeneric(std::move(frame));
+    ManageFrameGeneric(std::move(frame), codec_header.pictureId);
     return;
   }
 
   frame->picture_id = codec_header.pictureId % kPicIdLength;
 
   if (last_unwrap_ == -1)
     last_unwrap_ = codec_header.pictureId;
 
   if (last_picture_id_ == -1)
     last_picture_id_ = frame->picture_id;
@@ skipping 120 matching lines @@
 }
 
 void RtpFrameReferenceFinder::ManageFrameVp9(
     std::unique_ptr<RtpFrameObject> frame) {
   RTPVideoTypeHeader* rtp_codec_header = frame->GetCodecHeader();
   if (!rtp_codec_header)
     return;
 
   const RTPVideoHeaderVP9& codec_header = rtp_codec_header->VP9;
 
-  if (codec_header.picture_id == kNoPictureId) {
-    ManageFrameGeneric(std::move(frame));
+  if (codec_header.picture_id == kNoPictureId ||
+      codec_header.temporal_idx == kNoTemporalIdx) {
+    ManageFrameGeneric(std::move(frame), codec_header.picture_id);
     return;
   }
 
   frame->spatial_layer = codec_header.spatial_idx;
   frame->inter_layer_predicted = codec_header.inter_layer_predicted;
   frame->picture_id = codec_header.picture_id % kPicIdLength;
 
   if (last_unwrap_ == -1)
     last_unwrap_ = codec_header.picture_id;
 
@@ skipping 196 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