Make VEA client of command buffer; move sync. IPC to VDA/VEA::Initialize()

content/common/gpu/media/exynos_video_encode_accelerator.cc

 // Copyright 2013 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 "content/common/gpu/media/exynos_video_encode_accelerator.h"
 
 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <sys/eventfd.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
 
 #include "base/callback.h"
 #include "base/command_line.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/posix/eintr_wrapper.h"
 #include "content/public/common/content_switches.h"
 #include "media/base/bitstream_buffer.h"
 
 #define NOTIFY_ERROR(x)                                            \
   do {                                                             \
     SetEncoderState(kError);                                       \
     DLOG(ERROR) << "calling NotifyError(): " << x;                 \
     NotifyError(x);                                                \
   } while (0)
 
-#define IOCTL_OR_ERROR_RETURN(fd, type, arg)                       \
+#define IOCTL_OR_ERROR_RETURN_VALUE(fd, type, arg, value)          \
   do {                                                             \
     if (HANDLE_EINTR(ioctl(fd, type, arg) != 0)) {                 \
       DPLOG(ERROR) << __func__ << "(): ioctl() failed: " << #type; \
       NOTIFY_ERROR(kPlatformFailureError);                         \
-      return;                                                      \
+      return value;                                                \
     }                                                              \
   } while (0)
 
-#define IOCTL_OR_ERROR_RETURN_FALSE(fd, type, arg)                 \
-  do {                                                             \
-    if (HANDLE_EINTR(ioctl(fd, type, arg) != 0)) {                 \
-      DPLOG(ERROR) << __func__ << "(): ioctl() failed: " << #type; \
-      NOTIFY_ERROR(kPlatformFailureError);                         \
-      return false;                                                \
-    }                                                              \
-  } while (0)
+#define IOCTL_OR_ERROR_RETURN(fd, type, arg) \
+  IOCTL_OR_ERROR_RETURN_VALUE(fd, type, arg, ((void)0))

[Pawel Osciak, 2014/03/13 06:18:13]

You could also just s/((void)0)// I think?

[sheu, 2014/03/13 22:39:52]

I think that's a gcc-specific extension.

+
+#define IOCTL_OR_ERROR_RETURN_FALSE(fd, type, arg) \
+  IOCTL_OR_ERROR_RETURN_VALUE(fd, type, arg, false)
 
 namespace content {
 
 namespace {
 
 const char kExynosGscDevice[] = "/dev/gsc1";
 const char kExynosMfcDevice[] = "/dev/mfc-enc";
 
 // File descriptors we need to poll, one-bit flag for each.
 enum PollFds {
@@ skipping 64 matching lines @@
     gsc_fd_ = -1;
   }
   if (mfc_fd_ != -1) {
     DestroyMfcInputBuffers();
     DestroyMfcOutputBuffers();
     close(mfc_fd_);
     mfc_fd_ = -1;
   }
 }
 
-void ExynosVideoEncodeAccelerator::Initialize(
+bool ExynosVideoEncodeAccelerator::Initialize(
     media::VideoFrame::Format input_format,
     const gfx::Size& input_visible_size,
     media::VideoCodecProfile output_profile,
     uint32 initial_bitrate,
     Client* client) {
   DVLOG(3) << "Initialize(): input_format=" << input_format
            << ", input_visible_size=" << input_visible_size.ToString()
            << ", output_profile=" << output_profile
            << ", initial_bitrate=" << initial_bitrate;
 
@@ skipping 11 matching lines @@
   converted_allocated_size_.SetSize(
       (converted_visible_size_.width() + 0xF) & ~0xF,
       (converted_visible_size_.height() + 0xF) & ~0xF);
   output_visible_size_ = converted_visible_size_;
 
   switch (input_format) {
     case media::VideoFrame::I420:
       input_format_fourcc_ = V4L2_PIX_FMT_YUV420M;
       break;
     default:
-      NOTIFY_ERROR(kInvalidArgumentError);
-      return;
+      DLOG(ERROR) << "Initialize(): invalid input_format=" << input_format;
+      return false;
   }
 
   if (output_profile >= media::H264PROFILE_MIN &&
       output_profile <= media::H264PROFILE_MAX) {
     output_format_fourcc_ = V4L2_PIX_FMT_H264;
   } else if (output_profile >= media::VP8PROFILE_MIN &&
              output_profile <= media::VP8PROFILE_MAX) {
     output_format_fourcc_ = V4L2_PIX_FMT_VP8;
   } else {
-    NOTIFY_ERROR(kInvalidArgumentError);
-    return;
+    DLOG(ERROR) << "Initialize(): invalid output_profile=" << output_profile;
+    return false;
   }
 
   // Open the color conversion device.
   DVLOG(2) << "Initialize(): opening GSC device: " << kExynosGscDevice;
   gsc_fd_ =
       HANDLE_EINTR(open(kExynosGscDevice, O_RDWR | O_NONBLOCK | O_CLOEXEC));
   if (gsc_fd_ == -1) {
     DPLOG(ERROR) << "Initialize(): could not open GSC device: "
                  << kExynosGscDevice;
-    NOTIFY_ERROR(kPlatformFailureError);
-    return;
+    return false;
   }
 
   // Capabilities check.
   struct v4l2_capability caps;
   memset(&caps, 0, sizeof(caps));
   const __u32 kCapsRequired = V4L2_CAP_VIDEO_CAPTURE_MPLANE |
                               V4L2_CAP_VIDEO_OUTPUT_MPLANE | V4L2_CAP_STREAMING;
-  IOCTL_OR_ERROR_RETURN(gsc_fd_, VIDIOC_QUERYCAP, &caps);
+  if (HANDLE_EINTR(ioctl(gsc_fd_, VIDIOC_QUERYCAP, &caps))) {
+    DPLOG(ERROR) << "Initialize(): ioctl() failed: VIDIOC_QUERYCAP";
+    return false;
+  }
   if ((caps.capabilities & kCapsRequired) != kCapsRequired) {
     DLOG(ERROR) << "Initialize(): ioctl() failed: VIDIOC_QUERYCAP: "
                    "caps check failed: 0x" << std::hex << caps.capabilities;
-    NOTIFY_ERROR(kPlatformFailureError);
-    return;
+    return false;
   }
 
   // Open the video encoder device.
   DVLOG(2) << "Initialize(): opening MFC device: " << kExynosMfcDevice;
   mfc_fd_ =
       HANDLE_EINTR(open(kExynosMfcDevice, O_RDWR | O_NONBLOCK | O_CLOEXEC));
   if (mfc_fd_ == -1) {
     DPLOG(ERROR) << "Initialize(): could not open MFC device: "
                  << kExynosMfcDevice;
-    NOTIFY_ERROR(kPlatformFailureError);
-    return;
+    return false;
   }
 
   memset(&caps, 0, sizeof(caps));
-  IOCTL_OR_ERROR_RETURN(mfc_fd_, VIDIOC_QUERYCAP, &caps);
+  if (HANDLE_EINTR(ioctl(mfc_fd_, VIDIOC_QUERYCAP, &caps))) {
+    DPLOG(ERROR) << "Initialize(): ioctl() failed: VIDIOC_QUERYCAP";
+    return false;
+  }
   if ((caps.capabilities & kCapsRequired) != kCapsRequired) {
     DLOG(ERROR) << "Initialize(): ioctl() failed: VIDIOC_QUERYCAP: "
                    "caps check failed: 0x" << std::hex << caps.capabilities;
-    NOTIFY_ERROR(kPlatformFailureError);
-    return;
+    return false;
   }
 
   // Create the interrupt fd.
   DCHECK_EQ(device_poll_interrupt_fd_, -1);
   device_poll_interrupt_fd_ = eventfd(0, EFD_NONBLOCK | EFD_CLOEXEC);
   if (device_poll_interrupt_fd_ == -1) {
     DPLOG(ERROR) << "Initialize(): eventfd() failed";
-    NOTIFY_ERROR(kPlatformFailureError);
-    return;
+    return false;
   }
 
   DVLOG(3)
       << "Initialize(): input_visible_size_=" << input_visible_size_.ToString()
       << ", input_allocated_size_=" << input_allocated_size_.ToString()
       << ", converted_visible_size_=" << converted_visible_size_.ToString()
       << ", converted_allocated_size_=" << converted_allocated_size_.ToString()
       << ", output_visible_size_=" << output_visible_size_.ToString();
 
   if (!CreateGscInputBuffers() || !CreateGscOutputBuffers())
-    return;
+    return false;
 
   // MFC setup for encoding is rather particular in ordering:
   //
   // 1. Format (VIDIOC_S_FMT) set first on OUTPUT and CAPTURE queues.
   // 2. VIDIOC_REQBUFS, VIDIOC_QBUF, and VIDIOC_STREAMON on CAPTURE queue.
   // 3. VIDIOC_REQBUFS (and later VIDIOC_QBUF and VIDIOC_STREAMON) on OUTPUT
   //    queue.
   //
   // Unfortunately, we cannot do (3) in Initialize() here since we have no
   // buffers to QBUF in step (2) until the client has provided output buffers
   // through UseOutputBitstreamBuffer().  So, we just do (1), and the
   // VIDIOC_REQBUFS part of (2) here.  The rest is done the first time we get
   // a UseOutputBitstreamBuffer() callback.
 
   if (!SetMfcFormats())
-    return;
+    return false;
 
   if (!InitMfcControls())
-    return;
+    return false;
 
   // VIDIOC_REQBUFS on CAPTURE queue.
   if (!CreateMfcOutputBuffers())
-    return;
-
+    return false;
 
   if (!encoder_thread_.Start()) {
     DLOG(ERROR) << "Initialize(): encoder thread failed to start";
-    NOTIFY_ERROR(kPlatformFailureError);
-    return;
+    return false;
   }
 
   RequestEncodingParametersChange(initial_bitrate, kInitialFramerate);
 
   SetEncoderState(kInitialized);
 
   child_message_loop_proxy_->PostTask(
-      FROM_HERE, base::Bind(&Client::NotifyInitializeDone, client_));
-
-  child_message_loop_proxy_->PostTask(
       FROM_HERE,
       base::Bind(&Client::RequireBitstreamBuffers,
                  client_,
                  gsc_input_buffer_map_.size(),
                  input_allocated_size_,
                  output_buffer_byte_size_));
+  return true;
 }
 
 void ExynosVideoEncodeAccelerator::Encode(
     const scoped_refptr<media::VideoFrame>& frame,
     bool force_keyframe) {
   DVLOG(3) << "Encode(): force_keyframe=" << force_keyframe;
   DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
 
   encoder_thread_.message_loop()->PostTask(
       FROM_HERE,
@@ skipping 1243 matching lines @@
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   reqbufs.memory = V4L2_MEMORY_MMAP;
   if (HANDLE_EINTR(ioctl(mfc_fd_, VIDIOC_REQBUFS, &reqbufs)) != 0)
     DPLOG(ERROR) << "DestroyMfcOutputBuffers(): ioctl() failed: VIDIOC_REQBUFS";
 
   mfc_output_buffer_map_.clear();
   mfc_free_output_buffers_.clear();
 }
 
 }  // namespace content