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

content/common/gpu/media/generic_v4l2_device.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 <libdrm/drm_fourcc.h>
 #include <linux/videodev2.h>
 #include <poll.h>
@@ skipping 158 matching lines @@
   }
 #endif
 
   device_poll_interrupt_fd_.reset(eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC));
   if (!device_poll_interrupt_fd_.is_valid()) {
     return false;
   }
   return true;
 }
 
+std::vector<base::ScopedFD> GenericV4L2Device::GetDmabufsForV4L2Buffer(
+    int index,
+    size_t num_planes,
+    enum v4l2_buf_type type) {
+  DCHECK(V4L2_TYPE_IS_MULTIPLANAR(type));
+
+  std::vector<base::ScopedFD> dmabuf_fds;
+  for (size_t i = 0; i < num_planes; ++i) {
+    struct v4l2_exportbuffer expbuf;
+    memset(&expbuf, 0, sizeof(expbuf));
+    expbuf.type = type;
+    expbuf.index = index;
+    expbuf.plane = i;
+    expbuf.flags = O_CLOEXEC;
+    if (Ioctl(VIDIOC_EXPBUF, &expbuf) != 0) {
+      dmabuf_fds.clear();
+      break;
+    }
+
+    dmabuf_fds.push_back(base::ScopedFD(expbuf.fd));
+  }
+
+  return dmabuf_fds;
+}
+
 bool GenericV4L2Device::CanCreateEGLImageFrom(uint32_t v4l2_pixfmt) {
   static uint32_t kEGLImageDrmFmtsSupported[] = {
     DRM_FORMAT_ARGB8888,
 #if defined(ARCH_CPU_ARMEL)
     DRM_FORMAT_NV12,
     DRM_FORMAT_MT21,
 #endif
   };
 
   return std::find(
       kEGLImageDrmFmtsSupported,
       kEGLImageDrmFmtsSupported + arraysize(kEGLImageDrmFmtsSupported),
       V4L2PixFmtToDrmFormat(v4l2_pixfmt)) !=
       kEGLImageDrmFmtsSupported + arraysize(kEGLImageDrmFmtsSupported);
 }
 
-EGLImageKHR GenericV4L2Device::CreateEGLImage(EGLDisplay egl_display,
-                                              EGLContext /* egl_context */,
-                                              GLuint texture_id,
-                                              gfx::Size frame_buffer_size,
-                                              unsigned int buffer_index,
-                                              uint32_t v4l2_pixfmt,
-                                              size_t num_v4l2_planes) {
+EGLImageKHR GenericV4L2Device::CreateEGLImage(
+    EGLDisplay egl_display,
+    EGLContext /* egl_context */,
+    GLuint texture_id,
+    const gfx::Size& size,
+    unsigned int buffer_index,
+    uint32_t v4l2_pixfmt,
+    const std::vector<base::ScopedFD>& dmabuf_fds) {
   DVLOG(3) << "CreateEGLImage()";
   if (!CanCreateEGLImageFrom(v4l2_pixfmt)) {
     LOG(ERROR) << "Unsupported V4L2 pixel format";
     return EGL_NO_IMAGE_KHR;
   }
 
   media::VideoPixelFormat vf_format = V4L2PixFmtToVideoPixelFormat(v4l2_pixfmt);
   // Number of components, as opposed to the number of V4L2 planes, which is
   // just a buffer count.
   size_t num_planes = media::VideoFrame::NumPlanes(vf_format);
   DCHECK_LE(num_planes, 3u);
-  if (num_planes < num_v4l2_planes) {
+  if (num_planes < dmabuf_fds.size()) {
     // It's possible for more than one DRM plane to reside in one V4L2 plane,
     // but not the other way around. We must use all V4L2 planes.
     LOG(ERROR) << "Invalid plane count";
     return EGL_NO_IMAGE_KHR;
   }
 
-  scoped_ptr<base::ScopedFD[]> dmabuf_fds(new base::ScopedFD[num_v4l2_planes]);
-  // Export dmabuf fds so we can create an EGLImage from them.
-  for (size_t i = 0; i < num_v4l2_planes; ++i) {
-    struct v4l2_exportbuffer expbuf;
-    memset(&expbuf, 0, sizeof(expbuf));
-    expbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
-    expbuf.index = buffer_index;
-    expbuf.plane = i;
-    expbuf.flags = O_CLOEXEC;
-    if (Ioctl(VIDIOC_EXPBUF, &expbuf) != 0) {
-      return EGL_NO_IMAGE_KHR;
-    }
-    dmabuf_fds[i].reset(expbuf.fd);
-  }
-
   std::vector<EGLint> attrs;
   attrs.push_back(EGL_WIDTH);
-  attrs.push_back(frame_buffer_size.width());
+  attrs.push_back(size.width());
   attrs.push_back(EGL_HEIGHT);
-  attrs.push_back(frame_buffer_size.height());
+  attrs.push_back(size.height());
   attrs.push_back(EGL_LINUX_DRM_FOURCC_EXT);
   attrs.push_back(V4L2PixFmtToDrmFormat(v4l2_pixfmt));
 
   // For existing formats, if we have less buffers (V4L2 planes) than
   // components (planes), the remaining planes are stored in the last
   // V4L2 plane. Use one V4L2 plane per each component until we run out of V4L2
   // planes, and use the last V4L2 plane for all remaining components, each
   // with an offset equal to the size of the preceding planes in the same
   // V4L2 plane.
   size_t v4l2_plane = 0;
   size_t plane_offset = 0;
   for (size_t plane = 0; plane < num_planes; ++plane) {
     attrs.push_back(EGL_DMA_BUF_PLANE0_FD_EXT + plane * 3);
     attrs.push_back(dmabuf_fds[v4l2_plane].get());
     attrs.push_back(EGL_DMA_BUF_PLANE0_OFFSET_EXT + plane * 3);
     attrs.push_back(plane_offset);
     attrs.push_back(EGL_DMA_BUF_PLANE0_PITCH_EXT + plane * 3);
-    attrs.push_back(media::VideoFrame::RowBytes(plane, vf_format,
-                    frame_buffer_size.width()));
+    attrs.push_back(
+        media::VideoFrame::RowBytes(plane, vf_format, size.width()));
 
-    if (v4l2_plane + 1 < num_v4l2_planes) {
+    if (v4l2_plane + 1 < dmabuf_fds.size()) {
       ++v4l2_plane;

[kcwu, 2016/03/28 02:28:36]

reset plane_offset to 0 here?

[Pawel Osciak, 2016/03/31 05:42:33]

Good catch, thanks. Done.

     } else {
-      plane_offset += media::VideoFrame::PlaneSize(
-          vf_format, plane, frame_buffer_size).GetArea();
+      plane_offset +=
+          media::VideoFrame::PlaneSize(vf_format, plane, size).GetArea();
     }
   }
 
   attrs.push_back(EGL_NONE);
 
   EGLImageKHR egl_image = eglCreateImageKHR(
       egl_display, EGL_NO_CONTEXT, EGL_LINUX_DMA_BUF_EXT, NULL, &attrs[0]);
   if (egl_image == EGL_NO_IMAGE_KHR) {
     LOG(ERROR) << "Failed creating EGL image: " << ui::GetLastEGLErrorString();
     return egl_image;
@@ skipping 24 matching lines @@
   StubPathMap paths;
   paths[kModuleV4l2].push_back(kV4l2Lib);
 
   return InitializeStubs(paths);
 #else
   return true;
 #endif
 }
 
 }  //  namespace content