MJPEG acceleration for V4L2

content/common/gpu/media/v4l2_jpeg_decode_accelerator.cc

-// Copyright 2014 The Chromium Authors. All rights reserved.
+// 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.
 
 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <sys/eventfd.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/numerics/safe_conversions.h"
-#include "content/common/gpu/media/v4l2_image_processor.h"
+#include "content/common/gpu/media/v4l2_jpeg_decode_accelerator.h"
 #include "media/base/bind_to_current_loop.h"
+#include "media/base/video_frame.h"
 
-#define NOTIFY_ERROR()                      \
-  do {                                      \
-    LOG(ERROR) << "calling NotifyError()";  \
-    NotifyError();                          \
-  } while (0)
+//#undef DVLOG
+//#define DVLOG VLOG
 
 #define IOCTL_OR_ERROR_RETURN_VALUE(type, arg, value)              \
   do {                                                             \
     if (device_->Ioctl(type, arg) != 0) {                          \
       PLOG(ERROR) << __func__ << "(): ioctl() failed: " << #type;  \
       return value;                                                \
     }                                                              \
   } while (0)
 
 #define IOCTL_OR_ERROR_RETURN(type, arg) \
   IOCTL_OR_ERROR_RETURN_VALUE(type, arg, ((void)0))
 
 #define IOCTL_OR_ERROR_RETURN_FALSE(type, arg) \
   IOCTL_OR_ERROR_RETURN_VALUE(type, arg, false)
 
 #define IOCTL_OR_LOG_ERROR(type, arg)                              \
   do {                                                             \
     if (device_->Ioctl(type, arg) != 0)                            \
       PLOG(ERROR) << __func__ << "(): ioctl() failed: " << #type;  \
   } while (0)
 
 namespace content {
 
-V4L2ImageProcessor::InputRecord::InputRecord() : at_device(false) {
+V4L2JpegDecodeAccelerator::InputRecord::InputRecord() : at_device(false) {
 }
 
-V4L2ImageProcessor::InputRecord::~InputRecord() {
+V4L2JpegDecodeAccelerator::InputRecord::~InputRecord() {
 }
 
-V4L2ImageProcessor::OutputRecord::OutputRecord()
-    : at_device(false), at_client(false) {
+V4L2JpegDecodeAccelerator::OutputRecord::OutputRecord()
+    : address(nullptr), length(0), at_device(false) {
 }
 
-V4L2ImageProcessor::OutputRecord::~OutputRecord() {
+V4L2JpegDecodeAccelerator::OutputRecord::~OutputRecord() {
 }
 
-V4L2ImageProcessor::JobRecord::JobRecord() {
+V4L2JpegDecodeAccelerator::JobRecord::JobRecord(
+    media::BitstreamBuffer bitstream_buffer,
+    scoped_refptr<media::VideoFrame> video_frame)
+    : bitstream_buffer(bitstream_buffer), frame(video_frame) {
 }
 
-V4L2ImageProcessor::JobRecord::~JobRecord() {
+V4L2JpegDecodeAccelerator::JobRecord::~JobRecord() {
 }
 
-V4L2ImageProcessor::V4L2ImageProcessor(const scoped_refptr<V4L2Device>& device)
-    : input_format_(media::VideoFrame::UNKNOWN),
-      output_format_(media::VideoFrame::UNKNOWN),
-      input_format_fourcc_(0),
-      output_format_fourcc_(0),
-      input_planes_count_(0),
-      output_planes_count_(0),
-      child_message_loop_proxy_(base::MessageLoopProxy::current()),
+V4L2JpegDecodeAccelerator::V4L2JpegDecodeAccelerator(
+    const scoped_refptr<V4L2Device>& device,
+    const scoped_refptr<base::MessageLoopProxy>& io_message_loop_proxy)
+    : child_message_loop_proxy_(base::MessageLoopProxy::current()),
+      io_message_loop_proxy_(io_message_loop_proxy),
       device_(device),
-      device_thread_("V4L2ImageProcessorThread"),
-      device_poll_thread_("V4L2ImageProcessorDevicePollThread"),
+      device_thread_("V4L2JpegDecodeThread"),
+      device_poll_thread_("V4L2JpegDecodeDevicePollThread"),
       input_streamon_(false),
       input_buffer_queued_count_(0),
       output_streamon_(false),
       output_buffer_queued_count_(0),
       device_weak_factory_(this) {
+  device_weak_ = device_weak_factory_.GetWeakPtr();
 }
 
-V4L2ImageProcessor::~V4L2ImageProcessor() {
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+V4L2JpegDecodeAccelerator::~V4L2JpegDecodeAccelerator() {
   DCHECK(!device_thread_.IsRunning());
   DCHECK(!device_poll_thread_.IsRunning());
-
   DestroyInputBuffers();
   DestroyOutputBuffers();
 }
 
-void V4L2ImageProcessor::NotifyError() {
-  if (!child_message_loop_proxy_->BelongsToCurrentThread())
-    child_message_loop_proxy_->PostTask(FROM_HERE, error_cb_);
-  else
-    error_cb_.Run();
+void V4L2JpegDecodeAccelerator::NotifyError(int32_t bitstream_buffer_id,
+                                            Error error) {
+  if (!child_message_loop_proxy_->BelongsToCurrentThread()) {

[wuchengli, 2015/05/25 10:29:23]

Don't use this pattern. See piman's comment in
https://codereview.chromium.org/1124423008/diff/1/content/common/gpu/media/va....

[henryhsu, 2015/06/05 03:28:56]

Done.

+    child_message_loop_proxy_->PostTask(
+        FROM_HERE,
+        base::Bind(&V4L2JpegDecodeAccelerator::NotifyError,
+                   device_weak_, bitstream_buffer_id, error));
+    return;
+  }
+  LOG(ERROR) << "Notifying of error " << error << " for buffer id "
+             << bitstream_buffer_id;
+  if (client_) {
+    client_->NotifyError(bitstream_buffer_id, error);
+    client_ptr_factory_.reset();
+  }
 }
 
-bool V4L2ImageProcessor::Initialize(media::VideoFrame::Format input_format,
-                                    media::VideoFrame::Format output_format,
-                                    gfx::Size input_visible_size,
-                                    gfx::Size output_visible_size,
-                                    gfx::Size output_allocated_size,
-                                    const base::Closure& error_cb) {
-  DCHECK(!error_cb.is_null());
-  error_cb_ = error_cb;
+bool V4L2JpegDecodeAccelerator::Initialize(Client* client) {
+  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
 
-  // TODO(posciak): Replace Exynos-specific format/parameter hardcoding in this
-  // class with proper capability enumeration.
-  DCHECK_EQ(input_format, media::VideoFrame::I420);
-  DCHECK_EQ(output_format, media::VideoFrame::NV12);
-
-  input_format_ = input_format;
-  output_format_ = output_format;
-  input_format_fourcc_ = V4L2Device::VideoFrameFormatToV4L2PixFmt(input_format);
-  output_format_fourcc_ =
-      V4L2Device::VideoFrameFormatToV4L2PixFmt(output_format);
-
-  if (!input_format_fourcc_ || !output_format_fourcc_) {
-    LOG(ERROR) << "Unrecognized format(s)";
-    return false;
-  }
-
-  input_visible_size_ = input_visible_size;
-  output_visible_size_ = output_visible_size;
-  output_allocated_size_ = output_allocated_size;
-
-  input_planes_count_ = media::VideoFrame::NumPlanes(input_format);
-  DCHECK_LE(input_planes_count_, static_cast<size_t>(VIDEO_MAX_PLANES));
-  output_planes_count_ = media::VideoFrame::NumPlanes(output_format);
-  DCHECK_LE(output_planes_count_, static_cast<size_t>(VIDEO_MAX_PLANES));
+  client_ptr_factory_.reset(new base::WeakPtrFactory<Client>(client));
+  client_ = client_ptr_factory_->GetWeakPtr();

[kcwu, 2015/05/26 10:47:23]

No need to use weak pointer for |client|. |client| must outlive than |this|
according to JDA interface. And in practice, |this| is owned by |client|.

[henryhsu, 2015/06/05 03:28:56]

Done.

 
   // Capabilities check.
   struct v4l2_capability caps;
-  memset(&caps, 0, sizeof(caps));
-  const __u32 kCapsRequired = V4L2_CAP_VIDEO_CAPTURE_MPLANE |
-                              V4L2_CAP_VIDEO_OUTPUT_MPLANE | V4L2_CAP_STREAMING;
+  // TODO(henryhsu): Do we need V4L2_CAP_STREAMING capability?
+  const __u32 kCapsRequired = V4L2_CAP_VIDEO_CAPTURE |

[wuchengli, 2015/05/25 10:29:23]

We should only need V4L2_CAP_VIDEO_M2M_MPLANE | V4L2_CAP_STREAMING. Fix the
driver. V4L2_CAP_VIDEO_CAPTURE and V4L2_CAP_VIDEO_OUTPUT are legacy.

[henryhsu, 2015/06/05 03:28:55]

s5p-jpeg doesn't support multiple planar. I think it should be
V4L2_CAP_VIDEO_M2M | V4L2_CAP_STREAMING.

+                              V4L2_CAP_VIDEO_OUTPUT;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QUERYCAP, &caps);
   if ((caps.capabilities & kCapsRequired) != kCapsRequired) {
-    LOG(ERROR) << "Initialize(): ioctl() failed: VIDIOC_QUERYCAP: "
-                  "caps check failed: 0x" << std::hex << caps.capabilities;
+    LOG(ERROR) << "Initialize(): ioctl() failed: VIDIOC_QUERYCAP"
+        ", caps check failed: 0x" << std::hex << caps.capabilities;
     return false;
   }
 
-  if (!CreateInputBuffers() || !CreateOutputBuffers())
-    return false;
-
   if (!device_thread_.Start()) {
     LOG(ERROR) << "Initialize(): encoder thread failed to start";
     return false;
   }
 
-  // StartDevicePoll will NOTIFY_ERROR on failure, so IgnoreResult is fine here.
+  // StartDevicePoll will NotifyError on failure, so IgnoreResult is fine here.

[kcwu, 2015/05/26 10:47:22]

Nobody use the return value of StartDevicePoll. How about make it return void?

[henryhsu, 2015/06/05 03:28:55]

Done.

   device_thread_.message_loop()->PostTask(
       FROM_HERE,
-      base::Bind(base::IgnoreResult(&V4L2ImageProcessor::StartDevicePoll),
-                 base::Unretained(this)));
+      base::Bind(
+          base::IgnoreResult(&V4L2JpegDecodeAccelerator::StartDevicePoll),
+          base::Unretained(this)));
 
-  DVLOG(1) << "V4L2ImageProcessor initialized for "
-           << " input_format:"
-           << media::VideoFrame::FormatToString(input_format)
-           << ", output_format:"
-           << media::VideoFrame::FormatToString(output_format)
-           << ", input_visible_size: " << input_visible_size.ToString()
-           << ", input_allocated_size: " << input_allocated_size_.ToString()
-           << ", output_visible_size: " << output_visible_size.ToString()
-           << ", output_allocated_size: " << output_allocated_size.ToString();
+  DVLOG(1) << "V4L2JpegDecodeAccelerator initialized.";
 
   return true;
 }
 
-void V4L2ImageProcessor::Process(const scoped_refptr<media::VideoFrame>& frame,
-                                 const FrameReadyCB& cb) {
-  DVLOG(3) << __func__ << ": ts=" << frame->timestamp().InMilliseconds();
+void V4L2JpegDecodeAccelerator::Decode(
+    const media::BitstreamBuffer& bitstream_buffer,
+    const scoped_refptr<media::VideoFrame>& video_frame) {
+  DVLOG(1) << "Decode(): input_id=" << bitstream_buffer.id()
+           << ", size=" << bitstream_buffer.size();
+  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
+  // TODO(henryhsu): DCHECK or DCHECK
+  DCHECK_EQ(video_frame->format(), media::VideoFrame::I420);
 
-  scoped_ptr<JobRecord> job_record(new JobRecord());
-  job_record->frame = frame;
-  job_record->ready_cb = cb;
+  scoped_ptr<JobRecord> job_record(
+      new JobRecord(bitstream_buffer, video_frame));
 
   device_thread_.message_loop()->PostTask(
       FROM_HERE,
-      base::Bind(&V4L2ImageProcessor::ProcessTask,
+      base::Bind(&V4L2JpegDecodeAccelerator::DecodeTask,
                  base::Unretained(this),
                  base::Passed(&job_record)));
 }
 
-void V4L2ImageProcessor::ProcessTask(scoped_ptr<JobRecord> job_record) {
+void V4L2JpegDecodeAccelerator::DecodeTask(scoped_ptr<JobRecord> job_record) {
   DCHECK_EQ(device_thread_.message_loop(), base::MessageLoop::current());
-
   input_queue_.push(make_linked_ptr(job_record.release()));
+  if (!CheckBufferAttributes())
+    return;
   Enqueue();
 }
 
-void V4L2ImageProcessor::Destroy() {
+void V4L2JpegDecodeAccelerator::Destroy() {
   DVLOG(3) << __func__;
   DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
 
   // If the device thread is running, destroy using posted task.
   if (device_thread_.IsRunning()) {
     device_thread_.message_loop()->PostTask(
         FROM_HERE,
-        base::Bind(&V4L2ImageProcessor::DestroyTask, base::Unretained(this)));
+        base::Bind(&V4L2JpegDecodeAccelerator::DestroyTask,
+                   base::Unretained(this)));
     // Wait for tasks to finish/early-exit.
     device_thread_.Stop();
   } else {
     // Otherwise DestroyTask() is not needed.
     DCHECK(!device_poll_thread_.IsRunning());
     DCHECK(!device_weak_factory_.HasWeakPtrs());
   }
-
   delete this;
 }
 
-void V4L2ImageProcessor::DestroyTask() {
+void V4L2JpegDecodeAccelerator::DestroyTask() {
   DCHECK_EQ(device_thread_.message_loop(), base::MessageLoop::current());
 
   device_weak_factory_.InvalidateWeakPtrs();
 
   // Stop streaming and the device_poll_thread_.
   StopDevicePoll();
 }
 
-bool V4L2ImageProcessor::CreateInputBuffers() {
+bool V4L2JpegDecodeAccelerator::CheckBufferAttributes() {
   DVLOG(3) << __func__;
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK_EQ(device_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK(!input_queue_.empty());
+  linked_ptr<JobRecord> job_record = input_queue_.front();
+
+  // Check image resolution and format are the same as previous.
+  if (job_record->frame->format() != output_format_ ||
+      job_record->frame->coded_size() != image_coded_size_) {
+    image_coded_size_ = job_record->frame->coded_size();
+    output_format_ = job_record->frame->format();
+    if (input_streamon_ || output_streamon_) {
+//      ResetBuffers();
+//      input_queue_.push(job_record);
+    } else if (!CreateInputBuffers() || !CreateOutputBuffers()) {
+      return false;
+    }
+  }
+  return true;
+}
+
+//void V4L2JpegDecodeAccelerator::ResetBuffers() {
+//  DVLOG(3) << __func__;
+//  if (!StopDevicePoll())
+//    return;
+//}
+
+bool V4L2JpegDecodeAccelerator::CreateInputBuffers() {
+  DVLOG(3) << __func__;
+  DCHECK_EQ(device_thread_.message_loop(), base::MessageLoop::current());
   DCHECK(!input_streamon_);
 
-  struct v4l2_control control;
-  memset(&control, 0, sizeof(control));
-  control.id = V4L2_CID_ROTATE;
-  control.value = 0;
-  IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_CTRL, &control);
-
-  memset(&control, 0, sizeof(control));
-  control.id = V4L2_CID_HFLIP;
-  control.value = 0;
-  IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_CTRL, &control);
-
-  memset(&control, 0, sizeof(control));
-  control.id = V4L2_CID_VFLIP;
-  control.value = 0;
-  IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_CTRL, &control);
-
-  memset(&control, 0, sizeof(control));
-  control.id = V4L2_CID_ALPHA_COMPONENT;
-  control.value = 255;
-  IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_CTRL, &control);
+  DCHECK(!input_queue_.empty());
+  linked_ptr<JobRecord> job_record = input_queue_.front();
+  size_t reserve_size = job_record->bitstream_buffer.size() * 2;
 
   struct v4l2_format format;
   memset(&format, 0, sizeof(format));
-  format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
-  format.fmt.pix_mp.width = input_visible_size_.width();
-  format.fmt.pix_mp.height = input_visible_size_.height();
-  format.fmt.pix_mp.pixelformat = input_format_fourcc_;
-  format.fmt.pix_mp.num_planes = input_planes_count_;
-  for (size_t i = 0; i < input_planes_count_; ++i) {
-    format.fmt.pix_mp.plane_fmt[i].sizeimage =
-        media::VideoFrame::PlaneAllocationSize(
-            input_format_, i, input_allocated_size_);
-    format.fmt.pix_mp.plane_fmt[i].bytesperline =
-        base::checked_cast<__u32>(input_allocated_size_.width());
-  }
+  format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+  format.fmt.pix.width = job_record->frame->coded_size().width();
+  format.fmt.pix.height = job_record->frame->coded_size().height();
+  format.fmt.pix.pixelformat = V4L2_PIX_FMT_JPEG;
+  format.fmt.pix.sizeimage = reserve_size;
+  format.fmt.pix.field = V4L2_FIELD_ANY;
+  format.fmt.pix.bytesperline = 0;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_FMT, &format);
 
-  input_allocated_size_ = V4L2Device::CodedSizeFromV4L2Format(format);
-  DCHECK(gfx::Rect(input_allocated_size_).Contains(
-      gfx::Rect(input_visible_size_)));
-
-  struct v4l2_crop crop;
-  memset(&crop, 0, sizeof(crop));
-  crop.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
-  crop.c.left = 0;
-  crop.c.top = 0;
-  crop.c.width = base::checked_cast<__u32>(input_visible_size_.width());
-  crop.c.height = base::checked_cast<__u32>(input_visible_size_.height());
-  IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_CROP, &crop);
-
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count = kInputBufferCount;
-  reqbufs.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
-  reqbufs.memory = V4L2_MEMORY_USERPTR;
+  reqbufs.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+  reqbufs.memory = V4L2_MEMORY_MMAP;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_REQBUFS, &reqbufs);
 
   DCHECK(input_buffer_map_.empty());
   input_buffer_map_.resize(reqbufs.count);
 
-  for (size_t i = 0; i < input_buffer_map_.size(); ++i)
+  for (size_t i = 0; i < input_buffer_map_.size(); ++i) {
     free_input_buffers_.push_back(i);
 
+    struct v4l2_buffer buffer;
+    memset(&buffer, 0, sizeof(buffer));
+    buffer.index = i;
+    buffer.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+    buffer.memory = V4L2_MEMORY_MMAP;
+    IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QUERYBUF, &buffer);
+    void* address = device_->Mmap(NULL,
+                                  buffer.length,
+                                  PROT_READ | PROT_WRITE,
+                                  MAP_SHARED,
+                                  buffer.m.offset);
+    if (address == MAP_FAILED) {
+      PLOG(ERROR) << "CreateInputBuffers(): mmap() failed";
+      return false;
+    }
+    input_buffer_map_[i].address = address;
+    input_buffer_map_[i].length = buffer.length;
+  }
+
   return true;
 }
 
-bool V4L2ImageProcessor::CreateOutputBuffers() {
+bool V4L2JpegDecodeAccelerator::CreateOutputBuffers() {
   DVLOG(3) << __func__;
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK_EQ(device_thread_.message_loop(), base::MessageLoop::current());
   DCHECK(!output_streamon_);
 
+  DCHECK(!input_queue_.empty());
+  linked_ptr<JobRecord> job_record = input_queue_.front();
+
+  size_t frame_size = media::VideoFrame::AllocationSize(
+      output_format_,job_record->frame->coded_size());
+  // TODO(henryhsu): not support YUV410M format
+  uint32 output_format_fourcc_ = V4L2_PIX_FMT_YUV420;
+  //      V4L2Device::VideoFrameFormatToV4L2PixFmt(output_format_);
   struct v4l2_format format;
   memset(&format, 0, sizeof(format));
-  format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
-  format.fmt.pix_mp.width = output_allocated_size_.width();
-  format.fmt.pix_mp.height = output_allocated_size_.height();
-  format.fmt.pix_mp.pixelformat = output_format_fourcc_;
-  format.fmt.pix_mp.num_planes = output_planes_count_;
-  for (size_t i = 0; i < output_planes_count_; ++i) {
-    format.fmt.pix_mp.plane_fmt[i].sizeimage =
-        media::VideoFrame::PlaneAllocationSize(
-            output_format_, i, output_allocated_size_);
-    format.fmt.pix_mp.plane_fmt[i].bytesperline =
-        base::checked_cast<__u32>(output_allocated_size_.width());
-  }
+  format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+  format.fmt.pix.width = job_record->frame->coded_size().width();
+  format.fmt.pix.height = job_record->frame->coded_size().height();
+  format.fmt.pix.sizeimage = frame_size;
+  format.fmt.pix.pixelformat = output_format_fourcc_;
+  format.fmt.pix.field = V4L2_FIELD_ANY;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_FMT, &format);
 
-  gfx::Size adjusted_allocated_size =
-      V4L2Device::CodedSizeFromV4L2Format(format);
-  DCHECK(gfx::Rect(adjusted_allocated_size).Contains(
-      gfx::Rect(output_allocated_size_)));
-  output_allocated_size_ = adjusted_allocated_size;
-
-  struct v4l2_crop crop;
-  memset(&crop, 0, sizeof(crop));
-  crop.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
-  crop.c.left = 0;
-  crop.c.top = 0;
-  crop.c.width = base::checked_cast<__u32>(output_visible_size_.width());
-  crop.c.height = base::checked_cast<__u32>(output_visible_size_.height());
-  IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_CROP, &crop);
-
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count = kOutputBufferCount;
-  reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+  reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   reqbufs.memory = V4L2_MEMORY_MMAP;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_REQBUFS, &reqbufs);
 
   DCHECK(output_buffer_map_.empty());
   output_buffer_map_.resize(reqbufs.count);
+
   for (size_t i = 0; i < output_buffer_map_.size(); ++i) {
-    OutputRecord& output_record = output_buffer_map_[i];
-    output_record.fds.resize(output_planes_count_);
-    for (size_t j = 0; j < output_planes_count_; ++j) {
-      struct v4l2_exportbuffer expbuf;
-      memset(&expbuf, 0, sizeof(expbuf));
-      expbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
-      expbuf.index = i;
-      expbuf.plane = j;
-      expbuf.flags = O_CLOEXEC;
-      IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_EXPBUF, &expbuf);
-      output_record.fds[j] = expbuf.fd;
+    free_output_buffers_.push_back(i);
+
+    struct v4l2_buffer buffer;
+    memset(&buffer, 0, sizeof(buffer));
+    buffer.index = i;
+    buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    buffer.memory = V4L2_MEMORY_MMAP;
+    IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QUERYBUF, &buffer);
+    void* address = device_->Mmap(NULL,
+                                  buffer.length,
+                                  PROT_READ | PROT_WRITE,
+                                  MAP_SHARED,
+                                  buffer.m.offset);
+    if (address == MAP_FAILED) {
+      PLOG(ERROR) << "CreateOutputBuffers(): mmap() failed";
+      return false;
     }
-    free_output_buffers_.push_back(i);
+    output_buffer_map_[i].address = address;
+    output_buffer_map_[i].length = buffer.length;
   }
 
   return true;
 }
 
-void V4L2ImageProcessor::DestroyInputBuffers() {
+void V4L2JpegDecodeAccelerator::DestroyInputBuffers() {
   DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
   DCHECK(!input_streamon_);
 
+  for (size_t buf = 0; buf < input_buffer_map_.size(); ++buf) {
+    InputRecord& input_record = input_buffer_map_[buf];
+    device_->Munmap(input_record.address, input_record.length);
+  }
+
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count = 0;
-  reqbufs.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
-  reqbufs.memory = V4L2_MEMORY_USERPTR;
+  reqbufs.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+  reqbufs.memory = V4L2_MEMORY_MMAP;
   IOCTL_OR_LOG_ERROR(VIDIOC_REQBUFS, &reqbufs);
 
   input_buffer_map_.clear();
   free_input_buffers_.clear();
 }
 
-void V4L2ImageProcessor::DestroyOutputBuffers() {
+void V4L2JpegDecodeAccelerator::DestroyOutputBuffers() {
   DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
   DCHECK(!output_streamon_);
 
   for (size_t buf = 0; buf < output_buffer_map_.size(); ++buf) {
     OutputRecord& output_record = output_buffer_map_[buf];
-    for (size_t plane = 0; plane < output_record.fds.size(); ++plane)
-      close(output_record.fds[plane]);
-    output_record.fds.clear();
+    device_->Munmap(output_record.address, output_record.length);
   }
 
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count = 0;
-  reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+  reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   reqbufs.memory = V4L2_MEMORY_MMAP;
   IOCTL_OR_LOG_ERROR(VIDIOC_REQBUFS, &reqbufs);
 
   output_buffer_map_.clear();
   free_output_buffers_.clear();
 }
 
-void V4L2ImageProcessor::DevicePollTask(bool poll_device) {
+void V4L2JpegDecodeAccelerator::DevicePollTask(bool poll_device) {
   DCHECK_EQ(device_poll_thread_.message_loop(), base::MessageLoop::current());
 
   bool event_pending;
   if (!device_->Poll(poll_device, &event_pending)) {
-    NOTIFY_ERROR();
+    NotifyError(-1, media::JpegDecodeAccelerator::PLATFORM_FAILURE);
     return;
   }
 
   // All processing should happen on ServiceDeviceTask(), since we shouldn't
   // touch encoder state from this thread.
   device_thread_.message_loop()->PostTask(
       FROM_HERE,
-      base::Bind(&V4L2ImageProcessor::ServiceDeviceTask,
+      base::Bind(&V4L2JpegDecodeAccelerator::ServiceDeviceTask,
                  base::Unretained(this)));
 }
 
-void V4L2ImageProcessor::ServiceDeviceTask() {
+void V4L2JpegDecodeAccelerator::ServiceDeviceTask() {
   DCHECK_EQ(device_thread_.message_loop(), base::MessageLoop::current());
   // ServiceDeviceTask() should only ever be scheduled from DevicePollTask(),
   // so either:
   // * device_poll_thread_ is running normally
   // * device_poll_thread_ scheduled us, but then a DestroyTask() shut it down,
   //   in which case we should early-out.
   if (!device_poll_thread_.message_loop())
     return;
 
   Dequeue();
   Enqueue();
 
-  if (!device_->ClearDevicePollInterrupt())
+  if (!device_->ClearDevicePollInterrupt()) {
     return;
+  }
 
   bool poll_device =
       (input_buffer_queued_count_ > 0 && output_buffer_queued_count_ > 0);
 
   device_poll_thread_.message_loop()->PostTask(
       FROM_HERE,
-      base::Bind(&V4L2ImageProcessor::DevicePollTask,
+      base::Bind(&V4L2JpegDecodeAccelerator::DevicePollTask,
                  base::Unretained(this),
                  poll_device));
 
   DVLOG(2) << __func__ << ": buffer counts: INPUT["
            << input_queue_.size() << "] => DEVICE["
            << free_input_buffers_.size() << "+"
            << input_buffer_queued_count_ << "/"
            << input_buffer_map_.size() << "->"
            << free_output_buffers_.size() << "+"
            << output_buffer_queued_count_ << "/"
            << output_buffer_map_.size() << "] => CLIENT["
            << output_buffer_map_.size() - output_buffer_queued_count_ -
               free_output_buffers_.size() << "]";
 }
 
-void V4L2ImageProcessor::Enqueue() {
+void V4L2JpegDecodeAccelerator::Enqueue() {
   DCHECK_EQ(device_thread_.message_loop(), base::MessageLoop::current());
 
   const int old_inputs_queued = input_buffer_queued_count_;
   while (!input_queue_.empty() && !free_input_buffers_.empty()) {
     if (!EnqueueInputRecord())
       return;
   }
   if (old_inputs_queued == 0 && input_buffer_queued_count_ != 0) {
     // We started up a previously empty queue.
     // Queue state changed; signal interrupt.
-    if (!device_->SetDevicePollInterrupt())
+    if (!device_->SetDevicePollInterrupt()) {

[kcwu, 2015/05/26 10:47:23]

Why do we need to SetDevicePollInterrupt?
Assume there is no decode pending now and one new input comming. The code flow
will be:
1. main thread Decode, post DecodeTask to device thread
2. device thread DecodeTask, call Enqueue and SetDevicePollInterrupt here.
3. the poll thread got interrupted and post ServiceDeviceTask to device thread
4. device thread ServiceDeviceTask call Dequeue & Enqueue. But this is sooner
than device decoding finished, Dequeue got nothing.
   Then it posts DevicePollTask to poll thread.
5. poll thread wait device decoding finished. Then post ServiceDeviceTask to
device thread again.
6. this time ServiceDeviceTask call Dequeue and got output.

step 3 & 4 is actually doing nothing. They could be saved without
SetDevicePollInterrupt.

[henryhsu, 2015/06/05 03:28:55]

As discussed before, I removed this to save one trip for one frame.

       return;
+    }
     // VIDIOC_STREAMON if we haven't yet.
     if (!input_streamon_) {
-      __u32 type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
+      __u32 type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
       IOCTL_OR_ERROR_RETURN(VIDIOC_STREAMON, &type);
       input_streamon_ = true;
     }
   }
 
   // TODO(posciak): Fix this to be non-Exynos specific.

[wuchengli, 2015/05/25 10:29:23]

This is a new driver. We have a chance not to have any workaround in the code.
Please fix the driver if it's a bug.

[Pawel Osciak, 2015/05/25 11:05:01]

As far as I know this only applies to GSC, I don't think JPEG has the same
issue.

[henryhsu, 2015/06/05 03:28:55]

Done.

   // Exynos GSC is liable to race conditions if more than one output buffer is
   // simultaneously enqueued, so enqueue just one.
   if (output_buffer_queued_count_ == 0 && !free_output_buffers_.empty()) {
     const int old_outputs_queued = output_buffer_queued_count_;
     if (!EnqueueOutputRecord())
       return;
     if (old_outputs_queued == 0 && output_buffer_queued_count_ != 0) {
       // We just started up a previously empty queue.
       // Queue state changed; signal interrupt.
-      if (!device_->SetDevicePollInterrupt())
+      if (!device_->SetDevicePollInterrupt()) {
         return;
+      }
       // Start VIDIOC_STREAMON if we haven't yet.
       if (!output_streamon_) {
-        __u32 type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+        __u32 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
         IOCTL_OR_ERROR_RETURN(VIDIOC_STREAMON, &type);
         output_streamon_ = true;
       }
     }
   }
   DCHECK_LE(output_buffer_queued_count_, 1);
 }
 
-void V4L2ImageProcessor::Dequeue() {
+void V4L2JpegDecodeAccelerator::Dequeue() {
   DCHECK_EQ(device_thread_.message_loop(), base::MessageLoop::current());
 
   // Dequeue completed input (VIDEO_OUTPUT) buffers,
   // and recycle to the free list.
   struct v4l2_buffer dqbuf;
-  struct v4l2_plane planes[VIDEO_MAX_PLANES];
   while (input_buffer_queued_count_ > 0) {
     DCHECK(input_streamon_);
     memset(&dqbuf, 0, sizeof(dqbuf));
-    memset(&planes, 0, sizeof(planes));
-    dqbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
-    dqbuf.memory = V4L2_MEMORY_USERPTR;
-    dqbuf.m.planes = planes;
-    dqbuf.length = input_planes_count_;
+    dqbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+    dqbuf.memory = V4L2_MEMORY_MMAP;
     if (device_->Ioctl(VIDIOC_DQBUF, &dqbuf) != 0) {
       if (errno == EAGAIN) {
         // EAGAIN if we're just out of buffers to dequeue.
         break;
       }
       PLOG(ERROR) << "ioctl() failed: VIDIOC_DQBUF";
-      NOTIFY_ERROR();
+      NotifyError(dqbuf.index, media::JpegDecodeAccelerator::PLATFORM_FAILURE);
       return;
     }
     InputRecord& input_record = input_buffer_map_[dqbuf.index];
     DCHECK(input_record.at_device);
     input_record.at_device = false;
-    input_record.frame = NULL;
     free_input_buffers_.push_back(dqbuf.index);
     input_buffer_queued_count_--;
   }
 
   // Dequeue completed output (VIDEO_CAPTURE) buffers, recycle to the free list.
   // Return the finished buffer to the client via the job ready callback.
   while (output_buffer_queued_count_ > 0) {
     DCHECK(output_streamon_);
     memset(&dqbuf, 0, sizeof(dqbuf));
-    memset(&planes, 0, sizeof(planes));
-    dqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+    dqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     dqbuf.memory = V4L2_MEMORY_MMAP;
-    dqbuf.m.planes = planes;
-    dqbuf.length = output_planes_count_;
     if (device_->Ioctl(VIDIOC_DQBUF, &dqbuf) != 0) {
       if (errno == EAGAIN) {
         // EAGAIN if we're just out of buffers to dequeue.
         break;
       }
       PLOG(ERROR) << "ioctl() failed: VIDIOC_DQBUF";
-      NOTIFY_ERROR();
+      NotifyError(dqbuf.index, media::JpegDecodeAccelerator::PLATFORM_FAILURE);
       return;
     }
     OutputRecord& output_record = output_buffer_map_[dqbuf.index];
     DCHECK(output_record.at_device);
     output_record.at_device = false;
-    output_record.at_client = true;
+    free_output_buffers_.push_back(dqbuf.index);
     output_buffer_queued_count_--;
 
     // Jobs are always processed in FIFO order.
     DCHECK(!running_jobs_.empty());
     linked_ptr<JobRecord> job_record = running_jobs_.front();
     running_jobs_.pop();
 
-    scoped_refptr<media::VideoFrame> output_frame =
-        media::VideoFrame::WrapExternalDmabufs(
-            output_format_,
-            output_allocated_size_,
-            gfx::Rect(output_visible_size_),
-            output_visible_size_,
-            output_record.fds,
-            job_record->frame->timestamp(),
-            media::BindToCurrentLoop(
-                base::Bind(&V4L2ImageProcessor::ReuseOutputBuffer,
-                           device_weak_factory_.GetWeakPtr(),
-                           dqbuf.index)));
+    memcpy(job_record->frame->data(media::VideoFrame::kYPlane),
+           output_record.address,
+           output_record.length);
 
     DVLOG(3) << "Processing finished, returning frame, ts="
-             << output_frame->timestamp().InMilliseconds();
+             << job_record->frame->timestamp().InMilliseconds();
 
-    child_message_loop_proxy_->PostTask(
-        FROM_HERE, base::Bind(job_record->ready_cb, output_frame));
+    if (client_)
+      client_->VideoFrameReady(job_record->bitstream_buffer.id());
   }
 }
 
-void V4L2ImageProcessor::ReuseOutputBuffer(int index) {
-  DVLOG(3) << "Reusing output buffer, index=" << index;
-  DCHECK_EQ(device_thread_.message_loop(), base::MessageLoop::current());
-
-  OutputRecord& output_record = output_buffer_map_[index];
-  DCHECK(output_record.at_client);
-  DCHECK(!output_record.at_device);
-  output_record.at_client = false;
-  free_output_buffers_.push_back(index);
-
-  Enqueue();
-}
-
-bool V4L2ImageProcessor::EnqueueInputRecord() {
+bool V4L2JpegDecodeAccelerator::EnqueueInputRecord() {
   DCHECK(!input_queue_.empty());
   DCHECK(!free_input_buffers_.empty());
 
   // Enqueue an input (VIDEO_OUTPUT) buffer for an input video frame.
   linked_ptr<JobRecord> job_record = input_queue_.front();
   input_queue_.pop();
   const int index = free_input_buffers_.back();
   InputRecord& input_record = input_buffer_map_[index];
   DCHECK(!input_record.at_device);
-  input_record.frame = job_record->frame;
+
+  scoped_ptr<base::SharedMemory> shm(
+      new base::SharedMemory(job_record->bitstream_buffer.handle(), true));
+  if (!shm->Map(job_record->bitstream_buffer.size())) {
+    LOG(ERROR) << "Decode(): could not map bitstream_buffer";
+    NotifyError(job_record->bitstream_buffer.id(), UNREADABLE_INPUT);
+    return false;
+  }
   struct v4l2_buffer qbuf;
-  struct v4l2_plane qbuf_planes[VIDEO_MAX_PLANES];
   memset(&qbuf, 0, sizeof(qbuf));
-  memset(qbuf_planes, 0, sizeof(qbuf_planes));
+  memcpy(input_record.address, shm->memory(), input_record.length);
   qbuf.index = index;
-  qbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
-  qbuf.memory = V4L2_MEMORY_USERPTR;
-  qbuf.m.planes = qbuf_planes;
-  qbuf.length = input_planes_count_;
-  for (size_t i = 0; i < input_planes_count_; ++i) {
-    qbuf.m.planes[i].bytesused = media::VideoFrame::PlaneAllocationSize(
-        input_record.frame->format(), i, input_allocated_size_);
-    qbuf.m.planes[i].length = qbuf.m.planes[i].bytesused;
-    qbuf.m.planes[i].m.userptr =
-        reinterpret_cast<unsigned long>(input_record.frame->data(i));
-  }
+  qbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+  qbuf.memory = V4L2_MEMORY_MMAP;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QBUF, &qbuf);
   input_record.at_device = true;
   running_jobs_.push(job_record);
   free_input_buffers_.pop_back();
   input_buffer_queued_count_++;
 
   DVLOG(3) << __func__ << ": enqueued frame ts="
            << job_record->frame->timestamp().InMilliseconds() << " to device.";
 
   return true;
 }
 
-bool V4L2ImageProcessor::EnqueueOutputRecord() {
+bool V4L2JpegDecodeAccelerator::EnqueueOutputRecord() {
   DCHECK(!free_output_buffers_.empty());
 
   // Enqueue an output (VIDEO_CAPTURE) buffer.
   const int index = free_output_buffers_.back();
   OutputRecord& output_record = output_buffer_map_[index];
   DCHECK(!output_record.at_device);
   struct v4l2_buffer qbuf;
-  struct v4l2_plane qbuf_planes[VIDEO_MAX_PLANES];
   memset(&qbuf, 0, sizeof(qbuf));
-  memset(qbuf_planes, 0, sizeof(qbuf_planes));
   qbuf.index = index;
-  qbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+  qbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
   qbuf.memory = V4L2_MEMORY_MMAP;
-  qbuf.m.planes = qbuf_planes;
-  qbuf.length = output_planes_count_;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QBUF, &qbuf);
   output_record.at_device = true;
   free_output_buffers_.pop_back();
   output_buffer_queued_count_++;
   return true;
 }
 
-bool V4L2ImageProcessor::StartDevicePoll() {
+bool V4L2JpegDecodeAccelerator::StartDevicePoll() {
   DVLOG(3) << __func__ << ": starting device poll";
   DCHECK_EQ(device_thread_.message_loop(), base::MessageLoop::current());
   DCHECK(!device_poll_thread_.IsRunning());
 
   // Start up the device poll thread and schedule its first DevicePollTask().
   if (!device_poll_thread_.Start()) {
     LOG(ERROR) << "StartDevicePoll(): Device thread failed to start";
-    NOTIFY_ERROR();
+    NotifyError(-1, media::JpegDecodeAccelerator::PLATFORM_FAILURE);
     return false;
   }
   // Enqueue a poll task with no devices to poll on - will wait only for the
   // poll interrupt
   device_poll_thread_.message_loop()->PostTask(
       FROM_HERE,
       base::Bind(
-          &V4L2ImageProcessor::DevicePollTask, base::Unretained(this), false));
+          &V4L2JpegDecodeAccelerator::DevicePollTask,
+          base::Unretained(this), false));
 
   return true;
 }
 
-bool V4L2ImageProcessor::StopDevicePoll() {
+bool V4L2JpegDecodeAccelerator::StopDevicePoll() {
   DVLOG(3) << __func__ << ": stopping device poll";
   if (device_thread_.IsRunning())
     DCHECK_EQ(device_thread_.message_loop(), base::MessageLoop::current());
 
   // Signal the DevicePollTask() to stop, and stop the device poll thread.
-  if (!device_->SetDevicePollInterrupt())
+  if (!device_->SetDevicePollInterrupt()) {
     return false;
+  }
   device_poll_thread_.Stop();
 
   // Clear the interrupt now, to be sure.
-  if (!device_->ClearDevicePollInterrupt())
+  if (!device_->ClearDevicePollInterrupt()) {
     return false;
+  }
 
   if (input_streamon_) {
-    __u32 type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
+    __u32 type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
     IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_STREAMOFF, &type);
   }
   input_streamon_ = false;
 
   if (output_streamon_) {
-    __u32 type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+    __u32 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
     IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_STREAMOFF, &type);
   }
   output_streamon_ = false;
 
   // Reset all our accounting info.
   while (!input_queue_.empty())
     input_queue_.pop();
 
   while (!running_jobs_.empty())
     running_jobs_.pop();
 
   free_input_buffers_.clear();
   for (size_t i = 0; i < input_buffer_map_.size(); ++i) {
     InputRecord& input_record = input_buffer_map_[i];
     input_record.at_device = false;
-    input_record.frame = NULL;
     free_input_buffers_.push_back(i);
   }
   input_buffer_queued_count_ = 0;
 
   free_output_buffers_.clear();
   for (size_t i = 0; i < output_buffer_map_.size(); ++i) {
     OutputRecord& output_record = output_buffer_map_[i];
     output_record.at_device = false;
-    if (!output_record.at_client)
-      free_output_buffers_.push_back(i);
+    free_output_buffers_.push_back(i);
   }
   output_buffer_queued_count_ = 0;
 
   return true;
 }
 
 }  // namespace content