V4L2VideoDecodeAccelerator: support external buffer import

media/gpu/v4l2_video_decode_accelerator.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.
 //
 // This file contains an implementation of VideoDecodeAccelerator
 // that utilizes hardware video decoders, which expose Video4Linux 2 API
 // (http://linuxtv.org/downloads/v4l-dvb-apis/).
 
 #ifndef MEDIA_GPU_V4L2_VIDEO_DECODE_ACCELERATOR_H_
 #define MEDIA_GPU_V4L2_VIDEO_DECODE_ACCELERATOR_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
+#include <list>
 #include <memory>
 #include <queue>
 #include <vector>
 
 #include "base/callback_forward.h"
 #include "base/macros.h"
 #include "base/memory/linked_ptr.h"
 #include "base/memory/ref_counted.h"
 #include "base/synchronization/waitable_event.h"
 #include "base/threading/thread.h"
@@ skipping 67 matching lines @@
       const GetGLContextCallback& get_gl_context_cb,
       const MakeGLContextCurrentCallback& make_context_current_cb,
       const scoped_refptr<V4L2Device>& device);
   ~V4L2VideoDecodeAccelerator() override;
 
   // VideoDecodeAccelerator implementation.
   // Note: Initialize() and Destroy() are synchronous.
   bool Initialize(const Config& config, Client* client) override;
   void Decode(const BitstreamBuffer& bitstream_buffer) override;
   void AssignPictureBuffers(const std::vector<PictureBuffer>& buffers) override;
+  void ImportBufferForPicture(
+      int32_t picture_buffer_id,
+      const 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;
 
   static VideoDecodeAccelerator::SupportedProfiles GetSupportedProfiles();
@@ skipping 64 matching lines @@
 
   // Record for output buffers.
   struct OutputRecord {
     OutputRecord();
     OutputRecord(OutputRecord&&) = default;
     ~OutputRecord();
     OutputRecordState state;
     EGLImageKHR egl_image;  // EGLImageKHR for the output buffer.
     EGLSyncKHR egl_sync;    // sync the compositor's use of the EGLImage.
     int32_t picture_id;     // picture buffer id as returned to PictureReady().
+    GLuint texture_id;
     bool cleared;           // Whether the texture is cleared and safe to render
                             // from. See TextureManager for details.
-    // Exported fds for image processor to import.
-    std::vector<base::ScopedFD> fds;
+    // Input fds of the processor. Exported from the decoder.
+    std::vector<base::ScopedFD> processor_input_fds;
+    // Output fds of the processor. Used only when OutputMode is IMPORT.
+    std::vector<base::ScopedFD> processor_output_fds;
   };
 
   //
   // Decoding tasks, to be run on decode_thread_.
   //
 
   // Enqueue a BitstreamBuffer to decode.  This will enqueue a buffer to the
   // decoder_input_queue_, then queue a DecodeBufferTask() to actually decode
   // the buffer.
   void DecodeTask(const BitstreamBuffer& bitstream_buffer);
@@ skipping 15 matching lines @@
   // non-error conditions; for example when pipeline is full and should be
   // retried later.
   bool AppendToInputFrame(const void* data, size_t size);
   // Flush data for one decoded frame.
   bool FlushInputFrame();
 
   // Allocate V4L2 buffers and assign them to |buffers| provided by the client
   // via AssignPictureBuffers() on decoder thread.
   void AssignPictureBuffersTask(const std::vector<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);
+  // Use buffer backed by dmabuf file descriptors in |dmabuf_fds| for the
+  // OutputRecord associated with |picture_buffer_id|, taking ownership of the
+  // file descriptors. |stride| is the number of bytes from one row of pixels
+  // to the next row.
+  void ImportBufferForPictureTask(int32_t picture_buffer_id,
+                                  std::vector<base::ScopedFD> dmabuf_fds,
+                                  int32_t stride);
 
-  // Assign |egl_images| to previously-allocated V4L2 buffers in
-  // output_buffer_map_ and picture ids from |buffers| and finish the resolution
-  // change sequence.
-  void AssignEGLImages(const std::vector<media::PictureBuffer>& buffers,
-                       const std::vector<EGLImageKHR>& egl_images);
+  // Create an EGLImage for the buffer associated with V4L2 |buffer_index| and
+  // for |picture_buffer_id|, backed by dmabuf file descriptors in
+  // |passed_dmabuf_fds|, taking ownership of them.
+  // The buffer should be bound to |texture_id| and is of |size| and format
+  // described by |fourcc|.
+  void CreateEGLImageFor(size_t buffer_index,
+                         int32_t picture_buffer_id,
+                         std::vector<base::ScopedFD> dmabuf_fds,
+                         GLuint texture_id,
+                         const gfx::Size& size,
+                         uint32_t fourcc);
+
+  // Take the EGLImage |egl_image|, created for |picture_buffer_id|, and use it
+  // for OutputRecord at |buffer_index|. The buffer is backed by
+  // |passed_dmabuf_fds|, and the OutputRecord takes ownership of them.
+  void AssignEGLImage(size_t buffer_index,
+                      int32_t picture_buffer_id,
+                      EGLImageKHR egl_image,
+                      std::vector<base::ScopedFD> dmabuf_fds);
 
   // Service I/O on the V4L2 devices.  This task should only be scheduled from
   // DevicePollTask().  If |event_pending| is true, one or more events
   // on file descriptor are pending.
   void ServiceDeviceTask(bool event_pending);
   // Handle the various device queues.
   void Enqueue();
   void Dequeue();
 
   // Return true if there is a resolution change event pending.
@@ skipping 94 matching lines @@
 
   // Set input and output formats before starting decode.
   bool SetupFormats();
   // Return a usable input format of image processor. Return 0 if not found.
   uint32_t FindImageProcessorInputFormat();
   // Return a usable output format of image processor. Return 0 if not found.
   uint32_t FindImageProcessorOutputFormat();
   // Reset image processor and drop all processing frames.
   bool ResetImageProcessor();
 
+  bool CreateImageProcessor();
+  // Send a frame to the image processor to process. The index of decoder
+  // output buffer is |output_buffer_index| and its id is |bitstream_buffer_id|.
+  bool ProcessFrame(int32_t bitstream_buffer_id, int output_buffer_index);
+
   //
   // Methods run on child thread.
   //
 
   // Send decoded pictures to PictureReady.
   void SendPictureReady();
 
   // Callback that indicates a picture has been cleared.
   void PictureCleared();
 
@@ skipping 31 matching lines @@
   // Before decoder_thread_ has started, the decoder state is managed by
   // the child (main) thread.  After decoder_thread_ has started, the decoder
   // thread should be the only one managing these.
   //
 
   // This thread services tasks posted from the VDA API entry points by the
   // child thread and device service callbacks posted from the device thread.
   base::Thread decoder_thread_;
   // Decoder state machine state.
   State decoder_state_;
+
+  Config::OutputMode output_mode_;
+
   // BitstreamBuffer we're presently reading.
   std::unique_ptr<BitstreamBufferRef> decoder_current_bitstream_buffer_;
   // The V4L2Device this class is operating upon.
   scoped_refptr<V4L2Device> device_;
   // FlushTask() and ResetTask() should not affect buffers that have been
   // queued afterwards.  For flushing or resetting the pipeline then, we will
   // delay these buffers until after the flush or reset completes.
   int decoder_delay_bitstream_buffer_id_;
   // Input buffer we're presently filling.
   int decoder_current_input_buffer_;
@@ skipping 36 matching lines @@
   std::vector<int> free_input_buffers_;
   // Mapping of int index to input buffer record.
   std::vector<InputRecord> input_buffer_map_;
 
   // Output buffer state.
   bool output_streamon_;
   // Output buffers enqueued to device.
   int output_buffer_queued_count_;
   // Output buffers ready to use, as a FIFO since we want oldest-first to hide
   // synchronization latency with GL.
-  std::queue<int> free_output_buffers_;
+  std::list<int> free_output_buffers_;
   // Mapping of int index to output buffer record.
   std::vector<OutputRecord> output_buffer_map_;
   // Required size of DPB for decoding.
   int output_dpb_size_;
 
   // Number of planes (i.e. separate memory buffers) for output.
   size_t output_planes_count_;
 
   // Pictures that are ready but not sent to PictureReady yet.
   std::queue<PictureRecord> pending_picture_ready_;
@@ skipping 55 matching lines @@
 
   // The WeakPtrFactory for |weak_this_|.
   base::WeakPtrFactory<V4L2VideoDecodeAccelerator> weak_this_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(V4L2VideoDecodeAccelerator);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_GPU_V4L2_VIDEO_DECODE_ACCELERATOR_H_