Add support for Tegra V4L2 VDA

content/common/gpu/media/v4l2_video_decode_accelerator.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 <errno.h>
 #include <fcntl.h>
 #include <libdrm/drm_fourcc.h>
 #include <linux/videodev2.h>
 #include <poll.h>
@@ skipping 339 matching lines @@
     DCHECK_EQ(output_record.egl_sync, EGL_NO_SYNC_KHR);
     DCHECK_EQ(output_record.picture_id, -1);
     DCHECK_EQ(output_record.cleared, false);
 
     attrs[7]  = output_record.fds[0];
     attrs[9]  = 0;
     attrs[11] = frame_buffer_size_.width();
     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
       // has been transferred to output_buffer_map_. After we error-out here
       // the destructor will handle their cleanup.
       NOTIFY_ERROR(PLATFORM_FAILURE);
       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);
     DVLOG(3) << "AssignPictureBuffers(): buffer[" << i
              << "]: picture_id=" << output_record.picture_id;
   }
 
   pictures_assigned_.Signal();
 }
 
@@ skipping 320 matching lines @@
 
 bool V4L2VideoDecodeAccelerator::DecodeBufferInitial(
     const void* data, size_t size, size_t* endpos) {
   DVLOG(3) << "DecodeBufferInitial(): data=" << data << ", size=" << size;
   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
   DCHECK_NE(decoder_state_, kUninitialized);
   DCHECK_NE(decoder_state_, kDecoding);
   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_)
     return true;
 
   if (!FlushInputFrame())
     return false;
 
   // Recycle buffers.
   Dequeue();
 
+chk_format_info:
   // Check and see if we have format info yet.
   struct v4l2_format format;
   bool again = false;
   if (!GetFormatInfo(&format, &again))
     return false;
 
   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;
   }
 
   // Run this initialization only on first startup.
   if (decoder_state_ == kInitialized) {
     DVLOG(3) << "DecodeBufferInitial(): running initialization";
     // Success! Setup our parameters.
     if (!CreateBuffersForFormat(format))
       return false;
@@ skipping 1003 matching lines @@
 
   DVLOG(3) << "CreateOutputBuffers(): ProvidePictureBuffers(): "
            << "buffer_count=" << output_buffer_map_.size()
            << ", width=" << frame_buffer_size_.width()
            << ", height=" << frame_buffer_size_.height();
   child_message_loop_proxy_->PostTask(FROM_HERE,
                                       base::Bind(&Client::ProvidePictureBuffers,
                                                  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
   // allocation, we may end up Resetting before AssignPictureBuffers arrives,
   // resulting in unnecessary complications and subtle bugs.
   // For example, if the client calls Decode(Input1), Reset(), Decode(Input2)
   // in a sequence, and Decode(Input1) results in us getting here and exiting
   // without waiting, we might end up running Reset{,Done}Task() before
   // AssignPictureBuffers is scheduled, thus cleaning up and pushing buffers
   // to the free_output_buffers_ map twice. If we somehow marked buffers as
@@ skipping 147 matching lines @@
 
 void V4L2VideoDecodeAccelerator::PictureCleared() {
   DVLOG(3) << "PictureCleared(). clearing count=" << picture_clearing_count_;
   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
   DCHECK_GT(picture_clearing_count_, 0);
   picture_clearing_count_--;
   SendPictureReady();
 }
 
 }  // namespace content