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 24 matching lines @@
       const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner);
   ~V4L2JpegDecodeAccelerator() override;
 
   // JpegDecodeAccelerator implementation.
   bool Initialize(Client* client) override;
   void Decode(const BitstreamBuffer& bitstream_buffer,
               const scoped_refptr<VideoFrame>& video_frame) override;
   bool IsSupported() override;
 
  private:
+  // Input pixel format is alwasy V4L2_PIX_FMT_JPEG.
+  static const uint32_t kInputPlanes = 1;
+  // Ouput buffer has three physical planes.

[wuchengli, 2016/12/16 03:15:15]

I found the number of planes can be 1 V4L2_PIX_FMT_YUV420 or 3
V4L2_PIX_FMT_YUV420M. So the number of output planes is not always 1. T his is
the number of maximum output planes. Actually we can just use VIDEO_MAX_PLANES
from linux/videodev2.h. kOutputPlanes can be removed.

+  static const uint32_t kOutputPlanes = 3;
+
   // Record for input/output buffers.
   struct BufferRecord {
     BufferRecord();
     ~BufferRecord();
-    void* address;  // mmap() address.
-    size_t length;  // mmap() length.
+    void* address[kOutputPlanes];  // mmap() address.
+    size_t length[kOutputPlanes];  // mmap() length.
+    size_t num_planes;             // Number of mapped planes.

[wuchengli, 2016/12/16 03:15:15]

s/planes/physical planes/. So it's clear this is not logical planes.

 
     // 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 |src_buffer| to I420 and copy the result to |dst_frame|.
+  // The function currently accepts the following format as |src_pixelformat|:
+  //   - All splane formats that libyuv::ConvertToI420 can handle.
+  //   - V4L2_YUV_420M
+  //   - V4L2_YUV_422MV
+  bool ConvertOutputImage(const uint32_t src_pixelformat,
+                          const BufferRecord& src_buffer,
+                          const gfx::Size& src_coded_size,
+                          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 51 matching lines @@
   // Thread used to poll the V4L2 for events only.
   base::Thread device_poll_thread_;
   // Device poll task runner.
   scoped_refptr<base::SingleThreadTaskRunner> device_poll_task_runner_;
 
   // All the below members except |weak_factory_| are accessed from
   // |decoder_thread_| only (if it's running).
   std::queue<linked_ptr<JobRecord>> input_jobs_;
   std::queue<linked_ptr<JobRecord>> running_jobs_;
 
+  // V4L2 buffer type of the input buffer.
+  v4l2_buf_type input_buf_type_;
   // Input queue state.
   bool input_streamon_;
   // Mapping of int index to an input buffer record.
   std::vector<BufferRecord> input_buffer_map_;
   // Indices of input buffers ready to use; LIFO since we don't care about
   // ordering.
   std::vector<int> free_input_buffers_;
 
+  // V4L2 buffer type of the output buffer.
+  v4l2_buf_type output_buf_type_;
   // Output queue state.
   bool output_streamon_;
   // Mapping of int index to an output buffer record.
   std::vector<BufferRecord> output_buffer_map_;
   // Indices of output buffers ready to use; LIFO since we don't care about
   // ordering.
   std::vector<int> free_output_buffers_;
 
   // Weak factory for producing weak pointers on the child thread.
   base::WeakPtrFactory<V4L2JpegDecodeAccelerator> weak_factory_;
   // 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_