content/common/gpu/media/generic_v4l2_device.cc

   1 // Copyright 2014 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4 //
   5
   6 #include <fcntl.h>
   7 #include <libdrm/drm_fourcc.h>
   8 #include <linux/videodev2.h>
   9 #include <poll.h>
  10 #include <sys/eventfd.h>
  11 #include <sys/ioctl.h>
  12 #include <sys/mman.h>
  13
  14 #include "base/files/scoped_file.h"
  15 #include "base/posix/eintr_wrapper.h"
  16 #include "base/trace_event/trace_event.h"
  17 #include "content/common/gpu/media/generic_v4l2_device.h"
  18 #include "ui/gl/egl_util.h"
  19 #include "ui/gl/gl_bindings.h"
  20
  21 #if defined(USE_LIBV4L2)
  22 // Auto-generated for dlopen libv4l2 libraries
  23 #include "content/common/gpu/media/v4l2_stubs.h"
  24 #include "third_party/v4l-utils/lib/include/libv4l2.h"
  25
  26 using content_common_gpu_media::kModuleV4l2;
  27 using content_common_gpu_media::InitializeStubs;
  28 using content_common_gpu_media::StubPathMap;
  29
  30 static const base::FilePath::CharType kV4l2Lib[] =
  31     FILE_PATH_LITERAL("/usr/lib/libv4l2.so");
  32 #endif
  33
  34 namespace content {
  35
  36 namespace {
  37 const char kDecoderDevice[] = "/dev/video-dec";
  38 const char kEncoderDevice[] = "/dev/video-enc";
  39 const char kImageProcessorDevice[] = "/dev/image-proc0";
  40 const char kJpegDecoderDevice[] = "/dev/jpeg-dec";
  41 }
  42
  43 GenericV4L2Device::GenericV4L2Device(Type type)
  44     : V4L2Device(type),
  45       use_libv4l2_(false) {
  46 }
  47
  48 GenericV4L2Device::~GenericV4L2Device() {
  49 #if defined(USE_LIBV4L2)
  50   if (use_libv4l2_ && device_fd_.is_valid())
  51     v4l2_close(device_fd_.release());
  52 #endif
  53 }
  54
  55 int GenericV4L2Device::Ioctl(int request, void* arg) {
  56 #if defined(USE_LIBV4L2)
  57   if (use_libv4l2_)
  58     return HANDLE_EINTR(v4l2_ioctl(device_fd_.get(), request, arg));
  59 #endif
  60   return HANDLE_EINTR(ioctl(device_fd_.get(), request, arg));
  61 }
  62
  63 bool GenericV4L2Device::Poll(bool poll_device, bool* event_pending) {
  64   struct pollfd pollfds[2];
  65   nfds_t nfds;
  66   int pollfd = -1;
  67
  68   pollfds[0].fd = device_poll_interrupt_fd_.get();
  69   pollfds[0].events = POLLIN | POLLERR;
  70   nfds = 1;
  71
  72   if (poll_device) {
  73     DVLOG(3) << "Poll(): adding device fd to poll() set";
  74     pollfds[nfds].fd = device_fd_.get();
  75     pollfds[nfds].events = POLLIN | POLLOUT | POLLERR | POLLPRI;
  76     pollfd = nfds;
  77     nfds++;
  78   }
  79
  80   if (HANDLE_EINTR(poll(pollfds, nfds, -1)) == -1) {
  81     DPLOG(ERROR) << "poll() failed";
  82     return false;
  83   }
  84   *event_pending = (pollfd != -1 && pollfds[pollfd].revents & POLLPRI);
  85   return true;
  86 }
  87
  88 void* GenericV4L2Device::Mmap(void* addr,
  89                              unsigned int len,
  90                              int prot,
  91                              int flags,
  92                              unsigned int offset) {
  93   return mmap(addr, len, prot, flags, device_fd_.get(), offset);
  94 }
  95
  96 void GenericV4L2Device::Munmap(void* addr, unsigned int len) {
  97   munmap(addr, len);
  98 }
  99
 100 bool GenericV4L2Device::SetDevicePollInterrupt() {
 101   DVLOG(3) << "SetDevicePollInterrupt()";
 102
 103   const uint64 buf = 1;
 104   if (HANDLE_EINTR(write(device_poll_interrupt_fd_.get(), &buf, sizeof(buf))) ==
 105       -1) {
 106     DPLOG(ERROR) << "SetDevicePollInterrupt(): write() failed";
 107     return false;
 108   }
 109   return true;
 110 }
 111
 112 bool GenericV4L2Device::ClearDevicePollInterrupt() {
 113   DVLOG(3) << "ClearDevicePollInterrupt()";
 114
 115   uint64 buf;
 116   if (HANDLE_EINTR(read(device_poll_interrupt_fd_.get(), &buf, sizeof(buf))) ==
 117       -1) {
 118     if (errno == EAGAIN) {
 119       // No interrupt flag set, and we're reading nonblocking.  Not an error.
 120       return true;
 121     } else {
 122       DPLOG(ERROR) << "ClearDevicePollInterrupt(): read() failed";
 123       return false;
 124     }
 125   }
 126   return true;
 127 }
 128
 129 bool GenericV4L2Device::Initialize() {
 130   const char* device_path = NULL;
 131   static bool v4l2_functions_initialized = PostSandboxInitialization();
 132   if (!v4l2_functions_initialized) {
 133     LOG(ERROR) << "Failed to initialize LIBV4L2 libs";
 134     return false;
 135   }
 136
 137   switch (type_) {
 138     case kDecoder:
 139       device_path = kDecoderDevice;
 140       break;
 141     case kEncoder:
 142       device_path = kEncoderDevice;
 143       break;
 144     case kImageProcessor:
 145       device_path = kImageProcessorDevice;
 146       break;
 147     case kJpegDecoder:
 148       device_path = kJpegDecoderDevice;
 149       break;
 150   }
 151
 152   DVLOG(2) << "Initialize(): opening device: " << device_path;
 153   // Open the video device.
 154   device_fd_.reset(
 155       HANDLE_EINTR(open(device_path, O_RDWR | O_NONBLOCK | O_CLOEXEC)));
 156   if (!device_fd_.is_valid()) {
 157     return false;
 158   }
 159 #if defined(USE_LIBV4L2)
 160   if (type_ == kEncoder &&
 161       HANDLE_EINTR(v4l2_fd_open(device_fd_.get(), V4L2_DISABLE_CONVERSION)) !=
 162           -1) {
 163     DVLOG(2) << "Using libv4l2 for " << device_path;
 164     use_libv4l2_ = true;
 165   }
 166 #endif
 167
 168   device_poll_interrupt_fd_.reset(eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC));
 169   if (!device_poll_interrupt_fd_.is_valid()) {
 170     return false;
 171   }
 172   return true;
 173 }
 174
 175 bool GenericV4L2Device::CanCreateEGLImageFrom(uint32_t v4l2_pixfmt) {
 176   static uint32_t kEGLImageDrmFmtsSupported[] = {
 177     DRM_FORMAT_ARGB8888,
 178 #if defined(ARCH_CPU_ARMEL)
 179     DRM_FORMAT_NV12,
 180     DRM_FORMAT_MT12,
 181 #endif
 182   };
 183
 184   return std::find(
 185       kEGLImageDrmFmtsSupported,
 186       kEGLImageDrmFmtsSupported + arraysize(kEGLImageDrmFmtsSupported),
 187       V4L2PixFmtToDrmFormat(v4l2_pixfmt)) !=
 188       kEGLImageDrmFmtsSupported + arraysize(kEGLImageDrmFmtsSupported);
 189 }
 190
 191 EGLImageKHR GenericV4L2Device::CreateEGLImage(EGLDisplay egl_display,
 192                                               EGLContext /* egl_context */,
 193                                               GLuint texture_id,
 194                                               gfx::Size frame_buffer_size,
 195                                               unsigned int buffer_index,
 196                                               uint32_t v4l2_pixfmt,
 197                                               size_t num_v4l2_planes) {
 198   DVLOG(3) << "CreateEGLImage()";
 199   if (!CanCreateEGLImageFrom(v4l2_pixfmt)) {
 200     LOG(ERROR) << "Unsupported V4L2 pixel format";
 201     return EGL_NO_IMAGE_KHR;
 202   }
 203
 204   media::VideoPixelFormat vf_format = V4L2PixFmtToVideoPixelFormat(v4l2_pixfmt);
 205   // Number of components, as opposed to the number of V4L2 planes, which is
 206   // just a buffer count.
 207   size_t num_planes = media::VideoFrame::NumPlanes(vf_format);
 208   DCHECK_LE(num_planes, 3u);
 209   if (num_planes < num_v4l2_planes) {
 210     // It's possible for more than one DRM plane to reside in one V4L2 plane,
 211     // but not the other way around. We must use all V4L2 planes.
 212     LOG(ERROR) << "Invalid plane count";
 213     return EGL_NO_IMAGE_KHR;
 214   }
 215
 216   scoped_ptr<base::ScopedFD[]> dmabuf_fds(new base::ScopedFD[num_v4l2_planes]);
 217   // Export dmabuf fds so we can create an EGLImage from them.
 218   for (size_t i = 0; i < num_v4l2_planes; ++i) {
 219     struct v4l2_exportbuffer expbuf;
 220     memset(&expbuf, 0, sizeof(expbuf));
 221     expbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
 222     expbuf.index = buffer_index;
 223     expbuf.plane = i;
 224     expbuf.flags = O_CLOEXEC;
 225     if (Ioctl(VIDIOC_EXPBUF, &expbuf) != 0) {
 226       return EGL_NO_IMAGE_KHR;
 227     }
 228     dmabuf_fds[i].reset(expbuf.fd);
 229   }
 230
 231   std::vector<EGLint> attrs;
 232   attrs.push_back(EGL_WIDTH);
 233   attrs.push_back(frame_buffer_size.width());
 234   attrs.push_back(EGL_HEIGHT);
 235   attrs.push_back(frame_buffer_size.height());
 236   attrs.push_back(EGL_LINUX_DRM_FOURCC_EXT);
 237   attrs.push_back(V4L2PixFmtToDrmFormat(v4l2_pixfmt));
 238
 239   // For existing formats, if we have less buffers (V4L2 planes) than
 240   // components (planes), the remaining planes are stored in the last
 241   // V4L2 plane. Use one V4L2 plane per each component until we run out of V4L2
 242   // planes, and use the last V4L2 plane for all remaining components, each
 243   // with an offset equal to the size of the preceding planes in the same
 244   // V4L2 plane.
 245   size_t v4l2_plane = 0;
 246   size_t plane_offset = 0;
 247   for (size_t plane = 0; plane < num_planes; ++plane) {
 248     attrs.push_back(EGL_DMA_BUF_PLANE0_FD_EXT + plane * 3);
 249     attrs.push_back(dmabuf_fds[v4l2_plane].get());
 250     attrs.push_back(EGL_DMA_BUF_PLANE0_OFFSET_EXT + plane * 3);
 251     attrs.push_back(plane_offset);
 252     attrs.push_back(EGL_DMA_BUF_PLANE0_PITCH_EXT + plane * 3);
 253     attrs.push_back(media::VideoFrame::RowBytes(plane, vf_format,
 254                     frame_buffer_size.width()));
 255
 256     if (v4l2_plane + 1 < num_v4l2_planes) {
 257       ++v4l2_plane;
 258     } else {
 259       plane_offset += media::VideoFrame::PlaneSize(
 260           vf_format, plane, frame_buffer_size).GetArea();
 261     }
 262   }
 263
 264   attrs.push_back(EGL_NONE);
 265
 266   EGLImageKHR egl_image = eglCreateImageKHR(
 267       egl_display, EGL_NO_CONTEXT, EGL_LINUX_DMA_BUF_EXT, NULL, &attrs[0]);
 268   if (egl_image == EGL_NO_IMAGE_KHR) {
 269     LOG(ERROR) << "Failed creating EGL image: " << ui::GetLastEGLErrorString();
 270     return egl_image;
 271   }
 272   glBindTexture(GL_TEXTURE_EXTERNAL_OES, texture_id);
 273   glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, egl_image);
 274
 275   return egl_image;
 276 }
 277
 278 EGLBoolean GenericV4L2Device::DestroyEGLImage(EGLDisplay egl_display,
 279                                              EGLImageKHR egl_image) {
 280   return eglDestroyImageKHR(egl_display, egl_image);
 281 }
 282
 283 GLenum GenericV4L2Device::GetTextureTarget() { return GL_TEXTURE_EXTERNAL_OES; }
 284
 285 uint32 GenericV4L2Device::PreferredInputFormat() {
 286   // TODO(posciak): We should support "dontcare" returns here once we
 287   // implement proper handling (fallback, negotiation) for this in users.
 288   CHECK_EQ(type_, kEncoder);
 289   return V4L2_PIX_FMT_NV12M;
 290 }
 291
 292 // static
 293 bool GenericV4L2Device::PostSandboxInitialization() {
 294 #if defined(USE_LIBV4L2)
 295   StubPathMap paths;
 296   paths[kModuleV4l2].push_back(kV4l2Lib);
 297
 298   return InitializeStubs(paths);
 299 #else
 300   return true;
 301 #endif
 302 }
 303
 304 }  //  namespace content