EVDA: Modify V4L APIs for 3.8 kernel

content/common/gpu/media/exynos_video_decode_accelerator.cc

 // Copyright (c) 2012 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 <linux/videodev2.h>
 #include <poll.h>
 #include <sys/eventfd.h>
@@ skipping 1176 matching lines @@
   DCHECK_NE(decoder_state_, kUninitialized);
   TRACE_EVENT0("Video Decoder", "EVDA::DequeueMfc");
 
   // Dequeue completed MFC input (VIDEO_OUTPUT) buffers, and recycle to the free
   // list.
   struct v4l2_buffer dqbuf;
   struct v4l2_plane planes[2];
   while (mfc_input_buffer_queued_count_ > 0) {
     DCHECK(mfc_input_streamon_);
     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 (ioctl(mfc_fd_, VIDIOC_DQBUF, &dqbuf) != 0) {
       if (errno == EAGAIN) {
         // EAGAIN if we're just out of buffers to dequeue.
         break;
       }
       DPLOG(ERROR) << "DequeueMfc(): ioctl() failed: VIDIOC_DQBUF";
       NOTIFY_ERROR(PLATFORM_FAILURE);
       return;
     }
     MfcInputRecord& input_record = mfc_input_buffer_map_[dqbuf.index];
@@ skipping 111 matching lines @@
   DVLOG(3) << "DequeueGsc()";
   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
   DCHECK_NE(decoder_state_, kUninitialized);
   DCHECK_NE(decoder_state_, kInitialized);
   DCHECK_NE(decoder_state_, kAfterReset);
   TRACE_EVENT0("Video Decoder", "EVDA::DequeueGsc");
 
   // Dequeue completed GSC input (VIDEO_OUTPUT) buffers, and recycle to the free
   // list.  Also recycle the corresponding MFC output buffers at this time.
   struct v4l2_buffer dqbuf;
+  struct v4l2_plane planes[2];
   while (gsc_input_buffer_queued_count_ > 0) {
     DCHECK(gsc_input_streamon_);
     memset(&dqbuf, 0, sizeof(dqbuf));
+    memset(planes, 0, sizeof(planes));
     dqbuf.type   = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
     dqbuf.memory = V4L2_MEMORY_DMABUF;
+    dqbuf.m.planes = planes;
+    dqbuf.length = 2;
     if (ioctl(gsc_fd_, VIDIOC_DQBUF, &dqbuf) != 0) {
       if (errno == EAGAIN) {
         // EAGAIN if we're just out of buffers to dequeue.
         break;
       }
       DPLOG(ERROR) << "DequeueGsc(): ioctl() failed: VIDIOC_DQBUF";
       NOTIFY_ERROR(PLATFORM_FAILURE);
       return;
     }
     GscInputRecord& input_record = gsc_input_buffer_map_[dqbuf.index];
     MfcOutputRecord& output_record =
         mfc_output_buffer_map_[input_record.mfc_output];
     DCHECK(input_record.at_device);
     gsc_free_input_buffers_.push_back(dqbuf.index);
     mfc_free_output_buffers_.push_back(input_record.mfc_output);
     input_record.at_device = false;
     input_record.mfc_output = -1;
     output_record.input_id = -1;
     gsc_input_buffer_queued_count_--;
   }
 
   // Dequeue completed GSC output (VIDEO_CAPTURE) buffers, and send them off to
   // the client.  Don't recycle to its free list yet -- we can't do that until
   // ReusePictureBuffer() returns it to us.
   while (gsc_output_buffer_queued_count_ > 0) {
     DCHECK(gsc_output_streamon_);
     memset(&dqbuf, 0, sizeof(dqbuf));
+    memset(planes, 0, sizeof(planes));
     dqbuf.type   = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
     dqbuf.memory = V4L2_MEMORY_DMABUF;
+    dqbuf.m.planes = planes;
+    dqbuf.length = 1;
     if (ioctl(gsc_fd_, VIDIOC_DQBUF, &dqbuf) != 0) {
       if (errno == EAGAIN) {
         // EAGAIN if we're just out of buffers to dequeue.
         break;
       }
       DPLOG(ERROR) << "DequeueGsc(): ioctl() failed: VIDIOC_DQBUF";
       NOTIFY_ERROR(PLATFORM_FAILURE);
       return;
     }
     GscOutputRecord& output_record = gsc_output_buffer_map_[dqbuf.index];
@@ skipping 679 matching lines @@
   IOCTL_OR_ERROR_RETURN_FALSE(gsc_fd_, VIDIOC_S_CTRL, &control);
 
   memset(&control, 0, sizeof(control));
   control.id = V4L2_CID_VFLIP;
   control.value = 0;
   IOCTL_OR_ERROR_RETURN_FALSE(gsc_fd_, VIDIOC_S_CTRL, &control);
 
   memset(&control, 0, sizeof(control));
   control.id = V4L2_CID_GLOBAL_ALPHA;
   control.value = 255;
-  IOCTL_OR_ERROR_RETURN_FALSE(gsc_fd_, VIDIOC_S_CTRL, &control);
+  if (HANDLE_EINTR(ioctl(gsc_fd_, VIDIOC_S_CTRL, &control)) != 0) {

[sheu, 2013/05/23 23:03:04]

This is the 3.4/3.8 compatibility bit.

+    memset(&control, 0, sizeof(control));
+    control.id = V4L2_CID_ALPHA_COMPONENT;
+    control.value = 255;
+    IOCTL_OR_ERROR_RETURN_FALSE(gsc_fd_, VIDIOC_S_CTRL, &control);
+  }
 
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count = kGscInputBufferCount;
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
   reqbufs.memory = V4L2_MEMORY_USERPTR;
   IOCTL_OR_ERROR_RETURN_FALSE(gsc_fd_, VIDIOC_REQBUFS, &reqbufs);
 
   gsc_input_buffer_map_.resize(reqbufs.count);
   for (size_t i = 0; i < gsc_input_buffer_map_.size(); ++i) {
@@ skipping 145 matching lines @@
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   reqbufs.memory = V4L2_MEMORY_DMABUF;
   if (ioctl(gsc_fd_, VIDIOC_REQBUFS, &reqbufs) != 0)
     DPLOG(ERROR) << "DestroyGscOutputBuffers(): ioctl() failed: VIDIOC_REQBUFS";
 
   gsc_output_buffer_map_.clear();
   gsc_free_output_buffers_.clear();
 }
 
 }  // namespace content