Work on flexible mode and screen sharing.

webrtc/modules/video_coding/main/source/decoding_state.cc

 /*
  *  Copyright (c) 2011 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/main/source/decoding_state.h"
 
 #include "webrtc/modules/interface/module_common_types.h"
 #include "webrtc/modules/video_coding/main/source/frame_buffer.h"
 #include "webrtc/modules/video_coding/main/source/jitter_buffer_common.h"
 #include "webrtc/modules/video_coding/main/source/packet.h"
 
 namespace webrtc {
 
 VCMDecodingState::VCMDecodingState()
     : sequence_num_(0),
       time_stamp_(0),
       picture_id_(kNoPictureId),
       temporal_id_(kNoTemporalIdx),
       tl0_pic_id_(kNoTl0PicIdx),
       full_sync_(true),
-      in_initial_state_(true) {}
+      in_initial_state_(true) {
+  memset(frame_decoded_, 0, sizeof(frame_decoded_));

[sprang_webrtc, 2015/09/15 15:41:22]

Don't think you need this?

[philipel, 2015/09/16 09:35:54]

I think I do:
http://stackoverflow.com/questions/7760291/default-initialization-of-c-member...

[sprang_webrtc, 2015/09/25 09:53:15]

You're right. I was drunk.
Maybe frame_decoded_{} would work though?

+}
 
 VCMDecodingState::~VCMDecodingState() {}
 
 void VCMDecodingState::Reset() {
   // TODO(mikhal): Verify - not always would want to reset the sync
   sequence_num_ = 0;
   time_stamp_ = 0;
   picture_id_ = kNoPictureId;
   temporal_id_ = kNoTemporalIdx;
   tl0_pic_id_ = kNoTl0PicIdx;
   full_sync_ = true;
   in_initial_state_ = true;
+  memset(frame_decoded_, 0, sizeof(frame_decoded_));
 }
 
 uint32_t VCMDecodingState::time_stamp() const {
   return time_stamp_;
 }
 
 uint16_t VCMDecodingState::sequence_num() const {
   return sequence_num_;
 }
 
 bool VCMDecodingState::IsOldFrame(const VCMFrameBuffer* frame) const {
   assert(frame != NULL);
   if (in_initial_state_)
     return false;
   return !IsNewerTimestamp(frame->TimeStamp(), time_stamp_);
 }
 
 bool VCMDecodingState::IsOldPacket(const VCMPacket* packet) const {
   assert(packet != NULL);
   if (in_initial_state_)
     return false;
   return !IsNewerTimestamp(packet->timestamp, time_stamp_);
 }
 
 void VCMDecodingState::SetState(const VCMFrameBuffer* frame) {
   assert(frame != NULL && frame->GetHighSeqNum() >= 0);
-  UpdateSyncState(frame);
+  if (frame->CodecSpecific()->codecType != kVideoCodecVP9)
+    UpdateSyncState(frame);
   sequence_num_ = static_cast<uint16_t>(frame->GetHighSeqNum());
   time_stamp_ = frame->TimeStamp();
   picture_id_ = frame->PictureId();
   temporal_id_ = frame->TemporalId();
   tl0_pic_id_ = frame->Tl0PicId();
+
+  if (UsingFlexibleMode(frame)) {
+    uint16_t frame_index = picture_id_ % kFrameDecodedLength;
+    if (in_initial_state_) {
+      fd_cleared_to_ = frame_index;
+      frame_decoded_[frame_index] = true;
+    } else if (frame->FrameType() == kVideoFrameKey) {
+      memset(frame_decoded_, 0, sizeof(frame_decoded_));
+      fd_cleared_to_ = frame_index;
+    } else {
+      while (fd_cleared_to_ != frame_index) {
+        fd_cleared_to_ = (fd_cleared_to_ + 1) % kFrameDecodedLength;
+        frame_decoded_[fd_cleared_to_] = false;
+      }
+      frame_decoded_[frame_index] = true;
+    }
+  }
+
   in_initial_state_ = false;
 }
 
 void VCMDecodingState::CopyFrom(const VCMDecodingState& state) {
   sequence_num_ = state.sequence_num_;
   time_stamp_ = state.time_stamp_;
   picture_id_ = state.picture_id_;
   temporal_id_ = state.temporal_id_;
   tl0_pic_id_ = state.tl0_pic_id_;
   full_sync_ = state.full_sync_;
   in_initial_state_ = state.in_initial_state_;
+  fd_cleared_to_ = state.fd_cleared_to_;
+  memcpy(frame_decoded_, state.frame_decoded_, sizeof(frame_decoded_));
 }
 
 bool VCMDecodingState::UpdateEmptyFrame(const VCMFrameBuffer* frame) {
   bool empty_packet = frame->GetHighSeqNum() == frame->GetLowSeqNum();
   if (in_initial_state_ && empty_packet) {
     // Drop empty packets as long as we are in the initial state.
     return true;
   }
   if ((empty_packet && ContinuousSeqNum(frame->GetHighSeqNum())) ||
       ContinuousFrame(frame)) {
@@ skipping 73 matching lines @@
     return true;
   // tl0picId is either not used, or should remain unchanged.
   if (frame->Tl0PicId() != tl0_pic_id_)
     return false;
   // Base layers are not continuous or temporal layers are inactive.
   // In the presence of temporal layers, check for Picture ID/sequence number
   // continuity if sync can be restored by this frame.
   if (!full_sync_ && !frame->LayerSync())
     return false;
   if (UsingPictureId(frame)) {
-    return ContinuousPictureId(frame->PictureId());
+    if (UsingFlexibleMode(frame)) {
+      return ContinuousFrameRefs(frame);
+    } else {
+      return ContinuousPictureId(frame->PictureId());
+    }
   } else {
     return ContinuousSeqNum(static_cast<uint16_t>(frame->GetLowSeqNum()));
   }
 }
 
 bool VCMDecodingState::ContinuousPictureId(int picture_id) const {
   int next_picture_id = picture_id_ + 1;
   if (picture_id < picture_id_) {
     // Wrap
     if (picture_id_ >= 0x80) {
@@ skipping 22 matching lines @@
   else if (tl0_pic_id_ == kNoTl0PicIdx && temporal_id_ == kNoTemporalIdx &&
            temporal_id == 0)
     return true;
 
   // Current implementation: Look for base layer continuity.
   if (temporal_id != 0)
     return false;
   return (static_cast<uint8_t>(tl0_pic_id_ + 1) == tl0_pic_id);
 }
 
+bool VCMDecodingState::ContinuousFrameRefs(const VCMFrameBuffer* frame) const {
+  bool continuous = true;
+  uint8_t num_refs = frame->CodecSpecific()->codecSpecific.VP9.num_ref_pics;
+  for (uint8_t r = 0; r < num_refs; ++r) {
+    uint16_t frame_ref = frame->PictureId() -
+                         frame->CodecSpecific()->codecSpecific.VP9.p_diff[r];
+    continuous &= frame_decoded_[frame_ref % kFrameDecodedLength];

[sprang_webrtc, 2015/09/15 15:41:22]

Just return false early here, and true below.

[philipel, 2015/09/16 09:35:54]

Done.

+  }
+  return continuous;
+}
+
 bool VCMDecodingState::UsingPictureId(const VCMFrameBuffer* frame) const {
   return (frame->PictureId() != kNoPictureId && picture_id_ != kNoPictureId);
 }
 
+bool VCMDecodingState::UsingFlexibleMode(const VCMFrameBuffer* frame) const {
+  return frame->CodecSpecific()->codecType == kVideoCodecVP9 &&
+         frame->CodecSpecific()->codecSpecific.VP9.flexible_mode;
+}
+
 }  // namespace webrtc