media/gpu: switch v4l2_jpeg_decode_accelerator to use multi-planar APIs

media/gpu/v4l2_jpeg_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 MEDIA_GPU_V4L2_JPEG_DECODE_ACCELERATOR_H_
 #define MEDIA_GPU_V4L2_JPEG_DECODE_ACCELERATOR_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 28 matching lines @@
   bool Initialize(Client* client) override;
   void Decode(const BitstreamBuffer& bitstream_buffer,
               const scoped_refptr<VideoFrame>& video_frame) override;
   bool IsSupported() override;
 
  private:
   // Record for input/output buffers.
   struct BufferRecord {
     BufferRecord();
     ~BufferRecord();
-    void* address;  // mmap() address.
-    size_t length;  // mmap() length.
+    void* address[VIDEO_MAX_PLANES];  // mmap() address.
+    size_t length[VIDEO_MAX_PLANES];  // mmap() length.
 
     // Set true during QBUF and DQBUF. |address| will be accessed by hardware.
     bool at_device;
   };
 
   // Job record. Jobs are processed in a FIFO order. This is separate from
   // BufferRecord of input, because a BufferRecord of input may be returned
   // before we dequeue the corresponding output buffer. It can't always be
   // associated with a BufferRecord of output immediately either, because at
   // the time of submission we may not have one available (and don't need one
@@ skipping 14 matching lines @@
   void EnqueueInput();
   void EnqueueOutput();
   void Dequeue();
   bool EnqueueInputRecord();
   bool EnqueueOutputRecord();
   bool CreateInputBuffers();
   bool CreateOutputBuffers();
   void DestroyInputBuffers();
   void DestroyOutputBuffers();
 
+  // Convert |output_buffer| to I420 and copy the result to |dst_frame|.
+  // The function can convert to I420 from the following formats:
+  //   - All splane formats that libyuv::ConvertToI420 can handle.
+  //   - V4L2_PIX_FMT_YUV_420M
+  //   - V4L2_PIX_FMT_YUV_422M
+  bool ConvertOutputImage(const BufferRecord& output_buffer,
+                          const scoped_refptr<VideoFrame>& dst_frame);
+
   // Return the number of input/output buffers enqueued to the device.
   size_t InputBufferQueuedCount();
   size_t OutputBufferQueuedCount();
 
   // Return true if input buffer size is not enough.
   bool ShouldRecreateInputBuffers();
   // Destroy and create input buffers. Return false on error.
   bool RecreateInputBuffers();
   // Destroy and create output buffers. Return false on error.
   bool RecreateOutputBuffers();
@@ skipping 25 matching lines @@
 
   // The number of input buffers and output buffers.
   const size_t kBufferCount = 2;
 
   // Coded size of output buffer.
   gfx::Size output_buffer_coded_size_;
 
   // Pixel format of output buffer.
   uint32_t output_buffer_pixelformat_;
 
+  // Number of physical planes the output buffers have.
+  size_t output_buffer_num_planes_;
+
   // ChildThread's task runner.
   scoped_refptr<base::SingleThreadTaskRunner> child_task_runner_;
 
   // GPU IO task runner.
   scoped_refptr<base::SingleThreadTaskRunner> io_task_runner_;
 
   // The client of this class.
   Client* client_;
 
   // The V4L2Device this class is operating upon.
@@ skipping 34 matching lines @@
   // Point to |this| for use in posting tasks from the decoder thread back to
   // the ChildThread.
   base::WeakPtr<V4L2JpegDecodeAccelerator> weak_ptr_;
 
   DISALLOW_COPY_AND_ASSIGN(V4L2JpegDecodeAccelerator);
 };
 
 }  // namespace media
 
 #endif  // MEDIA_GPU_V4L2_JPEG_DECODE_ACCELERATOR_H_