Do not use libv4l if no plugin is registered.

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 <fcntl.h>
 #include <libdrm/drm_fourcc.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <sys/eventfd.h>
@@ skipping 11 matching lines @@
 // Auto-generated for dlopen libv4l2 libraries
 #include "content/common/gpu/media/v4l2_stubs.h"
 #include "third_party/v4l-utils/lib/include/libv4l2.h"
 
 using content_common_gpu_media::kModuleV4l2;
 using content_common_gpu_media::InitializeStubs;
 using content_common_gpu_media::StubPathMap;
 
 static const base::FilePath::CharType kV4l2Lib[] =
     FILE_PATH_LITERAL("/usr/lib/libv4l2.so");
-#else
-#define v4l2_close close
-#define v4l2_ioctl ioctl
 #endif
 
 namespace content {
 
 namespace {
 const char kDecoderDevice[] = "/dev/video-dec";
 const char kEncoderDevice[] = "/dev/video-enc";
 const char kImageProcessorDevice[] = "/dev/gsc0";
 }
 
 GenericV4L2Device::GenericV4L2Device(Type type)
     : type_(type),
-      device_fd_(-1),
-      device_poll_interrupt_fd_(-1) {}
+      use_libv4l2_(false) {
+}
 
 GenericV4L2Device::~GenericV4L2Device() {
-  if (device_poll_interrupt_fd_ != -1) {
-    close(device_poll_interrupt_fd_);
-    device_poll_interrupt_fd_ = -1;
-  }
-  if (device_fd_ != -1) {
-    v4l2_close(device_fd_);
-    device_fd_ = -1;
-  }
+#if defined(USE_LIBV4L2)
+  if (use_libv4l2_ && device_fd_.is_valid())
+    v4l2_close(device_fd_.release());
+#endif
 }
 
 int GenericV4L2Device::Ioctl(int request, void* arg) {
-  return HANDLE_EINTR(v4l2_ioctl(device_fd_, request, arg));
+#if defined(USE_LIBV4L2)
+  if (use_libv4l2_)
+    return HANDLE_EINTR(v4l2_ioctl(device_fd_.get(), request, arg));
+#endif
+  return HANDLE_EINTR(ioctl(device_fd_.get(), request, arg));
 }
 
 bool GenericV4L2Device::Poll(bool poll_device, bool* event_pending) {
   struct pollfd pollfds[2];
   nfds_t nfds;
   int pollfd = -1;
 
-  pollfds[0].fd = device_poll_interrupt_fd_;
+  pollfds[0].fd = device_poll_interrupt_fd_.get();
   pollfds[0].events = POLLIN | POLLERR;
   nfds = 1;
 
   if (poll_device) {
     DVLOG(3) << "Poll(): adding device fd to poll() set";
-    pollfds[nfds].fd = device_fd_;
+    pollfds[nfds].fd = device_fd_.get();
     pollfds[nfds].events = POLLIN | POLLOUT | POLLERR | POLLPRI;
     pollfd = nfds;
     nfds++;
   }
 
   if (HANDLE_EINTR(poll(pollfds, nfds, -1)) == -1) {
     DPLOG(ERROR) << "poll() failed";
     return false;
   }
   *event_pending = (pollfd != -1 && pollfds[pollfd].revents & POLLPRI);
   return true;
 }
 
 void* GenericV4L2Device::Mmap(void* addr,
                              unsigned int len,
                              int prot,
                              int flags,
                              unsigned int offset) {
-  return mmap(addr, len, prot, flags, device_fd_, offset);
+  return mmap(addr, len, prot, flags, device_fd_.get(), offset);
 }
 
 void GenericV4L2Device::Munmap(void* addr, unsigned int len) {
   munmap(addr, len);
 }
 
 bool GenericV4L2Device::SetDevicePollInterrupt() {
   DVLOG(3) << "SetDevicePollInterrupt()";
 
   const uint64 buf = 1;
-  if (HANDLE_EINTR(write(device_poll_interrupt_fd_, &buf, sizeof(buf))) == -1) {
+  if (HANDLE_EINTR(write(device_poll_interrupt_fd_.get(), &buf, sizeof(buf))) ==
+      -1) {
     DPLOG(ERROR) << "SetDevicePollInterrupt(): write() failed";
     return false;
   }
   return true;
 }
 
 bool GenericV4L2Device::ClearDevicePollInterrupt() {
   DVLOG(3) << "ClearDevicePollInterrupt()";
 
   uint64 buf;
-  if (HANDLE_EINTR(read(device_poll_interrupt_fd_, &buf, sizeof(buf))) == -1) {
+  if (HANDLE_EINTR(read(device_poll_interrupt_fd_.get(), &buf, sizeof(buf))) ==
+      -1) {
     if (errno == EAGAIN) {
       // No interrupt flag set, and we're reading nonblocking.  Not an error.
       return true;
     } else {
       DPLOG(ERROR) << "ClearDevicePollInterrupt(): read() failed";
       return false;
     }
   }
   return true;
 }
@@ skipping 13 matching lines @@
     case kEncoder:
       device_path = kEncoderDevice;
       break;
     case kImageProcessor:
       device_path = kImageProcessorDevice;
       break;
   }
 
   DVLOG(2) << "Initialize(): opening device: " << device_path;
   // Open the video device.
-  device_fd_ = HANDLE_EINTR(open(device_path, O_RDWR | O_NONBLOCK | O_CLOEXEC));
-  if (device_fd_ == -1) {
+  device_fd_.reset(
+      HANDLE_EINTR(open(device_path, O_RDWR | O_NONBLOCK | O_CLOEXEC)));
+  if (!device_fd_.is_valid()) {
     return false;
   }
 #if defined(USE_LIBV4L2)
-  if (HANDLE_EINTR(v4l2_fd_open(device_fd_, V4L2_DISABLE_CONVERSION)) == -1) {
-    v4l2_close(device_fd_);
-    return false;
+  if (HANDLE_EINTR(v4l2_fd_open(device_fd_.get(), V4L2_DISABLE_CONVERSION)) !=
+      -1) {
+    DVLOG(2) << "Using libv4l2 for " << device_path;
+    use_libv4l2_ = true;
   }
 #endif
 
-  device_poll_interrupt_fd_ = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
-  if (device_poll_interrupt_fd_ == -1) {
+  device_poll_interrupt_fd_.reset(eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC));
+  if (!device_poll_interrupt_fd_.is_valid()) {
     return false;
   }
   return true;
 }
 
 bool GenericV4L2Device::CanCreateEGLImageFrom(uint32_t v4l2_pixfmt) {
   static uint32_t kEGLImageDrmFmtsSupported[] = {
     DRM_FORMAT_ARGB8888,
 #if defined(ARCH_CPU_ARMEL)
     DRM_FORMAT_NV12,
@@ skipping 115 matching lines @@
   StubPathMap paths;
   paths[kModuleV4l2].push_back(kV4l2Lib);
 
   return InitializeStubs(paths);
 #else
   return true;
 #endif
 }
 
 }  //  namespace content