Add support for Tegra V4L2 VDA

content/common/gpu/media/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 defines the V4L2Device interface which is used by the
 // V4L2DecodeAccelerator class to delegate/pass the device specific
 // handling of any of the functionalities.
 
 #ifndef CONTENT_COMMON_GPU_MEDIA_V4L2_VIDEO_DEVICE_H_
 #define CONTENT_COMMON_GPU_MEDIA_V4L2_VIDEO_DEVICE_H_
 
+#include "ui/gfx/size.h"
+#include "ui/gl/gl_bindings.h"
+
 namespace content {
 
 class V4L2Device {
  public:
   V4L2Device();
   virtual ~V4L2Device();
 
   // Tries to create and initialize an appropriate V4L2Device object for the
   // current platform and returns a scoped_ptr<V4L2Device> on success else
   // returns NULL.
-  static scoped_ptr<V4L2Device> Create();
+  static scoped_ptr<V4L2Device> Create(EGLContext egl_context);
 
   // Parameters and return value are the same as for the standard ioctl() system
   // call.
   virtual int Ioctl(int request, void* arg) = 0;
 
   // This method sleeps until either:
   // - SetDevicePollInterrupt() is called (on another thread),
   // - |poll_device| is true, and there is new data to be read from the device,
   //   or an event from the device has arrived; in the latter case
   //   |*event_pending| will be set to true.
@@ skipping 10 matching lines @@
   virtual bool SetDevicePollInterrupt() = 0;
   virtual bool ClearDevicePollInterrupt() = 0;
 
   // Wrappers for standard mmap/munmap system calls.
   virtual void* Mmap(void* addr,
                      unsigned int len,
                      int prot,
                      int flags,
                      unsigned int offset) = 0;
   virtual void Munmap(void* addr, unsigned int len) = 0;
+
+  // Does all the initialization of V4L2Device, returns true on success.
+  virtual bool Initialize() = 0;
+
+  // This method is used to create the EglImage since each V4L2Device
+  // may have its own format. The texture_id is used to bind the
+  // texture to the created eglImage. buffer_index can be used to associate
+  // the created EglImage by the underlying V4L2Device implementation.
+  virtual EGLImageKHR CreateEGLImage(EGLDisplay egl_display,
+                                     GLuint texture_id,
+                                     gfx::Size frame_buffer_size,
+                                     unsigned int buffer_index,
+                                     unsigned int total_buffers) = 0;
+
+  virtual void DestroyEGLImage(unsigned int buffer_index) = 0;

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

Documentation please. This should also state who is the owner responsible for
destroying the images.

[shivdasp, 2014/03/27 05:40:37]

This method is not required, since we will close the dmabuf fds while in
createEGLImage() and eglDestroyImageKHR() is common to both the devices.
In next patchset this will be gone.
On 2014/03/27 05:18:06, Pawel Osciak wrote:

[Pawel Osciak, 2014/03/27 05:58:35]

I still feel we should have it even if only to call eglDestroyImageKHR directly,
for symmetry.

[sheu, 2014/03/27 07:08:49]

IMO we could call it CreateEGLImageForBuffer(..., unsigned int index) and not
have to shell out for the Destroy() part.  For this particular bit I don't think
symmetry is necessary.

+
+  // This method returns the supported texture target for the V4L2Device.
+  virtual GLenum GetTextureTarget() = 0;
+
+  // Returns the pixel format supported by this V4L2Device.
+  virtual uint32 GetCapturePixelFormat() = 0;

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

Why do we need this? G_FMT tells us this.

[shivdasp, 2014/03/27 05:40:37]

My understanding is that we call S_FMT() in VDA with the pixelformat that we
expect and is compatible with the device. This is checked when we do
GetFormatInfo().
Similarly number of planes on the CAPTURE_PLANE are also device specific.
I added these methods so that if Exynos or Tegra change their pixel format and
number of planes in future, it should not break the other.


On 2014/03/27 05:18:06, Pawel Osciak wrote:

[Pawel Osciak, 2014/03/27 05:58:35]

This is because we prefer that format for performance reasons. This should made
more dynamic, but I'm ok with not doing it for now.

Please rename to PreferredOutputFormat() and make it static.

[shivdasp, 2014/03/27 06:51:46]

Sorry I didn't get it.
I thought this method would be extended by the device specific class since it
can be different. Do you mean having a static data members that are initialized
to pixel format and number of planes in the ExynosV4L2Device and TegraV4L2Device
?

[Pawel Osciak, 2014/03/27 06:59:56]

Yeah sorry please ignore the static part.

As I mentioned though, you shouldn't need a plane number getter. G_FMT returns
this.

[sheu, 2014/03/27 07:08:49]

That's right actually.  All we use the plane number getter is to DCHECK on it,
and if we were DCHECKing on it we should rather be doing it in the
device-specific V4L2VideoDevice implementation.  And since we're going to hide
the EGLImage creation logic inside the V4L2VideoDevice implementation, there's
no reason to expose the plane count here.

[shivdasp, 2014/03/27 07:40:07]

Apart from DCHECK , we use the plane count in EnqueueOutputRecord() line 1145
too. Though this plane count is actually coming from output_record.fds it is
actually device implementation specific. We populate the v4l2 struct arguments
based on the num_planes that we expect by the underlying driver.
So I think having a getter() will protect any such changes in device
implementations.
If you agree, I have made some changes to remove the fds from OutputRecord since
it is not really needed and it simplifies things a bit, I will upload it in few
mins.

[Pawel Osciak, 2014/03/27 07:45:06]

The number of planes should come from v4l2_pix_format_mplane.num_planes on
G_FMT.

[shivdasp, 2014/03/27 07:54:55]

It does come from G_FMT but we have a CHECK_EQ in CreateBuffersForFormat() to
compare it with constant 2. Instead of a constant 2 in VDA, I am trying to use a
getter() from device specific implementation so that changes in either device
should not break because of this CHECK. Please have a look at my next patchset.

+
+  // Returns the number of planes on CAPTURE PLANE for this V4L2Device.
+  virtual uint8 GetNumberOfPlanes() = 0;

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

GetCapturePlaneCount()?  (Something with "Capture" in it)

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

Alright will "Capture" this in my next patchset.
On 2014/03/27 02:00:23, sheu wrote:

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

G_FMT can also tell us this.

 };
+
 }  //  namespace content
 
 #endif  //  CONTENT_COMMON_GPU_MEDIA_V4L2_VIDEO_DEVICE_H_