V4L2VideoDecodeAccelerator: support external buffer import

media/gpu/v4l2_video_encode_accelerator.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 "media/gpu/v4l2_video_encode_accelerator.h"
 
 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <string.h>
@@ skipping 164 matching lines @@
     scoped_refptr<V4L2Device> device =
         V4L2Device::Create(V4L2Device::kImageProcessor);
     image_processor_.reset(new V4L2ImageProcessor(device));
 
     // Convert from input_format to device_input_format_, keeping the size
     // at visible_size_ and requiring the output buffers to be of at least
     // input_allocated_size_. Unretained is safe because |this| owns image
     // processor and there will be no callbacks after processor destroys.
     if (!image_processor_->Initialize(
             input_format, device_input_format_, V4L2_MEMORY_USERPTR,
-            visible_size_, visible_size_, visible_size_, input_allocated_size_,
-            kImageProcBufferCount,
+            V4L2_MEMORY_MMAP, visible_size_, visible_size_, visible_size_,
+            input_allocated_size_, kImageProcBufferCount,
             base::Bind(&V4L2VideoEncodeAccelerator::ImageProcessorError,
                        base::Unretained(this)))) {
       LOG(ERROR) << "Failed initializing image processor";
       return false;
     }
     // The output of image processor is the input of encoder. Output coded
     // width of processor must be the same as input coded width of encoder.
     // Output coded height of processor can be larger but not smaller than the
     // input coded height of encoder. For example, suppose input size of encoder
     // is 320x193. It is OK if the output of processor is 320x208.
@@ skipping 54 matching lines @@
                                         bool force_keyframe) {
   DVLOG(3) << "Encode(): force_keyframe=" << force_keyframe;
   DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   if (image_processor_) {
     if (free_image_processor_output_buffers_.size() > 0) {
       int output_buffer_index = free_image_processor_output_buffers_.back();
       free_image_processor_output_buffers_.pop_back();
       // Unretained is safe because |this| owns image processor and there will
       // be no callbacks after processor destroys.
-      image_processor_->Process(
-          frame, output_buffer_index,
-          base::Bind(&V4L2VideoEncodeAccelerator::FrameProcessed,
-                     base::Unretained(this), force_keyframe,
-                     frame->timestamp()));
+      if (!image_processor_->Process(
+              frame, output_buffer_index, std::vector<base::ScopedFD>(),
+              base::Bind(&V4L2VideoEncodeAccelerator::FrameProcessed,
+                         base::Unretained(this), force_keyframe,
+                         frame->timestamp()))) {
+        NOTIFY_ERROR(kPlatformFailureError);
+      }
     } else {
       ImageProcessorInputRecord record;
       record.frame = frame;
       record.force_keyframe = force_keyframe;
       image_processor_input_queue_.push(record);
     }
   } else {
     encoder_thread_.task_runner()->PostTask(
         FROM_HERE, base::Bind(&V4L2VideoEncodeAccelerator::EncodeTask,
                               base::Unretained(this), frame, force_keyframe));
@@ skipping 1064 matching lines @@
   reqbufs.count = 0;
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   reqbufs.memory = V4L2_MEMORY_MMAP;
   IOCTL_OR_LOG_ERROR(VIDIOC_REQBUFS, &reqbufs);
 
   output_buffer_map_.clear();
   free_output_buffers_.clear();
 }
 
 }  // namespace media