Drop VP8 frames older than the last sync frame in the 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.
  */
 
@@ skipping 280 matching lines @@
   // Find all references for this frame.
   frame->num_references = 0;
   for (uint8_t layer = 0; layer <= codec_header.temporalIdx; ++layer) {
     // If we have not yet received a previous frame on this temporal layer,
     // stash this frame.
     if (layer_info_it->second[layer] == -1) {
       stashed_frames_.push_back(std::move(frame));
       return;
     }
 
+    // If the last frame on this layer is ahead of this frame it means that
+    // a layer sync frame has been received after this frame for the same
+    // base layer frame, drop this frame.

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

Is this always true though?

What if we received a stream with to layers where TL1 only depends on TL0? Maybe
because in that case all TL1 frames are sync frames, so it's still correct?

Anyway, if we have already decoded frame T, all frames prior to T are too late
to decode, right?

[philipel, 2016/10/05 14:47:42]

I can't find a case where this it not true, remember that every base layer frame
has its own LayerInfo.

Generally we should not make assumptions about which frame that has been decoded
or not since we pass the frame forward as soon as we have calculated all its
references, but in this case we know that dropping this frame is OK since we
know that we have passed on a more recent layer sync frame for this base layer
frame.

+    if (AheadOf<uint16_t, kPicIdLength>(layer_info_it->second[layer],
+                                        frame->picture_id))

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

{}

[philipel, 2016/10/05 14:47:42]

Done.

+      return;
+
     // 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_.push_back(std::move(frame));
       return;
     }
 
+    RTC_DCHECK(AheadOf(frame->picture_id, layer_info_it->second[layer]));
     ++frame->num_references;
     frame->references[layer] = layer_info_it->second[layer];
   }
 
   CompletedFrameVp8(std::move(frame));
 }
 
 void RtpFrameReferenceFinder::CompletedFrameVp8(
     std::unique_ptr<RtpFrameObject> frame) {
   RTPVideoTypeHeader* rtp_codec_header = frame->GetCodecHeader();
@@ skipping 247 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