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 #endif
 181   };
 182
 183   return std::find(
 184       kEGLImageDrmFmtsSupported,
 185       kEGLImageDrmFmtsSupported + arraysize(kEGLImageDrmFmtsSupported),
 186       V4L2PixFmtToDrmFormat(v4l2_pixfmt)) !=
 187       kEGLImageDrmFmtsSupported + arraysize(kEGLImageDrmFmtsSupported);
 188 }
 189
 190 EGLImageKHR GenericV4L2Device::CreateEGLImage(EGLDisplay egl_display,
 191                                               EGLContext /* egl_context */,
 192                                               GLuint texture_id,
 193                                               gfx::Size frame_buffer_size,
 194                                               unsigned int buffer_index,
 195                                               uint32_t v4l2_pixfmt,
 196                                               size_t num_v4l2_planes) {
 197   DVLOG(3) << "CreateEGLImage()";
 198   if (!CanCreateEGLImageFrom(v4l2_pixfmt)) {
 199     LOG(ERROR) << "Unsupported V4L2 pixel format";
 200     return EGL_NO_IMAGE_KHR;
 201   }
 202
 203   media::VideoPixelFormat vf_format = V4L2PixFmtToVideoPixelFormat(v4l2_pixfmt);
 204   // Number of components, as opposed to the number of V4L2 planes, which is
 205   // just a buffer count.
 206   size_t num_planes = media::VideoFrame::NumPlanes(vf_format);
 207   DCHECK_LE(num_planes, 3u);
 208   if (num_planes < num_v4l2_planes) {
 209     // It's possible for more than one DRM plane to reside in one V4L2 plane,
 210     // but not the other way around. We must use all V4L2 planes.
 211     LOG(ERROR) << "Invalid plane count";
 212     return EGL_NO_IMAGE_KHR;
 213   }
 214
 215   scoped_ptr<base::ScopedFD[]> dmabuf_fds(new base::ScopedFD[num_v4l2_planes]);
 216   // Export dmabuf fds so we can create an EGLImage from them.
 217   for (size_t i = 0; i < num_v4l2_planes; ++i) {
 218     struct v4l2_exportbuffer expbuf;
 219     memset(&expbuf, 0, sizeof(expbuf));
 220     expbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
 221     expbuf.index = buffer_index;
 222     expbuf.plane = i;
 223     expbuf.flags = O_CLOEXEC;
 224     if (Ioctl(VIDIOC_EXPBUF, &expbuf) != 0) {
 225       return EGL_NO_IMAGE_KHR;
 226     }
 227     dmabuf_fds[i].reset(expbuf.fd);
 228   }
 229
 230   std::vector<EGLint> attrs;
 231   attrs.push_back(EGL_WIDTH);
 232   attrs.push_back(frame_buffer_size.width());
 233   attrs.push_back(EGL_HEIGHT);
 234   attrs.push_back(frame_buffer_size.height());
 235   attrs.push_back(EGL_LINUX_DRM_FOURCC_EXT);
 236   attrs.push_back(V4L2PixFmtToDrmFormat(v4l2_pixfmt));
 237
 238   // For existing formats, if we have less buffers (V4L2 planes) than
 239   // components (planes), the remaining planes are stored in the last
 240   // V4L2 plane. Use one V4L2 plane per each component until we run out of V4L2
 241   // planes, and use the last V4L2 plane for all remaining components, each
 242   // with an offset equal to the size of the preceding planes in the same
 243   // V4L2 plane.
 244   size_t v4l2_plane = 0;
 245   size_t plane_offset = 0;
 246   for (size_t plane = 0; plane < num_planes; ++plane) {
 247     attrs.push_back(EGL_DMA_BUF_PLANE0_FD_EXT + plane * 3);
 248     attrs.push_back(dmabuf_fds[v4l2_plane].get());
 249     attrs.push_back(EGL_DMA_BUF_PLANE0_OFFSET_EXT + plane * 3);
 250     attrs.push_back(plane_offset);
 251     attrs.push_back(EGL_DMA_BUF_PLANE0_PITCH_EXT + plane * 3);
 252     attrs.push_back(media::VideoFrame::RowBytes(plane, vf_format,
 253                     frame_buffer_size.width()));
 254
 255     if (v4l2_plane + 1 < num_v4l2_planes) {
 256       ++v4l2_plane;
 257     } else {
 258       plane_offset += media::VideoFrame::PlaneSize(
 259           vf_format, plane, frame_buffer_size).GetArea();
 260     }
 261   }
 262
 263   attrs.push_back(EGL_NONE);
 264
 265   EGLImageKHR egl_image = eglCreateImageKHR(
 266       egl_display, EGL_NO_CONTEXT, EGL_LINUX_DMA_BUF_EXT, NULL, &attrs[0]);
 267   if (egl_image == EGL_NO_IMAGE_KHR) {
 268     LOG(ERROR) << "Failed creating EGL image: " << ui::GetLastEGLErrorString();
 269     return egl_image;
 270   }
 271   glBindTexture(GL_TEXTURE_EXTERNAL_OES, texture_id);
 272   glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, egl_image);
 273
 274   return egl_image;
 275 }
 276
 277 EGLBoolean GenericV4L2Device::DestroyEGLImage(EGLDisplay egl_display,
 278                                              EGLImageKHR egl_image) {
 279   return eglDestroyImageKHR(egl_display, egl_image);
 280 }
 281
 282 GLenum GenericV4L2Device::GetTextureTarget() { return GL_TEXTURE_EXTERNAL_OES; }
 283
 284 uint32 GenericV4L2Device::PreferredInputFormat() {
 285   // TODO(posciak): We should support "dontcare" returns here once we
 286   // implement proper handling (fallback, negotiation) for this in users.
 287   CHECK_EQ(type_, kEncoder);
 288   return V4L2_PIX_FMT_NV12M;
 289 }
 290
 291 // static
 292 bool GenericV4L2Device::PostSandboxInitialization() {
 293 #if defined(USE_LIBV4L2)
 294   StubPathMap paths;
 295   paths[kModuleV4l2].push_back(kV4l2Lib);
 296
 297   return InitializeStubs(paths);
 298 #else
 299   return true;
 300 #endif
 301 }
 302
 303 }  //  namespace content