Parse VP9 compressed header

media/gpu/vp9_decoder.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/gpu/vp9_decoder.h"
 
 #include <memory>
 
 #include "base/logging.h"
 #include "media/base/limits.h"
 #include "media/gpu/vp9_decoder.h"
 
 namespace media {
 
 VP9Decoder::VP9Accelerator::VP9Accelerator() {}
 
 VP9Decoder::VP9Accelerator::~VP9Accelerator() {}
 
 VP9Decoder::VP9Decoder(VP9Accelerator* accelerator)
-    : state_(kNeedStreamMetadata), accelerator_(accelerator) {
+    : state_(kNeedStreamMetadata), parser_(false), accelerator_(accelerator) {
   DCHECK(accelerator_);
   ref_frames_.resize(kVp9NumRefFrames);
 }
 
 VP9Decoder::~VP9Decoder() {}
 
 void VP9Decoder::SetStream(const uint8_t* ptr, size_t size) {
   DCHECK(ptr);
   DCHECK(size);
 
@@ skipping 16 matching lines @@
 
   if (state_ == kDecoding)
     state_ = kAfterReset;
 }
 
 VP9Decoder::DecodeResult VP9Decoder::Decode() {
   while (1) {
     // Read a new frame header if one is not awaiting decoding already.
     if (!curr_frame_hdr_) {
       std::unique_ptr<Vp9FrameHeader> hdr(new Vp9FrameHeader());
-      Vp9Parser::Result res = parser_.ParseNextFrame(hdr.get());
+      Vp9Parser::Result res = parser_.ParseNextFrame(hdr.get(), nullptr);
       switch (res) {
         case Vp9Parser::kOk:
           curr_frame_hdr_.reset(hdr.release());
           break;
 
         case Vp9Parser::kEOStream:
           return kRanOutOfStreamData;
 
         case Vp9Parser::kInvalidStream:
           DVLOG(1) << "Error parsing stream";
           SetError();
           return kDecodeError;
+
+        case Vp9Parser::kAwaitingRefresh:
+          NOTREACHED();
       }
     }
 
     if (state_ != kDecoding) {
       // Not kDecoding, so we need a resume point (a keyframe), as we are after
       // reset or at the beginning of the stream. Drop anything that is not
       // a keyframe in such case, and continue looking for a keyframe.
       if (curr_frame_hdr_->IsKeyframe()) {
         state_ = kDecoding;
       } else {
         curr_frame_hdr_.reset();
         continue;
       }
     }
 
     if (curr_frame_hdr_->show_existing_frame) {
       // This frame header only instructs us to display one of the
       // previously-decoded frames, but has no frame data otherwise. Display
       // and continue decoding subsequent frames.
-      size_t frame_to_show = curr_frame_hdr_->frame_to_show;
+      size_t frame_to_show = curr_frame_hdr_->frame_to_show_map_idx;
       if (frame_to_show >= ref_frames_.size() || !ref_frames_[frame_to_show]) {
         DVLOG(1) << "Request to show an invalid frame";
         SetError();
         return kDecodeError;
       }
 
       if (!accelerator_->OutputPicture(ref_frames_[frame_to_show])) {
         SetError();
         return kDecodeError;
       }
 
       curr_frame_hdr_.reset();
       continue;
     }
 
-    gfx::Size new_pic_size(curr_frame_hdr_->width, curr_frame_hdr_->height);
+    gfx::Size new_pic_size(curr_frame_hdr_->frame_width,
+                           curr_frame_hdr_->frame_height);
     DCHECK(!new_pic_size.IsEmpty());
 
     if (new_pic_size != pic_size_) {
       DVLOG(1) << "New resolution: " << new_pic_size.ToString();
 
       if (!curr_frame_hdr_->IsKeyframe()) {
         // TODO(posciak): This is doable, but requires a few modifications to
         // VDA implementations to allow multiple picture buffer sets in flight.
         DVLOG(1) << "Resolution change currently supported for keyframes only";
         SetError();
@@ skipping 58 matching lines @@
   return pic_size_;
 }
 
 size_t VP9Decoder::GetRequiredNumOfPictures() const {
   // kMaxVideoFrames to keep higher level media pipeline populated, +2 for the
   // pictures being parsed and decoded currently.
   return limits::kMaxVideoFrames + kVp9NumRefFrames + 2;
 }
 
 }  // namespace media