V4L2VideoDecodeAccelerator: support external buffer import

media/gpu/v4l2_image_processor.h

 // Copyright 2014 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 MEDIA_GPU_V4L2_IMAGE_PROCESSOR_H_
 #define MEDIA_GPU_V4L2_IMAGE_PROCESSOR_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 23 matching lines @@
   // Initializes the processor to convert from |input_format| to |output_format|
   // and/or scale from |input_visible_size| to |output_visible_size|.
   // Request the input buffers to be of at least |input_allocated_size| and the
   // output buffers to be of at least |output_allocated_size|. The number of
   // input buffers and output buffers will be |num_buffers|. Provided |error_cb|
   // will be called if an error occurs. Return true if the requested
   // configuration is supported.
   bool Initialize(VideoPixelFormat input_format,
                   VideoPixelFormat output_format,
                   v4l2_memory input_memory_type,
+                  v4l2_memory output_memory_type,
                   gfx::Size input_visible_size,
                   gfx::Size input_allocated_size,
                   gfx::Size output_visible_size,
                   gfx::Size output_allocated_size,
                   int num_buffers,
                   const base::Closure& error_cb);
 
   // Returns a vector of dmabuf file descriptors, exported for V4L2 output
   // buffer with |index|. The size of vector will be the number of planes of the
   // buffer. Return an empty vector on failure.
@@ skipping 23 matching lines @@
   gfx::Size output_allocated_size() const { return output_allocated_size_; }
 
   // Callback to be used to return the index of a processed image to the
   // client. After the client is done with the frame, call Process with the
   // index to return the output buffer to the image processor.
   typedef base::Callback<void(int output_buffer_index)> FrameReadyCB;
 
   // Called by client to process |frame|. The resulting processed frame will be
   // stored in |output_buffer_index| output buffer and notified via |cb|. The
   // processor will drop all its references to |frame| after it finishes
-  // accessing it.
-  void Process(const scoped_refptr<VideoFrame>& frame,
+  // accessing it. If |output_memory_type_| is V4L2_MEMORY_DMABUF, the caller
+  // should pass non-empty |output_dmabuf_fds| and the processed frame will be
+  // stored in those buffers. If the number of |output_dmabuf_fds| is not
+  // expected, this function will return false.
+  bool Process(const scoped_refptr<VideoFrame>& frame,
                int output_buffer_index,
+               std::vector<base::ScopedFD> output_dmabuf_fds,
                const FrameReadyCB& cb);
 
   // Reset all processing frames. After this method returns, no more callbacks
   // will be invoked. V4L2ImageProcessor is ready to process more frames.
   bool Reset();
 
   // Stop all processing and clean up. After this method returns no more
   // callbacks will be invoked.  Deletes |this| unconditionally, so make sure
   // to drop all pointers to it!
   void Destroy();
 
  private:
   // Record for input buffers.
   struct InputRecord {
     InputRecord();
     ~InputRecord();
     scoped_refptr<VideoFrame> frame;
     bool at_device;
   };
 
   // Record for output buffers.
   struct OutputRecord {
     OutputRecord();
+    OutputRecord(OutputRecord&&) = default;
     ~OutputRecord();
     bool at_device;
+    // The processed frame will be stored in these buffers if
+    // |output_memory_type_| is V4L2_MEMORY_DMABUF
+    std::vector<base::ScopedFD> dmabuf_fds;
   };
 
   // Job record. Jobs are processed in a FIFO order. This is separate from
   // InputRecord, because an InputRecord may be returned before we dequeue
   // the corresponding output buffer. The processed frame will be stored in
-  // |output_buffer_index| output buffer.
+  // |output_buffer_index| output buffer. If |output_memory_type_| is
+  // V4L2_MEMORY_DMABUF, the processed frame will be stored in
+  // |output_dmabuf_fds|.
   struct JobRecord {
     JobRecord();
     ~JobRecord();
     scoped_refptr<VideoFrame> frame;
     int output_buffer_index;
+    std::vector<base::ScopedFD> output_dmabuf_fds;
     FrameReadyCB ready_cb;
   };
 
   void EnqueueInput();
   void EnqueueOutput(int index);
   void Dequeue();
   bool EnqueueInputRecord();
   bool EnqueueOutputRecord(int index);
   bool CreateInputBuffers();
   bool CreateOutputBuffers();
@@ skipping 21 matching lines @@
   gfx::Size input_visible_size_;
   gfx::Size input_allocated_size_;
 
   // The visible/allocated sizes of the destination frame.
   gfx::Size output_visible_size_;
   gfx::Size output_allocated_size_;
 
   VideoPixelFormat input_format_;
   VideoPixelFormat output_format_;
   v4l2_memory input_memory_type_;
+  v4l2_memory output_memory_type_;
   uint32_t input_format_fourcc_;
   uint32_t output_format_fourcc_;
 
   size_t input_planes_count_;
   size_t output_planes_count_;
 
   // Our original calling task runner for the child thread.
   const scoped_refptr<base::SingleThreadTaskRunner> child_task_runner_;
 
   // V4L2 device in use.
@@ skipping 40 matching lines @@
 
   // Weak factory for producing weak pointers on the child thread.
   base::WeakPtrFactory<V4L2ImageProcessor> weak_this_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(V4L2ImageProcessor);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_GPU_V4L2_IMAGE_PROCESSOR_H_