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 252 matching lines @@
   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;
   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;
     // 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
+      // to trigger decoder initialization.
+      if ((current_format_.fmt.pix_mp.width == 0) ||
+          (current_format_.fmt.pix_mp.height == 0)) {
+        DVLOG(3) << "DequeueEvents(): Decoder init through resolution change ";
+        resolution_change_pending_ = true;
+      } else {
+        // Check if this is real RESOLUTION CHANGE event or not.
+        struct v4l2_format format;
+        bool again = false;
+        bool ret = GetFormatInfo(&format, &again);
+        if (!ret || again) {
+          DVLOG(3) << "DequeueEvents(): GetFormatInfo() failed ";
+          NOTIFY_ERROR(PLATFORM_FAILURE);
+          return;
+        }
+        if ((format.fmt.pix_mp.width != current_format_.fmt.pix_mp.width) ||
+            (format.fmt.pix_mp.height != current_format_.fmt.pix_mp.height)) {
+          DVLOG(2) << "DequeueEvents(): Resolution change detected";
+          current_format_ = format;
+          resolution_change_pending_ = true;
+        } else {
+          DVLOG(2) << "DequeueEvents(): Dropping resolution change event";
+        }
+      }

[sheu, 2014/03/21 23:19:54]

Pawel brought up the point that it might be a change to the number of reference
frames/output buffers required.  Can you also check for
V4L2_CID_MIN_BUFFERS_FOR_CAPTURE, and skip only if that is less than the current
allocation count equal as well?

[shivdasp, 2014/03/24 06:01:27]

Done, please refer patchset#9.
On 2014/03/21 23:19:54, sheu wrote:

     } 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 733 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