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;
     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_