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

media/gpu/vaapi_video_decode_accelerator.cc

 // Copyright (c) 2012 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/vaapi_video_decode_accelerator.h"
 
 #include <string.h>
 
 #include <memory>
 
@@ skipping 227 matching lines @@
 class VaapiVideoDecodeAccelerator::VaapiVP9Accelerator
     : public VP9Decoder::VP9Accelerator {
  public:
   VaapiVP9Accelerator(VaapiVideoDecodeAccelerator* vaapi_dec,
                       VaapiWrapper* vaapi_wrapper);
   ~VaapiVP9Accelerator() override;
 
   // VP9Decoder::VP9Accelerator implementation.
   scoped_refptr<VP9Picture> CreateVP9Picture() override;
 
-  bool SubmitDecode(
-      const scoped_refptr<VP9Picture>& pic,
-      const Vp9SegmentationParams& seg,
-      const Vp9LoopFilterParams& lf,
-      const std::vector<scoped_refptr<VP9Picture>>& ref_pictures) override;
+  bool SubmitDecode(const scoped_refptr<VP9Picture>& pic,
+                    const Vp9SegmentationParams& seg,
+                    const Vp9LoopFilterParams& lf,
+                    const std::vector<scoped_refptr<VP9Picture>>& ref_pictures,
+                    const base::Closure& done_cb) override;
 
   bool OutputPicture(const scoped_refptr<VP9Picture>& pic) override;
 
+  bool IsFrameContextRequired() const override { return false; }
+
+  bool GetFrameContext(const scoped_refptr<VP9Picture>& pic,
+                       Vp9FrameContext* frame_ctx) override;
+
  private:
   scoped_refptr<VaapiDecodeSurface> VP9PictureToVaapiDecodeSurface(
       const scoped_refptr<VP9Picture>& pic);
 
   VaapiWrapper* vaapi_wrapper_;
   VaapiVideoDecodeAccelerator* vaapi_dec_;
 
   DISALLOW_COPY_AND_ASSIGN(VaapiVP9Accelerator);
 };
 
@@ skipping 346 matching lines @@
         break;
 
       case AcceleratedVideoDecoder::kRanOutOfSurfaces:
         // No more output buffers in the decoder, try getting more or go to
         // sleep waiting for them.
         if (!WaitForSurfaces_Locked())
           return;
 
         break;
 
+      case AcceleratedVideoDecoder::kNeedContextUpdate:
+        // This should not happen as we return false from
+        // IsFrameContextRequired().
+        NOTREACHED() << "Context updates not supported";
+        return;
+
       case AcceleratedVideoDecoder::kDecodeError:
         RETURN_AND_NOTIFY_ON_FAILURE(false, "Error decoding stream",
                                      PLATFORM_FAILURE, );
         return;
     }
   }
 }
 
 void VaapiVideoDecodeAccelerator::InitiateSurfaceSetChange(size_t num_pics,
                                                            gfx::Size size) {
@@ skipping 1080 matching lines @@
   if (!va_surface)
     return nullptr;
 
   return new VaapiVP9Picture(va_surface);
 }
 
 bool VaapiVideoDecodeAccelerator::VaapiVP9Accelerator::SubmitDecode(
     const scoped_refptr<VP9Picture>& pic,
     const Vp9SegmentationParams& seg,
     const Vp9LoopFilterParams& lf,
-    const std::vector<scoped_refptr<VP9Picture>>& ref_pictures) {
+    const std::vector<scoped_refptr<VP9Picture>>& ref_pictures,
+    const base::Closure& done_cb) {
+  // TODO(posciak): We don't currently have the ability to know when the surface
+  // is decoded, as we submit both the decode job and output independently and
+  // don't wait for just the decode to be finished, instead relying on the
+  // driver to execute them in correct order.
+  DCHECK(!done_cb.is_null());
+
   VADecPictureParameterBufferVP9 pic_param;
   memset(&pic_param, 0, sizeof(pic_param));
 
   const Vp9FrameHeader* frame_hdr = pic->frame_hdr.get();
   DCHECK(frame_hdr);
 
   if (frame_hdr->profile != 0) {
     DVLOG(1) << "Unsupported profile" << frame_hdr->profile;
     return false;
   }
@@ skipping 108 matching lines @@
 
 bool VaapiVideoDecodeAccelerator::VaapiVP9Accelerator::OutputPicture(
     const scoped_refptr<VP9Picture>& pic) {
   scoped_refptr<VaapiDecodeSurface> dec_surface =
       VP9PictureToVaapiDecodeSurface(pic);
 
   vaapi_dec_->SurfaceReady(dec_surface);
   return true;
 }
 
+bool VaapiVideoDecodeAccelerator::VaapiVP9Accelerator::GetFrameContext(
+    const scoped_refptr<VP9Picture>& pic,
+    Vp9FrameContext* frame_ctx) {
+  NOTIMPLEMENTED() << "Frame context update not supported";
+  return false;
+}
+
 scoped_refptr<VaapiVideoDecodeAccelerator::VaapiDecodeSurface>
 VaapiVideoDecodeAccelerator::VaapiVP9Accelerator::
     VP9PictureToVaapiDecodeSurface(const scoped_refptr<VP9Picture>& pic) {
   VaapiVP9Picture* vaapi_pic = pic->AsVaapiVP9Picture();
   CHECK(vaapi_pic);
   return vaapi_pic->dec_surface();
 }
 
 // static
 VideoDecodeAccelerator::SupportedProfiles
 VaapiVideoDecodeAccelerator::GetSupportedProfiles() {
   return VaapiWrapper::GetSupportedDecodeProfiles();
 }
 
 }  // namespace media