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 can have as many as three planes.

[wuchengli, 2016/12/15 09:18:25]

It looks like the output is always three planes, not one or two. s/can have as
many as/have/

s/three planes/three physical planes/

[jcliang, 2016/12/15 14:55:47]

Done.

I was thinking there are 2-plane and 4-plane pixel format as well, but for now
it's always 3-plane.

+  static const uint32_t kOutputPlanes = 3;
+  // Maximum number of buffer planes we are able to handle.
+  static const uint32_t kMaxBufferPlanes = 3;

[wuchengli, 2016/12/15 09:18:25]

We are hard-coding the number of planes to be always 3 (kOutputPlanes).
kMaxBufferPlanes can be removed.

[jcliang, 2016/12/15 14:55:47]

Done.

+
   // Record for input/output buffers.
   struct BufferRecord {
     BufferRecord();
     ~BufferRecord();
-    void* address;  // mmap() address.
-    size_t length;  // mmap() length.
+    void* address[kMaxBufferPlanes];  // mmap() address.
+    size_t length[kMaxBufferPlanes];  // mmap() length.
+    size_t num_planes;                // Number of mapped 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 13 matching lines @@
 
   void EnqueueInput();
   void EnqueueOutput();
   void Dequeue();
   bool EnqueueInputRecord();
   bool EnqueueOutputRecord();
   bool CreateInputBuffers();
   bool CreateOutputBuffers();
   void DestroyInputBuffers();
   void DestroyOutputBuffers();
 

[wuchengli, 2016/12/15 09:18:25]

Document this function. What's the output format? What's the supported input
formats?

This is not copy anymore. Use a better name. ConvertOutputImage?

[jcliang, 2016/12/15 14:55:47]

Done.

+  bool CopyOutputImage(const uint32_t src_pixelformat,
+                       const BufferRecord& src_output_record,
+                       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_