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>
 #include <sys/eventfd.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
 
 #include "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/memory/shared_memory.h"
 #include "base/message_loop/message_loop.h"
 #include "base/message_loop/message_loop_proxy.h"
+#include "base/numerics/safe_conversions.h"
 #include "base/posix/eintr_wrapper.h"
 #include "content/common/gpu/media/v4l2_video_decode_accelerator.h"
 #include "media/filters/h264_parser.h"
 #include "ui/gl/scoped_binders.h"
 
 namespace content {
 
 #define NOTIFY_ERROR(x)                                               \
   do {                                                                \
     SetDecoderState(kError);                                          \
@@ skipping 102 matching lines @@
 V4L2VideoDecodeAccelerator::InputRecord::~InputRecord() {
 }
 
 V4L2VideoDecodeAccelerator::OutputRecord::OutputRecord()
     : at_device(false),
       at_client(false),
       egl_image(EGL_NO_IMAGE_KHR),
       egl_sync(EGL_NO_SYNC_KHR),
       picture_id(-1),
       cleared(false) {
-  for (size_t i = 0; i < arraysize(fds); ++i)
-    fds[i] = -1;
 }
 
 V4L2VideoDecodeAccelerator::OutputRecord::~OutputRecord() {}
 
 V4L2VideoDecodeAccelerator::PictureRecord::PictureRecord(
     bool cleared,
     const media::Picture& picture)
     : cleared(cleared), picture(picture) {}
 
 V4L2VideoDecodeAccelerator::PictureRecord::~PictureRecord() {}
@@ skipping 18 matching lines @@
       decoder_flushing_(false),
       resolution_change_pending_(false),
       resolution_change_reset_pending_(false),
       decoder_partial_frame_pending_(false),
       input_streamon_(false),
       input_buffer_queued_count_(0),
       output_streamon_(false),
       output_buffer_queued_count_(0),
       output_buffer_pixelformat_(0),
       output_dpb_size_(0),
+      output_planes_count_(0),
       picture_clearing_count_(0),
       pictures_assigned_(false, false),
       device_poll_thread_("V4L2DevicePollThread"),
       make_context_current_(make_context_current),
       egl_display_(egl_display),
       video_profile_(media::VIDEO_CODEC_PROFILE_UNKNOWN) {}
 
 V4L2VideoDecodeAccelerator::~V4L2VideoDecodeAccelerator() {
   DCHECK(!decoder_thread_.IsRunning());
   DCHECK(!device_poll_thread_.IsRunning());
@@ skipping 68 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;
+  format.fmt.pix_mp.pixelformat = device_->PreferredOutputFormat();
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_FMT, &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 &&
@@ skipping 42 matching lines @@
     return;
   }
 
   if (!make_context_current_.Run()) {
     DLOG(ERROR) << "AssignPictureBuffers(): could not make context current";
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return;
   }
 
   gfx::ScopedTextureBinder bind_restore(GL_TEXTURE_EXTERNAL_OES, 0);
-  EGLint attrs[] = {
-      EGL_WIDTH,                     0, EGL_HEIGHT,                    0,
-      EGL_LINUX_DRM_FOURCC_EXT,      0, EGL_DMA_BUF_PLANE0_FD_EXT,     0,
-      EGL_DMA_BUF_PLANE0_OFFSET_EXT, 0, EGL_DMA_BUF_PLANE0_PITCH_EXT,  0,
-      EGL_DMA_BUF_PLANE1_FD_EXT,     0, EGL_DMA_BUF_PLANE1_OFFSET_EXT, 0,
-      EGL_DMA_BUF_PLANE1_PITCH_EXT,  0, EGL_NONE, };
-  attrs[1] = frame_buffer_size_.width();
-  attrs[3] = frame_buffer_size_.height();
-  attrs[5] = DRM_FORMAT_NV12;
 
   // It's safe to manipulate all the buffer state here, because the decoder
   // thread is waiting on pictures_assigned_.
   DCHECK(free_output_buffers_.empty());
   for (size_t i = 0; i < output_buffer_map_.size(); ++i) {
     DCHECK(buffers[i].size() == frame_buffer_size_);
 
     OutputRecord& output_record = output_buffer_map_[i];
     DCHECK(!output_record.at_device);
     DCHECK(!output_record.at_client);
     DCHECK_EQ(output_record.egl_image, EGL_NO_IMAGE_KHR);
     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_,
+                                                    buffers[i].texture_id(),
+                                                    frame_buffer_size_,
+                                                    i,
+                                                    output_planes_count_);
     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 610 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;
+      resolution_change_pending_ = IsResolutionChangeNecessary();
     } 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());
   DCHECK_NE(decoder_state_, kUninitialized);
   TRACE_EVENT0("Video Decoder", "V4L2VDA::Dequeue");
 
   // Dequeue completed input (VIDEO_OUTPUT) buffers, and recycle to the free
   // list.
-  struct v4l2_buffer dqbuf;
-  struct v4l2_plane planes[2];
   while (input_buffer_queued_count_ > 0) {
     DCHECK(input_streamon_);
+    struct v4l2_buffer dqbuf;
+    struct v4l2_plane planes[1];
     memset(&dqbuf, 0, sizeof(dqbuf));
     memset(planes, 0, sizeof(planes));
     dqbuf.type   = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
     dqbuf.memory = V4L2_MEMORY_MMAP;
     dqbuf.m.planes = planes;
     dqbuf.length = 1;
     if (device_->Ioctl(VIDIOC_DQBUF, &dqbuf) != 0) {
       if (errno == EAGAIN) {
         // EAGAIN if we're just out of buffers to dequeue.
         break;
       }
       DPLOG(ERROR) << "Dequeue(): ioctl() failed: VIDIOC_DQBUF";
       NOTIFY_ERROR(PLATFORM_FAILURE);
       return;
     }
     InputRecord& input_record = input_buffer_map_[dqbuf.index];
     DCHECK(input_record.at_device);
     free_input_buffers_.push_back(dqbuf.index);
     input_record.at_device = false;
     input_record.bytes_used = 0;
     input_record.input_id = -1;
     input_buffer_queued_count_--;
   }
 
   // Dequeue completed output (VIDEO_CAPTURE) buffers, and queue to the
   // completed queue.
   while (output_buffer_queued_count_ > 0) {
     DCHECK(output_streamon_);
+    struct v4l2_buffer dqbuf;
+    scoped_ptr<struct v4l2_plane[]> planes(
+        new v4l2_plane[output_planes_count_]);
     memset(&dqbuf, 0, sizeof(dqbuf));
-    memset(planes, 0, sizeof(planes));
+    memset(planes.get(), 0, sizeof(struct v4l2_plane) * output_planes_count_);
     dqbuf.type   = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
     dqbuf.memory = V4L2_MEMORY_MMAP;
-    dqbuf.m.planes = planes;
-    dqbuf.length = 2;
+    dqbuf.m.planes = planes.get();
+    dqbuf.length = output_planes_count_;
     if (device_->Ioctl(VIDIOC_DQBUF, &dqbuf) != 0) {
       if (errno == EAGAIN) {
         // EAGAIN if we're just out of buffers to dequeue.
         break;
       }
       DPLOG(ERROR) << "Dequeue(): ioctl() failed: VIDIOC_DQBUF";
       NOTIFY_ERROR(PLATFORM_FAILURE);
       return;
     }
     OutputRecord& output_record = output_buffer_map_[dqbuf.index];
@@ skipping 75 matching lines @@
       DVLOG(1) << __func__ << " eglClientWaitSyncKHR failed!";
     }
     if (eglDestroySyncKHR(egl_display_, output_record.egl_sync) != EGL_TRUE) {
       DLOG(FATAL) << __func__ << " eglDestroySyncKHR failed!";
       NOTIFY_ERROR(PLATFORM_FAILURE);
       return false;
     }
     output_record.egl_sync = EGL_NO_SYNC_KHR;
   }
   struct v4l2_buffer qbuf;
-  struct v4l2_plane qbuf_planes[arraysize(output_record.fds)];
+  scoped_ptr<struct v4l2_plane[]> qbuf_planes(
+      new v4l2_plane[output_planes_count_]);
   memset(&qbuf, 0, sizeof(qbuf));
-  memset(qbuf_planes, 0, sizeof(qbuf_planes));
+  memset(
+      qbuf_planes.get(), 0, sizeof(struct v4l2_plane) * output_planes_count_);
   qbuf.index    = buffer;
   qbuf.type     = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   qbuf.memory   = V4L2_MEMORY_MMAP;
-  qbuf.m.planes = qbuf_planes;
-  qbuf.length   = arraysize(output_record.fds);
+  qbuf.m.planes = qbuf_planes.get();
+  qbuf.length = output_planes_count_;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QBUF, &qbuf);
   free_output_buffers_.pop();
   output_record.at_device = true;
   output_buffer_queued_count_++;
   return true;
 }
 
 void V4L2VideoDecodeAccelerator::ReusePictureBufferTask(
     int32 picture_buffer_id, scoped_ptr<EGLSyncKHRRef> egl_sync_ref) {
   DVLOG(3) << "ReusePictureBufferTask(): picture_buffer_id="
@@ skipping 450 matching lines @@
       return false;
     }
   }
 
   return true;
 }
 
 bool V4L2VideoDecodeAccelerator::CreateBuffersForFormat(
     const struct v4l2_format& format) {
   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
-  CHECK_EQ(format.fmt.pix_mp.num_planes, 2);
+  output_planes_count_ = format.fmt.pix_mp.num_planes;
   frame_buffer_size_.SetSize(
       format.fmt.pix_mp.width, format.fmt.pix_mp.height);
   output_buffer_pixelformat_ = format.fmt.pix_mp.pixelformat;
-  DCHECK_EQ(output_buffer_pixelformat_, V4L2_PIX_FMT_NV12M);
+  DCHECK_EQ(output_buffer_pixelformat_, device_->PreferredOutputFormat());
   DVLOG(3) << "CreateBuffersForFormat(): new resolution: "
            << frame_buffer_size_.ToString();
 
   if (!CreateOutputBuffers())
     return false;
 
   return true;
 }
 
 bool V4L2VideoDecodeAccelerator::CreateInputBuffers() {
@@ skipping 76 matching lines @@
   // Output format setup in Initialize().
 
   // Allocate the output buffers.
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count  = output_dpb_size_ + kDpbOutputBufferExtraCount;
   reqbufs.type   = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   reqbufs.memory = V4L2_MEMORY_MMAP;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_REQBUFS, &reqbufs);
 
-  // Create DMABUFs from output buffers.
   output_buffer_map_.resize(reqbufs.count);
-  for (size_t i = 0; i < output_buffer_map_.size(); ++i) {
-    OutputRecord& output_record = output_buffer_map_[i];
-    for (size_t j = 0; j < arraysize(output_record.fds); ++j) {
-      // Export the DMABUF fd so we can export it as a texture.
-      struct v4l2_exportbuffer expbuf;
-      memset(&expbuf, 0, sizeof(expbuf));
-      expbuf.type  = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
-      expbuf.index = i;
-      expbuf.plane = j;
-      expbuf.flags = O_CLOEXEC;
-      IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_EXPBUF, &expbuf);
-      output_record.fds[j] = expbuf.fd;
-    }
-  }
 
   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 32 matching lines @@
 }
 
 bool V4L2VideoDecodeAccelerator::DestroyOutputBuffers() {
   DVLOG(3) << "DestroyOutputBuffers()";
   DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
   DCHECK(!output_streamon_);
   bool success = true;
 
   for (size_t i = 0; i < output_buffer_map_.size(); ++i) {
     OutputRecord& output_record = output_buffer_map_[i];
-    for (size_t j = 0; j < arraysize(output_record.fds); ++j) {
-      if (output_record.fds[j] != -1) {
-        if (close(output_record.fds[j])) {
-          DVPLOG(1) << __func__ << " close() on a dmabuf fd failed.";
-          success = false;
-        }
-      }
-    }
+
     if (output_record.egl_image != EGL_NO_IMAGE_KHR) {
-      if (eglDestroyImageKHR(egl_display_, output_record.egl_image) !=
+      if (device_->DestroyEGLImage(egl_display_, output_record.egl_image) !=
           EGL_TRUE) {
-        DVLOG(1) << __func__ << " eglDestroyImageKHR failed.";
+        DVLOG(1) << __func__ << " DestroyEGLImage failed.";
         success = false;
       }
     }
 
     if (output_record.egl_sync != EGL_NO_SYNC_KHR) {
       if (eglDestroySyncKHR(egl_display_, output_record.egl_sync) != EGL_TRUE) {
         DVLOG(1) << __func__ << " eglDestroySyncKHR failed.";
         success = false;
       }
     }
@@ skipping 82 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_) {
+    DVLOG(3)
+        << "IsResolutionChangeNecessary(): Returning true since DPB mismatch ";
+    return true;
+  }
+  struct v4l2_format format;
+  bool again = false;
+  bool ret = GetFormatInfo(&format, &again);
+  if (!ret || again) {
+    DVLOG(3) << "IsResolutionChangeNecessary(): GetFormatInfo() failed";
+    return false;

[Ami GONE FROM CHROMIUM, 2014/03/28 19:33:40]

Response below makes sense to me for why you return false at l.1920, but not why
it makes sense to return true if GetFormatInfo fails.

[shivdasp, 2014/03/28 20:39:26]

GetFormatInfo() on failure will call NOTIFY_PLATFORM() so VDA goes into error
state anyways.

On 2014/03/28 19:33:40, Ami Fischman wrote:

+  }
+  gfx::Size new_size(base::checked_cast<int>(format.fmt.pix_mp.width),
+                     base::checked_cast<int>(format.fmt.pix_mp.height));
+  if (frame_buffer_size_ != new_size) {
+    DVLOG(3) << "IsResolutionChangeNecessary(): Resolution change detected";
+    return true;
+  }
+  return false;
+}
+
 }  // namespace content