V4L2SVDA: Add a VP9Accelerator implementation utilizing the V4L2 VP9 frame API.

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/bind.h"
 #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), parser_(false), accelerator_(accelerator) {
-  DCHECK(accelerator_);
+    : state_(kNeedStreamMetadata),
+      accelerator_(accelerator),
+      parser_(accelerator->IsFrameContextRequired()) {
   ref_frames_.resize(kVp9NumRefFrames);
 }
 
 VP9Decoder::~VP9Decoder() {}
 
 void VP9Decoder::SetStream(const uint8_t* ptr, size_t size) {
   DCHECK(ptr);
   DCHECK(size);
 
   DVLOG(4) << "New input stream at: " << (void*)ptr << " size: " << size;
@@ skipping 15 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(), nullptr);
+      Vp9Parser::Result res = parser_.ParseNextFrame(hdr.get());
       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();
+          DVLOG(4) << "Awaiting context update";
+          return kNeedContextUpdate;
       }
     }
 
     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 {
@@ skipping 62 matching lines @@
 }
 
 void VP9Decoder::RefreshReferenceFrames(const scoped_refptr<VP9Picture>& pic) {
   for (size_t i = 0; i < kVp9NumRefFrames; ++i) {
     DCHECK(!pic->frame_hdr->IsKeyframe() || pic->frame_hdr->RefreshFlag(i));
     if (pic->frame_hdr->RefreshFlag(i))
       ref_frames_[i] = pic;
   }
 }
 
+void VP9Decoder::UpdateFrameContext(
+    const scoped_refptr<VP9Picture>& pic,
+    const base::Callback<void(const Vp9FrameContext&)>& context_refresh_cb) {
+  DCHECK(!context_refresh_cb.is_null());
+  Vp9FrameContext frame_ctx;
+  memset(&frame_ctx, 0, sizeof(frame_ctx));
+
+  if (!accelerator_->GetFrameContext(pic, &frame_ctx)) {
+    SetError();
+    return;
+  }
+
+  context_refresh_cb.Run(frame_ctx);
+}
+
 bool VP9Decoder::DecodeAndOutputPicture(scoped_refptr<VP9Picture> pic) {
   DCHECK(!pic_size_.IsEmpty());
   DCHECK(pic->frame_hdr);
 
-  if (!accelerator_->SubmitDecode(pic, parser_.GetSegmentation(),
-                                  parser_.GetLoopFilter(), ref_frames_))
+  base::Closure done_cb;
+  const auto& context_refresh_cb =
+      parser_.GetContextRefreshCb(pic->frame_hdr->frame_context_idx);
+  if (!context_refresh_cb.is_null())
+    done_cb = base::Bind(&VP9Decoder::UpdateFrameContext,
+                         base::Unretained(this), pic, context_refresh_cb);
+
+  const Vp9Parser::Context& context = parser_.context();
+  if (!accelerator_->SubmitDecode(pic, context.segmentation(),
+                                  context.loop_filter(), ref_frames_, done_cb))
     return false;
 
   if (pic->frame_hdr->show_frame) {
     if (!accelerator_->OutputPicture(pic))
       return false;
   }
 
   RefreshReferenceFrames(pic);
   return true;
 }
 
 void VP9Decoder::SetError() {
   Reset();
   state_ = kError;
 }
 
 gfx::Size VP9Decoder::GetPicSize() const {
   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