Add support for Tegra V4L2 VDA

content/common/gpu/media/exynos_v4l2_video_device.h

 // 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.
 //
 // This file contains the implementation of ExynosV4L2Device used on
 // Exynos platform.
 
 #ifndef CONTENT_COMMON_GPU_MEDIA_EXYNOS_V4L2_VIDEO_DEVICE_H_
 #define CONTENT_COMMON_GPU_MEDIA_EXYNOS_V4L2_VIDEO_DEVICE_H_
 
 #include "content/common/gpu/media/v4l2_video_device.h"
 
 namespace content {
 
 class ExynosV4L2Device : public V4L2Device {
  public:
   ExynosV4L2Device();
   virtual ~ExynosV4L2Device();
 
   // V4L2Device implementation.
-  int Ioctl(int request, void* arg) OVERRIDE;
-  bool Poll(bool poll_device, bool* event_pending) OVERRIDE;
-  bool SetDevicePollInterrupt() OVERRIDE;
-  bool ClearDevicePollInterrupt() OVERRIDE;
-  void* Mmap(void* addr,
-             unsigned int len,
-             int prot,
-             int flags,
-             unsigned int offset) OVERRIDE;
-  void Munmap(void* addr, unsigned int len) OVERRIDE;
-
-  // Does all the initialization of device fds, returns true on success.
-  bool Initialize();
+  virtual int Ioctl(int request, void* arg) OVERRIDE;
+  virtual bool Poll(bool poll_device, bool* event_pending) OVERRIDE;
+  virtual bool SetDevicePollInterrupt() OVERRIDE;
+  virtual bool ClearDevicePollInterrupt() OVERRIDE;
+  virtual void* Mmap(void* addr,
+                     unsigned int len,
+                     int prot,
+                     int flags,
+                     unsigned int offset) OVERRIDE;
+  virtual void Munmap(void* addr, unsigned int len) OVERRIDE;
+  virtual bool Initialize() OVERRIDE;
+  virtual EGLImageKHR CreateEGLImage(EGLDisplay egl_display,
+                                     GLuint texture_id,
+                                     gfx::Size frame_buffer_size,
+                                     unsigned int buffer_index,
+                                     unsigned int total_buffers) OVERRIDE;
+  virtual void DestroyEGLImage(unsigned int buffer_index) OVERRIDE;
+  virtual GLenum GetTextureTarget() OVERRIDE;
+  virtual uint32 GetCapturePixelFormat() OVERRIDE;
+  virtual uint8 GetNumberOfPlanes() OVERRIDE;
 
  private:
+  // Record for output buffer.
+  struct DeviceOutputRecord {
+    DeviceOutputRecord();
+    ~DeviceOutputRecord();
+    int fds[2];             // file descriptors for each plane.
+    EGLImageKHR egl_image;  // EGLImageKHR for the output buffer.
+  };

[sheu, 2014/03/27 02:00:23]

Since we already have the output buffers being tracked in the V4L2VDA, I think
we could dispense with tracking them here altogether.  The CreateEGLImage() call
only needs:

* EGLDisplay egl_display
* GLuint texture_id
* gfx::Size frame_buffer_size
* unsigned int buffer_index

It can call EXPBUF on the buffer_index, create the EGLImage from the DMABUF fd,
and then close the fd immediately.  The EGLImage is returned to the V4L2VDA and
can be closed with the normal eglDestroyImageKHR call.  We don't have to hold on
to the fd or the EGLImage.

[shivdasp, 2014/03/27 02:41:04]

Ohh I did not know that the fd can be closed immediately here.
All the DeviceOutputRecord and map business was to have a correct fd being
closed while destroying . But looks like this is not needed at all.
All the code around device_output_buffer_map_ will also be removed. Thanks.

[Pawel Osciak, 2014/03/27 05:18:06]

John is right.

To add more detail: the owner of buffers allocated with reqbufs(mmap) holds a
reference to each buffer (this is not a dmabuf fd-based reference). Expbuf
creating dmabufs adds additional reference on the buffers after producing the
fds. Passing the fds to EGLImage adds a third reference to each buffer (this is
a second reference on the file), because the GL driver calls dup() on the passed
fds. Closing the fds here immediately after EGLImage is created is ok, because
the VDA retains the first, non-fd-based reference from the initial reqbufs,
while the GL driver keeps its dup()ed one.

+
+  // Mapping of int index to output buffer record.
+  std::vector<DeviceOutputRecord> device_output_buffer_map_;
+
   // The actual device fd.
   int device_fd_;
 
   // eventfd fd to signal device poll thread when its poll() should be
   // interrupted.
   int device_poll_interrupt_fd_;
 
   DISALLOW_COPY_AND_ASSIGN(ExynosV4L2Device);
 };
 }  //  namespace content
 
 #endif  // CONTENT_COMMON_GPU_MEDIA_EXYNOS_V4L2_VIDEO_DEVICE_H_