// 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/debug/trace_event.h"
#include "base/message_loop/message_loop_proxy.h"
#include "base/posix/eintr_wrapper.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)                       \
  do {                                                             \
    if (HANDLE_EINTR(ioctl(fd, type, arg) != 0)) {                 \
      DPLOG(ERROR) << __func__ << "(): ioctl() failed: " << #type; \
      NOTIFY_ERROR(kPlatformFailureError);                         \
      return;                                                      \
    }                                                              \
  } 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)

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 {
  kPollGsc = (1 << 0),
  kPollMfc = (1 << 1),
};

}  // anonymous namespace

struct ExynosVideoEncodeAccelerator::BitstreamBufferRef {
  BitstreamBufferRef(int32 id, scoped_ptr<base::SharedMemory> shm, size_t size)
      : id(id), shm(shm.Pass()), size(size) {}
  const int32 id;
  const scoped_ptr<base::SharedMemory> shm;
  const size_t size;
};


ExynosVideoEncodeAccelerator::GscInputRecord::GscInputRecord()
    : at_device(false) {}

ExynosVideoEncodeAccelerator::GscOutputRecord::GscOutputRecord()
    : at_device(false), mfc_input(-1) {}

ExynosVideoEncodeAccelerator::MfcInputRecord::MfcInputRecord()
    : at_device(false) {
  fd[0] = fd[1] = -1;
}

ExynosVideoEncodeAccelerator::MfcOutputRecord::MfcOutputRecord()
    : at_device(false), address(NULL), length(0) {}

ExynosVideoEncodeAccelerator::ExynosVideoEncodeAccelerator(
    media::VideoEncodeAccelerator::Client* client)
    : child_message_loop_proxy_(base::MessageLoopProxy::current()),
      weak_this_ptr_factory_(this),
      weak_this_(weak_this_ptr_factory_.GetWeakPtr()),
      client_ptr_factory_(client),
      client_(client_ptr_factory_.GetWeakPtr()),
      encoder_thread_("ExynosEncoderThread"),
      encoder_state_(kUninitialized),
      output_buffer_byte_size_(0),
      stream_header_size_(0),
      input_format_fourcc_(0),
      output_format_fourcc_(0),
      gsc_fd_(-1),
      gsc_input_streamon_(false),
      gsc_input_buffer_queued_count_(0),
      gsc_output_streamon_(false),
      gsc_output_buffer_queued_count_(0),
      mfc_fd_(-1),
      mfc_input_streamon_(false),
      mfc_input_buffer_queued_count_(0),
      mfc_output_streamon_(false),
      mfc_output_buffer_queued_count_(0),
      device_poll_thread_("ExynosEncoderDevicePollThread"),
      device_poll_interrupt_fd_(-1) {
  DCHECK(client_);
}

ExynosVideoEncodeAccelerator::~ExynosVideoEncodeAccelerator() {
  DCHECK(!encoder_thread_.IsRunning());
  DCHECK(!device_poll_thread_.IsRunning());

  if (device_poll_interrupt_fd_ != -1) {
    HANDLE_EINTR(close(device_poll_interrupt_fd_));
    device_poll_interrupt_fd_ = -1;
  }
  if (gsc_fd_ != -1) {
    DestroyGscInputBuffers();
    DestroyGscOutputBuffers();
    HANDLE_EINTR(close(gsc_fd_));
    gsc_fd_ = -1;
  }
  if (mfc_fd_ != -1) {
    DestroyMfcInputBuffers();
    DestroyMfcOutputBuffers();
    HANDLE_EINTR(close(mfc_fd_));
    mfc_fd_ = -1;
  }
}

void ExynosVideoEncodeAccelerator::Initialize(
    media::VideoFrame::Format input_format,
    const gfx::Size& input_visible_size,
    media::VideoCodecProfile output_profile,
    uint32 initial_bitrate) {
  DVLOG(3) << "Initialize(): input_format=" << input_format
           << ", input_visible_size=" << input_visible_size.ToString()
           << ", output_profile=" << output_profile
           << ", initial_bitrate=" << initial_bitrate;

  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
  DCHECK_EQ(encoder_state_, kUninitialized);

  input_visible_size_ = input_visible_size;
  input_allocated_size_.SetSize((input_visible_size_.width() + 0xF) & ~0xF,
                                (input_visible_size_.height() + 0xF) & ~0xF);
  converted_visible_size_.SetSize((input_visible_size_.width() + 0x1) & ~0x1,
                                  (input_visible_size_.height() + 0x1) & ~0x1);
  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::RGB32:
      input_format_fourcc_ = V4L2_PIX_FMT_RGB32;
      break;
    case media::VideoFrame::I420:
      input_format_fourcc_ = V4L2_PIX_FMT_YUV420M;
      break;
    default:
      NOTIFY_ERROR(kInvalidArgumentError);
      return;
  }

  if (output_profile >= media::H264PROFILE_MIN &&
      output_profile <= media::H264PROFILE_MAX) {
    output_format_fourcc_ = V4L2_PIX_FMT_H264;
  } else {
    NOTIFY_ERROR(kInvalidArgumentError);
    return;
  }

  // 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;
  }

  // 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 ((caps.capabilities & kCapsRequired) != kCapsRequired) {
    DLOG(ERROR) << "Initialize(): ioctl() failed: VIDIOC_QUERYCAP: "
                   "caps check failed: 0x" << std::hex << caps.capabilities;
    NOTIFY_ERROR(kPlatformFailureError);
    return;
  }

  // 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;
  }

  memset(&caps, 0, sizeof(caps));
  IOCTL_OR_ERROR_RETURN(mfc_fd_, VIDIOC_QUERYCAP, &caps);
  if ((caps.capabilities & kCapsRequired) != kCapsRequired) {
    DLOG(ERROR) << "Initialize(): ioctl() failed: VIDIOC_QUERYCAP: "
                   "caps check failed: 0x" << std::hex << caps.capabilities;
    NOTIFY_ERROR(kPlatformFailureError);
    return;
  }

  // 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;
  }

  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;

  // 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;

  // VIDIOC_REQBUFS on CAPTURE queue.
  if (!CreateMfcOutputBuffers())
    return;


  if (!encoder_thread_.Start()) {
    DLOG(ERROR) << "Initialize(): encoder thread failed to start";
    NOTIFY_ERROR(kPlatformFailureError);
    return;
  }

  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_));
}

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,
      base::Bind(&ExynosVideoEncodeAccelerator::EncodeTask,
                 base::Unretained(this),
                 frame,
                 force_keyframe));
}

void ExynosVideoEncodeAccelerator::UseOutputBitstreamBuffer(
    const media::BitstreamBuffer& buffer) {
  DVLOG(3) << "UseOutputBitstreamBuffer(): id=" << buffer.id();
  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());

  if (buffer.size() < output_buffer_byte_size_) {
    NOTIFY_ERROR(kInvalidArgumentError);
    return;
  }

  scoped_ptr<base::SharedMemory> shm(
      new base::SharedMemory(buffer.handle(), false));
  if (!shm->Map(buffer.size())) {
    NOTIFY_ERROR(kPlatformFailureError);
    return;
  }

  scoped_ptr<BitstreamBufferRef> buffer_ref(
      new BitstreamBufferRef(buffer.id(), shm.Pass(), buffer.size()));
  encoder_thread_.message_loop()->PostTask(
      FROM_HERE,
      base::Bind(&ExynosVideoEncodeAccelerator::UseOutputBitstreamBufferTask,
                 base::Unretained(this),
                 base::Passed(&buffer_ref)));
}

void ExynosVideoEncodeAccelerator::RequestEncodingParametersChange(
    uint32 bitrate,
    uint32 framerate) {
  DVLOG(3) << "RequestEncodingParametersChange(): bitrate=" << bitrate
           << ", framerate=" << framerate;
  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());

  encoder_thread_.message_loop()->PostTask(
      FROM_HERE,
      base::Bind(
          &ExynosVideoEncodeAccelerator::RequestEncodingParametersChangeTask,
          base::Unretained(this),
          bitrate,
          framerate));
}

void ExynosVideoEncodeAccelerator::Destroy() {
  DVLOG(3) << "Destroy()";
  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());

  // We're destroying; cancel all callbacks.
  client_ptr_factory_.InvalidateWeakPtrs();

  // If the encoder thread is running, destroy using posted task.
  if (encoder_thread_.IsRunning()) {
    encoder_thread_.message_loop()->PostTask(
        FROM_HERE,
        base::Bind(&ExynosVideoEncodeAccelerator::DestroyTask,
                   base::Unretained(this)));
    // DestroyTask() will put the encoder into kError state and cause all tasks
    // to no-op.
    encoder_thread_.Stop();
  } else {
    // Otherwise, call the destroy task directly.
    DestroyTask();
  }

  // Set to kError state just in case.
  SetEncoderState(kError);

  delete this;
}

// static
std::vector<media::VideoEncodeAccelerator::SupportedProfile>
ExynosVideoEncodeAccelerator::GetSupportedProfiles() {
  std::vector<SupportedProfile> profiles(1);
  SupportedProfile& profile = profiles[0];
  profile.profile = media::H264PROFILE_MAIN;
  profile.max_resolution.SetSize(1920, 1088);
  profile.max_framerate.numerator = 30;
  profile.max_framerate.denominator = 1;
  return profiles;
}

void ExynosVideoEncodeAccelerator::EncodeTask(
    const scoped_refptr<media::VideoFrame>& frame, bool force_keyframe) {
  DVLOG(3) << "EncodeTask(): force_keyframe=" << force_keyframe;
  DCHECK_EQ(encoder_thread_.message_loop(), base::MessageLoop::current());
  DCHECK_NE(encoder_state_, kUninitialized);

  if (encoder_state_ == kError) {
    DVLOG(2) << "EncodeTask(): early out: kError state";
    return;
  }

  encoder_input_queue_.push_back(frame);
  EnqueueGsc();

  if (force_keyframe) {
    // TODO(sheu): this presently makes for slightly imprecise encoding
    // parameters updates.  To precisely align the parameter updates with the
    // incoming input frame, we should track the parameters through the GSC
    // pipeline and only apply them when the MFC input is about to be queued.
    struct v4l2_ext_control ctrls[1];
    struct v4l2_ext_controls control;
    memset(&ctrls, 0, sizeof(ctrls));
    memset(&control, 0, sizeof(control));
    ctrls[0].id    = V4L2_CID_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE;
    ctrls[0].value = V4L2_MPEG_MFC51_VIDEO_FORCE_FRAME_TYPE_I_FRAME;
    control.ctrl_class = V4L2_CTRL_CLASS_MPEG;
    control.count = 1;
    control.controls = ctrls;
    IOCTL_OR_ERROR_RETURN(mfc_fd_, VIDIOC_S_EXT_CTRLS, &control);
  }
}

void ExynosVideoEncodeAccelerator::UseOutputBitstreamBufferTask(
    scoped_ptr<BitstreamBufferRef> buffer_ref) {
  DVLOG(3) << "UseOutputBitstreamBufferTask(): id=" << buffer_ref->id;
  DCHECK_EQ(encoder_thread_.message_loop(), base::MessageLoop::current());

  encoder_output_queue_.push_back(
      linked_ptr<BitstreamBufferRef>(buffer_ref.release()));
  EnqueueMfc();

  if (encoder_state_ == kInitialized) {
    // Finish setting up our MFC OUTPUT queue.  See: Initialize().
    // VIDIOC_REQBUFS on OUTPUT queue.
    if (!CreateMfcInputBuffers())
      return;
    if (!StartDevicePoll())
      return;
    encoder_state_ = kEncoding;
  }
}

void ExynosVideoEncodeAccelerator::DestroyTask() {
  DVLOG(3) << "DestroyTask()";

  // DestroyTask() should run regardless of encoder_state_.

  // Stop streaming and the device_poll_thread_.
  StopDevicePoll();

  // Set our state to kError, and early-out all tasks.
  encoder_state_ = kError;
}

void ExynosVideoEncodeAccelerator::ServiceDeviceTask() {
  DVLOG(3) << "ServiceDeviceTask()";
  DCHECK_EQ(encoder_thread_.message_loop(), base::MessageLoop::current());
  DCHECK_NE(encoder_state_, kUninitialized);
  DCHECK_NE(encoder_state_, kInitialized);

  if (encoder_state_ == kError) {
    DVLOG(2) << "ServiceDeviceTask(): early out: kError state";
    return;
  }

  DequeueGsc();
  DequeueMfc();
  EnqueueGsc();
  EnqueueMfc();

  // Clear the interrupt fd.
  if (!ClearDevicePollInterrupt())
    return;

  unsigned int poll_fds = 0;
  // Add GSC fd, if we should poll on it.
  // GSC has to wait until both input and output buffers are queued.
  if (gsc_input_buffer_queued_count_ > 0 && gsc_output_buffer_queued_count_ > 0)
    poll_fds |= kPollGsc;
  // Add MFC fd, if we should poll on it.
  // MFC can be polled as soon as either input or output buffers are queued.
  if (mfc_input_buffer_queued_count_ + mfc_output_buffer_queued_count_ > 0)
    poll_fds |= kPollMfc;

  // ServiceDeviceTask() should only ever be scheduled from DevicePollTask(),
  // so either:
  // * device_poll_thread_ is running normally
  // * device_poll_thread_ scheduled us, but then a DestroyTask() shut it down,
  //   in which case we're in kError state, and we should have early-outed
  //   already.
  DCHECK(device_poll_thread_.message_loop());
  // Queue the DevicePollTask() now.
  device_poll_thread_.message_loop()->PostTask(
      FROM_HERE,
      base::Bind(&ExynosVideoEncodeAccelerator::DevicePollTask,
                 base::Unretained(this),
                 poll_fds));

  DVLOG(2) << "ServiceDeviceTask(): buffer counts: ENC["
           << encoder_input_queue_.size() << "] => GSC["
           << gsc_free_input_buffers_.size() << "+"
           << gsc_input_buffer_queued_count_ << "/"
           << gsc_input_buffer_map_.size() << "->"
           << gsc_free_output_buffers_.size() << "+"
           << gsc_output_buffer_queued_count_ << "/"
           << gsc_output_buffer_map_.size() << "] => "
           << mfc_ready_input_buffers_.size() << " => MFC["
           << mfc_free_input_buffers_.size() << "+"
           << mfc_input_buffer_queued_count_ << "/"
           << mfc_input_buffer_map_.size() << "->"
           << mfc_free_output_buffers_.size() << "+"
           << mfc_output_buffer_queued_count_ << "/"
           << mfc_output_buffer_map_.size() << "] => OUT["
           << encoder_output_queue_.size() << "]";
}

void ExynosVideoEncodeAccelerator::EnqueueGsc() {
  DVLOG(3) << "EnqueueGsc()";
  DCHECK_EQ(encoder_thread_.message_loop(), base::MessageLoop::current());

  const int old_gsc_inputs_queued = gsc_input_buffer_queued_count_;
  while (!encoder_input_queue_.empty() && !gsc_free_input_buffers_.empty()) {
    if (!EnqueueGscInputRecord())
      return;
  }
  if (old_gsc_inputs_queued == 0 && gsc_input_buffer_queued_count_ != 0) {
    // We started up a previously empty queue.
    // Queue state changed; signal interrupt.
    if (!SetDevicePollInterrupt())
      return;
    // Start VIDIOC_STREAMON if we haven't yet.
    if (!gsc_input_streamon_) {
      __u32 type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
      IOCTL_OR_ERROR_RETURN(gsc_fd_, VIDIOC_STREAMON, &type);
      gsc_input_streamon_ = true;
    }
  }

  // Enqueue a GSC output, only if we need one.  GSC output buffers write
  // directly to MFC input buffers, so we'll have to check for free MFC input
  // buffers as well.
  // GSC is liable to race conditions if more than one output buffer is
  // simultaneously enqueued, so enqueue just one.
  if (gsc_input_buffer_queued_count_ != 0 &&
      gsc_output_buffer_queued_count_ == 0 &&
      !gsc_free_output_buffers_.empty() && !mfc_free_input_buffers_.empty()) {
    const int old_gsc_outputs_queued = gsc_output_buffer_queued_count_;
    if (!EnqueueGscOutputRecord())
      return;
    if (old_gsc_outputs_queued == 0 && gsc_output_buffer_queued_count_ != 0) {
      // We just started up a previously empty queue.
      // Queue state changed; signal interrupt.
      if (!SetDevicePollInterrupt())
        return;
      // Start VIDIOC_STREAMON if we haven't yet.
      if (!gsc_output_streamon_) {
        __u32 type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
        IOCTL_OR_ERROR_RETURN(gsc_fd_, VIDIOC_STREAMON, &type);
        gsc_output_streamon_ = true;
      }
    }
  }
  DCHECK_LE(gsc_output_buffer_queued_count_, 1);
}

void ExynosVideoEncodeAccelerator::DequeueGsc() {
  DVLOG(3) << "DequeueGsc()";
  DCHECK_EQ(encoder_thread_.message_loop(), base::MessageLoop::current());

  // Dequeue completed GSC input (VIDEO_OUTPUT) buffers, and recycle to the free
  // list.
  struct v4l2_buffer dqbuf;
  struct v4l2_plane planes[3];
  while (gsc_input_buffer_queued_count_ > 0) {
    DCHECK(gsc_input_streamon_);
    memset(&dqbuf, 0, sizeof(dqbuf));
    memset(&planes, 0, sizeof(planes));
    dqbuf.type     = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
    dqbuf.memory   = V4L2_MEMORY_USERPTR;
    dqbuf.m.planes = planes;
    dqbuf.length   = arraysize(planes);
    if (HANDLE_EINTR(ioctl(gsc_fd_, VIDIOC_DQBUF, &dqbuf)) != 0) {
      if (errno == EAGAIN) {
        // EAGAIN if we're just out of buffers to dequeue.
        break;
      }
      DPLOG(ERROR) << "DequeueGsc(): ioctl() failed: VIDIOC_DQBUF";
      NOTIFY_ERROR(kPlatformFailureError);
      return;
    }
    GscInputRecord& input_record = gsc_input_buffer_map_[dqbuf.index];
    DCHECK(input_record.at_device);
    DCHECK(input_record.frame.get());
    input_record.at_device = false;
    input_record.frame = NULL;
    gsc_free_input_buffers_.push_back(dqbuf.index);
    gsc_input_buffer_queued_count_--;
  }

  // Dequeue completed GSC output (VIDEO_CAPTURE) buffers, and recycle to the
  // free list.  Queue the corresponding MFC buffer to the GSC->MFC holding
  // queue.
  while (gsc_output_buffer_queued_count_ > 0) {
    DCHECK(gsc_output_streamon_);
    memset(&dqbuf, 0, sizeof(dqbuf));
    memset(&planes, 0, sizeof(planes));
    dqbuf.type     = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
    dqbuf.memory   = V4L2_MEMORY_DMABUF;
    dqbuf.m.planes = planes;
    dqbuf.length   = 2;
    if (HANDLE_EINTR(ioctl(gsc_fd_, VIDIOC_DQBUF, &dqbuf)) != 0) {
      if (errno == EAGAIN) {
        // EAGAIN if we're just out of buffers to dequeue.
        break;
      }
      DPLOG(ERROR) << "DequeueGsc(): ioctl() failed: VIDIOC_DQBUF";
      NOTIFY_ERROR(kPlatformFailureError);
      return;
    }
    GscOutputRecord& output_record = gsc_output_buffer_map_[dqbuf.index];
    DCHECK(output_record.at_device);
    DCHECK(output_record.mfc_input != -1);
    mfc_ready_input_buffers_.push_back(output_record.mfc_input);
    output_record.at_device = false;
    output_record.mfc_input = -1;
    gsc_free_output_buffers_.push_back(dqbuf.index);
    gsc_output_buffer_queued_count_--;
  }
}
void ExynosVideoEncodeAccelerator::EnqueueMfc() {
  DVLOG(3) << "EnqueueMfc()";
  DCHECK_EQ(encoder_thread_.message_loop(), base::MessageLoop::current());

  // Enqueue all the MFC inputs we can.
  const int old_mfc_inputs_queued = mfc_input_buffer_queued_count_;
  while (!mfc_ready_input_buffers_.empty()) {
    if (!EnqueueMfcInputRecord())
      return;
  }
  if (old_mfc_inputs_queued == 0 && mfc_input_buffer_queued_count_ != 0) {
    // We just started up a previously empty queue.
    // Queue state changed; signal interrupt.
    if (!SetDevicePollInterrupt())
      return;
    // Start VIDIOC_STREAMON if we haven't yet.
    if (!mfc_input_streamon_) {
      __u32 type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
      IOCTL_OR_ERROR_RETURN(mfc_fd_, VIDIOC_STREAMON, &type);
      mfc_input_streamon_ = true;
    }
  }

  // Enqueue all the MFC outputs we can.
  const int old_mfc_outputs_queued = mfc_output_buffer_queued_count_;
  while (!mfc_free_output_buffers_.empty() && !encoder_output_queue_.empty()) {
    if (!EnqueueMfcOutputRecord())
      return;
  }
  if (old_mfc_outputs_queued == 0 && mfc_output_buffer_queued_count_ != 0) {
    // We just started up a previously empty queue.
    // Queue state changed; signal interrupt.
    if (!SetDevicePollInterrupt())
      return;
    // Start VIDIOC_STREAMON if we haven't yet.
    if (!mfc_output_streamon_) {
      __u32 type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
      IOCTL_OR_ERROR_RETURN(mfc_fd_, VIDIOC_STREAMON, &type);
      mfc_output_streamon_ = true;
    }
  }
}

void ExynosVideoEncodeAccelerator::DequeueMfc() {
  DVLOG(3) << "DequeueMfc()";
  DCHECK_EQ(encoder_thread_.message_loop(), base::MessageLoop::current());

  // Dequeue completed MFC input (VIDEO_OUTPUT) buffers, and recycle to the free
  // list.
  struct v4l2_buffer dqbuf;
  struct v4l2_plane planes[2];
  while (mfc_input_buffer_queued_count_ > 0) {
    DCHECK(mfc_input_streamon_);
    memset(&dqbuf, 0, sizeof(dqbuf));
    memset(&planes, 0, sizeof(planes));
    dqbuf.type     = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
    dqbuf.memory   = V4L2_MEMORY_MMAP;
    dqbuf.m.planes = planes;
    dqbuf.length   = 2;
    if (HANDLE_EINTR(ioctl(mfc_fd_, VIDIOC_DQBUF, &dqbuf)) != 0) {
      if (errno == EAGAIN) {
        // EAGAIN if we're just out of buffers to dequeue.
        break;
      }
      DPLOG(ERROR) << "DequeueMfc(): ioctl() failed: VIDIOC_DQBUF";
      NOTIFY_ERROR(kPlatformFailureError);
      return;
    }
    MfcInputRecord& input_record = mfc_input_buffer_map_[dqbuf.index];
    DCHECK(input_record.at_device);
    input_record.at_device = false;
    mfc_free_input_buffers_.push_back(dqbuf.index);
    mfc_input_buffer_queued_count_--;
  }

  // Dequeue completed MFC output (VIDEO_CAPTURE) buffers, and recycle to the
  // free list.  Notify the client that an output buffer is complete.
  while (mfc_output_buffer_queued_count_ > 0) {
    DCHECK(mfc_output_streamon_);
    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   = 1;
    if (HANDLE_EINTR(ioctl(mfc_fd_, VIDIOC_DQBUF, &dqbuf)) != 0) {
      if (errno == EAGAIN) {
        // EAGAIN if we're just out of buffers to dequeue.
        break;
      }
      DPLOG(ERROR) << "DequeueMfc(): ioctl() failed: VIDIOC_DQBUF";
      NOTIFY_ERROR(kPlatformFailureError);
      return;
    }
    const bool key_frame = ((dqbuf.flags & V4L2_BUF_FLAG_KEYFRAME) != 0);
    MfcOutputRecord& output_record = mfc_output_buffer_map_[dqbuf.index];
    DCHECK(output_record.at_device);
    DCHECK(output_record.buffer_ref.get());

    void* output_data = output_record.address;
    size_t output_size = dqbuf.m.planes[0].bytesused;
    // This shouldn't happen, but just in case. We should be able to recover
    // after next keyframe after showing some corruption.
    DCHECK_LE(output_size, output_buffer_byte_size_);
    if (output_size > output_buffer_byte_size_)
      output_size = output_buffer_byte_size_;
    uint8* target_data =
        reinterpret_cast<uint8*>(output_record.buffer_ref->shm->memory());
    if (stream_header_size_ == 0) {
      // Assume that the first buffer dequeued is the stream header.
      stream_header_size_ = output_size;
      stream_header_.reset(new uint8[stream_header_size_]);
      memcpy(stream_header_.get(), output_data, stream_header_size_);
    }
    if (key_frame &&
        output_buffer_byte_size_ - stream_header_size_ >= output_size) {
      // Insert stream header before every keyframe.
      memcpy(target_data, stream_header_.get(), stream_header_size_);
      memcpy(target_data + stream_header_size_, output_data, output_size);
      output_size += stream_header_size_;
    } else {
      memcpy(target_data, output_data, output_size);
    }
    DVLOG(3) << "DequeueMfc(): returning "
                "bitstream_buffer_id=" << output_record.buffer_ref->id
             << ", key_frame=" << key_frame;
    child_message_loop_proxy_->PostTask(
        FROM_HERE,
        base::Bind(&Client::BitstreamBufferReady,
                   client_,
                   output_record.buffer_ref->id,
                   output_size,
                   key_frame));
    output_record.at_device = false;
    output_record.buffer_ref.reset();
    mfc_free_output_buffers_.push_back(dqbuf.index);
    mfc_output_buffer_queued_count_--;
  }
}

bool ExynosVideoEncodeAccelerator::EnqueueGscInputRecord() {
  DVLOG(3) << "EnqueueGscInputRecord()";
  DCHECK(!encoder_input_queue_.empty());
  DCHECK(!gsc_free_input_buffers_.empty());

  // Enqueue a GSC input (VIDEO_OUTPUT) buffer for an input video frame
  scoped_refptr<media::VideoFrame> frame = encoder_input_queue_.front();
  const int gsc_buffer = gsc_free_input_buffers_.back();
  GscInputRecord& input_record = gsc_input_buffer_map_[gsc_buffer];
  DCHECK(!input_record.at_device);
  DCHECK(!input_record.frame.get());
  struct v4l2_buffer qbuf;
  struct v4l2_plane qbuf_planes[3];
  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.memory   = V4L2_MEMORY_USERPTR;
  qbuf.m.planes = qbuf_planes;
  switch (input_format_fourcc_) {
    case V4L2_PIX_FMT_RGB32: {
      qbuf.m.planes[0].bytesused = input_allocated_size_.GetArea() * 4;
      qbuf.m.planes[0].length    = input_allocated_size_.GetArea() * 4;
      qbuf.m.planes[0].m.userptr = reinterpret_cast<unsigned long>(
          frame->data(media::VideoFrame::kRGBPlane));
      qbuf.length = 1;
      break;
    }
    case V4L2_PIX_FMT_YUV420M: {
      qbuf.m.planes[0].bytesused = input_allocated_size_.GetArea();
      qbuf.m.planes[0].length    = input_allocated_size_.GetArea();
      qbuf.m.planes[0].m.userptr = reinterpret_cast<unsigned long>(
          frame->data(media::VideoFrame::kYPlane));
      qbuf.m.planes[1].bytesused = input_allocated_size_.GetArea() / 4;
      qbuf.m.planes[1].length    = input_allocated_size_.GetArea() / 4;
      qbuf.m.planes[1].m.userptr = reinterpret_cast<unsigned long>(
          frame->data(media::VideoFrame::kUPlane));
      qbuf.m.planes[2].bytesused = input_allocated_size_.GetArea() / 4;
      qbuf.m.planes[2].length    = input_allocated_size_.GetArea() / 4;
      qbuf.m.planes[2].m.userptr = reinterpret_cast<unsigned long>(
          frame->data(media::VideoFrame::kVPlane));
      qbuf.length = 3;
      break;
    }
    default:
      NOTREACHED();
      NOTIFY_ERROR(kIllegalStateError);
      return false;
  }
  IOCTL_OR_ERROR_RETURN_FALSE(gsc_fd_, VIDIOC_QBUF, &qbuf);
  input_record.at_device = true;
  input_record.frame = frame;
  encoder_input_queue_.pop_front();
  gsc_free_input_buffers_.pop_back();
  gsc_input_buffer_queued_count_++;
  return true;
}

bool ExynosVideoEncodeAccelerator::EnqueueGscOutputRecord() {
  DVLOG(3) << "EnqueueGscOutputRecord()";
  DCHECK(!gsc_free_output_buffers_.empty());
  DCHECK(!mfc_free_input_buffers_.empty());

  // Enqueue a GSC output (VIDEO_CAPTURE) buffer.
  const int gsc_buffer = gsc_free_output_buffers_.back();
  const int mfc_buffer = mfc_free_input_buffers_.back();
  GscOutputRecord& output_record = gsc_output_buffer_map_[gsc_buffer];
  MfcInputRecord& input_record = mfc_input_buffer_map_[mfc_buffer];
  DCHECK(!output_record.at_device);
  DCHECK_EQ(output_record.mfc_input, -1);
  DCHECK(!input_record.at_device);
  struct v4l2_buffer qbuf;
  struct v4l2_plane qbuf_planes[2];
  memset(&qbuf, 0, sizeof(qbuf));
  memset(qbuf_planes, 0, sizeof(qbuf_planes));
  qbuf.index            = gsc_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 = input_record.fd[0];
  qbuf.m.planes[1].m.fd = input_record.fd[1];
  qbuf.length           = 2;
  IOCTL_OR_ERROR_RETURN_FALSE(gsc_fd_, VIDIOC_QBUF, &qbuf);
  output_record.at_device = true;
  output_record.mfc_input = mfc_buffer;
  mfc_free_input_buffers_.pop_back();
  gsc_free_output_buffers_.pop_back();
  gsc_output_buffer_queued_count_++;
  return true;
}

bool ExynosVideoEncodeAccelerator::EnqueueMfcInputRecord() {
  DVLOG(3) << "EnqueueMfcInputRecord()";
  DCHECK(!mfc_ready_input_buffers_.empty());

  // Enqueue a MFC input (VIDEO_OUTPUT) buffer.
  const int mfc_buffer = mfc_ready_input_buffers_.front();
  MfcInputRecord& input_record = mfc_input_buffer_map_[mfc_buffer];
  DCHECK(!input_record.at_device);
  struct v4l2_buffer qbuf;
  struct v4l2_plane qbuf_planes[2];
  memset(&qbuf, 0, sizeof(qbuf));
  memset(qbuf_planes, 0, sizeof(qbuf_planes));
  qbuf.index     = mfc_buffer;
  qbuf.type      = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
  qbuf.memory    = V4L2_MEMORY_MMAP;
  qbuf.m.planes  = qbuf_planes;
  qbuf.length    = 2;
  IOCTL_OR_ERROR_RETURN_FALSE(mfc_fd_, VIDIOC_QBUF, &qbuf);
  input_record.at_device = true;
  mfc_ready_input_buffers_.pop_front();
  mfc_input_buffer_queued_count_++;
  return true;
}

bool ExynosVideoEncodeAccelerator::EnqueueMfcOutputRecord() {
  DVLOG(3) << "EnqueueMfcOutputRecord()";
  DCHECK(!mfc_free_output_buffers_.empty());
  DCHECK(!encoder_output_queue_.empty());

  // Enqueue a MFC output (VIDEO_CAPTURE) buffer.
  linked_ptr<BitstreamBufferRef> output_buffer = encoder_output_queue_.back();
  const int mfc_buffer = mfc_free_output_buffers_.back();
  MfcOutputRecord& output_record = mfc_output_buffer_map_[mfc_buffer];
  DCHECK(!output_record.at_device);
  DCHECK(!output_record.buffer_ref.get());
  struct v4l2_buffer qbuf;
  struct v4l2_plane qbuf_planes[1];
  memset(&qbuf, 0, sizeof(qbuf));
  memset(qbuf_planes, 0, sizeof(qbuf_planes));
  qbuf.index                 = mfc_buffer;
  qbuf.type                  = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
  qbuf.memory                = V4L2_MEMORY_MMAP;
  qbuf.m.planes              = qbuf_planes;
  qbuf.length                = 1;
  IOCTL_OR_ERROR_RETURN_FALSE(mfc_fd_, VIDIOC_QBUF, &qbuf);
  output_record.at_device = true;
  output_record.buffer_ref = output_buffer;
  encoder_output_queue_.pop_back();
  mfc_free_output_buffers_.pop_back();
  mfc_output_buffer_queued_count_++;
  return true;
}

bool ExynosVideoEncodeAccelerator::StartDevicePoll() {
  DVLOG(3) << "StartDevicePoll()";
  DCHECK_EQ(encoder_thread_.message_loop(), base::MessageLoop::current());
  DCHECK(!device_poll_thread_.IsRunning());

  // Start up the device poll thread and schedule its first DevicePollTask().
  if (!device_poll_thread_.Start()) {
    DLOG(ERROR) << "StartDevicePoll(): Device thread failed to start";
    NOTIFY_ERROR(kPlatformFailureError);
    return false;
  }
  // Enqueue a poll task with no devices to poll on -- it will wait only on the
  // interrupt fd.
  device_poll_thread_.message_loop()->PostTask(
      FROM_HERE,
      base::Bind(&ExynosVideoEncodeAccelerator::DevicePollTask,
                 base::Unretained(this),
                 0));

  return true;
}

bool ExynosVideoEncodeAccelerator::StopDevicePoll() {
  DVLOG(3) << "StopDevicePoll()";

  // Signal the DevicePollTask() to stop, and stop the device poll thread.
  if (!SetDevicePollInterrupt())
    return false;
  device_poll_thread_.Stop();
  // Clear the interrupt now, to be sure.
  if (!ClearDevicePollInterrupt())
    return false;

  // Stop streaming.
  if (gsc_input_streamon_) {
    __u32 type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
    IOCTL_OR_ERROR_RETURN_FALSE(gsc_fd_, VIDIOC_STREAMOFF, &type);
  }
  gsc_input_streamon_ = false;
  if (gsc_output_streamon_) {
    __u32 type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
    IOCTL_OR_ERROR_RETURN_FALSE(gsc_fd_, VIDIOC_STREAMOFF, &type);
  }
  gsc_output_streamon_ = false;
  if (mfc_input_streamon_) {
    __u32 type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
    IOCTL_OR_ERROR_RETURN_FALSE(mfc_fd_, VIDIOC_STREAMOFF, &type);
  }
  mfc_input_streamon_ = false;
  if (mfc_output_streamon_) {
    __u32 type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
    IOCTL_OR_ERROR_RETURN_FALSE(mfc_fd_, VIDIOC_STREAMOFF, &type);
  }
  mfc_output_streamon_ = false;

  // Reset all our accounting info.
  encoder_input_queue_.clear();
  gsc_free_input_buffers_.clear();
  for (size_t i = 0; i < gsc_input_buffer_map_.size(); ++i) {
    GscInputRecord& input_record = gsc_input_buffer_map_[i];
    input_record.at_device = false;
    input_record.frame = NULL;
    gsc_free_input_buffers_.push_back(i);
  }
  gsc_input_buffer_queued_count_ = 0;
  gsc_free_output_buffers_.clear();
  for (size_t i = 0; i < gsc_output_buffer_map_.size(); ++i) {
    GscOutputRecord& output_record = gsc_output_buffer_map_[i];
    output_record.at_device = false;
    output_record.mfc_input = -1;
    gsc_free_output_buffers_.push_back(i);
  }
  gsc_output_buffer_queued_count_ = 0;
  mfc_ready_input_buffers_.clear();
  mfc_free_input_buffers_.clear();
  for (size_t i = 0; i < mfc_input_buffer_map_.size(); ++i) {
    MfcInputRecord& input_record = mfc_input_buffer_map_[i];
    input_record.at_device = false;
    mfc_free_input_buffers_.push_back(i);
  }
  mfc_input_buffer_queued_count_ = 0;
  mfc_free_output_buffers_.clear();
  for (size_t i = 0; i < mfc_output_buffer_map_.size(); ++i) {
    MfcOutputRecord& output_record = mfc_output_buffer_map_[i];
    output_record.at_device = false;
    output_record.buffer_ref.reset();
    mfc_free_output_buffers_.push_back(i);
  }
  mfc_output_buffer_queued_count_ = 0;
  encoder_output_queue_.clear();

  DVLOG(3) << "StopDevicePoll(): device poll stopped";
  return true;
}

bool ExynosVideoEncodeAccelerator::SetDevicePollInterrupt() {
  DVLOG(3) << "SetDevicePollInterrupt()";

  // We might get called here if we fail during initialization, in which case we
  // don't have a file descriptor.
  if (device_poll_interrupt_fd_ == -1)
    return true;

  const uint64 buf = 1;
  if (HANDLE_EINTR((write(device_poll_interrupt_fd_, &buf, sizeof(buf)))) <
      static_cast<ssize_t>(sizeof(buf))) {
    DPLOG(ERROR) << "SetDevicePollInterrupt(): write() failed";
    NOTIFY_ERROR(kPlatformFailureError);
    return false;
  }
  return true;
}

bool ExynosVideoEncodeAccelerator::ClearDevicePollInterrupt() {
  DVLOG(3) << "ClearDevicePollInterrupt()";

  // We might get called here if we fail during initialization, in which case we
  // don't have a file descriptor.
  if (device_poll_interrupt_fd_ == -1)
    return true;

  uint64 buf;
  if (HANDLE_EINTR(read(device_poll_interrupt_fd_, &buf, sizeof(buf))) <
      static_cast<ssize_t>(sizeof(buf))) {
    if (errno == EAGAIN) {
      // No interrupt flag set, and we're reading nonblocking.  Not an error.
      return true;
    } else {
      DPLOG(ERROR) << "ClearDevicePollInterrupt(): read() failed";
      NOTIFY_ERROR(kPlatformFailureError);
      return false;
    }
  }
  return true;
}

void ExynosVideoEncodeAccelerator::DevicePollTask(unsigned int poll_fds) {
  DVLOG(3) << "DevicePollTask()";
  DCHECK_EQ(device_poll_thread_.message_loop(), base::MessageLoop::current());
  DCHECK_NE(device_poll_interrupt_fd_, -1);

  // This routine just polls the set of device fds, and schedules a
  // ServiceDeviceTask() on encoder_thread_ when processing needs to occur.
  // Other threads may notify this task to return early by writing to
  // device_poll_interrupt_fd_.
  struct pollfd pollfds[3];
  nfds_t nfds;

  // Add device_poll_interrupt_fd_;
  pollfds[0].fd = device_poll_interrupt_fd_;
  pollfds[0].events = POLLIN | POLLERR;
  nfds = 1;

  // Add GSC fd, if we should poll on it.
  // GSC has to wait until both input and output buffers are queued.
  if (poll_fds & kPollGsc) {
    DVLOG(3) << "DevicePollTask(): adding GSC to poll() set";
    pollfds[nfds].fd = gsc_fd_;
    pollfds[nfds].events = POLLIN | POLLOUT | POLLERR;
    nfds++;
  }
  if (poll_fds & kPollMfc) {
    DVLOG(3) << "DevicePollTask(): adding MFC to poll() set";
    pollfds[nfds].fd = mfc_fd_;
    pollfds[nfds].events = POLLIN | POLLOUT | POLLERR;
    nfds++;
  }

  // Poll it!
  if (HANDLE_EINTR(poll(pollfds, nfds, -1)) == -1) {
    DPLOG(ERROR) << "DevicePollTask(): poll() failed";
    NOTIFY_ERROR(kPlatformFailureError);
    return;
  }

  // All processing should happen on ServiceDeviceTask(), since we shouldn't
  // touch encoder state from this thread.
  encoder_thread_.message_loop()->PostTask(
      FROM_HERE,
      base::Bind(&ExynosVideoEncodeAccelerator::ServiceDeviceTask,
                 base::Unretained(this)));
}

void ExynosVideoEncodeAccelerator::NotifyError(Error error) {
  DVLOG(1) << "NotifyError(): error=" << error;

  if (!child_message_loop_proxy_->BelongsToCurrentThread()) {
    child_message_loop_proxy_->PostTask(
        FROM_HERE,
        base::Bind(
            &ExynosVideoEncodeAccelerator::NotifyError, weak_this_, error));
    return;
  }

  if (client_) {
    client_->NotifyError(error);
    client_ptr_factory_.InvalidateWeakPtrs();
  }
}

void ExynosVideoEncodeAccelerator::SetEncoderState(State state) {
  DVLOG(3) << "SetEncoderState(): state=" << state;

  // We can touch encoder_state_ only if this is the encoder thread or the
  // encoder thread isn't running.
  if (encoder_thread_.message_loop() != NULL &&
      encoder_thread_.message_loop() != base::MessageLoop::current()) {
    encoder_thread_.message_loop()->PostTask(
        FROM_HERE,
        base::Bind(&ExynosVideoEncodeAccelerator::SetEncoderState,
                   base::Unretained(this),
                   state));
  } else {
    encoder_state_ = state;
  }
}

void ExynosVideoEncodeAccelerator::RequestEncodingParametersChangeTask(
    uint32 bitrate,
    uint32 framerate) {
  DVLOG(3) << "RequestEncodingParametersChangeTask(): bitrate=" << bitrate
           << ", framerate=" << framerate;
  DCHECK_EQ(encoder_thread_.message_loop(), base::MessageLoop::current());

  if (bitrate < 1)
    bitrate = 1;
  if (framerate < 1)
    framerate = 1;

  struct v4l2_ext_control ctrls[1];
  struct v4l2_ext_controls control;
  memset(&ctrls, 0, sizeof(ctrls));
  memset(&control, 0, sizeof(control));
  ctrls[0].id    = V4L2_CID_MPEG_VIDEO_BITRATE;
  ctrls[0].value = bitrate;
  control.ctrl_class = V4L2_CTRL_CLASS_MPEG;
  control.count = arraysize(ctrls);
  control.controls = ctrls;
  IOCTL_OR_ERROR_RETURN(mfc_fd_, VIDIOC_S_EXT_CTRLS, &control);

  struct v4l2_streamparm parms;
  memset(&parms, 0, sizeof(parms));
  parms.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
  // Note that we are provided "frames per second" but V4L2 expects "time per
  // frame"; hence we provide the reciprocal of the framerate here.
  parms.parm.output.timeperframe.numerator = 1;
  parms.parm.output.timeperframe.denominator = framerate;
  IOCTL_OR_ERROR_RETURN(mfc_fd_, VIDIOC_S_PARM, &parms);
}

bool ExynosVideoEncodeAccelerator::CreateGscInputBuffers() {
  DVLOG(3) << "CreateGscInputBuffers()";
  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
  DCHECK_EQ(encoder_state_, kUninitialized);
  DCHECK(!gsc_input_streamon_);

  struct v4l2_control control;
  memset(&control, 0, sizeof(control));
  control.id    = V4L2_CID_ROTATE;
  control.value = 0;
  IOCTL_OR_ERROR_RETURN_FALSE(gsc_fd_, VIDIOC_S_CTRL, &control);

  // HFLIP actually seems to control vertical mirroring for GSC, and vice-versa.
  memset(&control, 0, sizeof(control));
  control.id    = V4L2_CID_HFLIP;
  control.value = 0;
  IOCTL_OR_ERROR_RETURN_FALSE(gsc_fd_, VIDIOC_S_CTRL, &control);

  memset(&control, 0, sizeof(control));
  control.id    = V4L2_CID_VFLIP;
  control.value = 0;
  IOCTL_OR_ERROR_RETURN_FALSE(gsc_fd_, VIDIOC_S_CTRL, &control);

  memset(&control, 0, sizeof(control));
  control.id    = V4L2_CID_ALPHA_COMPONENT;
  control.value = 255;
  if (HANDLE_EINTR(ioctl(gsc_fd_, VIDIOC_S_CTRL, &control)) != 0) {
    // TODO(posciak): This is a  temporary hack and should be removed when
    // all platforms migrate to kernel >=3.8.
    memset(&control, 0, sizeof(control));
    control.id    = V4L2_CID_GLOBAL_ALPHA;
    control.value = 255;
    IOCTL_OR_ERROR_RETURN_FALSE(gsc_fd_, VIDIOC_S_CTRL, &control);
  }

  struct v4l2_format format;
  memset(&format, 0, sizeof(format));
  format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
  format.fmt.pix_mp.width  = input_allocated_size_.width();
  format.fmt.pix_mp.height = input_allocated_size_.height();
  format.fmt.pix_mp.pixelformat = input_format_fourcc_;
  switch (input_format_fourcc_) {
    case V4L2_PIX_FMT_RGB32:
      format.fmt.pix_mp.plane_fmt[0].sizeimage =
          input_allocated_size_.GetArea() * 4;
      format.fmt.pix_mp.plane_fmt[0].bytesperline =
          input_allocated_size_.width() * 4;
      format.fmt.pix_mp.num_planes = 1;
      break;
    case V4L2_PIX_FMT_YUV420M:
      format.fmt.pix_mp.plane_fmt[0].sizeimage =
          input_allocated_size_.GetArea();
      format.fmt.pix_mp.plane_fmt[0].bytesperline =
          input_allocated_size_.width();
      format.fmt.pix_mp.plane_fmt[1].sizeimage =
          input_allocated_size_.GetArea() / 4;
      format.fmt.pix_mp.plane_fmt[1].bytesperline =
          input_allocated_size_.width() / 2;
      format.fmt.pix_mp.plane_fmt[2].sizeimage =
          input_allocated_size_.GetArea() / 4;
      format.fmt.pix_mp.plane_fmt[2].bytesperline =
          input_allocated_size_.width() / 2;
      format.fmt.pix_mp.num_planes = 3;
      break;
    default:
      NOTREACHED();
      NOTIFY_ERROR(kIllegalStateError);
      return false;
  }
  IOCTL_OR_ERROR_RETURN_FALSE(gsc_fd_, VIDIOC_S_FMT, &format);

  struct v4l2_crop crop;
  memset(&crop, 0, sizeof(crop));
  crop.type     = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
  crop.c.left   = 0;
  crop.c.top    = 0;
  crop.c.width  = input_visible_size_.width();
  crop.c.height = input_visible_size_.height();
  IOCTL_OR_ERROR_RETURN_FALSE(gsc_fd_, VIDIOC_S_CROP, &crop);

  struct v4l2_requestbuffers reqbufs;
  memset(&reqbufs, 0, sizeof(reqbufs));
  reqbufs.count  = kGscInputBufferCount;
  reqbufs.type   = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
  reqbufs.memory = V4L2_MEMORY_USERPTR;
  IOCTL_OR_ERROR_RETURN_FALSE(gsc_fd_, VIDIOC_REQBUFS, &reqbufs);

  DCHECK(gsc_input_buffer_map_.empty());
  gsc_input_buffer_map_.resize(reqbufs.count);
  for (size_t i = 0; i < gsc_input_buffer_map_.size(); ++i)
    gsc_free_input_buffers_.push_back(i);

  return true;
}

bool ExynosVideoEncodeAccelerator::CreateGscOutputBuffers() {
  DVLOG(3) << "CreateGscOutputBuffers()";
  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
  DCHECK_EQ(encoder_state_, kUninitialized);
  DCHECK(!gsc_output_streamon_);

  struct v4l2_format format;
  memset(&format, 0, sizeof(format));
  format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
  format.fmt.pix_mp.width = converted_allocated_size_.width();
  format.fmt.pix_mp.height = converted_allocated_size_.height();
  format.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_NV12M;
  format.fmt.pix_mp.plane_fmt[0].sizeimage =
      converted_allocated_size_.GetArea();
  format.fmt.pix_mp.plane_fmt[1].sizeimage =
      converted_allocated_size_.GetArea() / 2;
  format.fmt.pix_mp.plane_fmt[0].bytesperline =
      converted_allocated_size_.width();
  format.fmt.pix_mp.plane_fmt[1].bytesperline =
      converted_allocated_size_.width();
  format.fmt.pix_mp.num_planes = 2;
  IOCTL_OR_ERROR_RETURN_FALSE(gsc_fd_, VIDIOC_S_FMT, &format);

  struct v4l2_crop crop;
  memset(&crop, 0, sizeof(crop));
  crop.type     = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
  crop.c.left   = 0;
  crop.c.top    = 0;
  crop.c.width  = converted_visible_size_.width();
  crop.c.height = converted_visible_size_.height();
  IOCTL_OR_ERROR_RETURN_FALSE(gsc_fd_, VIDIOC_S_CROP, &crop);

  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;
  IOCTL_OR_ERROR_RETURN_FALSE(gsc_fd_, VIDIOC_REQBUFS, &reqbufs);

  DCHECK(gsc_output_buffer_map_.empty());
  gsc_output_buffer_map_.resize(reqbufs.count);
  for (size_t i = 0; i < gsc_output_buffer_map_.size(); ++i)
    gsc_free_output_buffers_.push_back(i);
  return true;
}

bool ExynosVideoEncodeAccelerator::SetMfcFormats() {
  DVLOG(3) << "SetMfcFormats()";
  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
  DCHECK(!mfc_input_streamon_);
  DCHECK(!mfc_output_streamon_);

  // VIDIOC_S_FMT on OUTPUT queue.
  struct v4l2_format format;
  memset(&format, 0, sizeof(format));
  format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
  format.fmt.pix_mp.width = input_allocated_size_.width();
  format.fmt.pix_mp.height = input_allocated_size_.height();
  format.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_NV12M;
  format.fmt.pix_mp.num_planes = 2;
  IOCTL_OR_ERROR_RETURN_FALSE(mfc_fd_, VIDIOC_S_FMT, &format);
  // We read direct from GSC, so we rely on the HW not changing our set
  // size/stride.
  DCHECK_EQ(format.fmt.pix_mp.plane_fmt[0].sizeimage,
            static_cast<__u32>(input_allocated_size_.GetArea()));
  DCHECK_EQ(format.fmt.pix_mp.plane_fmt[0].bytesperline,
            static_cast<__u32>(input_allocated_size_.width()));
  DCHECK_EQ(format.fmt.pix_mp.plane_fmt[1].sizeimage,
            static_cast<__u32>(input_allocated_size_.GetArea() / 2));
  DCHECK_EQ(format.fmt.pix_mp.plane_fmt[1].bytesperline,
            static_cast<__u32>(input_allocated_size_.width()));

  struct v4l2_crop crop;
  memset(&crop, 0, sizeof(crop));
  crop.type     = V4L2_BUF_TYPE_VIDEO_OUTPUT;
  crop.c.left   = 0;
  crop.c.top    = 0;
  crop.c.width  = input_visible_size_.width();
  crop.c.height = input_visible_size_.height();
  IOCTL_OR_ERROR_RETURN_FALSE(mfc_fd_, VIDIOC_S_CROP, &crop);

  // VIDIOC_S_FMT on CAPTURE queue.
  output_buffer_byte_size_ = kMfcOutputBufferSize;
  memset(&format, 0, sizeof(format));
  format.type                   = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
  format.fmt.pix_mp.width       = output_visible_size_.width();
  format.fmt.pix_mp.height      = output_visible_size_.height();
  format.fmt.pix_mp.pixelformat = output_format_fourcc_;
  format.fmt.pix_mp.plane_fmt[0].sizeimage = output_buffer_byte_size_;
  format.fmt.pix_mp.num_planes  = 1;
  IOCTL_OR_ERROR_RETURN_FALSE(mfc_fd_, VIDIOC_S_FMT, &format);

  struct v4l2_ext_control ctrls[8];
  struct v4l2_ext_controls control;
  memset(&ctrls, 0, sizeof(ctrls));
  memset(&control, 0, sizeof(control));
  // No B-frames, for lowest decoding latency.
  ctrls[0].id    = V4L2_CID_MPEG_VIDEO_B_FRAMES;
  ctrls[0].value = 0;
  // Enable frame-level bitrate control.
  ctrls[1].id    = V4L2_CID_MPEG_VIDEO_FRAME_RC_ENABLE;
  ctrls[1].value = 1;
  // Enable "tight" bitrate mode. For this to work properly, frame- and mb-level
  // bitrate controls have to be enabled as well.
  ctrls[2].id    = V4L2_CID_MPEG_MFC51_VIDEO_RC_REACTION_COEFF;
  ctrls[2].value = 1;
  // Force bitrate control to average over a GOP (for tight bitrate
  // tolerance).
  ctrls[3].id    = V4L2_CID_MPEG_MFC51_VIDEO_RC_FIXED_TARGET_BIT;
  ctrls[3].value = 1;
  // Quantization parameter maximum value (for variable bitrate control).
  ctrls[4].id    = V4L2_CID_MPEG_VIDEO_H264_MAX_QP;
  ctrls[4].value = 51;
  // Separate stream header so we can cache it and insert into the stream.
  ctrls[5].id    = V4L2_CID_MPEG_VIDEO_HEADER_MODE;
  ctrls[5].value = V4L2_MPEG_VIDEO_HEADER_MODE_SEPARATE;
  // Enable macroblock-level bitrate control.
  ctrls[6].id    = V4L2_CID_MPEG_VIDEO_MB_RC_ENABLE;
  ctrls[6].value = 1;
  // Disable periodic key frames.
  ctrls[7].id    = V4L2_CID_MPEG_VIDEO_GOP_SIZE;
  ctrls[7].value = 0;
  control.ctrl_class = V4L2_CTRL_CLASS_MPEG;
  control.count = arraysize(ctrls);
  control.controls = ctrls;
  IOCTL_OR_ERROR_RETURN_FALSE(mfc_fd_, VIDIOC_S_EXT_CTRLS, &control);

  return true;
}

bool ExynosVideoEncodeAccelerator::CreateMfcInputBuffers() {
  DVLOG(3) << "CreateMfcInputBuffers()";
  // This function runs on encoder_thread_ after output buffers have been
  // provided by the client.
  DCHECK_EQ(encoder_thread_.message_loop(), base::MessageLoop::current());
  DCHECK(!mfc_input_streamon_);

  struct v4l2_requestbuffers reqbufs;
  memset(&reqbufs, 0, sizeof(reqbufs));
  reqbufs.count = 1;  // Driver will allocate the appropriate number of buffers.
  reqbufs.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
  reqbufs.memory = V4L2_MEMORY_MMAP;
  IOCTL_OR_ERROR_RETURN_FALSE(mfc_fd_, VIDIOC_REQBUFS, &reqbufs);

  DCHECK(mfc_input_buffer_map_.empty());
  mfc_input_buffer_map_.resize(reqbufs.count);
  for (size_t i = 0; i < mfc_input_buffer_map_.size(); ++i) {
    MfcInputRecord& input_record = mfc_input_buffer_map_[i];
    for (int j = 0; j < 2; ++j) {
      // Export the DMABUF fd so GSC can write to it.
      struct v4l2_exportbuffer expbuf;
      memset(&expbuf, 0, sizeof(expbuf));
      expbuf.type  = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
      expbuf.index = i;
      expbuf.plane = j;
      expbuf.flags = O_CLOEXEC;
      IOCTL_OR_ERROR_RETURN_FALSE(mfc_fd_, VIDIOC_EXPBUF, &expbuf);
      input_record.fd[j] = expbuf.fd;
    }
    mfc_free_input_buffers_.push_back(i);
  }

  return true;
}

bool ExynosVideoEncodeAccelerator::CreateMfcOutputBuffers() {
  DVLOG(3) << "CreateMfcOutputBuffers()";
  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
  DCHECK(!mfc_output_streamon_);

  struct v4l2_requestbuffers reqbufs;
  memset(&reqbufs, 0, sizeof(reqbufs));
  reqbufs.count = kMfcOutputBufferCount;
  reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
  reqbufs.memory = V4L2_MEMORY_MMAP;
  IOCTL_OR_ERROR_RETURN_FALSE(mfc_fd_, VIDIOC_REQBUFS, &reqbufs);

  DCHECK(mfc_output_buffer_map_.empty());
  mfc_output_buffer_map_.resize(reqbufs.count);
  for (size_t i = 0; i < mfc_output_buffer_map_.size(); ++i) {
    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_CAPTURE_MPLANE;
    buffer.memory   = V4L2_MEMORY_MMAP;
    buffer.m.planes = planes;
    buffer.length   = arraysize(planes);
    IOCTL_OR_ERROR_RETURN_FALSE(mfc_fd_, VIDIOC_QUERYBUF, &buffer);
    void* address = mmap(NULL, buffer.m.planes[0].length,
        PROT_READ | PROT_WRITE, MAP_SHARED, mfc_fd_,
        buffer.m.planes[0].m.mem_offset);
    if (address == MAP_FAILED) {
      DPLOG(ERROR) << "CreateMfcOutputBuffers(): mmap() failed";
      return false;
    }
    mfc_output_buffer_map_[i].address = address;
    mfc_output_buffer_map_[i].length = buffer.m.planes[0].length;
    mfc_free_output_buffers_.push_back(i);
  }

  return true;
}

void ExynosVideoEncodeAccelerator::DestroyGscInputBuffers() {
  DVLOG(3) << "DestroyGscInputBuffers()";
  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
  DCHECK(!gsc_input_streamon_);

  struct v4l2_requestbuffers reqbufs;
  memset(&reqbufs, 0, sizeof(reqbufs));
  reqbufs.count = 0;
  reqbufs.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
  reqbufs.memory = V4L2_MEMORY_USERPTR;
  if (HANDLE_EINTR(ioctl(gsc_fd_, VIDIOC_REQBUFS, &reqbufs)) != 0)
    DPLOG(ERROR) << "DestroyGscInputBuffers(): ioctl() failed: VIDIOC_REQBUFS";

  gsc_input_buffer_map_.clear();
  gsc_free_input_buffers_.clear();
}

void ExynosVideoEncodeAccelerator::DestroyGscOutputBuffers() {
  DVLOG(3) << "DestroyGscOutputBuffers()";
  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
  DCHECK(!gsc_output_streamon_);

  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;
  if (HANDLE_EINTR(ioctl(gsc_fd_, VIDIOC_REQBUFS, &reqbufs)) != 0)
    DPLOG(ERROR) << "DestroyGscOutputBuffers(): ioctl() failed: VIDIOC_REQBUFS";

  gsc_output_buffer_map_.clear();
  gsc_free_output_buffers_.clear();
}

void ExynosVideoEncodeAccelerator::DestroyMfcInputBuffers() {
  DVLOG(3) << "DestroyMfcInputBuffers()";
  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
  DCHECK(!mfc_input_streamon_);

  for (size_t buf = 0; buf < mfc_input_buffer_map_.size(); ++buf) {
    MfcInputRecord& input_record = mfc_input_buffer_map_[buf];

    for (size_t plane = 0; plane < arraysize(input_record.fd); ++plane)
      HANDLE_EINTR(close(mfc_input_buffer_map_[buf].fd[plane]));
  }

  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;
  if (HANDLE_EINTR(ioctl(mfc_fd_, VIDIOC_REQBUFS, &reqbufs)) != 0)
    DPLOG(ERROR) << "DestroyMfcInputBuffers(): ioctl() failed: VIDIOC_REQBUFS";

  mfc_input_buffer_map_.clear();
  mfc_free_input_buffers_.clear();
}

void ExynosVideoEncodeAccelerator::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].address != NULL) {
      munmap(mfc_output_buffer_map_[i].address,
             mfc_output_buffer_map_[i].length);
    }
  }

  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;
  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
