V4L2VideoDecodeAccelerator: support external buffer import

media/gpu/v4l2_image_processor.cc

 // 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.
 
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <string.h>
 #include <sys/eventfd.h>
@@ skipping 39 matching lines @@
 V4L2ImageProcessor::OutputRecord::~OutputRecord() {}
 
 V4L2ImageProcessor::JobRecord::JobRecord() : output_buffer_index(-1) {}
 
 V4L2ImageProcessor::JobRecord::~JobRecord() {}
 
 V4L2ImageProcessor::V4L2ImageProcessor(const scoped_refptr<V4L2Device>& device)
     : input_format_(PIXEL_FORMAT_UNKNOWN),
       output_format_(PIXEL_FORMAT_UNKNOWN),
       input_memory_type_(V4L2_MEMORY_USERPTR),
+      output_memory_type_(V4L2_MEMORY_MMAP),
       input_format_fourcc_(0),
       output_format_fourcc_(0),
       input_planes_count_(0),
       output_planes_count_(0),
       child_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       device_(device),
       device_thread_("V4L2ImageProcessorThread"),
       device_poll_thread_("V4L2ImageProcessorDevicePollThread"),
       input_streamon_(false),
       input_buffer_queued_count_(0),
@@ skipping 23 matching lines @@
 
 void V4L2ImageProcessor::NotifyErrorOnChildThread(
     const base::Closure& error_cb) {
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   error_cb_.Run();
 }
 
 bool V4L2ImageProcessor::Initialize(VideoPixelFormat input_format,
                                     VideoPixelFormat output_format,
                                     v4l2_memory input_memory_type,
+                                    v4l2_memory output_memory_type,
                                     gfx::Size input_visible_size,
                                     gfx::Size input_allocated_size,
                                     gfx::Size output_visible_size,
                                     gfx::Size output_allocated_size,
                                     int num_buffers,
                                     const base::Closure& error_cb) {
   DCHECK(!error_cb.is_null());
   DCHECK_GT(num_buffers, 0);
   DCHECK(input_memory_type == V4L2_MEMORY_USERPTR ||
          input_memory_type == V4L2_MEMORY_DMABUF);
+  DCHECK(output_memory_type == V4L2_MEMORY_MMAP ||
+         output_memory_type == V4L2_MEMORY_DMABUF);
   error_cb_ = error_cb;
 
   input_format_ = input_format;
   output_format_ = output_format;
   input_format_fourcc_ = V4L2Device::VideoPixelFormatToV4L2PixFmt(input_format);
   output_format_fourcc_ =
       V4L2Device::VideoPixelFormatToV4L2PixFmt(output_format);
   num_buffers_ = num_buffers;
 
   if (!input_format_fourcc_ || !output_format_fourcc_) {
     LOG(ERROR) << "Unrecognized format(s)";
     return false;
   }
 
   input_memory_type_ = input_memory_type;
+  output_memory_type_ = output_memory_type;
   input_visible_size_ = input_visible_size;
   input_allocated_size_ = input_allocated_size;
   output_visible_size_ = output_visible_size;
   output_allocated_size_ = output_allocated_size;
 
   // Capabilities check.
   struct v4l2_capability caps;
   memset(&caps, 0, sizeof(caps));
   const __u32 kCapsRequired = V4L2_CAP_VIDEO_M2M_MPLANE | V4L2_CAP_STREAMING;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QUERYCAP, &caps);
@@ skipping 72 matching lines @@
   format.fmt.pix_mp.pixelformat = pixelformat;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_TRY_FMT, &format);
 
   *num_planes = format.fmt.pix_mp.num_planes;
   *size = V4L2Device::CodedSizeFromV4L2Format(format);
   DVLOG(1) << __func__ << ": adjusted output coded size=" << size->ToString()
            << ", num_planes=" << *num_planes;
   return true;
 }
 
-void V4L2ImageProcessor::Process(const scoped_refptr<VideoFrame>& frame,
+bool V4L2ImageProcessor::Process(const scoped_refptr<VideoFrame>& frame,
                                  int output_buffer_index,
+                                 std::vector<base::ScopedFD> output_dmabuf_fds,
                                  const FrameReadyCB& cb) {
   DVLOG(3) << __func__ << ": ts=" << frame->timestamp().InMilliseconds();
+  size_t expected_num_fds =
+      (output_memory_type_ == V4L2_MEMORY_DMABUF ? output_planes_count_ : 0);
+  if (expected_num_fds != output_dmabuf_fds.size()) {
+    LOG(ERROR) << __func__ << ": wrong number of output fds. Expected "
+               << expected_num_fds << ", actual " << output_dmabuf_fds.size();
+    return false;
+  }
 
   std::unique_ptr<JobRecord> job_record(new JobRecord());
   job_record->frame = frame;
   job_record->output_buffer_index = output_buffer_index;
+  job_record->output_dmabuf_fds = std::move(output_dmabuf_fds);
   job_record->ready_cb = cb;
 
   device_thread_.task_runner()->PostTask(
       FROM_HERE, base::Bind(&V4L2ImageProcessor::ProcessTask,
                             base::Unretained(this), base::Passed(&job_record)));
+  return true;
 }
 
 void V4L2ImageProcessor::ProcessTask(std::unique_ptr<JobRecord> job_record) {
   int index = job_record->output_buffer_index;
   DVLOG(3) << __func__ << ": Reusing output buffer, index=" << index;
   DCHECK(device_thread_.task_runner()->BelongsToCurrentThread());
+  DCHECK(output_buffer_map_[index].dmabuf_fds.empty());
+  output_buffer_map_[index].dmabuf_fds =
+      std::move(job_record->output_dmabuf_fds);
 
   EnqueueOutput(index);
   input_queue_.push(make_linked_ptr(job_record.release()));
   EnqueueInput();
 }
 
 bool V4L2ImageProcessor::Reset() {
   DVLOG(3) << __func__;
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   DCHECK(device_thread_.IsRunning());
@@ skipping 133 matching lines @@
   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 = num_buffers_;
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
-  reqbufs.memory = V4L2_MEMORY_MMAP;
+  reqbufs.memory = output_memory_type_;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_REQBUFS, &reqbufs);
   if (static_cast<int>(reqbufs.count) != num_buffers_) {
     LOG(ERROR) << "Failed to allocate output buffers. reqbufs.count="
                << reqbufs.count << ", num_buffers=" << num_buffers_;
     return false;
   }
 
   DCHECK(output_buffer_map_.empty());
   output_buffer_map_.resize(reqbufs.count);
 
@@ skipping 16 matching lines @@
 }
 
 void V4L2ImageProcessor::DestroyOutputBuffers() {
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   DCHECK(!output_streamon_);
 
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count = 0;
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
-  reqbufs.memory = V4L2_MEMORY_MMAP;
+  reqbufs.memory = output_memory_type_;
   IOCTL_OR_LOG_ERROR(VIDIOC_REQBUFS, &reqbufs);
 
   output_buffer_map_.clear();
 }
 
 void V4L2ImageProcessor::DevicePollTask(bool poll_device) {
   DCHECK(device_poll_thread_.task_runner()->BelongsToCurrentThread());
 
   bool event_pending;
   if (!device_->Poll(poll_device, &event_pending)) {
@@ skipping 120 matching lines @@
     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.memory = V4L2_MEMORY_MMAP;
+    dqbuf.memory = output_memory_type_;
     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";
       NotifyError();
       return;
     }
     OutputRecord& output_record = output_buffer_map_[dqbuf.index];
     DCHECK(output_record.at_device);
     output_record.at_device = false;
+    output_record.dmabuf_fds.clear();
     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();
 
     DVLOG(3) << "Processing finished, returning frame, index=" << dqbuf.index;
 
     child_task_runner_->PostTask(
@@ skipping 52 matching lines @@
   DCHECK_LT(static_cast<size_t>(index), output_buffer_map_.size());
   // Enqueue an output (VIDEO_CAPTURE) buffer.
   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.memory = V4L2_MEMORY_MMAP;
+  qbuf.memory = output_memory_type_;
+  if (output_memory_type_ == V4L2_MEMORY_DMABUF) {
+    for (size_t i = 0; i < output_record.dmabuf_fds.size(); ++i)
+      qbuf_planes[i].m.fd = output_record.dmabuf_fds[i].get();
+  }
   qbuf.m.planes = qbuf_planes;
   qbuf.length = output_planes_count_;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QBUF, &qbuf);
   output_record.at_device = true;
   output_buffer_queued_count_++;
   return true;
 }
 
 void V4L2ImageProcessor::StartDevicePoll() {
   DVLOG(3) << __func__ << ": starting device poll";
@@ skipping 64 matching lines @@
   output_buffer_queued_count_ = 0;
 }
 
 void V4L2ImageProcessor::FrameReady(const FrameReadyCB& cb,
                                     int output_buffer_index) {
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   cb.Run(output_buffer_index);
 }
 
 }  // namespace media