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 249 matching lines @@
     return false;
   }
 
   if (!CreateInputBuffers())
     return false;
 
   // Output format has to be setup before streaming starts.
   struct v4l2_format format;
   memset(&format, 0, sizeof(format));
   format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   format.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_NV12M;

[Pawel Osciak, 2014/03/25 08:21:08]

I think we discussed before that this should be fixed please...

   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_FMT, &format);
 
+  memset(&current_format_, 0, sizeof(current_format_));
+
   // Subscribe to the resolution change event.
   struct v4l2_event_subscription sub;
   memset(&sub, 0, sizeof(sub));
   sub.type = V4L2_EVENT_RESOLUTION_CHANGE;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_SUBSCRIBE_EVENT, &sub);
 
   // Initialize format-specific bits.
   if (video_profile_ >= media::H264PROFILE_MIN &&
       video_profile_ <= media::H264PROFILE_MAX) {
     decoder_h264_parser_.reset(new media::H264Parser());
@@ skipping 70 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 349 matching lines @@
 
   if (again) {
     // Need more stream to decode format, return true and schedule next buffer.
     *endpos = size;
     return true;
   }
 
   // Run this initialization only on first startup.
   if (decoder_state_ == kInitialized) {
     DVLOG(3) << "DecodeBufferInitial(): running initialization";
+    current_format_ = format;

[Pawel Osciak, 2014/03/25 08:21:08]

Please move this to the CreateBuffersForFormat call to avoid having it in
multiple places.

     // Success! Setup our parameters.
     if (!CreateBuffersForFormat(format))
       return false;
 
     // We expect to process the initial buffer once during stream init to
     // configure stream parameters, but will not consume the steam data on that
     // iteration.  Subsequent iterations (including after reset) do not require
     // the stream init step.
     *endpos = 0;
   } else {
@@ skipping 241 matching lines @@
   DCHECK_NE(decoder_state_, kUninitialized);
   DVLOG(3) << "DequeueEvents()";
 
   struct v4l2_event ev;
   memset(&ev, 0, sizeof(ev));
 
   while (device_->Ioctl(VIDIOC_DQEVENT, &ev) == 0) {
     if (ev.type == V4L2_EVENT_RESOLUTION_CHANGE) {
       DVLOG(3) << "DequeueEvents(): got resolution change event.";
       DCHECK(!resolution_change_pending_);
-      resolution_change_pending_ = true;
+      // Check if we already have current_format_ set or this is an event

[Pawel Osciak, 2014/03/25 08:21:08]

s/or this/or if this/

[shivdasp, 2014/03/25 10:36:40]

Done.

+      // to trigger decoder initialization.
+      if ((current_format_.fmt.pix_mp.width == 0) ||

[Pawel Osciak, 2014/03/25 08:21:08]

Since you are using the format only for size, I think you can use
frame_buffer_size_ instead and drop current_format_.

[shivdasp, 2014/03/25 10:36:40]

Done.

+          (current_format_.fmt.pix_mp.height == 0)) {
+        DVLOG(3) << "DequeueEvents(): Decoder init through resolution change ";
+        resolution_change_pending_ = true;
+      } else if (IsResolutionChangeNecessary()) {

[Pawel Osciak, 2014/03/25 08:21:08]

Also, IsResolutionChangeNecessary() should handle the initialization case as
well (i.e. return true if frame_buffer_size_.IsEmpty()) and this if/else
shouldn't be needed here.

+        DVLOG(3) << "DequeueEvents(): Resolution change event detected ";
+        resolution_change_pending_ = true;
+      }
     } else {
       DLOG(FATAL) << "DequeueEvents(): got an event (" << ev.type
                   << ") we haven't subscribed to.";
     }
   }
 }
 
 void V4L2VideoDecodeAccelerator::Dequeue() {
   DVLOG(3) << "Dequeue()";
   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
@@ skipping 510 matching lines @@
   }
 
   struct v4l2_format format;
   bool again;
   bool ret = GetFormatInfo(&format, &again);
   if (!ret || again) {
     DVLOG(3) << "Couldn't get format information after resolution change";
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return;
   }
-
+  // Store this new format.
+  current_format_ = format;
   if (!CreateBuffersForFormat(format)) {
     DVLOG(3) << "Couldn't reallocate buffers after resolution change";
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return;
   }
 
   decoder_state_ = kDecoding;
 
   if (resolution_change_reset_pending_) {
     resolution_change_reset_pending_ = false;
@@ skipping 202 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 146 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();
 }
 
+bool V4L2VideoDecodeAccelerator::IsResolutionChangeNecessary() {
+  DVLOG(3) << "IsResolutionChangeNecessary() ";
+  struct v4l2_control ctrl;
+  memset(&ctrl, 0, sizeof(ctrl));
+  ctrl.id = V4L2_CID_MIN_BUFFERS_FOR_CAPTURE;
+  IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_G_CTRL, &ctrl);
+  if (ctrl.value != output_dpb_size_)
+    return true;
+  struct v4l2_format format;
+  bool again = false;
+  bool ret = GetFormatInfo(&format, &again);
+  if (!ret || again) {
+    DVLOG(3) << "IsResolutionChangeNecessary(): GetFormatInfo() failed";
+    NOTIFY_ERROR(PLATFORM_FAILURE);

[Pawel Osciak, 2014/03/25 08:21:08]

This means we will send NOTIFY_ERROR twice in case G_FMT failed.

[shivdasp, 2014/03/25 10:36:40]

Since GetFormatInfo() does NOTIFY_ERROR already I will remove it from here.
On 2014/03/25 08:21:08, Pawel Osciak wrote:

+    return false;
+  }
+  if ((format.fmt.pix_mp.width != current_format_.fmt.pix_mp.width) ||
+      (format.fmt.pix_mp.height != current_format_.fmt.pix_mp.height)) {
+    DVLOG(3) << "IsResolutionChangeNecessary(): Resolution change detected";
+    current_format_ = format;

[Pawel Osciak, 2014/03/25 08:21:08]

If you are doing this here, then there is no need to do all the format getting
again in FinishResolutionChange.

+    return true;
+  } else {
+    DVLOG(3) << "IsResolutionChangeNecessary(): Dropping resolution change";

[Pawel Osciak, 2014/03/25 08:21:08]

No need for the else clause, just move it out please.

[shivdasp, 2014/03/25 10:36:40]

Done.

+  }
+  return false;
+}
+
 }  // namespace content