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 322 matching lines @@
     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.
 
   // Copy in and send to HW.
   if (!AppendToInputFrame(data, size))

[shivdasp, 2014/02/20 08:51:02]

I think there is a bug here. Imagine a situation where AppendToInputFrame()
fails because free_input_buffers_.empty() is true.
This could very well happen if the VIDIOC_G_FMT on CAPTURE_PLANE did not succeed
before we endup drying up the buffers. And once this condition is hit, we never
try to dequeue nor check formatinfo.

[Pawel Osciak, 2014/02/21 05:36:42]

If free_input_buffers_ is empty in ATIF(), then it will attempt to Dequeue()
input buffers for reuse. If that fails, something is wrong with the driver. It
should not keep input buffers if they are not needed for decode, and I don't see
a situation when it would need to keep input buffers if we don't have format
information yet.

Could you provide a specific example and an example stream when this would
happen?
Does this reproduce on Exynos?

[shivdasp, 2014/02/25 09:38:15]

The issue is that we try to Dequeue() only once in ATIF() and if it fails we
stall this thread. Dequeue() cannot be guaranteed to succeed and provide back a
buffer immediately when the client expects. I can see this issue on Tegra in 1
out of 5 times, depending upon how the threads are scheduled.
I think until we move out of the kInitialized into KDecoding, state we should
try and scheduleDecodeBufferTask and call GetFormatInfo() irrespective of
whether Dequeue() fails.
My current fix is to go to GetFormatInfo() below which keeps the thread going.
Have not tested on Exynos so can't say.

On 2014/02/21 05:36:42, Pawel Osciak wrote:

[sheu, 2014/03/06 08:51:34]

I think there's an actual bug here.  The reason why DecodeBufferInitial()
returns false in this case is to avoid immediately scheduling another decode
task, since AppendToInputFrame() failed because there's no input buffer
available, and trying again would just be a tight loop.  The idea is that we
should wait until another input buffer frees up.

Unfortunately, device_poll_thread_ is not running and so we're not polling and
we'll never inform the decoder_thread_ that a buffer frees up when it does.

I think the solution is to call StartDevicePoll() earlier, perhaps at the end of
Initialize().  All the DCHECKS on decoder_state_ and
device_poll_thread_.IsRunning() would naturally have to be re-audited to make
sure they fall in line with our new assumptions.

[shivdasp, 2014/03/06 11:10:09]

I have attempted a fix for this in patchset#7. Could you take a look at that ?
I agree there's a tight loop but the message is posted back to the
decoder_thread and with what I have tested, the thread scheduling allows the
underlying decoder thread to "report" stream format and get into the kDecoding
state. Please suggest how to go about this.
On Exynos I believe this condition seldom hits.

On 2014/03/06 08:51:34, 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.
@@ skipping 1023 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