Support external buffer import in VDA interface and add a V4L2SVDA impl.

content/common/gpu/media/v4l2_video_decode_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 <dlfcn.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <string.h>
@@ skipping 197 matching lines @@
   if (get_gl_context_cb_.is_null() || make_context_current_cb_.is_null()) {
     NOTREACHED() << "GL callbacks are required for this VDA";
     return false;
   }
 
   if (config.is_encrypted) {
     NOTREACHED() << "Encrypted streams are not supported for this VDA";
     return false;
   }
 
+  if (config.output_mode != Config::OutputMode::ALLOCATE) {
+    NOTREACHED() << "Only ALLOCATE OutputMode is supported by this VDA";
+    return false;
+  }
+
   if (!device_->SupportsDecodeProfileForV4L2PixelFormats(
           config.profile, arraysize(supported_input_fourccs_),
           supported_input_fourccs_)) {
     DVLOG(1) << "Initialize(): unsupported profile=" << config.profile;
     return false;
   }
 
   client_ptr_factory_.reset(new base::WeakPtrFactory<Client>(client));
   client_ = client_ptr_factory_->GetWeakPtr();
   // If we haven't been set up to decode on separate thread via
@@ skipping 139 matching lines @@
     DCHECK(buffers[i].size() == coded_size_);
 
     OutputRecord& output_record = output_buffer_map_[i];
     DCHECK(!output_record.at_device);
     DCHECK(!output_record.at_client);
     DCHECK_EQ(output_record.egl_image, EGL_NO_IMAGE_KHR);
     DCHECK_EQ(output_record.egl_sync, EGL_NO_SYNC_KHR);
     DCHECK_EQ(output_record.picture_id, -1);
     DCHECK_EQ(output_record.cleared, false);
 
+    std::vector<base::ScopedFD> dmabuf_fds;
+    dmabuf_fds = device_->GetDmabufsForV4L2Buffer(
+        i, output_planes_count_, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
+    if (dmabuf_fds.empty()) {
+      NOTIFY_ERROR(PLATFORM_FAILURE);
+      return;
+    }
+
     EGLImageKHR egl_image = device_->CreateEGLImage(egl_display_,
                                                     gl_context->GetHandle(),
                                                     buffers[i].texture_id(),
                                                     coded_size_,
                                                     i,
                                                     output_format_fourcc_,
-                                                    output_planes_count_);
+                                                    dmabuf_fds);
     if (egl_image == EGL_NO_IMAGE_KHR) {
       LOG(ERROR) << "AssignPictureBuffers(): could not create EGLImageKHR";
       // Ownership of EGLImages allocated in previous iterations of this loop
       // has been transferred to output_buffer_map_. After we error-out here
       // the destructor will handle their cleanup.
       NOTIFY_ERROR(PLATFORM_FAILURE);
       return;
     }
 
     output_record.egl_image = egl_image;
@@ skipping 1652 matching lines @@
 
 void V4L2VideoDecodeAccelerator::PictureCleared() {
   DVLOG(3) << "PictureCleared(). clearing count=" << picture_clearing_count_;
   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
   DCHECK_GT(picture_clearing_count_, 0);
   picture_clearing_count_--;
   SendPictureReady();
 }
 
 }  // namespace content