Support external buffer import in VDA interface and add a V4L2SVDA impl.

content/common/gpu/media/v4l2_slice_video_decode_accelerator.h

 // 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.
 
 #ifndef CONTENT_COMMON_GPU_MEDIA_V4L2_SLICE_VIDEO_DECODE_ACCELERATOR_H_
 #define CONTENT_COMMON_GPU_MEDIA_V4L2_SLICE_VIDEO_DECODE_ACCELERATOR_H_
 
 #include <linux/videodev2.h>
 #include <stddef.h>
 #include <stdint.h>
@@ skipping 30 matching lines @@
       EGLDisplay egl_display,
       const GetGLContextCallback& get_gl_context_cb,
       const MakeGLContextCurrentCallback& make_context_current_cb);
   ~V4L2SliceVideoDecodeAccelerator() override;
 
   // media::VideoDecodeAccelerator implementation.
   bool Initialize(const Config& config, Client* client) override;
   void Decode(const media::BitstreamBuffer& bitstream_buffer) override;
   void AssignPictureBuffers(
       const std::vector<media::PictureBuffer>& buffers) override;
+  void ImportBufferForPicture(int32_t picture_buffer_id,
+                              const std::vector<gfx::GpuMemoryBufferHandle>&
+                                  gpu_memory_buffer_handles) override;
   void ReusePictureBuffer(int32_t picture_buffer_id) override;
   void Flush() override;
   void Reset() override;
   void Destroy() override;
   bool TryToSetupDecodeOnSeparateThread(
       const base::WeakPtr<Client>& decode_client,
       const scoped_refptr<base::SingleThreadTaskRunner>& decode_task_runner)
       override;
+  media::VideoPixelFormat GetOutputFormat() const override;
 
   static media::VideoDecodeAccelerator::SupportedProfiles
       GetSupportedProfiles();
 
  private:
   class V4L2H264Accelerator;
   class V4L2VP8Accelerator;
 
   // Record for input buffers.
   struct InputRecord {
     InputRecord();
     int32_t input_id;
     void* address;
     size_t length;
     size_t bytes_used;
     bool at_device;
   };
 
   // Record for output buffers.
   struct OutputRecord {
     OutputRecord();
     bool at_device;

[kcwu, 2016/03/22 05:42:54]

How about merge |at_device| and |at_client| as single enum to indicate the
ownership and states?
Since 
1. they are not independent (it's not possible true for both at the same time)
2. there is special state now.
v4l2_slice_vda.cc line 1523, it sets output_record.at_client = true but not
really "at client";

     bool at_client;
     int32_t picture_id;
+    GLuint texture_id;
     EGLImageKHR egl_image;
     EGLSyncKHR egl_sync;
+    std::vector<base::ScopedFD> dmabuf_fds;
     bool cleared;
   };
 
   // See http://crbug.com/255116.
   // Input bitstream buffer size for up to 1080p streams.
   const size_t kInputBufferMaxSizeFor1080p = 1024 * 1024;
   // Input bitstream buffer size for up to 4k streams.
   const size_t kInputBufferMaxSizeFor4k = 4 * kInputBufferMaxSizeFor1080p;
   const size_t kNumInputBuffers = 16;
 
@@ skipping 107 matching lines @@
   // To be called if decoder_resetting_ is true. If not all pending frames are
   // decoded, return false, requesting the caller to try again later.
   // Otherwise perform reset by dropping all pending outputs (client is not
   // interested anymore), notifying it that reset is finished, and return true,
   // informing the caller that further progress can be made.
   bool FinishReset();
 
   // Allocate V4L2 buffers and assign them to |buffers| provided by the client
   // via AssignPictureBuffers() on decoder thread.
   void AssignPictureBuffersTask(
-    const std::vector<media::PictureBuffer>& buffers);
+      const std::vector<media::PictureBuffer>& buffers);
 
-  // Create EGLImages bound to textures in |buffers| for given
-  // |output_format_fourcc| and |output_planes_count|.
-  void CreateEGLImages(const std::vector<media::PictureBuffer>& buffers,
-                       uint32_t output_format_fourcc,
-                       size_t output_planes_count);
+  void ImportBufferForPictureTask(
+      int32_t picture_buffer_id,
+      // TODO(posciak): (crbug.com/561749) we should normally be able to pass
+      // the vector by itself via std::move, but it's not possible to do this
+      // if this method is used as a callback.
+      scoped_ptr<std::vector<base::ScopedFD>> passed_dmabuf_fds);
 
-  // Assign |egl_images| to previously-allocated V4L2 buffers in
-  // output_buffer_map_ and picture ids from |buffers| and finish the surface
-  // change sequence.
-  void AssignEGLImages(const std::vector<media::PictureBuffer>& buffers,
-                       const std::vector<EGLImageKHR>& egl_images);
+  void CreateEGLImageFor(
+      size_t buffer_index,
+      // TODO(posciak): (crbug.com/561749) we should normally be able to pass
+      // the vector by itself via std::move, but it's not possible to do this
+      // if this method is used as a callback.
+      scoped_ptr<std::vector<base::ScopedFD>> passed_dmabuf_fds,
+      GLuint texture_id,
+      const gfx::Size& size,
+      uint32_t fourcc);
+
+  void AssignEGLImage(
+      size_t buffer_index,
+      EGLImageKHR egl_image,
+      // TODO(posciak): (crbug.com/561749) we should normally be able to pass
+      // the vector by itself via std::move, but it's not possible to do this
+      // if this method is used as a callback.
+      scoped_ptr<std::vector<base::ScopedFD>> passed_dmabuf_fds);
 
   // Process pending events, if any.
   void ProcessPendingEventsIfNeeded();
 
   // Performed on decoder_thread_ as a consequence of poll() on decoder_thread_
   // returning an event.
   void ServiceDeviceTask();
 
   // Schedule poll if we have any buffers queued and the poll thread
   // is not stopped (on surface set change).
@@ skipping 125 matching lines @@
   // BitstreamBuffer currently being processed.
   scoped_ptr<BitstreamBufferRef> decoder_current_bitstream_buffer_;
 
   // Queue storing decode surfaces ready to be output as soon as they are
   // decoded. The surfaces must be output in order they are queued.
   std::queue<scoped_refptr<V4L2DecodeSurface>> decoder_display_queue_;
 
   // Decoder state.
   State state_;
 
+  Config::OutputMode output_mode_;
+
   // If any of these are true, we are waiting for the device to finish decoding
   // all previously-queued frames, so we can finish the flush/reset/surface
   // change flows. These can stack.
   bool decoder_flushing_;
   bool decoder_resetting_;
   bool surface_set_change_pending_;
 
   // Hardware accelerators.
   // TODO(posciak): Try to have a superclass here if possible.
   scoped_ptr<V4L2H264Accelerator> h264_accelerator_;
@@ skipping 33 matching lines @@
 
   DISALLOW_COPY_AND_ASSIGN(V4L2SliceVideoDecodeAccelerator);
 };
 
 class V4L2H264Picture;
 class V4L2VP8Picture;
 
 }  // namespace content
 
 #endif  // CONTENT_COMMON_GPU_MEDIA_V4L2_SLICE_VIDEO_DECODE_ACCELERATOR_H_