MJPEG acceleration for V4L2

content/common/gpu/media/v4l2_jpeg_decode_accelerator.cc

+// Copyright 2015 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 <linux/videodev2.h>
+#include <sys/mman.h>
+
+#include "base/bind.h"
+#include "base/thread_task_runner_handle.h"
+#include "content/common/gpu/media/v4l2_jpeg_decode_accelerator.h"
+
+#define IOCTL_OR_ERROR_RETURN_VALUE(type, arg, value, type_name)      \
+  do {                                                                \
+    if (device_->Ioctl(type, arg) != 0) {                             \
+      PLOG(ERROR) << __func__ << "(): ioctl() failed: " << type_name; \
+      return value;                                                   \
+    }                                                                 \
+  } while (0)
+
+#define IOCTL_OR_ERROR_RETURN(type, arg) \
+  IOCTL_OR_ERROR_RETURN_VALUE(type, arg, ((void)0), #type)
+
+#define IOCTL_OR_ERROR_RETURN_FALSE(type, arg) \
+  IOCTL_OR_ERROR_RETURN_VALUE(type, arg, false, #type)
+
+#define IOCTL_OR_LOG_ERROR(type, arg)                             \
+  do {                                                            \
+    if (device_->Ioctl(type, arg) != 0)                           \
+      PLOG(ERROR) << __func__ << "(): ioctl() failed: " << #type; \
+  } while (0)
+
+namespace content {
+
+V4L2JpegDecodeAccelerator::BufferRecord::BufferRecord()
+    : address(nullptr), length(0), at_device(false) {
+}
+
+V4L2JpegDecodeAccelerator::BufferRecord::~BufferRecord() {
+}
+
+V4L2JpegDecodeAccelerator::JobRecord::JobRecord(
+    media::BitstreamBuffer bitstream_buffer,
+    scoped_refptr<media::VideoFrame> video_frame)
+    : bitstream_buffer(bitstream_buffer), frame(video_frame) {
+}
+
+V4L2JpegDecodeAccelerator::JobRecord::~JobRecord() {
+}
+
+V4L2JpegDecodeAccelerator::V4L2JpegDecodeAccelerator(
+    const scoped_refptr<V4L2Device>& device,
+    const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
+    : recreate_input_buffers_pending_(false),
+      recreate_output_buffers_pending_(false),
+      child_task_runner_(base::ThreadTaskRunnerHandle::Get()),
+      io_task_runner_(io_task_runner),
+      client_(nullptr),
+      device_(device),
+      decoder_thread_("V4L2JpegDecodeThread"),
+      device_poll_thread_("V4L2JpegDecodeDevicePollThread"),
+      input_streamon_(false),
+      input_buffer_queued_count_(0),
+      output_streamon_(false),
+      output_buffer_queued_count_(0),
+      weak_factory_(this) {
+}
+
+V4L2JpegDecodeAccelerator::~V4L2JpegDecodeAccelerator() {
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
+
+  if (decoder_thread_.IsRunning()) {
+    decoder_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&V4L2JpegDecodeAccelerator::DestroyTask,
+                              base::Unretained(this)));
+    decoder_thread_.Stop();
+  }
+  weak_factory_.InvalidateWeakPtrs();
+  DCHECK(!device_poll_thread_.IsRunning());
+}
+
+void V4L2JpegDecodeAccelerator::DestroyTask() {
+  DCHECK(decoder_task_runner_->BelongsToCurrentThread());
+  // Stop streaming and the device_poll_thread_.
+  while (!input_jobs_.empty()) input_jobs_.pop();
+  StopDevicePoll();
+
+  DestroyInputBuffers();
+  DestroyOutputBuffers();
+}
+
+void V4L2JpegDecodeAccelerator::NotifyError(int32_t bitstream_buffer_id,
+                                            Error error) {
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
+  LOG(ERROR) << "Notifying of error " << error << " for buffer id "
+             << bitstream_buffer_id;
+  DCHECK(client_);
+  client_->NotifyError(bitstream_buffer_id, error);
+}
+
+void V4L2JpegDecodeAccelerator::PostNotifyError(
+    int32_t bitstream_buffer_id,
+    Error error) {
+  child_task_runner_->PostTask(
+      FROM_HERE,
+      base::Bind(&V4L2JpegDecodeAccelerator::NotifyError,
+                 weak_factory_.GetWeakPtr(), bitstream_buffer_id, error));
+}
+
+bool V4L2JpegDecodeAccelerator::Initialize(Client* client) {
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
+
+  // Capabilities check.
+  struct v4l2_capability caps;
+  const __u32 kCapsRequired = V4L2_CAP_STREAMING | V4L2_CAP_VIDEO_M2M;
+  IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QUERYCAP, &caps);
+  if ((caps.capabilities & kCapsRequired) != kCapsRequired) {
+    LOG(ERROR) << "Initialize(): VIDIOC_QUERYCAP, caps check failed: 0x"
+               << std::hex << caps.capabilities;
+    return false;
+  }
+
+  if (!decoder_thread_.Start()) {
+    LOG(ERROR) << "Initialize(): decoder thread failed to start";
+    return false;
+  }
+  client_ = client;
+  decoder_task_runner_ = decoder_thread_.task_runner();
+
+  decoder_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&V4L2JpegDecodeAccelerator::StartDevicePoll,
+                            base::Unretained(this)));
+
+  DVLOG(1) << "V4L2JpegDecodeAccelerator initialized.";
+  return true;
+}
+
+void V4L2JpegDecodeAccelerator::Decode(
+    const media::BitstreamBuffer& bitstream_buffer,
+    const scoped_refptr<media::VideoFrame>& video_frame) {
+  DVLOG(1) << "Decode(): input_id=" << bitstream_buffer.id()
+           << ", size=" << bitstream_buffer.size();
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
+  DCHECK_EQ(video_frame->format(), media::VideoFrame::I420);
+
+  scoped_ptr<JobRecord> job_record(
+      new JobRecord(bitstream_buffer, video_frame));
+
+  decoder_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&V4L2JpegDecodeAccelerator::DecodeTask,
+                            base::Unretained(this), base::Passed(&job_record)));
+}
+
+void V4L2JpegDecodeAccelerator::DecodeTask(scoped_ptr<JobRecord> job_record) {
+  DCHECK(decoder_task_runner_->BelongsToCurrentThread());
+  job_record->shm.reset(
+      new base::SharedMemory(job_record->bitstream_buffer.handle(), true));
+  if (!job_record->shm->Map(job_record->bitstream_buffer.size())) {
+    LOG(ERROR) << "Decode(): could not map bitstream_buffer";
+    PostNotifyError(job_record->bitstream_buffer.id(), UNREADABLE_INPUT);
+    return;
+  }
+  input_jobs_.push(make_linked_ptr(job_record.release()));
+
+  // Two situations can do recreate buffer directly:
+  // One is the first frame,
+  // Second is that input queue and output queue are both empty.
+  if ((!input_streamon_ && !output_streamon_) ||
+      (input_buffer_queued_count_ == 0 && output_buffer_queued_count_ == 0)) {
+    if (CreateBufferIfNecessary()) {
+      Enqueue();
+      device_poll_task_runner_->PostTask(
+          FROM_HERE, base::Bind(&V4L2JpegDecodeAccelerator::DevicePollTask,
+                                base::Unretained(this)));
+    }
+  }
+}
+
+void V4L2JpegDecodeAccelerator::CheckBufferAttributes() {
+  DVLOG(3) << __func__;
+  DCHECK(decoder_task_runner_->BelongsToCurrentThread());
+  DCHECK(!input_jobs_.empty());
+  linked_ptr<JobRecord> job_record = input_jobs_.front();
+
+  // Check input buffer size is enough
+  if (input_buffer_map_.empty() ||
+      job_record->bitstream_buffer.size() > input_buffer_map_.front().length) {
+    recreate_input_buffers_pending_ = true;
+  }
+
+  // Check image resolution is the same as previous.
+  if (job_record->frame->coded_size() != image_coded_size_) {
+    size_t frame_size = media::VideoFrame::AllocationSize(
+        job_record->frame->format(), job_record->frame->coded_size());
+    if (output_buffer_map_.empty() ||
+        frame_size > output_buffer_map_.front().length) {
+      recreate_output_buffers_pending_ = true;
+    }
+  }
+}
+
+bool V4L2JpegDecodeAccelerator::CreateBufferIfNecessary() {
+  DVLOG(3) << __func__;
+  DCHECK(decoder_task_runner_->BelongsToCurrentThread());
+
+  CheckBufferAttributes();
+  if (!recreate_input_buffers_pending_ && !recreate_output_buffers_pending_)
+    return true;
+
+  if (input_streamon_ || output_streamon_) {
+    if (!StopDevicePoll()) {
+      LOG(ERROR) << "Stop device poll thread failed when renew buffers.";
+      return false;
+    }
+    if (recreate_input_buffers_pending_)
+      DestroyInputBuffers();
+
+    if (recreate_output_buffers_pending_)
+      DestroyOutputBuffers();
+  }
+
+  if (recreate_input_buffers_pending_ && !CreateInputBuffers()) {
+    LOG(ERROR) << "Create Input buffer failed.";
+    return false;
+  }
+  if (recreate_output_buffers_pending_ && !CreateOutputBuffers()) {
+    LOG(ERROR) << "Create Output buffer failed.";
+    return false;
+  }
+
+  if (!device_poll_thread_.IsRunning())
+    StartDevicePoll();
+  return true;
+}
+
+bool V4L2JpegDecodeAccelerator::CreateInputBuffers() {
+  DVLOG(3) << __func__;
+  DCHECK(decoder_task_runner_->BelongsToCurrentThread());
+  DCHECK(!input_streamon_);
+  DCHECK(!input_jobs_.empty());
+  linked_ptr<JobRecord> job_record = input_jobs_.front();
+  // Reserve twice size to avoid recreating input buffer frequently.
+  size_t reserve_size = job_record->bitstream_buffer.size() * 2;
+
+  struct v4l2_format format;
+  memset(&format, 0, sizeof(format));
+  format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+  format.fmt.pix.width = job_record->frame->coded_size().width();
+  format.fmt.pix.height = job_record->frame->coded_size().height();
+  format.fmt.pix.pixelformat = V4L2_PIX_FMT_JPEG;
+  format.fmt.pix.sizeimage = reserve_size;
+  format.fmt.pix.field = V4L2_FIELD_ANY;
+  IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_FMT, &format);
+
+  struct v4l2_requestbuffers reqbufs;
+  memset(&reqbufs, 0, sizeof(reqbufs));
+  reqbufs.count = kBufferCount;
+  reqbufs.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+  reqbufs.memory = V4L2_MEMORY_MMAP;
+  IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_REQBUFS, &reqbufs);
+
+  DCHECK(input_buffer_map_.empty());
+  input_buffer_map_.resize(reqbufs.count);
+
+  for (size_t i = 0; i < input_buffer_map_.size(); ++i) {
+    free_input_buffers_.push_back(i);
+
+    struct v4l2_buffer buffer;
+    memset(&buffer, 0, sizeof(buffer));
+    buffer.index = i;
+    buffer.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+    buffer.memory = V4L2_MEMORY_MMAP;
+    IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QUERYBUF, &buffer);
+    void* address = device_->Mmap(NULL, buffer.length, PROT_READ | PROT_WRITE,
+                                  MAP_SHARED, buffer.m.offset);
+    if (address == MAP_FAILED) {
+      PLOG(ERROR) << "CreateInputBuffers(): mmap() failed";
+      return false;
+    }
+    input_buffer_map_[i].address = address;
+    input_buffer_map_[i].length = buffer.length;
+  }
+  recreate_input_buffers_pending_ = false;
+  return true;
+}
+
+bool V4L2JpegDecodeAccelerator::CreateOutputBuffers() {
+  DVLOG(3) << __func__;
+  DCHECK(decoder_task_runner_->BelongsToCurrentThread());
+  DCHECK(!output_streamon_);
+  DCHECK(!input_jobs_.empty());
+  linked_ptr<JobRecord> job_record = input_jobs_.front();
+
+  size_t frame_size = media::VideoFrame::AllocationSize(
+      media::VideoFrame::I420, job_record->frame->coded_size());
+  struct v4l2_format format;
+  memset(&format, 0, sizeof(format));
+  format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+  format.fmt.pix.width = job_record->frame->coded_size().width();
+  format.fmt.pix.height = job_record->frame->coded_size().height();
+  format.fmt.pix.sizeimage = frame_size;
+  format.fmt.pix.pixelformat = V4L2_PIX_FMT_YUV420;
+  format.fmt.pix.field = V4L2_FIELD_ANY;
+  IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_S_FMT, &format);
+
+  struct v4l2_requestbuffers reqbufs;
+  memset(&reqbufs, 0, sizeof(reqbufs));
+  reqbufs.count = kBufferCount;
+  reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+  reqbufs.memory = V4L2_MEMORY_MMAP;
+  IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_REQBUFS, &reqbufs);
+
+  DCHECK(output_buffer_map_.empty());
+  output_buffer_map_.resize(reqbufs.count);
+
+  for (size_t i = 0; i < output_buffer_map_.size(); ++i) {
+    free_output_buffers_.push_back(i);
+
+    struct v4l2_buffer buffer;
+    memset(&buffer, 0, sizeof(buffer));
+    buffer.index = i;
+    buffer.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    buffer.memory = V4L2_MEMORY_MMAP;
+    IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QUERYBUF, &buffer);
+    void* address = device_->Mmap(NULL, buffer.length, PROT_READ | PROT_WRITE,
+                                  MAP_SHARED, buffer.m.offset);
+    if (address == MAP_FAILED) {
+      PLOG(ERROR) << "CreateOutputBuffers(): mmap() failed";
+      return false;
+    }
+    output_buffer_map_[i].address = address;
+    output_buffer_map_[i].length = buffer.length;
+  }
+  image_coded_size_ = job_record->frame->coded_size();
+  recreate_output_buffers_pending_ = false;
+  return true;
+}
+
+void V4L2JpegDecodeAccelerator::DestroyInputBuffers() {
+  DCHECK(decoder_task_runner_->BelongsToCurrentThread());
+  DCHECK(!input_streamon_);
+
+  for (size_t buf = 0; buf < input_buffer_map_.size(); ++buf) {
+    BufferRecord& input_record = input_buffer_map_[buf];
+    device_->Munmap(input_record.address, input_record.length);
+  }
+
+  struct v4l2_requestbuffers reqbufs;
+  memset(&reqbufs, 0, sizeof(reqbufs));
+  reqbufs.count = 0;
+  reqbufs.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+  reqbufs.memory = V4L2_MEMORY_MMAP;
+  IOCTL_OR_LOG_ERROR(VIDIOC_REQBUFS, &reqbufs);
+
+  input_buffer_map_.clear();
+  free_input_buffers_.clear();
+}
+
+void V4L2JpegDecodeAccelerator::DestroyOutputBuffers() {
+  DCHECK(decoder_task_runner_->BelongsToCurrentThread());
+  DCHECK(!output_streamon_);
+
+  for (size_t buf = 0; buf < output_buffer_map_.size(); ++buf) {
+    BufferRecord& output_record = output_buffer_map_[buf];
+    device_->Munmap(output_record.address, output_record.length);
+  }
+
+  struct v4l2_requestbuffers reqbufs;
+  memset(&reqbufs, 0, sizeof(reqbufs));
+  reqbufs.count = 0;
+  reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+  reqbufs.memory = V4L2_MEMORY_MMAP;
+  IOCTL_OR_LOG_ERROR(VIDIOC_REQBUFS, &reqbufs);
+
+  output_buffer_map_.clear();
+  free_output_buffers_.clear();
+}
+
+void V4L2JpegDecodeAccelerator::DevicePollTask() {
+  DCHECK(device_poll_task_runner_->BelongsToCurrentThread());
+
+  bool event_pending;
+  if (!device_->Poll(true, &event_pending)) {
+    PostNotifyError(-1, media::JpegDecodeAccelerator::PLATFORM_FAILURE);
+    return;
+  }
+
+  // All processing should happen on ServiceDeviceTask(), since we shouldn't
+  // touch decoder state from this thread.
+  decoder_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&V4L2JpegDecodeAccelerator::ServiceDeviceTask,
+                            base::Unretained(this)));
+}
+
+void V4L2JpegDecodeAccelerator::ServiceDeviceTask() {
+  DCHECK(decoder_task_runner_->BelongsToCurrentThread());
+  // 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 should early-out.
+  if (!device_poll_thread_.IsRunning())
+    return;
+
+  Dequeue();
+  if (!input_jobs_.empty() && CreateBufferIfNecessary())
+    Enqueue();
+
+  if (!device_->ClearDevicePollInterrupt()) {
+    return;
+  }
+
+  if (input_buffer_queued_count_ > 0 && output_buffer_queued_count_ > 0) {
+    device_poll_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&V4L2JpegDecodeAccelerator::DevicePollTask,
+                              base::Unretained(this)));
+  }
+
+  DVLOG(2) << __func__ << ": buffer counts: INPUT["
+           << input_jobs_.size() << "] => DEVICE["
+           << free_input_buffers_.size() << "+"
+           << input_buffer_queued_count_ << "/"
+           << input_buffer_map_.size() << "->"
+           << free_output_buffers_.size() << "+"
+           << output_buffer_queued_count_ << "/"
+           << output_buffer_map_.size() << "] => CLIENT["
+           << output_buffer_map_.size() - output_buffer_queued_count_ -
+              free_output_buffers_.size() << "]";
+}
+
+void V4L2JpegDecodeAccelerator::Enqueue() {
+  DCHECK(decoder_task_runner_->BelongsToCurrentThread());
+
+  if (!recreate_input_buffers_pending_ && !recreate_output_buffers_pending_) {

[henryhsu, 2015/06/16 09:53:50]

This check can be removed since we always call CreateBufferIfNecessary before
Enqueue to make sure that current frame has correct input/output buffer size.
I'll update it in next patch.

+    while (!input_jobs_.empty() && !free_input_buffers_.empty()) {
+      if (!EnqueueInputRecord())
+        return;
+    }
+  }
+  if (input_buffer_queued_count_ != 0 && !input_streamon_) {
+    // Start VIDIOC_STREAMON if we haven't yet.
+    __u32 type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+    IOCTL_OR_ERROR_RETURN(VIDIOC_STREAMON, &type);
+    input_streamon_ = true;
+  }
+
+  while (output_buffer_queued_count_ < input_buffer_queued_count_ &&
+         !free_output_buffers_.empty()) {
+    if (!EnqueueOutputRecord())
+      return;
+  }
+  if (output_buffer_queued_count_ != 0 && !output_streamon_) {
+    // Start VIDIOC_STREAMON if we haven't yet.
+    __u32 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    IOCTL_OR_ERROR_RETURN(VIDIOC_STREAMON, &type);
+    output_streamon_ = true;
+  }
+}
+
+void V4L2JpegDecodeAccelerator::Dequeue() {
+  DCHECK(decoder_task_runner_->BelongsToCurrentThread());
+
+  // Dequeue completed input (VIDEO_OUTPUT) buffers,
+  // and recycle to the free list.
+  struct v4l2_buffer dqbuf;
+  while (input_buffer_queued_count_ > 0) {
+    DCHECK(input_streamon_);
+    memset(&dqbuf, 0, sizeof(dqbuf));
+    dqbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+    dqbuf.memory = V4L2_MEMORY_MMAP;
+    if (device_->Ioctl(VIDIOC_DQBUF, &dqbuf) != 0) {
+      if (errno == EAGAIN) {
+        // EAGAIN if we're just out of buffers to dequeue.
+        break;
+      }
+      PLOG(ERROR) << "ioctl() failed: VIDIOC_DQBUF";
+      PostNotifyError(dqbuf.index,
+                      media::JpegDecodeAccelerator::PLATFORM_FAILURE);
+      return;
+    }
+    BufferRecord& input_record = input_buffer_map_[dqbuf.index];
+    DCHECK(input_record.at_device);
+    input_record.at_device = false;
+    free_input_buffers_.push_back(dqbuf.index);
+    input_buffer_queued_count_--;
+  }
+
+  // Dequeue completed output (VIDEO_CAPTURE) buffers, recycle to the free list.
+  // Return the finished buffer to the client via the job ready callback.
+  while (output_buffer_queued_count_ > 0) {
+    DCHECK(output_streamon_);
+    memset(&dqbuf, 0, sizeof(dqbuf));
+    dqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    dqbuf.memory = V4L2_MEMORY_MMAP;
+    if (device_->Ioctl(VIDIOC_DQBUF, &dqbuf) != 0) {
+      if (errno == EAGAIN) {
+        // EAGAIN if we're just out of buffers to dequeue.
+        break;
+      }
+      PLOG(ERROR) << "ioctl() failed: VIDIOC_DQBUF";
+      PostNotifyError(dqbuf.index,
+                      media::JpegDecodeAccelerator::PLATFORM_FAILURE);
+      return;
+    }
+    BufferRecord& output_record = output_buffer_map_[dqbuf.index];
+    DCHECK(output_record.at_device);
+    output_record.at_device = false;
+    free_output_buffers_.push_back(dqbuf.index);
+    output_buffer_queued_count_--;
+
+    // Jobs are always processed in FIFO order.
+    DCHECK(!running_jobs_.empty());
+    linked_ptr<JobRecord> job_record = running_jobs_.front();
+    running_jobs_.pop();
+
+    memcpy(job_record->frame->data(media::VideoFrame::kYPlane),
+           output_record.address, output_record.length);
+
+    DVLOG(3) << "Decoding finished, returning frame, ts="
+             << job_record->frame->timestamp().InMilliseconds();
+
+    client_->VideoFrameReady(job_record->bitstream_buffer.id());
+  }
+}
+
+bool V4L2JpegDecodeAccelerator::EnqueueInputRecord() {
+  DCHECK(!input_jobs_.empty());
+  DCHECK(!free_input_buffers_.empty());
+
+  // Enqueue an input (VIDEO_OUTPUT) buffer for an input video frame.
+  linked_ptr<JobRecord> job_record = input_jobs_.front();
+  input_jobs_.pop();
+  const int index = free_input_buffers_.back();
+  BufferRecord& input_record = input_buffer_map_[index];
+  DCHECK(!input_record.at_device);
+
+  struct v4l2_buffer qbuf;
+  memset(&qbuf, 0, sizeof(qbuf));
+  memcpy(input_record.address, job_record->shm->memory(),
+         job_record->bitstream_buffer.size());
+  qbuf.index = index;
+  qbuf.type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+  qbuf.memory = V4L2_MEMORY_MMAP;
+  IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QBUF, &qbuf);
+  input_record.at_device = true;
+  running_jobs_.push(job_record);
+  free_input_buffers_.pop_back();
+  input_buffer_queued_count_++;
+
+  DVLOG(3) << __func__ << ": enqueued frame ts="
+           << job_record->frame->timestamp().InMilliseconds() << " to device.";
+  return true;
+}
+
+bool V4L2JpegDecodeAccelerator::EnqueueOutputRecord() {
+  DCHECK(!free_output_buffers_.empty());
+
+  // Enqueue an output (VIDEO_CAPTURE) buffer.
+  const int index = free_output_buffers_.back();
+  BufferRecord& output_record = output_buffer_map_[index];
+  DCHECK(!output_record.at_device);
+  struct v4l2_buffer qbuf;
+  memset(&qbuf, 0, sizeof(qbuf));
+  qbuf.index = index;
+  qbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+  qbuf.memory = V4L2_MEMORY_MMAP;
+  IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QBUF, &qbuf);
+  output_record.at_device = true;
+  free_output_buffers_.pop_back();
+  output_buffer_queued_count_++;
+  return true;
+}
+
+void V4L2JpegDecodeAccelerator::StartDevicePoll() {
+  DVLOG(3) << __func__ << ": starting device poll";
+  DCHECK(decoder_task_runner_->BelongsToCurrentThread());
+  DCHECK(!device_poll_thread_.IsRunning());
+
+  if (!device_poll_thread_.Start()) {
+    LOG(ERROR) << "StartDevicePoll(): Device thread failed to start";
+    PostNotifyError(-1, media::JpegDecodeAccelerator::PLATFORM_FAILURE);
+    return;
+  }
+  device_poll_task_runner_ = device_poll_thread_.task_runner();
+}
+
+bool V4L2JpegDecodeAccelerator::StopDevicePoll() {
+  DVLOG(3) << __func__ << ": stopping device poll";
+  if (decoder_thread_.IsRunning())
+    DCHECK(decoder_task_runner_->BelongsToCurrentThread());
+
+  // Signal the DevicePollTask() to stop, and stop the device poll thread.
+  if (!device_->SetDevicePollInterrupt()) {
+    LOG(ERROR) << "StopDevicePoll(): SetDevicePollInterrupt failed.";
+    PostNotifyError(-1, media::JpegDecodeAccelerator::PLATFORM_FAILURE);
+    return false;
+  }
+
+  device_poll_thread_.Stop();
+
+  // Clear the interrupt now, to be sure.
+  if (!device_->ClearDevicePollInterrupt())
+    return false;
+
+  if (input_streamon_) {
+    __u32 type = V4L2_BUF_TYPE_VIDEO_OUTPUT;
+    IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_STREAMOFF, &type);
+  }
+  input_streamon_ = false;
+
+  if (output_streamon_) {
+    __u32 type = V4L2_BUF_TYPE_VIDEO_CAPTURE;
+    IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_STREAMOFF, &type);
+  }
+  output_streamon_ = false;
+
+  while (!running_jobs_.empty())
+    running_jobs_.pop();
+
+  free_input_buffers_.clear();
+  for (size_t i = 0; i < input_buffer_map_.size(); ++i) {
+    BufferRecord& input_record = input_buffer_map_[i];
+    input_record.at_device = false;
+    free_input_buffers_.push_back(i);
+  }
+  input_buffer_queued_count_ = 0;
+
+  free_output_buffers_.clear();
+  for (size_t i = 0; i < output_buffer_map_.size(); ++i) {
+    BufferRecord& output_record = output_buffer_map_[i];
+    output_record.at_device = false;
+    free_output_buffers_.push_back(i);
+  }
+  output_buffer_queued_count_ = 0;
+
+  return true;
+}
+
+}  // namespace content