VDA implementation for Exynos, using V4L2

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 <sys/epoll.h>
+#include <sys/ioctl.h>
+#include <sys/mman.h>
+
+#include "base/bind.h"
+#include "base/message_loop.h"
+#include "base/message_loop_proxy.h"
+#include "base/shared_memory.h"
+#include "content/common/gpu/media/exynos_video_decode_accelerator.h"
+#include "ui/gl/gl_bindings.h"
+#include "ui/gl/gl_context.h"
+#include "ui/gl/gl_context_egl.h"
+#include "ui/gl/gl_surface_egl.h"
+
+namespace content {
+
+#define NOTIFY_ERROR(x)                           \
+  do {                                            \
+    LOG(ERROR) << "calling NotifyError(): " << x; \
+    NotifyError(x);                               \
+  } while (0)
+
+#define EXYNOS_MFC_DEVICE "/dev/mfc-dec"
+#define EXYNOS_GSC_DEVICE "/dev/gsc1"
+#define EXYNOS_MALI_DRIVER "libmali.so"
+
+static void* libmali_handle = NULL;
+static EGLBoolean(*mali_egl_image_get_buffer_ext_phandle)(
+    EGLImageKHR, EGLint*, void*) = NULL;
+static EGLSyncKHR(*egl_create_sync_khr)(
+    EGLDisplay, EGLenum, const EGLint*) = NULL;
+static EGLBoolean(*egl_destroy_sync_khr)(
+    EGLDisplay, EGLSyncKHR) = NULL;
+static EGLint(*egl_client_wait_sync_khr)(
+    EGLDisplay, EGLSyncKHR, EGLint, EGLTimeKHR) = NULL;
+
+ExynosVideoDecodeAccelerator::BitstreamBufferRecord::BitstreamBufferRecord(
+    base::SharedMemory* shm, size_t size, int32 input_id)
+    : shm(shm),
+      size(size),
+      input_id(input_id) {
+}
+
+ExynosVideoDecodeAccelerator::BitstreamBufferRecord::~BitstreamBufferRecord() {
+}
+
+ExynosVideoDecodeAccelerator::MfcInputRecord::MfcInputRecord()
+    : at_device(false),
+      offset(NULL),
+      length(0),
+      bytes_used(0),
+      input_id(-1) {
+}
+
+ExynosVideoDecodeAccelerator::MfcInputRecord::~MfcInputRecord() {
+}
+
+ExynosVideoDecodeAccelerator::MfcOutputRecord::MfcOutputRecord()
+    : at_device(false),
+      input_id(-1) {
+  bytes_used[0] = 0;
+  bytes_used[1] = 0;
+  offset[0] = NULL;
+  offset[1] = NULL;
+  length[0] = 0;
+  length[1] = 0;
+}
+
+ExynosVideoDecodeAccelerator::MfcOutputRecord::~MfcOutputRecord() {
+}
+
+ExynosVideoDecodeAccelerator::GscInputRecord::GscInputRecord()
+    : at_device(false),
+      mfc_output(-1) {
+}
+
+ExynosVideoDecodeAccelerator::GscInputRecord::~GscInputRecord() {
+}
+
+ExynosVideoDecodeAccelerator::GscOutputRecord::GscOutputRecord()
+    : at_device(false),
+      at_client(false),
+      fd(-1),
+      egl_image(EGL_NO_IMAGE_KHR),
+      egl_sync(EGL_NO_SYNC_KHR),
+      picture_id(-1) {
+}
+
+ExynosVideoDecodeAccelerator::GscOutputRecord::~GscOutputRecord() {
+}
+
+ExynosVideoDecodeAccelerator::EGLImageKHRArrayRef::EGLImageKHRArrayRef(
+    EGLDisplay egl_display, EGLImageKHR egl_images[], int egl_image_fds[],
+    int egl_images_count)
+    : egl_display(egl_display),
+      egl_images(egl_images),
+      egl_image_fds(egl_image_fds),
+      egl_images_count(egl_images_count) {
+}
+
+ExynosVideoDecodeAccelerator::EGLImageKHRArrayRef::~EGLImageKHRArrayRef() {
+  DCHECK_EQ(egl_images != NULL, egl_image_fds != NULL);
+  if (egl_images == NULL)
+    return;
+
+  for (int i = 0; i < egl_images_count; i++) {

[Ami GONE FROM CHROMIUM, 2012/11/02 17:57:06]

pre-increment, not post-
(everywhere)

[sheu, 2012/11/03 00:37:14]

Style guide says both are fine for POD scalar types.  For loop iteration though,
I guess there _is_ an argument to be made for it to be treated like any other
iterator type, i.e. always use pre-increment.

So ok.  Pre-increment in the loops, but post-increment other places because it
still looks funny to me.  (I still expect to see operators on the rhs of an
l-value.)

+    if (egl_images[i] != EGL_NO_IMAGE_KHR)
+      eglDestroyImageKHR(egl_display, egl_images[i]);
+    if (egl_image_fds[i] != -1)
+      close(egl_image_fds[i]);
+  }
+}
+
+ExynosVideoDecodeAccelerator::EGLSyncKHRRef::EGLSyncKHRRef(
+    EGLDisplay egl_display, EGLSyncKHR egl_sync)
+    : egl_display(egl_display),
+      egl_sync(egl_sync) {
+}
+
+ExynosVideoDecodeAccelerator::EGLSyncKHRRef::~EGLSyncKHRRef() {
+  if (egl_sync != EGL_NO_SYNC_KHR)
+    egl_destroy_sync_khr(egl_display, egl_sync);
+}
+
+ExynosVideoDecodeAccelerator::ExynosVideoDecodeAccelerator(
+    gfx::GLContext* gl_context,
+    Client* client,
+    const base::Callback<bool(void)>& make_context_current)
+    : child_message_loop_proxy_(base::MessageLoopProxy::current()),
+      weak_this_(base::AsWeakPtr(this)),
+      client_ptr_factory_(client),
+      client_(client_ptr_factory_.GetWeakPtr()),
+      decoder_thread_("ExynosDecoderThread"),
+      decoder_state_(kUninitialized),
+      decoder_current_bitstream_buffer_(NULL),
+      decoder_current_input_buffer_(-1),
+      decoder_decode_buffer_tasks_scheduled_(0),
+      decoder_frames_inflight_(0),
+      decoder_frames_at_client_(0),
+      decoder_flush_notify_requested_(false),
+      mfc_fd_(-1),
+      mfc_fd_closer_(&mfc_fd_),
+      mfc_input_streamon_(false),
+      mfc_input_buffer_count_(0),
+      mfc_input_buffer_queued_count_(0),
+      mfc_output_streamon_(false),
+      mfc_output_buffer_count_(0),
+      mfc_output_buffer_pixelformat_(0),
+      gsc_fd_(-1),
+      gsc_fd_closer_(&gsc_fd_),
+      gsc_input_streamon_(false),
+      gsc_input_buffer_count_(0),
+      gsc_output_streamon_(false),
+      gsc_output_buffer_count_(0),
+      gsc_output_buffer_prepared_count_(0),
+      gsc_output_buffer_queued_count_(0),
+      frame_buffer_size_(0, 0),
+      device_poll_thread_("ExynosDevicePollThread"),
+      gl_context_(gl_context),
+      make_context_current_(make_context_current),
+      egl_context_(EGL_NO_CONTEXT),
+      egl_display_(EGL_NO_DISPLAY),
+      video_profile_(media::VIDEO_CODEC_PROFILE_UNKNOWN) {
+}
+
+ExynosVideoDecodeAccelerator::~ExynosVideoDecodeAccelerator() {
+  Destroy();

[Ami GONE FROM CHROMIUM, 2012/11/02 21:11:08]

Part of VDA::Destroy()'s API is that it deletes |this| (and in fact that's the
only correct way to enter the dtor) so not sure what's up with this explicit
call, and the following DCHECKs will be use-after-free's if Destroy obeys its
contract.

[sheu, 2012/11/03 00:37:14]

Did not see that.  Alright, I'll have to run the VDA a few more times to check
that we're not actually leaking stuff.

+
+  // These maps have members that should be manually destroyed, e.g. file
+  // descriptors, mmap() segments, etc.
+  DCHECK(mfc_input_buffer_map_.empty());
+  DCHECK(mfc_output_buffer_map_.empty());
+  DCHECK(gsc_input_buffer_map_.empty());
+  DCHECK(gsc_output_buffer_map_.empty());
+}
+
+bool ExynosVideoDecodeAccelerator::Initialize(
+    media::VideoCodecProfile profile) {
+  DVLOG(3) << "Initialize()";
+  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK_EQ(decoder_state_, kUninitialized);
+
+  switch (profile) {
+    case media::H264PROFILE_BASELINE:
+      DVLOG(2) << "Initialize(): profile H264PROFILE_BASELINE";
+      break;
+    case media::H264PROFILE_MAIN:
+      DVLOG(2) << "Initialize(): profile H264PROFILE_MAIN";
+      break;
+    case media::H264PROFILE_HIGH:
+      DVLOG(2) << "Initialize(): profile H264PROFILE_HIGH";
+      break;
+    case media::VP8PROFILE_MAIN:
+      DVLOG(2) << "Initialize(): profile VP8PROFILE_MAIN";
+      break;
+    default:
+      DLOG(ERROR) << "Initialize(): unsupported profile=" << profile;
+      return false;
+  };
+  video_profile_ = profile;
+
+  gfx::GLContextEGL* context_egl = static_cast<gfx::GLContextEGL*>(gl_context_);
+  static bool sandbox_initialized = PostSandboxInitialization();
+  if (!sandbox_initialized) {
+    DLOG(ERROR) << "Initialize(): PostSandboxInitialization() failed";
+    decoder_state_ = kError;
+    NOTIFY_ERROR(PLATFORM_FAILURE);
+    return false;
+  }
+
+  egl_context_ = reinterpret_cast<EGLContext>(context_egl->GetHandle());
+  if (egl_context_ == EGL_NO_CONTEXT) {
+    DLOG(ERROR) << "Initialize(): could not get EGLContext";
+    decoder_state_ = kError;
+    NOTIFY_ERROR(PLATFORM_FAILURE);
+    return false;
+  }
+  egl_display_ = gfx::GLSurfaceEGL::GetHardwareDisplay();
+  if (egl_display_ == EGL_NO_DISPLAY) {
+    DLOG(ERROR) << "Initialize(): could not get EGLDisplay";
+    decoder_state_ = kError;
+    NOTIFY_ERROR(PLATFORM_FAILURE);
+    return false;
+  }
+
+  // Open the video devices.
+  DVLOG(2) << "Initialize(): opening MFC device: " << EXYNOS_MFC_DEVICE;
+  errno = 0;
+  mfc_fd_ = open(EXYNOS_MFC_DEVICE, O_RDWR | O_NONBLOCK);
+  if (mfc_fd_ == -1) {
+    DPLOG(ERROR) << "Initialize(): could not open MFC device: "
+                 << EXYNOS_MFC_DEVICE;
+    decoder_state_ = kError;
+    NOTIFY_ERROR(PLATFORM_FAILURE);
+    return false;
+  }
+  DVLOG(2) << "Initialize(): opening GSC device: " << EXYNOS_GSC_DEVICE;
+  errno = 0;
+  gsc_fd_ = open(EXYNOS_GSC_DEVICE, O_RDWR | O_NONBLOCK);
+  if (gsc_fd_ == -1) {
+    DPLOG(ERROR) << "Initialize(): could not open GSC device: "
+                 << EXYNOS_GSC_DEVICE;
+    decoder_state_ = kError;
+    NOTIFY_ERROR(PLATFORM_FAILURE);
+    return false;
+  }
+
+  // Capabilities check.
+  int ret;

[Ami GONE FROM CHROMIUM, 2012/11/02 17:57:06]

declare at first use (l.264 below

[sheu, 2012/11/03 00:37:14]

Done.

+  struct v4l2_capability caps;
+  const __u32 kCapsRequired =
+      V4L2_CAP_VIDEO_CAPTURE_MPLANE |
+      V4L2_CAP_VIDEO_OUTPUT_MPLANE |
+      V4L2_CAP_STREAMING;
+  errno = 0;
+  ret = ioctl(mfc_fd_, VIDIOC_QUERYCAP, &caps);
+  if (ret != 0) {
+    DPLOG(ERROR) << "Initialize(): ioctl() failed: VIDIOC_QUERYCAP";
+    decoder_state_ = kError;
+    NOTIFY_ERROR(PLATFORM_FAILURE);
+    return false;
+  } else if ((caps.capabilities & kCapsRequired) != kCapsRequired) {
+    DLOG(ERROR) << "Initialize(): ioctl() failed: VIDIOC_QUERYCAP"
+        ", caps check failed: 0x" << std::hex << caps.capabilities;
+    decoder_state_ = kError;
+    NOTIFY_ERROR(PLATFORM_FAILURE);
+    return false;
+  }
+  errno = 0;
+  ret = ioctl(gsc_fd_, VIDIOC_QUERYCAP, &caps);
+  if (ret != 0) {
+    DPLOG(ERROR) << "Initialize(): ioctl() failed: VIDIOC_QUERYCAP";
+    decoder_state_ = kError;
+    NOTIFY_ERROR(PLATFORM_FAILURE);
+    return false;
+  } else if ((caps.capabilities & kCapsRequired) != kCapsRequired) {
+    DLOG(ERROR) << "Initialize(): ioctl() failed: VIDIOC_QUERYCAP"
+        ", caps check failed: 0x" << std::hex << caps.capabilities;
+    decoder_state_ = kError;
+    NOTIFY_ERROR(PLATFORM_FAILURE);
+    return false;
+  }
+
+  // Some random ioctls that Exynos requires.
+  struct v4l2_control control;
+  memset(&control, 0, sizeof(control));
+  control.id = V4L2_CID_MPEG_MFC51_VIDEO_DECODER_H264_DISPLAY_DELAY; // also VP8
+  control.value = 8; // Magic number from Samsung folks.
+  errno = 0;
+  ret = ioctl(mfc_fd_, VIDIOC_S_CTRL, &control);
+  if (ret != 0) {
+    DPLOG(ERROR) << "Initialize(): ioctl() failed: "
+        "V4L2_CID_MPEG_MFC51_VIDEO_DECODER_H264_DISPLAY_DELAY";
+    decoder_state_ = kError;
+    NOTIFY_ERROR(PLATFORM_FAILURE);
+    return false;
+  }
+
+  if (!make_context_current_.Run()) {
+    DLOG(ERROR) << "Initialize(): could not make context current";
+    decoder_state_ = kError;
+    NOTIFY_ERROR(PLATFORM_FAILURE);
+    return false;
+  }
+
+  if (!CreateMfcInputBuffers()) {
+    decoder_state_ = kError;
+    NOTIFY_ERROR(PLATFORM_FAILURE);
+    return false;
+  }
+
+  // MFC 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_NV12MT_16X16;
+  ret = ioctl(mfc_fd_, VIDIOC_S_FMT, &format);
+  if (ret != 0) {
+    DPLOG(ERROR) << "Initialize(): ioctl() failed: VIDIOC_S_FMT";
+    return false;
+  }
+
+  if (!decoder_thread_.Start()) {
+    DLOG(ERROR) << "Initialize(): decoder thread failed to start";
+    decoder_state_ = kError;
+    NOTIFY_ERROR(PLATFORM_FAILURE);
+    return false;
+  }
+
+  // Decoder thread is started, but no tasks can have been posted to it yet.
+  // Safe to touch decoder_state_.
+  decoder_state_ = kInitialized;
+
+  child_message_loop_proxy_->PostTask(FROM_HERE, base::Bind(
+      &Client::NotifyInitializeDone, client_));
+  return true;
+}
+
+void ExynosVideoDecodeAccelerator::Decode(
+    const media::BitstreamBuffer& bitstream_buffer) {
+  DVLOG(1) << "Decode(): input_id=" << bitstream_buffer.id()
+           << ", size=" << bitstream_buffer.size();
+  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+
+  scoped_ptr<BitstreamBufferRecord> bitstream_record(new BitstreamBufferRecord(
+      new base::SharedMemory(bitstream_buffer.handle(), true),
+      bitstream_buffer.size(), bitstream_buffer.id()));
+  if (!bitstream_record->shm->Map(bitstream_buffer.size())) {
+    DLOG(ERROR) << "Decode(): could not map bitstream_buffer";
+    NOTIFY_ERROR(UNREADABLE_INPUT);
+    return;
+  }
+  DVLOG(3) << "Decode(): mapped to addr=" << bitstream_record->shm->memory();
+
+  // DecodeTask() will take care of running a DecodeBufferTask().
+  decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
+      &ExynosVideoDecodeAccelerator::DecodeTask, base::Unretained(this),
+      base::Passed(&bitstream_record)));
+}
+
+void ExynosVideoDecodeAccelerator::AssignPictureBuffers(
+    const std::vector<media::PictureBuffer>& buffers) {
+  DVLOG(3) << "AssignPictureBuffers(): buffer_count=" << buffers.size();
+  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+
+  if (!make_context_current_.Run()) {
+    DLOG(ERROR) << "AssignPictureBuffers(): could not make context current";
+    NOTIFY_ERROR(PLATFORM_FAILURE);
+    return;
+  }
+
+  DCHECK_EQ(gsc_output_buffer_count_, static_cast<int>(buffers.size()));
+  scoped_ptr<EGLImageKHRArrayRef> egl_images_ref(
+      new EGLImageKHRArrayRef(
+          egl_display_, new EGLImageKHR[buffers.size()],
+          new int[buffers.size()], buffers.size()));
+  for (int i = 0; i < egl_images_ref->egl_images_count; i++) {
+    egl_images_ref->egl_images[i] = EGL_NO_IMAGE_KHR;
+    egl_images_ref->egl_image_fds[i] = -1;
+  }
+
+  const static EGLint kImageAttrs[] = {

[Ami GONE FROM CHROMIUM, 2012/11/02 17:57:06]

The translator only has support for backing pixmaps for exynos boards; NVIDIA
doesn't need pixmaps at all:
http://code.google.com/searchframe#OAMlx_jo-ck/src/content/common/gpu/media/o...
So you can actually make the change you want in the translator without worrying
about nvidia, and use it here.

+    EGL_IMAGE_PRESERVED_KHR, 0,
+    EGL_NONE,
+  };
+  Display* x_display = base::MessagePumpForUI::GetDefaultXDisplay();
+  glActiveTexture(GL_TEXTURE0);
+  for (int i = 0; i < egl_images_ref->egl_images_count; i++) {
+    EGLImageKHR egl_image;
+    int fd, ret;
+    // Create the X pixmap and then create an EGLImageKHR from it, so we can
+    // get dma_buf backing.
+    Pixmap pixmap = XCreatePixmap(x_display, RootWindow(x_display, 0),
+        buffers[i].size().width(), buffers[i].size().height(), 32);
+    if (!pixmap) {
+      DLOG(ERROR) << "AssignPictureBuffers(): could not create X pixmap";
+      NOTIFY_ERROR(PLATFORM_FAILURE);
+      return;
+    }
+    glBindTexture(GL_TEXTURE_2D, buffers[i].texture_id());
+    egl_image = eglCreateImageKHR(
+        egl_display_, EGL_NO_CONTEXT, EGL_NATIVE_PIXMAP_KHR,
+        (EGLClientBuffer)pixmap, kImageAttrs);
+    // We can free the X pixmap immediately -- according to the
+    // EGL_KHR_image_base spec, the backing storage does not go away until the
+    // last referencing EGLImage is destroyed.
+    XFreePixmap(x_display, pixmap);
+    if (egl_image == EGL_NO_IMAGE_KHR) {
+      DLOG(ERROR) << "AssignPictureBuffers(): could not create EGLImageKHR";
+      NOTIFY_ERROR(PLATFORM_FAILURE);
+      return;
+    }
+    egl_images_ref->egl_images[i] = egl_image;
+    ret = mali_egl_image_get_buffer_ext_phandle(
+        egl_images_ref->egl_images[i], NULL, &fd);
+    if (!ret) {
+      DLOG(ERROR) << "AssignPictureBuffers(): "
+                  << "could not get EGLImageKHR dmabuf fd";
+      NOTIFY_ERROR(PLATFORM_FAILURE);
+      return;
+    }
+    egl_images_ref->egl_image_fds[i] = fd;
+    glEGLImageTargetTexture2DOES(GL_TEXTURE_2D, egl_image);
+  }
+  decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
+      &ExynosVideoDecodeAccelerator::AssignPictureBuffersTask,
+      base::Unretained(this), base::Passed(&egl_images_ref)));
+}
+
+void ExynosVideoDecodeAccelerator::ReusePictureBuffer(int32 picture_buffer_id) {
+  DVLOG(3) << "ReusePictureBuffer(): picture_buffer_id=" << picture_buffer_id;
+  // Must be run on child thread, as we'll insert a sync in the EGL context.
+  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+
+  if (!make_context_current_.Run()) {
+    DLOG(ERROR) << "ReusePictureBuffer(): could not make context current";
+    NOTIFY_ERROR(PLATFORM_FAILURE);
+    return;
+  }
+
+  EGLSyncKHR egl_sync;
+  egl_sync = egl_create_sync_khr(egl_display_, EGL_SYNC_FENCE_KHR, NULL);
+  if (egl_sync == EGL_NO_SYNC_KHR) {
+    DLOG(ERROR) << "ReusePictureBuffer(): eglCreateSyncKHR() failed";
+    NOTIFY_ERROR(PLATFORM_FAILURE);
+    return;
+  }
+
+  scoped_ptr<EGLSyncKHRRef> egl_sync_ref(new EGLSyncKHRRef(
+      egl_display_, egl_sync));
+  decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
+      &ExynosVideoDecodeAccelerator::ReusePictureBufferTask,
+      base::Unretained(this), picture_buffer_id, base::Passed(&egl_sync_ref)));
+}
+
+void ExynosVideoDecodeAccelerator::Flush() {
+  DVLOG(3) << "Flush()";
+  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
+      &ExynosVideoDecodeAccelerator::FlushTask, base::Unretained(this)));
+}
+
+void ExynosVideoDecodeAccelerator::Reset() {
+  DVLOG(3) << "Reset()";
+  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
+      &ExynosVideoDecodeAccelerator::ResetTask, base::Unretained(this)));
+}
+
+void ExynosVideoDecodeAccelerator::Destroy() {
+  DVLOG(3) << "Destroy()";
+  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+
+  // We're destroying; cancel all callbacks.
+  client_ptr_factory_.InvalidateWeakPtrs();
+
+  // If the decoder thread is running, destroy using posted task.
+  if (decoder_thread_.message_loop_proxy()->PostTask(FROM_HERE, base::Bind(
+        &ExynosVideoDecodeAccelerator::DestroyTask, base::Unretained(this)))) {
+    // DestroyTask() will cause the decoder_thread_ to flush all tasks.
+    decoder_thread_.Stop();
+  } else {
+    // Otherwise, call the destroy task directly.
+    DestroyTask();

[Ami GONE FROM CHROMIUM, 2012/11/02 17:57:06]

My point is that all other FooTask methods are unconditionally run on the
decoder thread, but this is only best-effort that way.

+  }
+
+  // Nuke the entire site from orbit -- it's the only way to be sure.
+  if (gsc_fd_ != -1) {
+    DestroyGscInputBuffers();
+    DestroyGscOutputBuffers();
+    close(gsc_fd_);
+    gsc_fd_ = -1;
+  }
+  if (mfc_fd_ != -1) {
+    DestroyMfcInputBuffers();
+    DestroyMfcOutputBuffers();
+    close(mfc_fd_);
+    mfc_fd_ = -1;
+  }
+
+  // Decoder thread is stopped by now; safe to touch decoder_state_.
+  decoder_state_ = kError;

[Ami GONE FROM CHROMIUM, 2012/11/02 21:11:08]

where's the 
delete this;
?

[sheu, 2012/11/03 00:37:14]

Done.

+}
+
+// static
+void ExynosVideoDecodeAccelerator::PreSandboxInitialization() {
+  DVLOG(3) << "PreSandboxInitialization()";
+  errno = 0;
+  libmali_handle = dlopen(EXYNOS_MALI_DRIVER, RTLD_LAZY | RTLD_LOCAL);
+  if (libmali_handle == NULL) {
+    DPLOG(ERROR) << "failed to dlopen() " << EXYNOS_MALI_DRIVER;
+  }
+}
+
+// static
+bool ExynosVideoDecodeAccelerator::PostSandboxInitialization() {
+  DVLOG(3) << "PostSandboxInitialization()";
+  if (libmali_handle == NULL) {
+    DLOG(ERROR) << "PostSandboxInitialization(): no " << EXYNOS_MALI_DRIVER
+        " driver handle";
+    return false;
+  }
+
+  errno = 0;
+  mali_egl_image_get_buffer_ext_phandle =
+      reinterpret_cast<EGLBoolean(*)(EGLImageKHR, EGLint*, void*)>(
+          dlsym(libmali_handle, "mali_egl_image_get_buffer_ext_phandle"));
+  if (mali_egl_image_get_buffer_ext_phandle == NULL) {
+    DPLOG(ERROR) << "PostSandboxInitialization(): failed to dlsym()"
+        " mali_egl_image_get_buffer_ext_phandle";
+    return false;
+  }
+
+  errno = 0;
+  egl_create_sync_khr =
+      reinterpret_cast<EGLSyncKHR(*)(EGLDisplay, EGLenum, const EGLint*)>(
+          dlsym(libmali_handle, "eglCreateSyncKHR"));
+  if (egl_create_sync_khr == NULL) {
+    DPLOG(ERROR) << "PostSandboxInitialization(): failed to dlsym()"
+        " eglCreateSyncKHR";
+    return false;
+  }
+
+  errno = 0;
+  egl_destroy_sync_khr =
+      reinterpret_cast<EGLBoolean(*)(EGLDisplay, EGLSyncKHR)>(
+          dlsym(libmali_handle, "eglDestroySyncKHR"));
+  if (egl_destroy_sync_khr == NULL) {
+    DPLOG(ERROR) << "PostSandboxInitialization(): failed to dlsym()"
+        " eglDestroySyncKHR";
+    return false;
+  }
+
+  errno = 0;
+  egl_client_wait_sync_khr =
+      reinterpret_cast<EGLint(*)(EGLDisplay, EGLSyncKHR, EGLint, EGLTimeKHR)>(
+          dlsym(libmali_handle, "eglClientWaitSyncKHR"));
+  if (egl_client_wait_sync_khr == NULL) {
+    DPLOG(ERROR) << "PostSandboxInitialization(): failed to dlsym()"
+        " eglClientWaitSyncKHR";
+    return false;
+  }
+
+  return true;
+}
+
+void ExynosVideoDecodeAccelerator::DecodeTask(
+    scoped_ptr<BitstreamBufferRecord> bitstream_record) {
+  DVLOG(3) << "DecodeTask(): input_id=" << bitstream_record->input_id;
+  DCHECK_EQ(decoder_thread_.message_loop(), MessageLoop::current());
+  DCHECK_NE(decoder_state_, kUninitialized);
+
+  if (decoder_state_ == kResetting) {
+    DVLOG(2) << "DecodeTask(): early out: kResetting state";
+    return;
+  } else if (decoder_state_ == kError) {
+    DVLOG(2) << "DecodeTask(): early out: kError state";
+    return;
+  }
+
+  decoder_input_queue_.push_front(
+      linked_ptr<BitstreamBufferRecord>(bitstream_record.release()));
+  decoder_decode_buffer_tasks_scheduled_++;
+  DecodeBufferTask();
+}
+
+void ExynosVideoDecodeAccelerator::DecodeBufferTask() {
+  DVLOG(3) << "DecodeBufferTask()";
+  DCHECK_EQ(decoder_thread_.message_loop(), MessageLoop::current());
+  DCHECK_NE(decoder_state_, kUninitialized);
+
+  decoder_decode_buffer_tasks_scheduled_--;
+
+  if (decoder_state_ == kResetting) {
+    DVLOG(2) << "DecodeBufferTask(): early out: kResetting state";
+    return;
+  } else if (decoder_state_ == kError) {
+    DVLOG(2) << "DecodeBufferTask(): early out: kError state";
+    return;
+  }
+
+  if (decoder_current_bitstream_buffer_ == NULL) {
+    if (decoder_input_queue_.empty()) {
+      // We're waiting for a new buffer -- exit without scheduling a new task.
+      return;
+    }
+    // Setup to use the next buffer.
+    decoder_current_bitstream_buffer_.reset(
+        decoder_input_queue_.back().release());
+    decoder_input_queue_.pop_back();
+    DVLOG(3) << "DecodeBufferTask(): reading input_id="
+             << decoder_current_bitstream_buffer_->input_id
+             << ", addr=" << decoder_current_bitstream_buffer_->shm->memory()
+             << ", size=" << decoder_current_bitstream_buffer_->size;
+  }
+  bool decode_result = false;
+  const void* data = decoder_current_bitstream_buffer_->shm->memory();
+  size_t size = decoder_current_bitstream_buffer_->size;
+  switch (decoder_state_) {
+    case kInitialized:
+    case kAfterReset:
+      decode_result = DecodeBufferInitial(data, size);
+      break;
+    case kDecoding:
+      decode_result = DecodeBufferContinue(data, size);
+      break;
+    default:
+      decoder_state_ = kError;
+      NOTIFY_ERROR(ILLEGAL_STATE);
+      return;
+  }
+  if (decoder_state_ == kError) {
+    // Failed during decode.
+    return;
+  } else if (!decode_result) {
+    // We might not have failed decode completely, but returned false due to
+    // insufficient resources, etc.  Retry this this buffer later; exit without
+    // scheduling another task.
+    return;
+  }
+
+  // Our current bitstream buffer is done; return it.
+  int32 input_id = decoder_current_bitstream_buffer_->input_id;
+  DVLOG(3) << "DecodeBufferTask(): finished input_id=" << input_id;
+  decoder_current_bitstream_buffer_.reset(NULL);
+  child_message_loop_proxy_->PostTask(FROM_HERE, base::Bind(
+      &Client::NotifyEndOfBitstreamBuffer, client_, input_id));
+
+  // If we're behind on tasks, schedule another one.
+  if (decoder_decode_buffer_tasks_scheduled_ <
+      static_cast<int>(decoder_input_queue_.size())) {

[Ami GONE FROM CHROMIUM, 2012/11/02 17:57:06]

I wonder whether you'd be happier by turning a bunch of the state-tracking
members into appropriate types for the comparisons they end up in (probably
mostly size_t).

+    decoder_decode_buffer_tasks_scheduled_++;
+    decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
+        &ExynosVideoDecodeAccelerator::DecodeBufferTask,
+        base::Unretained(this)));
+  }
+}
+
+bool ExynosVideoDecodeAccelerator::DecodeBufferInitial(
+    const void* data, size_t size) {
+  DVLOG(3) << "DecodeBufferInitial(): data=" << data << ", size=" << size;
+  DCHECK_EQ(decoder_thread_.message_loop(), MessageLoop::current());
+  DCHECK_NE(decoder_state_, kUninitialized);
+  DCHECK_NE(decoder_state_, kDecoding);
+  DCHECK(!device_poll_thread_.IsRunning());
+  // Initial decode.  We haven't been able to get output stream format info yet.
+  // Get it, and start decoding.
+
+  // Copy in and send to HW.
+  if (!AppendToInputFrame(data, size) || !FlushInputFrame())
+    return false;
+
+  // Recycle buffers.
+  DequeueMfc();
+
+  // Check and see if we have format info yet.
+  int ret;

[Ami GONE FROM CHROMIUM, 2012/11/02 17:57:06]

decl at first assignment at l.689 below.

[sheu, 2012/11/03 00:37:14]

Done.

+  struct v4l2_format format;
+  format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+  errno = 0;
+  ret = ioctl(mfc_fd_, VIDIOC_G_FMT, &format);
+  if (ret != 0) {
+    if (errno == EINVAL) {
+      // We will get EINVAL if we haven't seen sufficient stream to decode the
+      // format.  Return true and go to the next buffer.
+      return true;
+    } else {
+      DPLOG(ERROR) << "DecodeBufferInitial(): ioctl() failed: VIDIOC_G_FMT";
+      decoder_state_ = kError;
+      NOTIFY_ERROR(PLATFORM_FAILURE);
+      return false;
+    }
+  }
+
+  // Run this initialization only on first startup.
+  if (decoder_state_ == kInitialized) {
+    DVLOG(3) << "DecodeBufferInitial(): running one-time initialization";
+    // Success! Setup our parameters.
+    DCHECK_EQ(format.fmt.pix_mp.num_planes, 2);
+    // We don't handle midstream resizes right now.
+    if (!frame_buffer_size_.IsEmpty()) {
+      if (frame_buffer_size_.width() !=
+          static_cast<int>(format.fmt.pix_mp.width) ||

[Ami GONE FROM CHROMIUM, 2012/11/02 17:57:06]

The Chromium Way is to strongly prefer more-readable code.
I doubt "creating the object" will actually translate into less efficient object
code once -O2 is done with it.

[sheu, 2012/11/03 00:37:14]

Done.

+          frame_buffer_size_.height() !=
+          static_cast<int>(format.fmt.pix_mp.height)) {
+        // We don't handle mistream resizes right now.
+        NOTIMPLEMENTED();
+        decoder_state_ = kError;
+        NOTIFY_ERROR(UNREADABLE_INPUT);
+        return false;
+      }
+    }
+    frame_buffer_size_.SetSize(
+        format.fmt.pix_mp.width, format.fmt.pix_mp.height);
+    mfc_output_buffer_size_[0] = format.fmt.pix_mp.plane_fmt[0].sizeimage;
+    mfc_output_buffer_size_[1] = format.fmt.pix_mp.plane_fmt[1].sizeimage;
+    mfc_output_buffer_pixelformat_ = format.fmt.pix_mp.pixelformat;
+
+    // Create our other buffers.
+    if (!CreateMfcOutputBuffers() || !CreateGscInputBuffers() ||
+        !CreateGscOutputBuffers()) {
+      decoder_state_ = kError;
+      NOTIFY_ERROR(PLATFORM_FAILURE);
+      return false;
+    }
+  }
+
+  // StartDevicePoll will raise the error if there is one.
+  if (!StartDevicePoll()) {
+    return false;
+  }
+
+  decoder_state_ = kDecoding;
+
+  // This buffer contained the header that kicks off decoding of the video
+  // stream.  Return false here so it gets recycled into the next
+  // DecodeBufferContinue() and the start of actual output stream.
+  return false;
+}
+
+bool ExynosVideoDecodeAccelerator::DecodeBufferContinue(
+    const void* data, size_t size) {
+  DVLOG(3) << "DecodeBufferContinue(): data=" << data << ", size=" << size;
+  DCHECK_EQ(decoder_thread_.message_loop(), MessageLoop::current());
+  DCHECK_EQ(decoder_state_, kDecoding);
+
+  // We've already setup our output stream parameters, so just keep on truckin'.
+  return (AppendToInputFrame(data, size) && FlushInputFrame());
+}
+
+bool ExynosVideoDecodeAccelerator::AppendToInputFrame(
+    const void* data, size_t size) {
+  DVLOG(3) << "AppendToInputFrame()";
+  DCHECK_EQ(decoder_thread_.message_loop(), MessageLoop::current());
+  // We should have started streaming when we created MFC input buffers.
+  DCHECK(mfc_input_streamon_);
+  DCHECK(decoder_state_ == kInitialized || decoder_state_ == kDecoding);
+
+  // Flush if we're too big
+  if (decoder_current_input_buffer_ != -1) {
+    MfcInputRecord& input_record =
+        mfc_input_buffer_map_[decoder_current_input_buffer_];
+    if (input_record.bytes_used + size > input_record.length) {
+      if (!FlushInputFrame())
+        return false;
+      decoder_current_input_buffer_ = -1;
+    }
+  }
+
+  // Try to get an available input buffer
+  if (decoder_current_input_buffer_ == -1) {
+    if (mfc_free_input_buffers_.empty()) {
+      // See if we can get more free buffers from HW
+      DequeueMfc();
+      if (mfc_free_input_buffers_.empty()) {
+        // Nope!
+        DVLOG(2) << "AppendToInputFrame(): stalled for input buffers";
+        return false;
+      }
+    }
+    decoder_current_input_buffer_ = mfc_free_input_buffers_.back();
+    mfc_free_input_buffers_.pop_back();
+    MfcInputRecord& input_record =
+        mfc_input_buffer_map_[decoder_current_input_buffer_];
+    DCHECK_EQ(input_record.bytes_used, 0);
+    DCHECK_EQ(input_record.input_id, -1);
+    DCHECK(decoder_current_bitstream_buffer_ != NULL);
+    input_record.input_id = decoder_current_bitstream_buffer_->input_id;
+  }
+
+  // Copy in to the buffer.
+  MfcInputRecord& input_record =
+      mfc_input_buffer_map_[decoder_current_input_buffer_];
+  if (size > input_record.length - input_record.bytes_used) {
+    LOG(ERROR) << "AppendToInputFrame(): over-size frame, erroring";
+    NOTIFY_ERROR(UNREADABLE_INPUT);
+    return false;
+  }
+  memcpy((char*)input_record.offset + input_record.bytes_used, data, size);
+  input_record.bytes_used += size;
+
+  return true;
+}
+
+bool ExynosVideoDecodeAccelerator::FlushInputFrame() {
+  DVLOG(3) << "FlushInputFrame()";
+  DCHECK_EQ(decoder_thread_.message_loop(), MessageLoop::current());
+  DCHECK(decoder_state_ == kInitialized || decoder_state_ == kDecoding);
+  if (decoder_current_input_buffer_ == -1)
+    return true;
+
+  MfcInputRecord& input_record =
+      mfc_input_buffer_map_[decoder_current_input_buffer_];
+  if (input_record.bytes_used == 0)
+    return true;
+
+  // Queue it to MFC.
+  mfc_input_ready_queue_.push_back(decoder_current_input_buffer_);
+  decoder_frames_inflight_++;
+  decoder_current_input_buffer_ = -1;
+  DVLOG(3) << "FlushInputFrame(): submitting input_id="
+           << input_record.input_id;
+  // Kick the MFC once since there's new available input for it.
+  EnqueueMfc();
+
+  return (decoder_state_ != kError);
+}
+
+void ExynosVideoDecodeAccelerator::AssignPictureBuffersTask(
+    scoped_ptr<EGLImageKHRArrayRef> egl_images_ref) {
+  DVLOG(3) << "AssignPictureBuffersTask()";
+  DCHECK_EQ(decoder_thread_.message_loop(), MessageLoop::current());
+  DCHECK_NE(decoder_state_, kUninitialized);
+
+  // We run AssignPictureBuffersTask even if we're in kResetting.
+  if (decoder_state_ == kError) {
+    DVLOG(2) << "AssignPictureBuffersTask(): early out: kError state";
+    return;
+  }
+
+  DCHECK_EQ(egl_images_ref->egl_images_count,
+      static_cast<int>(gsc_output_buffer_map_.size()));
+  for (size_t i = 0; i < gsc_output_buffer_map_.size(); i++) {
+    // We should be blank right now.
+    GscOutputRecord& output_record = gsc_output_buffer_map_[i];
+    DCHECK_EQ(output_record.fd, -1);
+    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);
+    output_record.fd = egl_images_ref->egl_image_fds[i];
+    output_record.egl_image = egl_images_ref->egl_images[i];
+    output_record.picture_id = i;
+
+    // Take ownership of the EGLImage and fd.
+    egl_images_ref->egl_images[i] = EGL_NO_IMAGE_KHR;
+    egl_images_ref->egl_image_fds[i] = -1;
+    // And add this buffer to the free list.
+    gsc_free_output_buffers_.push_front(i);
+  }
+
+  // StartDevicePoll will raise the error if there is one.
+  StartDevicePoll();
+}
+
+void ExynosVideoDecodeAccelerator::ServiceDeviceTask() {
+  DVLOG(3) << "ServiceDeviceTask()";
+  DCHECK_EQ(decoder_thread_.message_loop(), MessageLoop::current());
+  DCHECK_NE(decoder_state_, kUninitialized);
+  DCHECK_NE(decoder_state_, kInitialized);
+  DCHECK_NE(decoder_state_, kAfterReset);
+
+  if (decoder_state_ == kResetting) {
+    DVLOG(2) << "ServiceDeviceTask(): early out: kResetting state";
+    return;
+  } else if (decoder_state_ == kError) {
+    DVLOG(2) << "ServiceDeviceTask(): early out: kError state";
+    return;
+  }
+
+  DequeueMfc();
+  DequeueGsc();
+  EnqueueMfc();
+  EnqueueGsc();
+
+  DVLOG(1) << "ServiceDeviceTask(): buffer counts: DEC["
+           << decoder_input_queue_.size() << "->"
+           << mfc_input_ready_queue_.size() << "] => MFC["
+           << mfc_free_input_buffers_.size() << "/"
+           << mfc_input_buffer_count_ << "->"
+           << mfc_free_output_buffers_.size() << "/"
+           << mfc_output_buffer_count_ << "] => "
+           << mfc_output_gsc_input_queue_.size() << " => GSC["
+           << gsc_free_input_buffers_.size() << "/"
+           << gsc_input_buffer_count_ << "->"
+           << gsc_free_output_buffers_.size() << "/"
+           << gsc_output_buffer_count_ << "] => VDA["
+           << decoder_frames_at_client_ << "]";
+}
+
+void ExynosVideoDecodeAccelerator::EnqueueMfc() {
+  DVLOG(3) << "EnqueueMfc()";
+  DCHECK_EQ(decoder_thread_.message_loop(), MessageLoop::current());
+  DCHECK_NE(decoder_state_, kUninitialized);
+
+  // Drain the pipe of completed decode buffers.
+  int ret;
+  struct v4l2_buffer qbuf;
+  struct v4l2_plane qbuf_planes[2];
+  while (!mfc_input_ready_queue_.empty()) {
+    // Enqueue the MFC input (VIDEO_OUTPUT) buffer.
+    int buffer = mfc_input_ready_queue_.back();
+    MfcInputRecord& input_record = mfc_input_buffer_map_[buffer];
+    DCHECK(!input_record.at_device);
+    memset(&qbuf, 0, sizeof(qbuf));
+    memset(qbuf_planes, 0, sizeof(qbuf_planes));
+    qbuf.index                 = buffer;
+    qbuf.type                  = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
+    qbuf.timestamp.tv_sec      = input_record.input_id;
+    qbuf.memory                = V4L2_MEMORY_MMAP;
+    qbuf.m.planes              = qbuf_planes;
+    qbuf.m.planes[0].bytesused = input_record.bytes_used;
+    qbuf.length                = 1;
+    errno = 0;
+    ret = ioctl(mfc_fd_, VIDIOC_QBUF, &qbuf);
+    if (ret != 0) {
+      DPLOG(ERROR) << "EnqueueMfc(): ioctl() failed: VIDIOC_QBUF";
+      decoder_state_ = kError;
+      NOTIFY_ERROR(PLATFORM_FAILURE);
+      return;
+    }
+    input_record.at_device = true;
+    mfc_input_ready_queue_.pop_back();
+    mfc_input_buffer_queued_count_++;
+    DVLOG(3) << "EnqueueMfc(): enqueued input_id=" << input_record.input_id;
+    if (!mfc_input_streamon_) {
+      __u32 type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
+      errno = 0;
+      ret = ioctl(mfc_fd_, VIDIOC_STREAMON, &type);
+      if (ret != 0) {
+        DPLOG(ERROR) << "EnqueueMfc(): ioctl() failed: VIDIOC_STREAMON";
+        decoder_state_ = kError;
+        NOTIFY_ERROR(PLATFORM_FAILURE);
+        return;
+      }
+      mfc_input_streamon_ = true;
+    }
+  }
+
+  // Enqueue all the MFC output (VIDEO_CAPTURE) buffers we can.
+  while (!mfc_free_output_buffers_.empty()) {
+    int buffer = mfc_free_output_buffers_.back();
+    MfcOutputRecord& output_record = mfc_output_buffer_map_[buffer];
+    DCHECK(!output_record.at_device);
+    DCHECK_EQ(output_record.input_id, -1);
+    memset(&qbuf, 0, sizeof(qbuf));
+    memset(qbuf_planes, 0, sizeof(qbuf_planes));
+    qbuf.index    = buffer;
+    qbuf.type     = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+    qbuf.memory   = V4L2_MEMORY_MMAP;
+    qbuf.m.planes = qbuf_planes;
+    qbuf.length   = 2;
+    errno = 0;
+    ret = ioctl(mfc_fd_, VIDIOC_QBUF, &qbuf);
+    if (ret != 0) {
+      DPLOG(ERROR) << "EnqueueMfc(): ioctl() failed: VIDIOC_QBUF";
+      decoder_state_ = kError;
+      NOTIFY_ERROR(PLATFORM_FAILURE);
+      return;
+    }
+    output_record.at_device = true;
+    mfc_free_output_buffers_.pop_back();
+    if (!mfc_output_streamon_) {
+      __u32 type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+      errno = 0;
+      ret = ioctl(mfc_fd_, VIDIOC_STREAMON, &type);
+      if (ret != 0) {
+        DPLOG(ERROR) << "EnqueueMfc(): ioctl() failed: VIDIOC_STREAMON";
+        decoder_state_ = kError;
+        NOTIFY_ERROR(PLATFORM_FAILURE);
+        return;
+      }
+      mfc_output_streamon_ = true;
+    }
+  }
+}
+
+void ExynosVideoDecodeAccelerator::DequeueMfc() {
+  DVLOG(3) << "DequeueMfc()";
+  DCHECK_EQ(decoder_thread_.message_loop(), MessageLoop::current());
+  DCHECK_NE(decoder_state_, kUninitialized);
+  DCHECK_NE(decoder_state_, kInitialized);
+
+  // Dequeue completed MFC input (VIDEO_OUTPUT) buffers, and recycle to the free
+  // list.  Note that if we ever run completely dry of input buffers on the MFC
+  // device, epoll() will return EPOLLERR and our DevicePollLoop() will exit

[Ami GONE FROM CHROMIUM, 2012/11/02 17:57:06]

It seems kinda crazy to have this affordance here.
Is it stupid to suggest that DevicePollLoop() should instead be aware of this
condition and re-enter the epoll?
If you're worried about burning CPU going into no-op epoll's repeatedly, my
suggestion is to use a condvar/notification/waitableevent.  I guess you might be
averse to that as an explicit piece of synchronization in a class that is
otherwise beautifully sync-free, but do you really think this bunch of code is a
better answer?

Does this prevent receiving the last picture fed to Decode() when decode is
paused (i.e. the client sends a bunch of buffers, but doesn't request Flush or
Reset, it just wants to receive pictures)?

[sheu, 2012/11/03 00:37:14]

If DevicePollLoop() wants to be aware of this, it's going to have to touch
decoder state, and we're going to have to do some locking.

I'm not sure how you would intend for the DevicePollLoop to wait on an event,
when it's already epoll()-ing on an FD.

I know this seems strange, but this doesn't affect the last picture returned to
client, since this buffer retention is on the OUTPUT queue (the decoder input
queue), and the CAPTURE queue (the decoder output queue) is fully drained as far
as it will go.

[Ami GONE FROM CHROMIUM, 2012/11/06 19:50:10]

An example of what I meant is: have a mutex dedicated to buffer deque.  
Acquire the mutex here for the duration of the draining, and release/acquire the
same mutex in the device thread around the epoll; that way the code handling
EPOLLERR can know whether it was triggered by the last buffer being yanked away
from the epoll.

[sheu, 2012/11/08 21:16:30]

Right, that would let us know if our EINVAL was due to streamoff or queue empty.
 That doesn't solve the problem though of having the device poll thread spin on
the epoll in the case of an empty buffer.

+  // early.  Work around this by never _completely_ draining the MFC input
+  // queue.  Note

[sheu, 2012/11/01 03:30:00]

Not uploaded yet, but fixed

+  struct v4l2_buffer dqbuf;
+  struct v4l2_plane planes[2];
+  DCHECK_EQ((decoder_current_input_buffer_ != -1 ? 1 : 0) +
+      static_cast<int>(mfc_input_ready_queue_.size()) +
+      static_cast<int>(mfc_free_input_buffers_.size()) +
+      mfc_input_buffer_queued_count_, mfc_input_buffer_count_);
+  while (mfc_input_buffer_queued_count_ > 1) {
+    int ret;

[Ami GONE FROM CHROMIUM, 2012/11/02 17:57:06]

decl at first use (I'm going to stop saying that now; please make a pass)

[sheu, 2012/11/03 00:37:14]

Done.

+    memset(&dqbuf, 0, sizeof(dqbuf));
+    dqbuf.type   = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
+    dqbuf.memory = V4L2_MEMORY_MMAP;
+    errno = 0;
+    ret = ioctl(mfc_fd_, VIDIOC_DQBUF, &dqbuf);
+    if (ret != 0) {
+      if (errno == EAGAIN) {
+        // Done all that we could.
+        break;
+      } else if (errno == EINVAL) {
+        // We're not streaming this queue; skip.
+        DVLOG(2) << "DequeueMfc(): VIDEO_OUTPUT not streaming, skipping";
+        break;
+      } else {
+        DPLOG(ERROR) << "DequeueMfc(): ioctl() failed: VIDIOC_DQBUF";
+        decoder_state_ = kError;
+        NOTIFY_ERROR(PLATFORM_FAILURE);
+        return;
+      }
+    }
+    MfcInputRecord& input_record = mfc_input_buffer_map_[dqbuf.index];
+    DCHECK(input_record.at_device);
+    input_record.at_device = false;
+    input_record.bytes_used = 0;
+    input_record.input_id = -1;
+    mfc_free_input_buffers_.push_back(dqbuf.index);
+    mfc_input_buffer_queued_count_--;
+  }
+
+  // Dequeue completed MFC output (VIDEO_CAPTURE) buffers, and queue to the
+  // completed queue.
+  memset(&dqbuf, 0, sizeof(dqbuf));
+  memset(planes, 0, sizeof(planes));
+  dqbuf.type   = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+  dqbuf.memory = V4L2_MEMORY_MMAP;
+  dqbuf.m.planes = planes;
+  dqbuf.length = 2;
+  errno = 0;
+  while (ioctl(mfc_fd_, VIDIOC_DQBUF, &dqbuf) == 0) {
+    MfcOutputRecord& output_record = mfc_output_buffer_map_[dqbuf.index];
+    DCHECK(output_record.at_device);
+    output_record.at_device = false;
+    output_record.input_id = dqbuf.timestamp.tv_sec;
+    output_record.bytes_used[0] = dqbuf.m.planes[0].bytesused;
+    output_record.bytes_used[1] = dqbuf.m.planes[1].bytesused;
+    DVLOG(3) << "DequeueMfc(): dequeued input_id=" << dqbuf.timestamp.tv_sec;
+    mfc_output_gsc_input_queue_.push_front(dqbuf.index);
+    memset(&dqbuf, 0, sizeof(dqbuf));
+    memset(planes, 0, sizeof(planes));
+    dqbuf.type   = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+    dqbuf.memory = V4L2_MEMORY_MMAP;
+    dqbuf.m.planes = planes;
+    dqbuf.length = 2;
+    errno = 0;
+  }
+  if (errno == EINVAL) {
+    // We're not streaming this queue; skip.

[Ami GONE FROM CHROMIUM, 2012/11/02 17:57:06]

does this happen only during startup/shutdown, and only during the first call to
ioctl (not subsequent loop iterations)?

[sheu, 2012/11/03 00:37:14]

Again, the OUTPUT and CAPTURE queues for each device are independent, so I want
to be able to run one without the other.

From the logical flow of the code, I don't think this particular case can
happen, but it's not really an error if it does.

+    DVLOG(2) << "DequeueMfc(): VIDEO_CAPTURE not streaming, skipping";
+  } else if (errno != EAGAIN) {
+    DPLOG(ERROR) << "DequeueMfc(): ioctl() failed: VIDIOC_DQBUF";
+    decoder_state_ = kError;
+    NOTIFY_ERROR(PLATFORM_FAILURE);
+    return;
+  }
+}
+
+void ExynosVideoDecodeAccelerator::EnqueueGsc() {
+  DVLOG(3) << "EnqueueGsc()";
+  DCHECK_EQ(decoder_thread_.message_loop(), MessageLoop::current());
+  DCHECK_NE(decoder_state_, kUninitialized);
+  DCHECK_NE(decoder_state_, kInitialized);
+  DCHECK_NE(decoder_state_, kAfterReset);
+
+  // Drain the pipe of completed MFC output buffers.
+  int ret;
+  struct v4l2_buffer qbuf;
+  struct v4l2_plane qbuf_planes[2];
+  DCHECK(gsc_output_streamon_);
+  while (!mfc_output_gsc_input_queue_.empty()) {
+    if (gsc_free_input_buffers_.empty())
+      break;

[Ami GONE FROM CHROMIUM, 2012/11/02 21:11:08]

return (it's a long way down to the closing braces of the broken while, and then
nothing else happens)

[sheu, 2012/11/03 00:37:14]

It is a long way down, but this isn't like error-out-return, it's more like
we're-done-here-break, and we just happen not to do anything afterwards.  I
don't think returning explicitly quite documents that, and it would have to be
changed if we were to want to add more work at the bottom of this function.

[Ami GONE FROM CHROMIUM, 2012/11/06 19:50:10]

The flip side is code added at the bottom of this function (far away from here)
will be run by paths through these breaks.
I think this is a mistake but will not force the issue.

+    // Bug workaround: GSC is liable to race conditions if more than one
+    // buffer is simultaneously queued.
+    if (gsc_output_buffer_queued_count_ > 0)
+      break;

[Ami GONE FROM CHROMIUM, 2012/11/02 21:11:08]

ditto return

+    if (gsc_output_buffer_prepared_count_ == 0) {
+      // Enqueue a GSC output (VIDEO_CAPTURE) buffer for the incoming GSC input
+      // buffer.
+      if (gsc_free_output_buffers_.empty())
+        break;

[Ami GONE FROM CHROMIUM, 2012/11/02 21:11:08]

ditto

+      int buffer = gsc_free_output_buffers_.back();
+      GscOutputRecord& output_record = gsc_output_buffer_map_[buffer];
+      DCHECK(!output_record.at_device);
+      DCHECK(!output_record.at_client);
+      if (output_record.egl_sync != EGL_NO_SYNC_KHR) {
+        // If we have to wait for completion, wait.  Note that
+        // gsc_free_output_buffers_ is a FIFO queue.
+        egl_client_wait_sync_khr(egl_display_, output_record.egl_sync, 0,
+            EGL_FOREVER_KHR);
+        egl_destroy_sync_khr(egl_display_, output_record.egl_sync);
+        output_record.egl_sync = EGL_NO_SYNC_KHR;
+      }
+      memset(&qbuf, 0, sizeof(qbuf));
+      memset(qbuf_planes, 0, sizeof(qbuf_planes));
+      qbuf.index            = buffer;
+      qbuf.type             = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+      qbuf.memory           = V4L2_MEMORY_DMABUF;
+      qbuf.m.planes         = qbuf_planes;
+      qbuf.m.planes[0].m.fd = output_record.fd;
+      qbuf.length           = 1;
+      errno = 0;
+      ret = ioctl(gsc_fd_, VIDIOC_QBUF, &qbuf);
+      if (ret != 0) {
+        DPLOG(ERROR) << "EnqueueGsc(): ioctl() failed: VIDIOC_QBUF";
+        decoder_state_ = kError;
+        NOTIFY_ERROR(PLATFORM_FAILURE);
+        return;
+      }
+      output_record.at_device = true;
+      gsc_free_output_buffers_.pop_back();
+      gsc_output_buffer_prepared_count_++;
+    }
+    // Now enqueue the GSC input (VIDEO_OUTPUT) buffer for the complete MFC
+    // output buffer.  We defer requeuing the MFC output buffer to its free
+    // list, as the GSC input will be using its data.
+    int mfc_buffer, gsc_buffer;
+    mfc_buffer = mfc_output_gsc_input_queue_.back();
+    gsc_buffer = gsc_free_input_buffers_.back();
+    MfcOutputRecord& output_record = mfc_output_buffer_map_[mfc_buffer];
+    DCHECK(!output_record.at_device);
+    GscInputRecord& input_record = gsc_input_buffer_map_[gsc_buffer];
+    DCHECK(!input_record.at_device);
+    DCHECK_EQ(input_record.mfc_output, -1);
+    memset(&qbuf, 0, sizeof(qbuf));
+    memset(qbuf_planes, 0, sizeof(qbuf_planes));
+    qbuf.index                 = gsc_buffer;
+    qbuf.type                  = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
+    qbuf.timestamp.tv_sec      = output_record.input_id;
+    qbuf.memory                = V4L2_MEMORY_USERPTR;
+    qbuf.m.planes              = qbuf_planes;
+    qbuf.m.planes[0].bytesused = output_record.bytes_used[0];
+    qbuf.m.planes[0].length    = mfc_output_buffer_size_[0];
+    qbuf.m.planes[0].m.userptr = (unsigned long)output_record.offset[0];
+    qbuf.m.planes[1].bytesused = output_record.bytes_used[1];
+    qbuf.m.planes[1].length    = mfc_output_buffer_size_[1];
+    qbuf.m.planes[1].m.userptr = (unsigned long)output_record.offset[1];
+    qbuf.length                = 2;
+    errno = 0;
+    ret = ioctl(gsc_fd_, VIDIOC_QBUF, &qbuf);
+    if (ret != 0) {
+      DPLOG(ERROR) << "EnqueueGsc(): ioctl() failed: VIDIOC_QBUF";
+      decoder_state_ = kError;
+      NOTIFY_ERROR(PLATFORM_FAILURE);
+      return;
+    }
+    input_record.at_device = true;
+    input_record.mfc_output = mfc_buffer;
+    output_record.bytes_used[0] = 0;
+    output_record.bytes_used[1] = 0;
+    mfc_output_gsc_input_queue_.pop_back();
+    gsc_free_input_buffers_.pop_back();
+    gsc_output_buffer_prepared_count_--;
+    gsc_output_buffer_queued_count_++;
+    DVLOG(3) << "EnqueueGsc(): enqueued input_id=" << output_record.input_id;
+    if (!gsc_input_streamon_) {
+      __u32 type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
+      errno = 0;
+      ret = ioctl(gsc_fd_, VIDIOC_STREAMON, &type);
+      if (ret != 0) {
+        DPLOG(ERROR) << "EnqueueGsc(): ioctl() failed: VIDIOC_STREAMON";
+        decoder_state_ = kError;
+        NOTIFY_ERROR(PLATFORM_FAILURE);
+        return;
+      }
+      gsc_input_streamon_ = true;
+    }
+  }
+}
+
+void ExynosVideoDecodeAccelerator::DequeueGsc() {
+  DVLOG(3) << "DequeueGsc()";
+  DCHECK_EQ(decoder_thread_.message_loop(), MessageLoop::current());
+  DCHECK_NE(decoder_state_, kUninitialized);
+  DCHECK_NE(decoder_state_, kInitialized);
+  DCHECK_NE(decoder_state_, kAfterReset);
+
+  // Dequeue completed GSC input (VIDEO_OUTPUT) buffers, and recycle to the free
+  // list.  Also recycle the corresponding MFC output buffers at this time.
+  // Note that if we ever run completely dry of input buffers on the GSC device,
+  // epoll() will return EPOLLERR and our DevicePollLoop() will exit early.
+  // Work around this by never _completely_ draining the GSC input queue.

[Ami GONE FROM CHROMIUM, 2012/11/02 21:11:08]

ditto point about synchronization vs. holding an extra buffer in the device

[sheu, 2012/11/03 00:37:14]

See above

+  struct v4l2_buffer dqbuf;
+  while (gsc_input_buffer_count_ >
+      static_cast<int>(gsc_free_input_buffers_.size()) + 1) {
+    int ret;
+    memset(&dqbuf, 0, sizeof(dqbuf));
+    dqbuf.type   = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
+    dqbuf.memory = V4L2_MEMORY_DMABUF;
+    errno = 0;
+    ret = ioctl(gsc_fd_, VIDIOC_DQBUF, &dqbuf);
+    if (ret != 0) {
+      if (errno == EAGAIN) {
+        // Done all that we could.
+        break;
+      } else if (errno == EINVAL) {
+        // We're not streaming this queue; skip.
+        DVLOG(2) << "DequeueGsc(): VIDEO_OUTPUT not streaming, skipping";
+        break;
+      } else {
+        DPLOG(ERROR) << "DequeueGsc(): ioctl() failed: VIDIOC_DQBUF";
+        decoder_state_ = kError;
+        NOTIFY_ERROR(PLATFORM_FAILURE);
+        return;
+      }
+    }
+    GscInputRecord& input_record = gsc_input_buffer_map_[dqbuf.index];
+    DCHECK(input_record.at_device);
+    input_record.at_device = false;
+    mfc_output_buffer_map_[input_record.mfc_output].input_id = -1;
+    mfc_free_output_buffers_.push_back(input_record.mfc_output);
+    input_record.mfc_output = -1;
+    gsc_free_input_buffers_.push_back(dqbuf.index);
+  }
+
+  // Dequeue completed GSC output (VIDEO_CAPTURE) buffers, and send them off to
+  // the VDA.  Don't recycle to its free list yet -- we can't do that until

[Ami GONE FROM CHROMIUM, 2012/11/02 21:11:08]

s/VDA/VDA::Client/

[sheu, 2012/11/03 00:37:14]

Done.

+  // ReusePictureBuffer() returns it to us.
+  memset(&dqbuf, 0, sizeof(dqbuf));
+  dqbuf.type   = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+  dqbuf.memory = V4L2_MEMORY_DMABUF;
+  errno = 0;
+  while (ioctl(gsc_fd_, VIDIOC_DQBUF, &dqbuf) == 0) {
+    GscOutputRecord& output_record = gsc_output_buffer_map_[dqbuf.index];
+    DCHECK(output_record.at_device);
+    DCHECK(!output_record.at_client);
+    DCHECK_EQ(output_record.egl_sync, EGL_NO_SYNC_KHR);
+    output_record.at_device = false;
+    output_record.at_client = true;
+    gsc_output_buffer_queued_count_--;
+    child_message_loop_proxy_->PostTask(FROM_HERE, base::Bind(
+        &Client::PictureReady, client_, media::Picture(
+            output_record.picture_id, dqbuf.timestamp.tv_sec)));
+    decoder_frames_inflight_--;
+    decoder_frames_at_client_++;
+    DVLOG(1) << "DequeueGsc(): dequeued input_id=" << dqbuf.timestamp.tv_sec
+             << " as picture_id=" << output_record.picture_id;
+    if (decoder_frames_inflight_ == 0 && decoder_flush_notify_requested_) {
+      // We were asked for a flush notification, so let's do it.
+      child_message_loop_proxy_->PostTask(FROM_HERE, base::Bind(
+          &Client::NotifyFlushDone, client_));
+    }
+    memset(&dqbuf, 0, sizeof(dqbuf));
+    dqbuf.type   = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+    dqbuf.memory = V4L2_MEMORY_DMABUF;
+    errno = 0;
+  }
+  if (errno == EINVAL) {
+    // We're not streaming this queue; skip.
+    DVLOG(2) << "DequeueGsc(): VIDEO_CAPTURE not streaming, skipping";
+  } else if (errno != EAGAIN) {
+    DPLOG(ERROR) << "DequeueGsc(): ioctl() failed: VIDIOC_DQBUF";
+    decoder_state_ = kError;
+    NOTIFY_ERROR(PLATFORM_FAILURE);
+    return;
+  }
+}
+
+void ExynosVideoDecodeAccelerator::ReusePictureBufferTask(
+    int32 picture_buffer_id, scoped_ptr<EGLSyncKHRRef> egl_sync_ref) {
+  DVLOG(3) << "ReusePictureBufferTask(): picture_buffer_id="
+           << picture_buffer_id;
+  DCHECK_EQ(decoder_thread_.message_loop(), MessageLoop::current());
+
+  // We run ReusePictureBufferTask even if we're in kResetting.
+  if (decoder_state_ == kError) {
+    DVLOG(2) << "ReusePictureBufferTask(): early out: kError state";
+    return;
+  }
+
+  size_t index;
+  for (index = 0; index < gsc_output_buffer_map_.size(); index++)
+    if (gsc_output_buffer_map_[index].picture_id == picture_buffer_id)
+      break;
+
+  if (index >= gsc_output_buffer_map_.size()) {
+    DLOG(ERROR) << "ReusePictureBufferTask(): picture_buffer_id not found";
+    decoder_state_ = kError;
+    NOTIFY_ERROR(INVALID_ARGUMENT);
+    return;
+  }
+
+  GscOutputRecord& output_record = gsc_output_buffer_map_[index];
+  DCHECK(!output_record.at_device);
+  DCHECK(output_record.at_client);
+  output_record.at_client = false;
+  output_record.egl_sync = egl_sync_ref->egl_sync;
+  gsc_free_output_buffers_.push_front(index);
+  decoder_frames_at_client_--;
+  // Take ownership of the EGLSync.
+  egl_sync_ref->egl_sync = EGL_NO_SYNC_KHR;
+  // We got a buffer back, so kick the GSC.
+  EnqueueGsc();
+}
+
+void ExynosVideoDecodeAccelerator::FlushTask() {
+  DVLOG(3) << "FlushTask()";
+  // Flush the currently-building frame.
+  FlushInputFrame();
+
+  if (decoder_frames_inflight_ == 0) {
+    // If we don't have anything actually queued, we can notify immediatey.
+    child_message_loop_proxy_->PostTask(FROM_HERE, base::Bind(
+        &Client::NotifyFlushDone, client_));
+  } else {
+    // We'll flag that we want a flush-finished notification, and just return.
+    decoder_flush_notify_requested_ = true;
+  }
+}
+
+void ExynosVideoDecodeAccelerator::ResetTask() {
+  DVLOG(3) << "ResetTask()";
+  DCHECK_EQ(decoder_thread_.message_loop(), MessageLoop::current());
+  // We stop streaming, but we _don't_ destroy our buffers.
+  if (!StopDevicePoll())
+    return;
+
+  if (decoder_current_bitstream_buffer_ != NULL) {
+    int input_id;
+    input_id = decoder_current_bitstream_buffer_->input_id;
+    decoder_current_bitstream_buffer_.reset(NULL);
+    child_message_loop_proxy_->PostTask(FROM_HERE, base::Bind(
+        &Client::NotifyEndOfBitstreamBuffer, client_, input_id));
+  }
+  while (!decoder_input_queue_.empty()) {
+    int input_id;
+    scoped_ptr<BitstreamBufferRecord>
+        bitstream_record(decoder_input_queue_.back().release());
+    decoder_input_queue_.pop_back();
+    input_id = bitstream_record->input_id;
+    child_message_loop_proxy_->PostTask(FROM_HERE, base::Bind(
+        &Client::NotifyEndOfBitstreamBuffer, client_, input_id));
+  }
+
+  decoder_current_input_buffer_ = -1;
+  decoder_decode_buffer_tasks_scheduled_ = 0;
+  decoder_frames_inflight_ = 0;
+  decoder_flush_notify_requested_ = false;
+
+  // Mark that we're resetting, then enqueue a ResetDoneTask().  All intervening
+  // jobs will early-out in the kResetting state.

[Ami GONE FROM CHROMIUM, 2012/11/02 21:11:08]

Do you want to make a pass and verify this?  Many FooTask() methods don't
actually early-return in kResetting.

[sheu, 2012/11/03 00:37:14]

Done.  FlushTask() was missing the early-return; everything else was there
already.

+  decoder_state_ = kResetting;
+  decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
+     &ExynosVideoDecodeAccelerator::ResetDoneTask, base::Unretained(this)));
+}
+
+void ExynosVideoDecodeAccelerator::ResetDoneTask() {
+  DVLOG(3) << "ResetDoneTask()";

[Ami GONE FROM CHROMIUM, 2012/11/02 21:11:08]

DCHECK decoder_thread

[sheu, 2012/11/03 00:37:14]

Done.

+  // Jobs drained, we're finished resetting.
+  decoder_state_ = kAfterReset;
+  child_message_loop_proxy_->PostTask(FROM_HERE, base::Bind(
+      &Client::NotifyResetDone, client_));
+}
+
+void ExynosVideoDecodeAccelerator::DestroyTask() {
+  DVLOG(3) << "DestroyTask()";
+  DCHECK_EQ(decoder_thread_.message_loop(), MessageLoop::current());
+
+  // Stop streaming and the device_poll_thread_.
+  StopDevicePoll();
+
+  decoder_current_bitstream_buffer_.reset(NULL);
+  decoder_current_input_buffer_ = -1;
+  decoder_decode_buffer_tasks_scheduled_ = 0;
+  decoder_frames_inflight_ = 0;
+  decoder_frames_at_client_ = 0;
+  decoder_flush_notify_requested_ = false;
+  decoder_input_queue_.clear();
+
+  // Set our state to kError.  This will cause all subsequent tasks to
+  // early-exit.
+  decoder_state_ = kError;
+}
+
+bool ExynosVideoDecodeAccelerator::StartDevicePoll() {
+  DVLOG(3) << "StartDevicePoll()";
+  DCHECK_EQ(decoder_thread_.message_loop(), MessageLoop::current());
+
+  // Early-out if we're already running.
+  if (device_poll_thread_.IsRunning()) {
+    DVLOG(2) << "StartDevicePoll(): early out: "
+             << "device poll thread already running";
+    return true;
+  }
+
+  // At least one of the OUTPUT or CAPTURE queues for each of MFC and GSC must
+  // be in STREAMON state for epoll() not to return EPOLERR.  So:
+  // * for MFC, we'll start the CAPTURE queue
+  // * for GSC, we'll start the CAPTURE queue
+  // STREAMON requires, unfortunately, that we have buffers already queued.
+  // We'll need to have the buffers available to queue.
+  if ((!mfc_output_streamon_ && mfc_free_output_buffers_.empty()) ||
+      gsc_free_output_buffers_.empty()) {
+    DVLOG(2) << "StartDevicePoll(): early out: output buffers unavailable";
+    return true;

[Ami GONE FROM CHROMIUM, 2012/11/02 21:11:08]

why true?

[sheu, 2012/11/03 00:37:14]

Added comment.  Basically, if we don't have output buffers yet, this isn't
necessarily an error; see the case of running StartDevicePoll from an initial
DecodeBufferInitial().

+  }
+
+  // The MFC output queue may already have been started when we started
+  // enqueuing MFC input buffers.
+  int ret;
+  struct v4l2_buffer qbuf;
+  struct v4l2_plane qbuf_planes[2];
+  if (!mfc_output_streamon_) {
+    // Queue and start the MFC CAPTURE queue
+    int buffer;
+    __u32 type;
+    memset(&qbuf, 0, sizeof(qbuf));
+    memset(qbuf_planes, 0, sizeof(qbuf_planes));
+    buffer = mfc_free_output_buffers_.back();
+    MfcOutputRecord& output_record = mfc_output_buffer_map_[buffer];
+    DCHECK(!output_record.at_device);
+    DCHECK_EQ(output_record.input_id, -1);
+    qbuf.index    = buffer;
+    qbuf.type     = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+    qbuf.memory   = V4L2_MEMORY_MMAP;
+    qbuf.m.planes = qbuf_planes;
+    qbuf.length   = 2;
+    errno = 0;
+    ret = ioctl(mfc_fd_, VIDIOC_QBUF, &qbuf);
+    if (ret != 0) {
+      DPLOG(ERROR) << "StartDevicePoll(): ioctl() failed: VIDIOC_QBUF";
+      decoder_state_ = kError;
+      NOTIFY_ERROR(PLATFORM_FAILURE);
+      return false;
+    }
+    output_record.at_device = true;
+    mfc_free_output_buffers_.pop_back();
+    type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+    errno = 0;
+    ret = ioctl(mfc_fd_, VIDIOC_STREAMON, &type);
+    if (ret != 0) {
+      DPLOG(ERROR) << "StartDevicePoll(): ioctl() failed: VIDIOC_STREAMON";
+      decoder_state_ = kError;
+      NOTIFY_ERROR(PLATFORM_FAILURE);
+      return false;
+    }
+    mfc_output_streamon_ = true;

[Ami GONE FROM CHROMIUM, 2012/11/02 21:11:08]

can most/all of the last 30 lines be deduped against another place in this file?

[sheu, 2012/11/03 00:37:14]

It could be, but I'd then be breaking the QBUF for MFC CAPTURE and GSC CAPTURE
out into its own helper function, which means I'd probably break out MFC OUTPUT
and GSC OUTPUT as well for consistency.  I could, but I think the
StartDevicePoll() and path is conceptually different enough that it should be
explicitly copied out.

+  }
+
+  // GSC output should not have been started before we received output buffers.
+  DCHECK(!gsc_output_streamon_);
+  {
+    // Queue and start the GSC CAPTURE queue
+    int buffer;
+    __u32 type;
+    memset(&qbuf, 0, sizeof(qbuf));
+    memset(qbuf_planes, 0, sizeof(qbuf_planes));
+    buffer = gsc_free_output_buffers_.back();
+    GscOutputRecord& output_record = gsc_output_buffer_map_[buffer];
+    DCHECK(!output_record.at_device);
+    DCHECK(!output_record.at_client);
+    qbuf.index            = buffer;
+    qbuf.type             = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+    qbuf.memory           = V4L2_MEMORY_DMABUF;
+    qbuf.m.planes         = qbuf_planes;
+    qbuf.m.planes[0].m.fd = gsc_output_buffer_map_[buffer].fd;
+    qbuf.length           = 1;
+    errno = 0;
+    ret = ioctl(gsc_fd_, VIDIOC_QBUF, &qbuf);
+    if (ret != 0) {
+      DPLOG(ERROR) << "StartDevicePoll(): ioctl() failed: VIDIOC_QBUF";
+      decoder_state_ = kError;
+      NOTIFY_ERROR(PLATFORM_FAILURE);
+      return false;
+    }
+    output_record.at_device = true;
+    gsc_free_output_buffers_.pop_back();
+    gsc_output_buffer_prepared_count_++;
+    type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+    errno = 0;
+    ret = ioctl(gsc_fd_, VIDIOC_STREAMON, &type);
+    if (ret != 0) {
+      DPLOG(ERROR) << "StartDevicePoll(): ioctl() failed: VIDIOC_STREAMON";

[Ami GONE FROM CHROMIUM, 2012/11/02 21:11:08]

ditto dedup this ~30 lines

[sheu, 2012/11/03 00:37:14]

See above

+      decoder_state_ = kError;
+      NOTIFY_ERROR(PLATFORM_FAILURE);
+      return false;
+    }
+    gsc_output_streamon_ = true;
+
+    if (!device_poll_thread_.Start()) {
+      DLOG(ERROR) << "StartDevicePoll(): Device thread failed to start";
+      decoder_state_ = kError;
+      NOTIFY_ERROR(PLATFORM_FAILURE);
+      return false;
+    }
+    device_poll_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
+        &ExynosVideoDecodeAccelerator::DevicePollLoop, base::Unretained(this)));
+  }
+
+  return true;
+}
+
+bool ExynosVideoDecodeAccelerator::StopDevicePoll() {
+  DVLOG(3) << "StopDevicePoll()";
+  DCHECK_EQ(decoder_thread_.message_loop(), MessageLoop::current());
+
+  // Stop streaming.
+  int ret;
+  if (mfc_input_streamon_) {
+    __u32 type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
+    errno = 0;
+    ret = ioctl(mfc_fd_, VIDIOC_STREAMOFF, &type);
+    if (ret != 0) {
+      DPLOG(ERROR) << "StopDevicePoll(): ioctl() failed: VIDIOC_STREAMOFF";
+      decoder_state_ = kError;
+      NOTIFY_ERROR(PLATFORM_FAILURE);
+      return false;

[Ami GONE FROM CHROMIUM, 2012/11/02 21:11:08]

This ioctl'ing business look really ripe for a helper to me.
(here and in lots of other places)

[sheu, 2012/11/03 00:37:14]

Don't know that I can actually make this very much more compact.  I've collapsed
the call into the conditional, but past that, every ioctl call is a unique and
special snowflake.

+    }
+  }
+  mfc_input_streamon_ = false;
+  if (mfc_output_streamon_) {
+    __u32 type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+    errno = 0;
+    ret = ioctl(mfc_fd_, VIDIOC_STREAMOFF, &type);
+    if (ret != 0) {
+      DPLOG(ERROR) << "StopDevicePoll(): ioctl() failed: VIDIOC_STREAMOFF";
+      decoder_state_ = kError;
+      NOTIFY_ERROR(PLATFORM_FAILURE);
+      return false;
+    }
+  }
+  mfc_output_streamon_ = false;
+  if (gsc_input_streamon_) {
+    __u32 type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
+    errno = 0;
+    ret = ioctl(gsc_fd_, VIDIOC_STREAMOFF, &type);
+    if (ret != 0) {
+      DPLOG(ERROR) << "StopDevicePoll(): ioctl() failed: VIDIOC_STREAMOFF";
+      decoder_state_ = kError;
+      NOTIFY_ERROR(PLATFORM_FAILURE);
+      return false;
+    }
+  }
+  gsc_input_streamon_ = false;
+  if (gsc_output_streamon_) {
+    __u32 type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+    errno = 0;
+    ret = ioctl(gsc_fd_, VIDIOC_STREAMOFF, &type);
+    if (ret != 0) {
+      DPLOG(ERROR) << "StopDevicePoll(): ioctl() failed: VIDIOC_STREAMOFF";
+      decoder_state_ = kError;
+      NOTIFY_ERROR(PLATFORM_FAILURE);
+      return false;
+    }
+  }
+  gsc_output_streamon_ = false;
+
+  // Stopping streaming should cause DevicePollLoop() to exit.  Join the thread.
+  device_poll_thread_.Stop();
+
+  // Reset all our accounting info.
+  mfc_input_ready_queue_.clear();
+  mfc_free_input_buffers_.clear();
+  DCHECK_EQ(mfc_input_buffer_count_,
+      static_cast<int>(mfc_input_buffer_map_.size()));
+  for (size_t i = 0; i < mfc_input_buffer_map_.size(); i++) {
+    mfc_free_input_buffers_.push_back(i);
+    mfc_input_buffer_map_[i].at_device = false;
+    mfc_input_buffer_map_[i].bytes_used = 0;
+    mfc_input_buffer_map_[i].input_id = -1;
+  }
+  mfc_input_buffer_queued_count_ = 0;
+  mfc_free_output_buffers_.clear();
+  DCHECK_EQ(mfc_output_buffer_count_,
+     static_cast<int>(mfc_output_buffer_map_.size()));
+  for (size_t i = 0; i < mfc_output_buffer_map_.size(); i++) {
+    mfc_free_output_buffers_.push_back(i);
+    mfc_output_buffer_map_[i].at_device = false;
+    mfc_output_buffer_map_[i].input_id = -1;
+  }
+  mfc_output_gsc_input_queue_.clear();
+  gsc_free_input_buffers_.clear();
+  DCHECK_EQ(gsc_input_buffer_count_,
+      static_cast<int>(gsc_input_buffer_map_.size()));
+  for (size_t i = 0; i < gsc_input_buffer_map_.size(); i++) {
+    gsc_free_input_buffers_.push_back(i);
+    gsc_input_buffer_map_[i].at_device = false;
+    gsc_input_buffer_map_[i].mfc_output = -1;
+  }
+  gsc_free_output_buffers_.clear();
+  DCHECK_EQ(gsc_output_buffer_count_,
+      static_cast<int>(gsc_output_buffer_map_.size()));
+  for (size_t i = 0; i < gsc_output_buffer_map_.size(); i++) {
+    // Only mark those free that aren't being held by the VDA.
+    if (!gsc_output_buffer_map_[i].at_client) {
+      gsc_free_output_buffers_.push_back(i);
+      gsc_output_buffer_map_[i].at_device = false;
+    }
+    if (gsc_output_buffer_map_[i].egl_sync != EGL_NO_SYNC_KHR) {
+      egl_destroy_sync_khr(egl_display_, gsc_output_buffer_map_[i].egl_sync);
+      gsc_output_buffer_map_[i].egl_sync = EGL_NO_SYNC_KHR;
+    }
+  }
+  gsc_output_buffer_prepared_count_ = 0;
+  gsc_output_buffer_queued_count_ = 0;
+
+  DVLOG(3) << "StopDevicePoll(): device poll stopped";
+  return true;
+}
+
+void ExynosVideoDecodeAccelerator::DevicePollLoop() {
+  DVLOG(3) << "DevicePollLoop()";
+  DCHECK_EQ(device_poll_thread_.message_loop(), MessageLoop::current());
+  // This routine just polls on the V4L2 devices, and notifies the
+  // decoder_thread_ when processing needs to occur.  The main loop will
+  // terminate when we return an EPOLLERR to epoll() on the device file
+  // descriptors, which should occur when the devices are sent VIDIOC_STREAMOFF
+  // on their queuespoll .

[sheu, 2012/11/01 03:30:00]

Not uploaded yet, but fixed.

+
+  int ret;
+  int epoll_fd = -1;
+  file_util::ScopedFD epoll_fd_closer(&epoll_fd);
+  struct epoll_event event;
+  errno = 0;
+  epoll_fd = epoll_create(2);
+  if (epoll_fd == -1) {
+    DPLOG(ERROR) << "DevicePollLoop(): epoll() failed";
+    NOTIFY_ERROR(PLATFORM_FAILURE);
+    return;
+  }
+  event.events = EPOLLIN | EPOLLOUT | EPOLLERR | EPOLLET;
+  event.data.fd = mfc_fd_;
+  errno = 0;
+  ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, mfc_fd_, &event);
+  if (ret != 0) {
+    DPLOG(ERROR) << "DevicePollLoop(): epoll_ctl() failed";
+    NOTIFY_ERROR(PLATFORM_FAILURE);
+    return;
+  }
+  event.events = EPOLLIN | EPOLLOUT | EPOLLERR | EPOLLET;
+  event.data.fd = gsc_fd_;
+  errno = 0;
+  ret = epoll_ctl(epoll_fd, EPOLL_CTL_ADD, gsc_fd_, &event);
+  if (ret != 0) {
+    DPLOG(ERROR) << "DevicePollLoop(): epoll_ctl() failed";
+    NOTIFY_ERROR(PLATFORM_FAILURE);
+    return;
+  }
+
+  for (;;) {
+    // We epoll() and wait for more interesting things to happen.
+    // If we get a VIDIOC_STREAMOFF to the device, epoll() will return EPOLLERR,
+    // and we know to exit the loop that way.
+    DVLOG(3) << "DevicePollLoop(): epoll()";
+    struct epoll_event event;
+    do {
+      errno = 0;
+      ret = epoll_wait(epoll_fd, &event, 1, -1);
+    } while (ret < 1 && errno == EINTR);
+    if (ret == -1) {
+      DPLOG(ERROR) << "DevicePollLoop(): epoll_wait() failed";
+      NOTIFY_ERROR(PLATFORM_FAILURE);
+      return;
+    }
+    if (event.data.fd == mfc_fd_) {
+      if ((event.events & EPOLLERR) != 0) {
+        DVLOG(2) << "DevicePollLoop(): epoll() returned EPOLERR for mfc_fd_";
+        // Not necessarily an error.
+        return;
+      }

[Ami GONE FROM CHROMIUM, 2012/11/02 21:11:08]

this if block can be extracted out of the fd check to dedup with the gsc_fd_
version?

[sheu, 2012/11/03 00:37:14]

done (see below)

+      decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
+          &ExynosVideoDecodeAccelerator::ServiceDeviceTask,
+          base::Unretained(this)));
+      // If we're behind on tasks, schedule another one.
+      int buffers_pending = static_cast<int>(decoder_input_queue_.size());
+      if (decoder_current_bitstream_buffer_ != NULL)

[Ami GONE FROM CHROMIUM, 2012/11/02 21:11:08]

why is it safe to inspect this on this thread?

[sheu, 2012/11/03 00:37:14]

Dang.  A real live thread-unsafety.

Fixed by moving to ServiceDeviceTask(), and refactored this function.

+        buffers_pending++;
+      if (decoder_decode_buffer_tasks_scheduled_ < buffers_pending) {

[Ami GONE FROM CHROMIUM, 2012/11/02 21:11:08]

ditto thread safety here and below.

[sheu, 2012/11/03 00:37:14]

(see above)

+        decoder_decode_buffer_tasks_scheduled_++;
+        decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
+            &ExynosVideoDecodeAccelerator::DecodeBufferTask,
+            base::Unretained(this)));
+      }
+    } else if (event.data.fd == gsc_fd_) {
+      if ((event.events & EPOLLERR) != 0) {
+        DVLOG(2) << "DevicePollLoop(): epoll() returned EPOLERR for gsc_fd_";
+        // Not necessarily an error.
+        return;
+      }
+      decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
+          &ExynosVideoDecodeAccelerator::ServiceDeviceTask,
+          base::Unretained(this)));
+    } else {
+      DLOG(ERROR) << "DevicePollLoop(): epoll() returned unknown fd";
+      NOTIFY_ERROR(PLATFORM_FAILURE);

[Ami GONE FROM CHROMIUM, 2012/11/02 17:57:06]

Your rationale for not including 
decoder_state_=kError;
in NOTIFY_ERROR is that you want N_E to be callable from any thread.  But in
these calls to N_E from the device thread, what is charged with putting the
decoder into an error state?

[sheu, 2012/11/03 01:30:09]

That's error-prone, I agree.  I was just counting on this not to happen, which
it shouldn't (unless a kernel bug comes up or something), but still...

Fixed by allowing a decoder_state_ update through PostTask().

+      return;

[Ami GONE FROM CHROMIUM, 2012/11/02 21:11:08]

I think you can simplify & shorten this function significantly by
early-detecting 
event.data.fd != gsc_fd_ && event.data.fd != mfc_fd_
and otherwise scheduling a ServiceDoneTask which can also take care of
requesting DecodeBufferTask if necessary.

[sheu, 2012/11/03 00:37:14]

My thoughts exactly.  Done.

+    }
+  }
+}
+
+void ExynosVideoDecodeAccelerator::NotifyError(Error error) {
+  DVLOG(2) << "NotifyError()";
+  if (child_message_loop_proxy_ != base::MessageLoopProxy::current()) {
+    child_message_loop_proxy_->PostTask(FROM_HERE, base::Bind(
+        &ExynosVideoDecodeAccelerator::NotifyError, weak_this_, error));
+    return;
+  }
+
+  if (client_) {
+    client_->NotifyError(error);
+    client_ptr_factory_.InvalidateWeakPtrs();
+  }
+}
+
+bool ExynosVideoDecodeAccelerator::CreateMfcInputBuffers() {
+  DVLOG(3) << "CreateMfcInputBuffers()";
+  // We always run this as we prepare to initialize.
+  DCHECK_EQ(decoder_state_, kUninitialized);
+  DCHECK(!mfc_input_streamon_);
+  DCHECK_EQ(mfc_input_buffer_count_, 0);
+
+  __u32 pixelformat = 0;
+  if (video_profile_ >= media::H264PROFILE_MIN &&
+      video_profile_ <= media::H264PROFILE_MAX) {
+    pixelformat = V4L2_PIX_FMT_H264;
+  } else if (video_profile_ >= media::VP8PROFILE_MIN &&
+      video_profile_ <= media::VP8PROFILE_MAX) {

[Ami GONE FROM CHROMIUM, 2012/11/02 21:11:08]

indent

[sheu, 2012/11/03 00:37:14]

Done.

+    pixelformat = V4L2_PIX_FMT_VP8;
+  }

[Ami GONE FROM CHROMIUM, 2012/11/02 21:11:08]

else NOTREACHED?

[sheu, 2012/11/03 00:37:14]

Done.

+
+  int ret;
+  struct v4l2_format format;
+  memset(&format, 0, sizeof(format));
+  format.type                              = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
+  format.fmt.pix_mp.pixelformat            = pixelformat;
+  format.fmt.pix_mp.plane_fmt[0].sizeimage = kMfcInputBufferMaxSize;
+  format.fmt.pix_mp.num_planes             = 1;
+  errno = 0;
+  ret = ioctl(mfc_fd_, VIDIOC_S_FMT, &format);
+  if (ret != 0) {
+    DPLOG(ERROR) << "CreateMfcInputBuffers(): ioctl() failed: VIDIOC_S_FMT";
+    return false;
+  }
+
+  struct v4l2_requestbuffers reqbufs;
+  memset(&reqbufs, 0, sizeof(reqbufs));
+  reqbufs.count  = kMfcInputBufferCount;
+  reqbufs.type   = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
+  reqbufs.memory = V4L2_MEMORY_MMAP;
+  errno = 0;
+  ret = ioctl(mfc_fd_, VIDIOC_REQBUFS, &reqbufs);
+  if (ret != 0) {
+    DPLOG(ERROR) << "CreateMfcInputBuffers(): ioctl() failed: VIDIOC_REQBUFS";
+    return false;
+  }
+  mfc_input_buffer_count_ = reqbufs.count;
+  mfc_input_buffer_map_.resize(mfc_input_buffer_count_);
+  for (int i = 0; i < mfc_input_buffer_count_; i++) {
+    mfc_free_input_buffers_.push_back(i);
+
+    // Query for the MEMORY_MMAP pointer.
+    struct v4l2_plane planes[1];
+    struct v4l2_buffer buffer;
+    memset(&buffer, 0, sizeof(buffer));
+    memset(planes, 0, sizeof(planes));
+    buffer.index    = i;
+    buffer.type     = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
+    buffer.memory   = V4L2_MEMORY_MMAP;
+    buffer.m.planes = planes;
+    buffer.length   = 1;
+    errno = 0;
+    ret = ioctl(mfc_fd_, VIDIOC_QUERYBUF, &buffer);
+    if (ret != 0) {
+      DPLOG(ERROR) << "CreateMfcInputBuffers(): "
+                   << "ioctl() failed: VIDIOC_QUERYBUF";
+      return false;
+    }
+    errno = 0;
+    void* offset = mmap(NULL, buffer.m.planes[0].length,
+        PROT_READ | PROT_WRITE, MAP_SHARED, mfc_fd_,
+        buffer.m.planes[0].m.mem_offset);
+    if (offset == MAP_FAILED) {
+      DPLOG(ERROR) << "CreateMfcInputBuffers(): mmap() failed";
+      return false;
+    }
+    mfc_input_buffer_map_[i].offset = offset;
+    mfc_input_buffer_map_[i].length = buffer.m.planes[0].length;
+  }
+
+  return true;
+}
+
+bool ExynosVideoDecodeAccelerator::CreateMfcOutputBuffers() {
+  DVLOG(3) << "CreateMfcOutputBuffers()";
+  DCHECK_EQ(decoder_state_, kInitialized);
+  DCHECK(!mfc_output_streamon_);
+  DCHECK_EQ(mfc_output_buffer_count_, 0);
+
+  // Number of MFC output buffers we need.
+  int ret;
+  struct v4l2_control ctrl;
+  memset(&ctrl, 0, sizeof(ctrl));
+  ctrl.id = V4L2_CID_MIN_BUFFERS_FOR_CAPTURE;
+  errno = 0;
+  ret = ioctl(mfc_fd_, VIDIOC_G_CTRL, &ctrl);
+  if (ret != 0) {
+    DPLOG(ERROR) << "CreateMfcOutputBuffers(): ioctl() failed: VIDIOC_G_CTRL";
+    return false;
+  }
+
+  // Output format setup in Initialize().
+
+  // Allocate the output buffers.
+  struct v4l2_requestbuffers reqbufs;
+  memset(&reqbufs, 0, sizeof(reqbufs));
+  reqbufs.count  = ctrl.value + kMfcOutputBufferExtraCount;
+  reqbufs.type   = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+  reqbufs.memory = V4L2_MEMORY_MMAP;
+  errno = 0;
+  ret = ioctl(mfc_fd_, VIDIOC_REQBUFS, &reqbufs);
+  if (ret != 0) {
+    DPLOG(ERROR) << "CreateMfcOutputBuffers(): ioctl() failed: VIDIOC_REQBUFS";
+    return false;
+  }
+
+  // Fill our free-buffers list, and create DMABUFs from them.
+  mfc_output_buffer_count_ = reqbufs.count;
+  mfc_output_buffer_map_.resize(mfc_output_buffer_count_);
+  for (int i = 0; i < mfc_output_buffer_count_; i++) {
+    mfc_free_output_buffers_.push_back(i);
+
+    // Query for the MEMORY_MMAP pointer.
+    struct v4l2_plane planes[2];
+    struct v4l2_buffer buffer;
+    memset(&buffer, 0, sizeof(buffer));
+    memset(planes, 0, sizeof(planes));
+    buffer.index    = i;
+    buffer.type     = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+    buffer.memory   = V4L2_MEMORY_MMAP;
+    buffer.m.planes = planes;
+    buffer.length   = 2;
+    errno = 0;
+    ret = ioctl(mfc_fd_, VIDIOC_QUERYBUF, &buffer);
+    if (ret != 0) {
+      DPLOG(ERROR) << "CreateMfcOutputBuffers(): "
+                   << "ioctl() failed: VIDIOC_QUERYBUF";
+      return false;
+    }
+
+    // Get their user memory for GSC input.
+    for (int j = 0; j < 2; j++) {
+      errno = 0;
+      void* offset = mmap(NULL, buffer.m.planes[j].length,
+          PROT_READ | PROT_WRITE, MAP_SHARED, mfc_fd_,
+          buffer.m.planes[j].m.mem_offset);
+      if (offset == MAP_FAILED) {
+        DPLOG(ERROR) << "CreateMfcInputBuffers(): mmap() failed";
+        return false;
+      }
+      mfc_output_buffer_map_[i].offset[j] = offset;
+      mfc_output_buffer_map_[i].length[j] = buffer.m.planes[j].length;
+    }
+  }
+
+  return true;
+}
+
+bool ExynosVideoDecodeAccelerator::CreateGscInputBuffers() {
+  DVLOG(3) << "CreateGscInputBuffers()";
+  DCHECK_EQ(decoder_state_, kInitialized);
+  DCHECK(!gsc_input_streamon_);
+  DCHECK_EQ(gsc_input_buffer_count_, 0);
+
+  int ret;
+  struct v4l2_format format;
+  memset(&format, 0, sizeof(format));
+  format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
+  format.fmt.pix_mp.width  = frame_buffer_size_.width();
+  format.fmt.pix_mp.height = frame_buffer_size_.height();
+  DCHECK_EQ(mfc_output_buffer_pixelformat_, V4L2_PIX_FMT_NV12MT_16X16);
+  format.fmt.pix_mp.pixelformat = mfc_output_buffer_pixelformat_;
+  format.fmt.pix_mp.plane_fmt[0].sizeimage = mfc_output_buffer_size_[0];
+  format.fmt.pix_mp.plane_fmt[1].sizeimage = mfc_output_buffer_size_[1];
+  // NV12MT_16X16 is a tiled format for which bytesperline doesn't make too much
+  // sense.  Convention seems to be to assume 8bpp for these tiled formats.
+  format.fmt.pix_mp.plane_fmt[0].bytesperline = frame_buffer_size_.width();
+  format.fmt.pix_mp.plane_fmt[1].bytesperline = frame_buffer_size_.width();
+  format.fmt.pix_mp.num_planes = 2;
+  errno = 0;
+  ret = ioctl(gsc_fd_, VIDIOC_S_FMT, &format);
+  if (ret != 0) {
+    DPLOG(ERROR) << "CreateGscInputBuffers(): ioctl() failed: VIDIOC_S_FMT";
+    return false;
+  }
+
+  struct v4l2_control control;
+  memset(&control, 0, sizeof(control));
+  control.id = V4L2_CID_ROTATE;
+  control.value = 0;
+  errno = 0;
+  ret = ioctl(gsc_fd_, VIDIOC_S_CTRL, &control);
+  if (ret != 0) {
+    DPLOG(ERROR) << "CreateGscInputBuffers(): ioctl() failed: VIDIOC_S_CTRL";
+    return false;
+  }
+
+  memset(&control, 0, sizeof(control));
+  control.id = V4L2_CID_HFLIP;
+  control.value = 0;
+  errno = 0;
+  ret = ioctl(gsc_fd_, VIDIOC_S_CTRL, &control);
+  if (ret != 0) {
+    DPLOG(ERROR) << "CreateGscInputBuffers(): ioctl() failed: VIDIOC_S_CTRL";
+    return false;
+  }
+
+  memset(&control, 0, sizeof(control));
+  control.id = V4L2_CID_VFLIP;
+  control.value = 0;
+  errno = 0;
+  ret = ioctl(gsc_fd_, VIDIOC_S_CTRL, &control);
+  if (ret != 0) {
+    DPLOG(ERROR) << "CreateGscInputBuffers(): ioctl() failed: VIDIOC_S_CTRL";
+    return false;
+  }
+
+  memset(&control, 0, sizeof(control));
+  control.id = V4L2_CID_GLOBAL_ALPHA;
+  control.value = 255;
+  errno = 0;
+  ret = ioctl(gsc_fd_, VIDIOC_S_CTRL, &control);
+  if (ret != 0) {
+    DPLOG(ERROR) << "CreateGscInputBuffers(): ioctl() failed: VIDIOC_S_CTRL";
+    return false;
+  }
+
+  struct v4l2_requestbuffers reqbufs;
+  memset(&reqbufs, 0, sizeof(reqbufs));
+  reqbufs.count = kGscOutputBufferCount;
+  reqbufs.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
+  reqbufs.memory = V4L2_MEMORY_USERPTR;
+  errno = 0;
+  ret = ioctl(gsc_fd_, VIDIOC_REQBUFS, &reqbufs);
+  if (ret != 0 ) {
+    DPLOG(ERROR) << "CreateGscInputBuffers(): ioctl() failed: VIDIOC_REQBUFS";
+    return false;
+  }

[Ami GONE FROM CHROMIUM, 2012/11/02 21:11:08]

man, I *really* hope you figure out a way to do ioctl's in fewer LOC...

[sheu, 2012/11/03 00:37:14]

I don't really know that there is, unfortunately.  Each ioctl call needs its
control struct filled out, and after collapsing the ioctl call into the
condition, there's not actually any more compactness to be had.

[Ami GONE FROM CHROMIUM, 2012/11/06 19:50:10]

Even if you can't reduce the LOCs, making dedicated helper functions for the
ioctls will seriously improve readability.  Can you take a crack at that?

+
+  gsc_input_buffer_count_ = reqbufs.count;
+  gsc_input_buffer_map_.resize(gsc_input_buffer_count_);
+  for (int i = 0; i < gsc_input_buffer_count_; i++) {
+    gsc_free_input_buffers_.push_back(i);
+    gsc_input_buffer_map_[i].mfc_output = -1;
+  }
+
+  return true;
+}
+
+bool ExynosVideoDecodeAccelerator::CreateGscOutputBuffers() {
+  DVLOG(3) << "CreateGscOutputBuffers()";
+  DCHECK_EQ(decoder_state_, kInitialized);
+  DCHECK(!gsc_output_streamon_);
+  DCHECK_EQ(gsc_output_buffer_count_, 0);
+
+  // GSC outputs into the EGLImages we create from the textures we are
+  // assigned.  Assume RGBA8888 format.
+  int ret;
+  struct v4l2_format format;
+  memset(&format, 0, sizeof(format));
+  format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+  format.fmt.pix_mp.width  = frame_buffer_size_.width();
+  format.fmt.pix_mp.height = frame_buffer_size_.height();
+  format.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_RGB32;

[Ami GONE FROM CHROMIUM, 2012/11/02 21:11:08]

Is V_P_F_RGB32 == RGBA8888 ?

[sheu, 2012/11/03 00:37:14]

Yep.  There's also V4L2_PIX_FMT_BGR32 for the other way.

+  format.fmt.pix_mp.plane_fmt[0].sizeimage =
+      frame_buffer_size_.width() * frame_buffer_size_.height() * 4;
+  format.fmt.pix_mp.plane_fmt[0].bytesperline = frame_buffer_size_.width() * 4;
+  format.fmt.pix_mp.num_planes = 1;
+  errno = 0;
+  ret = ioctl(gsc_fd_, VIDIOC_S_FMT, &format);
+  if (ret != 0) {
+    DPLOG(ERROR) << "CreateGscOutputBuffers(): ioctl() failed: VIDIOC_S_FMT";
+    return false;
+  }
+
+  struct v4l2_requestbuffers reqbufs;
+  memset(&reqbufs, 0, sizeof(reqbufs));
+  reqbufs.count = kGscOutputBufferCount;
+  reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+  reqbufs.memory = V4L2_MEMORY_DMABUF;
+  errno = 0;
+  ret = ioctl(gsc_fd_, VIDIOC_REQBUFS, &reqbufs);
+  if (ret != 0) {
+    DPLOG(ERROR) << "CreateGscOutputBuffers(): ioctl() failed: VIDIOC_REQBUFS";
+    return false;
+  }
+
+  // We don't actually fill in the freelist or the map here.  That happens once
+  // we have actual usable buffers, after AssignPictureBuffers();
+  gsc_output_buffer_count_ = reqbufs.count;
+  gsc_output_buffer_map_.resize(gsc_output_buffer_count_);
+
+  DVLOG(3) << "CreateGscOutputBuffers(): ProvidePictureBuffers(): "
+      << "buffer_count=" << gsc_output_buffer_count_
+      << ", width=" << frame_buffer_size_.width()
+      << ", height=" << frame_buffer_size_.height();

[sheu, 2012/11/01 03:30:00]

Not uploaded yet, but fixed

+  child_message_loop_proxy_->PostTask(FROM_HERE, base::Bind(
+      &Client::ProvidePictureBuffers, client_, gsc_output_buffer_count_,
+      gfx::Size(frame_buffer_size_.width(), frame_buffer_size_.height()),
+      GL_TEXTURE_2D));
+
+  return true;
+}
+
+void ExynosVideoDecodeAccelerator::DestroyMfcInputBuffers() {
+  DVLOG(3) << "DestroyMfcInputBuffers()";
+  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(!mfc_input_streamon_);
+
+  for (size_t i = 0; i < mfc_input_buffer_map_.size(); i++) {
+    if (mfc_input_buffer_map_[i].offset != NULL) {
+      munmap(mfc_input_buffer_map_[i].offset,
+          mfc_input_buffer_map_[i].length);
+    }
+  }
+
+  int ret;
+  struct v4l2_requestbuffers reqbufs;
+  memset(&reqbufs, 0, sizeof(reqbufs));
+  reqbufs.count = 0;
+  reqbufs.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
+  reqbufs.memory = V4L2_MEMORY_MMAP;
+  errno = 0;
+  ret = ioctl(mfc_fd_, VIDIOC_REQBUFS, &reqbufs);
+  if (ret != 0)
+    DPLOG(ERROR) << "DestroyMfcInputBuffers(): ioctl() failed: VIDIOC_REQBUFS";
+
+  mfc_input_buffer_map_.clear();
+  mfc_free_input_buffers_.clear();
+  mfc_input_buffer_count_ = 0;
+}
+
+void ExynosVideoDecodeAccelerator::DestroyMfcOutputBuffers() {
+  DVLOG(3) << "DestroyMfcOutputBuffers()";
+  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(!mfc_output_streamon_);
+
+  for (size_t i = 0; i < mfc_output_buffer_map_.size(); i++) {
+    if (mfc_output_buffer_map_[i].offset[0] != NULL)
+      munmap(mfc_output_buffer_map_[i].offset[0],
+          mfc_output_buffer_map_[i].length[0]);
+    if (mfc_output_buffer_map_[i].offset[1] != NULL)
+      munmap(mfc_output_buffer_map_[i].offset[1],
+          mfc_output_buffer_map_[i].length[1]);
+  }
+
+  int ret;
+  struct v4l2_requestbuffers reqbufs;
+  memset(&reqbufs, 0, sizeof(reqbufs));
+  reqbufs.count = 0;
+  reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+  reqbufs.memory = V4L2_MEMORY_MMAP;
+  errno = 0;
+  ret = ioctl(mfc_fd_, VIDIOC_REQBUFS, &reqbufs);
+  if (ret != 0)
+    DPLOG(ERROR) << "DestroyMfcOutputBuffers() ioctl() failed: VIDIOC_REQBUFS";
+
+  mfc_output_buffer_map_.clear();
+  mfc_free_output_buffers_.clear();
+  mfc_output_buffer_count_ = 0;
+}
+
+void ExynosVideoDecodeAccelerator::DestroyGscInputBuffers() {
+  DVLOG(3) << "DestroyGscInputBuffers()";
+  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(!gsc_input_streamon_);
+
+  int ret;
+  struct v4l2_requestbuffers reqbufs;
+  memset(&reqbufs, 0, sizeof(reqbufs));
+  reqbufs.count = 0;
+  reqbufs.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
+  reqbufs.memory = V4L2_MEMORY_DMABUF;
+  errno = 0;
+  ret = ioctl(gsc_fd_, VIDIOC_REQBUFS, &reqbufs);
+  if (ret != 0)
+    DPLOG(ERROR) << "DestroyGscInputBuffers(): ioctl() failed: VIDIOC_REQBUFS";
+
+  gsc_input_buffer_map_.clear();
+  gsc_free_input_buffers_.clear();
+  gsc_input_buffer_count_ = 0;
+}
+
+void ExynosVideoDecodeAccelerator::DestroyGscOutputBuffers() {
+  DVLOG(3) << "DestroyGscOutputBuffers()";
+  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DCHECK(!gsc_output_streamon_);
+
+  if (gsc_output_buffer_map_.size() != 0) {
+    if (!make_context_current_.Run())
+      DLOG(ERROR) << "DestroyGscOutputBuffers(): "
+                  << "could not make context current";
+
+    size_t i = 0;
+    do {
+      GscOutputRecord& output_record = gsc_output_buffer_map_[i];
+      if (output_record.fd != -1)
+        close(output_record.fd);
+      if (output_record.egl_image != EGL_NO_IMAGE_KHR)
+        eglDestroyImageKHR(egl_display_, output_record.egl_image);
+      if (output_record.egl_sync != EGL_NO_SYNC_KHR)
+        egl_destroy_sync_khr(egl_display_, output_record.egl_sync);
+      if (client_)
+        client_->DismissPictureBuffer(output_record.picture_id);
+      i++;
+    } while (i < gsc_output_buffer_map_.size());
+  }
+
+  int ret;
+  struct v4l2_requestbuffers reqbufs;
+  memset(&reqbufs, 0, sizeof(reqbufs));
+  reqbufs.count = 0;
+  reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+  reqbufs.memory = V4L2_MEMORY_DMABUF;
+  errno = 0;
+  ret = ioctl(gsc_fd_, VIDIOC_REQBUFS, &reqbufs);
+  if (ret != 0)
+    DPLOG(ERROR) << "DestroyGscOutputBuffers(): ioctl() failed: VIDIOC_REQBUFS";
+
+  gsc_output_buffer_map_.clear();
+  gsc_free_output_buffers_.clear();
+  gsc_output_buffer_count_ = 0;
+}
+
+}  // namespace content