Add support for Tegra V4L2 VDA

content/common/gpu/media/v4l2_video_decode_accelerator.cc

Index: content/common/gpu/media/v4l2_video_decode_accelerator.cc
diff --git a/content/common/gpu/media/v4l2_video_decode_accelerator.cc b/content/common/gpu/media/v4l2_video_decode_accelerator.cc
index 68baaa85c845c91dda916e544ddd9e15e27431a3..b4a603c0e8b41a308ad98e85b07b9a9560076134 100644
--- a/content/common/gpu/media/v4l2_video_decode_accelerator.cc
+++ b/content/common/gpu/media/v4l2_video_decode_accelerator.cc
@@ -357,9 +357,8 @@ void V4L2VideoDecodeAccelerator::AssignPictureBuffers(
     attrs[13] = output_record.fds[1];
     attrs[15] = 0;
     attrs[17] = frame_buffer_size_.width();
-
-    EGLImageKHR egl_image = eglCreateImageKHR(
-        egl_display_, EGL_NO_CONTEXT, EGL_LINUX_DMA_BUF_EXT, NULL, attrs);
+    EGLImageKHR egl_image = device_->CreateEGLImage(
+        egl_display_, attrs, buffers[i].texture_id(), i);
     if (egl_image == EGL_NO_IMAGE_KHR) {
       DLOG(ERROR) << "AssignPictureBuffers(): could not create EGLImageKHR";
       // Ownership of EGLImages allocated in previous iterations of this loop
@@ -369,9 +368,6 @@ void V4L2VideoDecodeAccelerator::AssignPictureBuffers(
       return;
     }
 
-    glBindTexture(GL_TEXTURE_EXTERNAL_OES, buffers[i].texture_id());
-    glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, egl_image);
-
     output_record.egl_image = egl_image;
     output_record.picture_id = buffers[i].id();
     free_output_buffers_.push(i);
@@ -712,10 +708,18 @@ bool V4L2VideoDecodeAccelerator::DecodeBufferInitial(
   DCHECK(!device_poll_thread_.IsRunning());
   // Initial decode.  We haven't been able to get output stream format info yet.
   // Get it, and start decoding.
+  bool no_free_input_buffers = false;
 
   // Copy in and send to HW.
-  if (!AppendToInputFrame(data, size))
+  if (!AppendToInputFrame(data, size)) {
+    if (free_input_buffers_.empty()) {
+      DVLOG(2) << "AppendToInputFrame(): no free input buffers";
+      // No free input buffers, try and see if format info is set.
+      no_free_input_buffers = true;
+      goto chk_format_info;

[sheu, 2014/03/07 00:18:08]

We seem to be allergic to "goto" statements in Chrome, for not entirely bad
reasons.

But also I don't see what jumping to GetFormatInfo would buy us.  It seems to me
that if we're out of buffers, whether we have format info or not does not
correlate with whether we'll soon be getting buffers.

[shivdasp, 2014/03/07 17:31:40]

Jumping to GetFormatInfo() will move us out of kInitialized state which is what
the bug really was. We did not try to check for format info if we were out of
buffers while in kInitialized state.
I am not sure how does starting of device poll earlier will solve this stuck up
problem. I will test it on my monday and update.
The problem I see is that if we do not allocate buffers on CAPTURE plane (which
will happen after formatinfo is set) the buffers on OUTPUT plane will not get
consumed and hence will not be dequeued. So even with device polling we cannot
send more bitstream. We should have got the FormatInfo() after processing the
first buffer itself but if the detection is getting delayed we should keep
checking for it while sending more bitstream buffers.


On 2014/03/07 00:18:08, sheu wrote:

[sheu, 2014/03/07 20:31:50]

Ah, i see how it is.  So if I have this right: the problem is that we queue data
to the OUTPUT queue for the decoder to initialize, but the decoder
initialization happens asynchronously.  So VIDIOC_G_FMT on the CAPTURE queue may
not succeed immediately; instead at some undefined point in the future the
decoder initialization will finish and VIDIOC_G_FMT will start returning the
proper format.  This is a problem in TegraVDA since when we fail to get the
format after each buffer we queue, we continue trying to queue buffers; the race
is between the decoder initialization finishing and the VDA running out of
buffers to continue to enqueue with.

For Exynos we get around this problem since VIDIOC_G_FMT on the CAPTURE queue is
synchronous w.r.t. the decoder initialization; i.e. it blocks until we know for
sure whether the decoder has initialized with the given input, or not.  That
brings to mind two possible solutions in the TegraVDA case:

1.  Either make VIDIOC_G_FMT on the CAPTURE queue synchronous, as in the Exynos
case
2.  Add a notification system for decoder initialization.  I'd go with the
V4L2_EVENT system, by adding a private event for the Tegra driver (see:
V4L2_EVENT_PRIVATE_START).

(1) would be a faster fix than (2).  Tight-loop polling (by constant reposting
of the task) is not the way to go.

[sheu, 2014/03/07 21:36:29]

Random thought for posciak@: if we make the decoder init notify through the
event system, we might even be able to unify this with the resolution change
event handling.  WDYT?

[shivdasp, 2014/03/10 05:58:13]

Ohh that's why this never happens on Exynos.
Alright, option (1) to make the VIDIOC_G_FMT on CAPTURE plane synchronous 
looks the quicker solution and we wouldn't have to change a thing in VDA.
I will make that change.
Will re-post a patch removing this fix in VDA and addressing your comments too.

Thanks.
On 2014/03/07 21:36:29, sheu wrote:

+    }
     return false;
+  }
 
   // If we only have a partial frame, don't flush and process yet.
   if (decoder_partial_frame_pending_)
@@ -727,6 +731,7 @@ bool V4L2VideoDecodeAccelerator::DecodeBufferInitial(
   // Recycle buffers.
   Dequeue();
 
+chk_format_info:
   // Check and see if we have format info yet.
   struct v4l2_format format;
   bool again = false;
@@ -735,6 +740,11 @@ bool V4L2VideoDecodeAccelerator::DecodeBufferInitial(
 
   if (again) {
     // Need more stream to decode format, return true and schedule next buffer.
+    if (no_free_input_buffers) {
+      // This buffer has not been consumed, so schedule another one.
+      *endpos = 0;
+      return true;
+    }
     *endpos = size;
     return true;
   }
@@ -1758,7 +1768,7 @@ bool V4L2VideoDecodeAccelerator::CreateOutputBuffers() {
                                                  client_,
                                                  output_buffer_map_.size(),
                                                  frame_buffer_size_,
-                                                 GL_TEXTURE_EXTERNAL_OES));
+                                                 device_->GetTextureTarget()));
 
   // Wait for the client to call AssignPictureBuffers() on the Child thread.
   // We do this, because if we continue decoding without finishing buffer