Add support for Tegra V4L2 VDA

content/common/gpu/media/tegra_v4l2_video_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 <dlfcn.h>
+#include <fcntl.h>
+
+#include "base/debug/trace_event.h"
+#include "base/posix/eintr_wrapper.h"
+#include "content/common/gpu/media/tegra_v4l2_video_device.h"
+#include "ui/gl/gl_bindings.h"
+
+namespace content {
+
+namespace {
+const char kDevice[] = "/dev/tegra_avpchannel";
+}
+
+typedef int32 (*TegraV4L2Open)(const char* name, int32 flags);
+typedef int32 (*TegraV4L2Close)(int32 fd);
+typedef int32 (*TegraV4L2Ioctl)(int32 fd, unsigned long cmd, ...);
+typedef int32 (*TegraV4L2Poll)(int32 fd, bool poll_device, bool* event_pending);
+typedef int32 (*TegraV4L2SetDevicePollInterrupt)(int32 fd);
+typedef int32 (*TegraV4L2ClearDevicePollInterrupt)(int32 fd);
+typedef void* (*TegraV4L2Mmap)(void* addr,
+                               size_t length,
+                               int prot,
+                               int flags,
+                               int fd,
+                               unsigned int offset);
+typedef int32 (*TegraV4L2Munmap)(void* addr, size_t length);
+typedef int32 (*TegraV4L2UseEglImage)(int fd,
+                                      unsigned int buffer_index,
+                                      void* egl_image);
+
+#define TEGRAV4L2_SYM(name) TegraV4L2##name TegraV4L2_##name = NULL
+
+TEGRAV4L2_SYM(Open);
+TEGRAV4L2_SYM(Close);
+TEGRAV4L2_SYM(Ioctl);
+TEGRAV4L2_SYM(Poll);
+TEGRAV4L2_SYM(SetDevicePollInterrupt);
+TEGRAV4L2_SYM(ClearDevicePollInterrupt);
+TEGRAV4L2_SYM(Mmap);
+TEGRAV4L2_SYM(Munmap);
+TEGRAV4L2_SYM(UseEglImage);
+
+#undef TEGRAV4L2_SYM
+
+TegraV4L2Device::TegraV4L2Device(EGLContext egl_context)
+    : device_fd_(-1), egl_context_(egl_context) {}
+
+TegraV4L2Device::~TegraV4L2Device() {
+  if (device_fd_ != -1) {
+    TegraV4L2_Close(device_fd_);
+    device_fd_ = -1;
+  }
+}
+
+int TegraV4L2Device::Ioctl(int flags, void* arg) {
+  return TegraV4L2_Ioctl(device_fd_, flags, arg);
+}
+
+bool TegraV4L2Device::Poll(bool poll_device, bool* event_pending) {
+  if (HANDLE_EINTR(TegraV4L2_Poll(device_fd_, poll_device, event_pending)) ==
+      -1) {
+    DLOG(ERROR) << "TegraV4L2Poll returned -1 ";
+    return false;
+  }
+  return true;
+}
+
+void* TegraV4L2Device::Mmap(void* addr,
+                            unsigned int len,
+                            int prot,
+                            int flags,
+                            unsigned int offset) {
+  return TegraV4L2_Mmap(addr, len, prot, flags, device_fd_, offset);
+}
+
+void TegraV4L2Device::Munmap(void* addr, unsigned int len) {
+  TegraV4L2_Munmap(addr, len);
+}
+
+bool TegraV4L2Device::SetDevicePollInterrupt() {
+  if (HANDLE_EINTR(TegraV4L2_SetDevicePollInterrupt(device_fd_)) == -1) {
+    DLOG(ERROR) << "Error in calling TegraV4L2SetDevicePollInterrupt";
+    return false;
+  }
+  return true;
+}
+
+bool TegraV4L2Device::ClearDevicePollInterrupt() {
+  if (HANDLE_EINTR(TegraV4L2_ClearDevicePollInterrupt(device_fd_)) == -1) {
+    DLOG(ERROR) << "Error in calling TegraV4L2ClearDevicePollInterrupt";
+    return false;
+  }
+  return true;
+}
+
+bool TegraV4L2Device::Initialize() {
+  static bool functions_initialized = InitializeLibrarySymbols();
+
+  if (!functions_initialized) {
+    DLOG(ERROR) << "Unable to initialize functions ";
+    return false;
+  }
+  device_fd_ =
+      HANDLE_EINTR(TegraV4L2_Open(kDevice, O_RDWR | O_NONBLOCK | O_CLOEXEC));
+  if (device_fd_ == -1) {
+    DLOG(ERROR) << "Unable to open tegra_v4l2_open ";
+    return false;
+  }
+  return true;
+}
+
+EGLImageKHR TegraV4L2Device::CreateEGLImage(EGLDisplay egl_display,
+                                            const EGLint* /*attrib*/,

[Pawel Osciak, 2014/03/25 08:21:08]

Ignoring attributes here and not in Exynos device, while doing the opposite with
buffer_index argument is not a perfect solution. Also, how do you handle
exportbuf ioctl? Do you ignore it? That's also not too great.

Also, how does close() on those dmabuf fds work for you now? When you ignore the
call, do you return -1? I guess that's what would make close() work.

It's hard to come up with a good solution here, but we should at least try to
minimize being confusing and. Always doing dmabuf export and ignoring fds,
ignoring attributes, ignoring some arguments make it even harder to reason about
things. 

We should instead abstract those operations and have them in V4L2Device, since
they depend on the device anyway. But we should at least be explicit about this.

So I'm thinking that we should pass only the buffer index to CreateEGLImage and
move dmabuf exporting and handling in general to V4L2Device for Exynos. Then
we'd also have to handle everything properly for destruction, but I feel that
having a DestroyEGLImage() counterpart in V4L2Device is probably better than
using V4L2Device::CreteEGLImage for creation, while destroying directly via
eglDestroyImageKHR.

Also keep in mind that CreateEGLImage is called on the ChildThread, instead of
the decoder_thread_, but currently the decoder_thread_ is sleeping until
AssignPictureBuffers is done, so we should be fine.

[shivdasp, 2014/03/25 10:36:40]

This is primarily because of the eglImages are created. The attr is not required
on
Tegra. We cannot remove this argument altogether because on Exynos it is
populated with certain fields which I will have to otherwise pass in to this
function. Similarly buffer_index is ignored on Exynos but on Tegra we need to
send it down to the library in UseEglImage() to associate with the correct
picture buffer.
EXPORTBUF ioctl actually does not populate anything since we do not support it.
And yes you are right, we return -1 and that's how the close() is also handled
in V4LVDA since it fd is closed only if it is not -1.
I think we need to add more interface functions in V4L2Device class to abstract
this then.
Okay I will add more interface API to V4L2Device.

[Pawel Osciak, 2014/03/25 11:20:56]

This is precisely why I'm suggesting attrs shouldn't be in the abstract
interface,
because they are not used on all platforms. Neither should the dmabufs handling
code,
including expbufs be in the platform-agnostic V4L2VDA class.

That's why I'm suggesting moving all the attrs, dmabufs, etc. related code to
CreateEglImage. You should be able to expbufs, fill in the attrs on Exynos and
create EGLImages
in the ExynosV4L2Device::CreateEglImage.

The Tegra implementation would not need it.

That's why I'm suggesting using buffer index argument on both platforms, and
also
size and num planes I would think. I think we should have something like:

V4L2Device::CreateEGLImage(EGLDisplay egl_display, int v4l2_buffer_index, GLuint
texture_id, gfx::Size size, size_t num_planes);
I think the only additional method would be DestroyEGLImage(EGLImage image).
This and the new CreateEGLImage().
Of course the related data such as fds, and their relation to egl_images should
be
handled internally by each device.

+                                            GLuint texture_id,
+                                            unsigned int buffer_index) {
+  EGLint attr = EGL_NONE;
+  EGLImageKHR egl_image =
+      eglCreateImageKHR(egl_display,
+                        egl_context_,
+                        EGL_GL_TEXTURE_2D_KHR,
+                        reinterpret_cast<EGLClientBuffer>(texture_id),
+                        &attr);
+  if (egl_image == EGL_NO_IMAGE_KHR) {
+    return egl_image;
+  }
+  if (TegraV4L2_UseEglImage(device_fd_, buffer_index, egl_image) != 0) {
+    eglDestroyImageKHR(egl_display, egl_image);
+    egl_image = EGL_NO_IMAGE_KHR;
+  }
+  return egl_image;
+}
+
+GLenum TegraV4L2Device::GetTextureTarget() { return GL_TEXTURE_2D; }
+
+bool TegraV4L2Device::InitializeLibrarySymbols() {
+#define TEGRAV4L2_DLSYM_OR_RETURN_ON_ERROR(name)          \
+  do {                                                    \
+    TegraV4L2_##name = reinterpret_cast<TegraV4L2##name>( \
+        dlsym(RTLD_DEFAULT, "TegraV4L2_" #name));         \
+    if (TegraV4L2_##name == NULL) {                       \
+      LOG(ERROR) << "Failed to dlsym TegraV4L2_" #name;   \
+      return false;                                       \
+    }                                                     \
+  } while (0)
+
+  TEGRAV4L2_DLSYM_OR_RETURN_ON_ERROR(Open);
+  TEGRAV4L2_DLSYM_OR_RETURN_ON_ERROR(Close);
+  TEGRAV4L2_DLSYM_OR_RETURN_ON_ERROR(Ioctl);
+  TEGRAV4L2_DLSYM_OR_RETURN_ON_ERROR(Poll);
+  TEGRAV4L2_DLSYM_OR_RETURN_ON_ERROR(SetDevicePollInterrupt);
+  TEGRAV4L2_DLSYM_OR_RETURN_ON_ERROR(ClearDevicePollInterrupt);
+  TEGRAV4L2_DLSYM_OR_RETURN_ON_ERROR(Mmap);
+  TEGRAV4L2_DLSYM_OR_RETURN_ON_ERROR(Munmap);
+  TEGRAV4L2_DLSYM_OR_RETURN_ON_ERROR(UseEglImage);
+#undef TEGRAV4L2_DLSYM
+  return true;
+}
+
+}  //  namespace content