V4L2VideoDecodeAccelerator: support external buffer import

media/gpu/v4l2_video_decode_accelerator.cc

 // Copyright 2014 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 "media/gpu/v4l2_video_decode_accelerator.h"
 
 #include <dlfcn.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <string.h>
 #include <sys/eventfd.h>
 #include <sys/ioctl.h>
 #include <sys/mman.h>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/message_loop/message_loop.h"
 #include "base/numerics/safe_conversions.h"
+#include "base/posix/eintr_wrapper.h"
 #include "base/single_thread_task_runner.h"
 #include "base/threading/thread_task_runner_handle.h"
 #include "base/trace_event/trace_event.h"
 #include "build/build_config.h"
 #include "media/base/media_switches.h"
 #include "media/filters/h264_parser.h"
 #include "media/gpu/shared_memory_region.h"
 #include "ui/gfx/geometry/rect.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/scoped_binders.h"
@@ skipping 99 matching lines @@
 V4L2VideoDecodeAccelerator::InputRecord::InputRecord()
     : at_device(false), address(NULL), length(0), bytes_used(0), input_id(-1) {}
 
 V4L2VideoDecodeAccelerator::InputRecord::~InputRecord() {}
 
 V4L2VideoDecodeAccelerator::OutputRecord::OutputRecord()
     : state(kFree),
       egl_image(EGL_NO_IMAGE_KHR),
       egl_sync(EGL_NO_SYNC_KHR),
       picture_id(-1),
+      texture_id(0),
       cleared(false) {}
 
 V4L2VideoDecodeAccelerator::OutputRecord::~OutputRecord() {}
 
 V4L2VideoDecodeAccelerator::PictureRecord::PictureRecord(bool cleared,
                                                          const Picture& picture)
     : cleared(cleared), picture(picture) {}
 
 V4L2VideoDecodeAccelerator::PictureRecord::~PictureRecord() {}
 
 V4L2VideoDecodeAccelerator::V4L2VideoDecodeAccelerator(
     EGLDisplay egl_display,
     const GetGLContextCallback& get_gl_context_cb,
     const MakeGLContextCurrentCallback& make_context_current_cb,
     const scoped_refptr<V4L2Device>& device)
     : child_task_runner_(base::ThreadTaskRunnerHandle::Get()),
       decoder_thread_("V4L2DecoderThread"),
       decoder_state_(kUninitialized),
+      output_mode_(Config::OutputMode::ALLOCATE),
       device_(device),
       decoder_delay_bitstream_buffer_id_(-1),
       decoder_current_input_buffer_(-1),
       decoder_decode_buffer_tasks_scheduled_(0),
       decoder_frames_at_client_(0),
       decoder_flushing_(false),
       reset_pending_(false),
       decoder_partial_frame_pending_(false),
       input_streamon_(false),
       input_buffer_queued_count_(0),
@@ skipping 19 matching lines @@
   DCHECK(!device_poll_thread_.IsRunning());
 
   // These maps have members that should be manually destroyed, e.g. file
   // descriptors, mmap() segments, etc.
   DCHECK(input_buffer_map_.empty());
   DCHECK(output_buffer_map_.empty());
 }
 
 bool V4L2VideoDecodeAccelerator::Initialize(const Config& config,
                                             Client* client) {
-  DVLOGF(3) << "profile: " << config.profile;
+  DVLOGF(3) << "profile: " << config.profile
+            << ", output_mode=" << static_cast<int>(config.output_mode);
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   DCHECK_EQ(decoder_state_, kUninitialized);
 
   if (!device_->SupportsDecodeProfileForV4L2PixelFormats(
           config.profile, arraysize(supported_input_fourccs_),
           supported_input_fourccs_)) {
     DVLOGF(1) << "unsupported profile=" << config.profile;
     return false;
   }
 
   if (config.is_encrypted) {
     NOTREACHED() << "Encrypted streams are not supported for this VDA";
     return false;
   }
 
-  if (config.output_mode != Config::OutputMode::ALLOCATE) {
-    NOTREACHED() << "Only ALLOCATE OutputMode is supported by this VDA";
+  if (config.output_mode != Config::OutputMode::ALLOCATE &&
+      config.output_mode != Config::OutputMode::IMPORT) {
+    NOTREACHED() << "Only ALLOCATE and IMPORT OutputModes are supported";
     return false;
   }
 
-  if (get_gl_context_cb_.is_null() || make_context_current_cb_.is_null()) {
-    NOTREACHED() << "GL callbacks are required for this VDA";
-    return false;
-  }
-
   client_ptr_factory_.reset(new base::WeakPtrFactory<Client>(client));
   client_ = client_ptr_factory_->GetWeakPtr();
   // If we haven't been set up to decode on separate thread via
   // TryToSetupDecodeOnSeparateThread(), use the main thread/client for
   // decode tasks.
   if (!decode_task_runner_) {
     decode_task_runner_ = child_task_runner_;
     DCHECK(!decode_client_);
     decode_client_ = client_;
   }
 
   video_profile_ = config.profile;
 
   if (egl_display_ == EGL_NO_DISPLAY) {
     LOGF(ERROR) << "could not get EGLDisplay";
     return false;
   }
 
   // We need the context to be initialized to query extensions.
-  if (!make_context_current_cb_.Run()) {
-    LOGF(ERROR) << "could not make context current";
-    return false;
-  }
+  if (!make_context_current_cb_.is_null()) {
+    if (!make_context_current_cb_.Run()) {
+      LOGF(ERROR) << "could not make context current";
+      return false;
+    }
 
 // TODO(posciak): crbug.com/450898.
 #if defined(ARCH_CPU_ARMEL)
-  if (!gl::g_driver_egl.ext.b_EGL_KHR_fence_sync) {
-    LOGF(ERROR) << "context does not have EGL_KHR_fence_sync";
-    return false;
+    if (!gl::g_driver_egl.ext.b_EGL_KHR_fence_sync) {
+      LOGF(ERROR) << "context does not have EGL_KHR_fence_sync";
+      return false;
+    }
+#endif
+  } else {
+    DVLOGF(1) << "No GL callbacks provided, initializing without GL support";
   }
-#endif
 
   // Capabilities check.
   struct v4l2_capability caps;
   const __u32 kCapsRequired = V4L2_CAP_VIDEO_M2M_MPLANE | V4L2_CAP_STREAMING;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QUERYCAP, &caps);
   if ((caps.capabilities & kCapsRequired) != kCapsRequired) {
     LOGF(ERROR) << "ioctl() failed: VIDIOC_QUERYCAP"
                 << ", caps check failed: 0x" << std::hex << caps.capabilities;
     return false;
   }
@@ skipping 13 matching lines @@
 
   if (!CreateInputBuffers())
     return false;
 
   if (!decoder_thread_.Start()) {
     LOGF(ERROR) << "decoder thread failed to start";
     return false;
   }
 
   decoder_state_ = kInitialized;
+  output_mode_ = config.output_mode;
 
   // StartDevicePoll will NOTIFY_ERROR on failure, so IgnoreResult is fine here.
   decoder_thread_.task_runner()->PostTask(
       FROM_HERE, base::Bind(base::IgnoreResult(
                                 &V4L2VideoDecodeAccelerator::StartDevicePoll),
                             base::Unretained(this)));
 
   return true;
 }
 
@@ skipping 51 matching lines @@
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   reqbufs.memory = V4L2_MEMORY_MMAP;
   IOCTL_OR_ERROR_RETURN(VIDIOC_REQBUFS, &reqbufs);
 
   if (reqbufs.count != buffers.size()) {
     DLOGF(ERROR) << "Could not allocate enough output buffers";
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return;
   }
 
-  if (image_processor_device_) {
-    DCHECK(!image_processor_);
-    image_processor_.reset(new V4L2ImageProcessor(image_processor_device_));
-    // Unretained is safe because |this| owns image processor and there will be
-    // no callbacks after processor destroys.
-    if (!image_processor_->Initialize(
-            V4L2Device::V4L2PixFmtToVideoPixelFormat(output_format_fourcc_),
-            V4L2Device::V4L2PixFmtToVideoPixelFormat(egl_image_format_fourcc_),
-            V4L2_MEMORY_DMABUF, visible_size_, coded_size_, visible_size_,
-            visible_size_, buffers.size(),
-            base::Bind(&V4L2VideoDecodeAccelerator::ImageProcessorError,
-                       base::Unretained(this)))) {
-      LOGF(ERROR) << "Initialize image processor failed";
-      NOTIFY_ERROR(PLATFORM_FAILURE);
+  DCHECK(free_output_buffers_.empty());
+  DCHECK(output_buffer_map_.empty());
+  output_buffer_map_.resize(buffers.size());
+  if (image_processor_device_ && output_mode_ == Config::OutputMode::ALLOCATE) {
+    if (!CreateImageProcessor())
+      return;
+  }
+
+  for (size_t i = 0; i < output_buffer_map_.size(); ++i) {
+    DCHECK(buffers[i].size() == egl_image_size_);
+
+    OutputRecord& output_record = output_buffer_map_[i];
+    DCHECK_EQ(output_record.state, kFree);
+    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);
+    DCHECK_EQ(output_record.cleared, false);
+    DCHECK_EQ(1u, buffers[i].texture_ids().size());
+    DCHECK(output_record.processor_input_fds.empty());
+
+    output_record.picture_id = buffers[i].id();
+    output_record.texture_id = buffers[i].texture_ids()[0];
+    // This will remain kAtClient until ImportBufferForPicture is called, either
+    // by the client, or by ourselves, if we are allocating.
+    output_record.state = kAtClient;
+
+    if (image_processor_device_) {
+      std::vector<base::ScopedFD> dmabuf_fds = device_->GetDmabufsForV4L2Buffer(
+          i, output_planes_count_, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
+      if (dmabuf_fds.empty()) {
+        LOGF(ERROR) << "Failed to get DMABUFs of decoder.";
+        NOTIFY_ERROR(PLATFORM_FAILURE);
+        return;
+      }
+      output_record.processor_input_fds = std::move(dmabuf_fds);
+    }
+
+    if (output_mode_ == Config::OutputMode::ALLOCATE) {
+      std::vector<base::ScopedFD> dmabuf_fds;
+      dmabuf_fds = egl_image_device_->GetDmabufsForV4L2Buffer(
+          i, egl_image_planes_count_, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
+      if (dmabuf_fds.empty()) {
+        LOGF(ERROR) << "Failed to get DMABUFs for EGLImage.";
+        NOTIFY_ERROR(PLATFORM_FAILURE);
+        return;
+      }
+      int plane_horiz_bits_per_pixel = VideoFrame::PlaneHorizontalBitsPerPixel(
+          V4L2Device::V4L2PixFmtToVideoPixelFormat(egl_image_format_fourcc_),
+          0);
+      ImportBufferForPictureTask(
+          output_record.picture_id, std::move(dmabuf_fds),
+          egl_image_size_.width() * plane_horiz_bits_per_pixel / 8);
+    }  // else we'll get triggered via ImportBufferForPicture() from client.
+
+    DVLOGF(3) << "buffer[" << i << "]: picture_id=" << output_record.picture_id;
+  }
+
+  if (output_mode_ == Config::OutputMode::ALLOCATE) {
+    DCHECK_EQ(kAwaitingPictureBuffers, decoder_state_);
+    DVLOGF(1) << "Change state to kDecoding";
+    decoder_state_ = kDecoding;
+    if (reset_pending_) {
+      FinishReset();
       return;
     }
-    DCHECK(image_processor_->output_allocated_size() == egl_image_size_);
-    if (image_processor_->input_allocated_size() != coded_size_) {
-      LOGF(ERROR) << "Image processor should be able to take the output coded "
-                  << "size of decoder " << coded_size_.ToString()
-                  << " without adjusting to "
-                  << image_processor_->input_allocated_size().ToString();
-      NOTIFY_ERROR(PLATFORM_FAILURE);
-      return;
-    }
+    ScheduleDecodeBufferTaskIfNeeded();
   }
-
-  child_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&V4L2VideoDecodeAccelerator::CreateEGLImages, weak_this_,
-                 buffers, egl_image_format_fourcc_, egl_image_planes_count_));
 }
 
-void V4L2VideoDecodeAccelerator::CreateEGLImages(
-    const std::vector<media::PictureBuffer>& buffers,
-    uint32_t output_format_fourcc,
-    size_t output_planes_count) {
-  DVLOGF(3);
+void V4L2VideoDecodeAccelerator::CreateEGLImageFor(
+    size_t buffer_index,
+    int32_t picture_buffer_id,
+    std::vector<base::ScopedFD> dmabuf_fds,
+    GLuint texture_id,
+    const gfx::Size& size,
+    uint32_t fourcc) {
+  DVLOGF(3) << "index=" << buffer_index;
   DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   if (get_gl_context_cb_.is_null() || make_context_current_cb_.is_null()) {
     DLOGF(ERROR) << "GL callbacks required for binding to EGLImages";
     NOTIFY_ERROR(INVALID_ARGUMENT);
     return;
   }
 
   gl::GLContext* gl_context = get_gl_context_cb_.Run();
   if (!gl_context || !make_context_current_cb_.Run()) {
     DLOGF(ERROR) << "No GL context";
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return;
   }
 
   gl::ScopedTextureBinder bind_restore(GL_TEXTURE_EXTERNAL_OES, 0);
 
-  std::vector<EGLImageKHR> egl_images;
-  for (size_t i = 0; i < buffers.size(); ++i) {
-    std::vector<base::ScopedFD> dmabuf_fds;
-    dmabuf_fds = egl_image_device_->GetDmabufsForV4L2Buffer(
-        i, egl_image_planes_count_, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
-    if (dmabuf_fds.empty()) {
-      LOGF(ERROR) << "Failed to get DMABUFs for EGLImage.";
-      NOTIFY_ERROR(PLATFORM_FAILURE);
-      return;
-    }
-
-    EGLImageKHR egl_image = egl_image_device_->CreateEGLImage(
-        egl_display_, gl_context->GetHandle(), buffers[i].texture_ids()[0],
-        buffers[i].size(), i, egl_image_format_fourcc_, dmabuf_fds);
-    if (egl_image == EGL_NO_IMAGE_KHR) {
-      LOGF(ERROR) << "could not create EGLImageKHR,"
-                  << " index=" << i
-                  << " texture_id=" << buffers[i].texture_ids()[0];
-      for (EGLImageKHR image : egl_images) {
-        egl_image_device_->DestroyEGLImage(egl_display_, image);
-      }
-      NOTIFY_ERROR(PLATFORM_FAILURE);
-      return;
-    }
-    egl_images.push_back(egl_image);
+  EGLImageKHR egl_image = egl_image_device_->CreateEGLImage(
+      egl_display_, gl_context->GetHandle(), texture_id, size, buffer_index,
+      fourcc, dmabuf_fds);
+  if (egl_image == EGL_NO_IMAGE_KHR) {
+    LOGF(ERROR) << "could not create EGLImageKHR,"
+                << " index=" << buffer_index << " texture_id=" << texture_id;
+    NOTIFY_ERROR(PLATFORM_FAILURE);
+    return;
   }
 
   decoder_thread_.task_runner()->PostTask(
-      FROM_HERE, base::Bind(&V4L2VideoDecodeAccelerator::AssignEGLImages,
-                            base::Unretained(this), buffers, egl_images));
+      FROM_HERE,
+      base::Bind(&V4L2VideoDecodeAccelerator::AssignEGLImage,
+                 base::Unretained(this), buffer_index, picture_buffer_id,
+                 egl_image, base::Passed(&dmabuf_fds)));
 }
 
-void V4L2VideoDecodeAccelerator::AssignEGLImages(
-    const std::vector<media::PictureBuffer>& buffers,
-    const std::vector<EGLImageKHR>& egl_images) {
-  DVLOGF(3);
+void V4L2VideoDecodeAccelerator::AssignEGLImage(
+    size_t buffer_index,
+    int32_t picture_buffer_id,
+    EGLImageKHR egl_image,
+    std::vector<base::ScopedFD> dmabuf_fds) {
+  DVLOGF(3) << "index=" << buffer_index << ", picture_id=" << picture_buffer_id;
   DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
-  DCHECK_EQ(buffers.size(), egl_images.size());
-  DCHECK(free_output_buffers_.empty());
-  DCHECK(output_buffer_map_.empty());
 
-  output_buffer_map_.resize(buffers.size());
-  for (size_t i = 0; i < output_buffer_map_.size(); ++i) {
-    DCHECK(buffers[i].size() == egl_image_size_);
-
-    OutputRecord& output_record = output_buffer_map_[i];
-    DCHECK_EQ(output_record.state, kFree);
-    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);
-    DCHECK_EQ(output_record.cleared, false);
-    DCHECK_LE(1u, buffers[i].texture_ids().size());
-
-    if (image_processor_device_) {
-      std::vector<base::ScopedFD> fds = device_->GetDmabufsForV4L2Buffer(
-          i, output_planes_count_, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE);
-      if (fds.empty()) {
-        LOGF(ERROR) << "Failed to get DMABUFs of decoder.";
-        NOTIFY_ERROR(PLATFORM_FAILURE);
-        return;
-      }
-      output_record.fds = std::move(fds);
-    }
-
-    output_record.egl_image = egl_images[i];
-    output_record.picture_id = buffers[i].id();
-
-    free_output_buffers_.push(i);
-    DVLOGF(3) << "buffer[" << i << "]: picture_id=" << output_record.picture_id;
-  }
-
-  decoder_state_ = kDecoding;
-  Enqueue();
-  if (reset_pending_) {
-    FinishReset();
+  // It's possible that while waiting for the EGLImages to be allocated and
+  // assigned, we have already decoded more of the stream and saw another
+  // resolution change. This is a normal situation, in such a case either there
+  // is no output record with this index awaiting an EGLImage to be assigned to
+  // it, or the record is already updated to use a newer PictureBuffer and is
+  // awaiting an EGLImage associated with a different picture_buffer_id. If so,
+  // just discard this image, we will get the one we are waiting for later.
+  if (buffer_index >= output_buffer_map_.size() ||
+      output_buffer_map_[buffer_index].picture_id != picture_buffer_id) {
+    DVLOGF(3) << "Picture set already changed, dropping EGLImage";
+    child_task_runner_->PostTask(
+        FROM_HERE, base::Bind(base::IgnoreResult(&V4L2Device::DestroyEGLImage),
+                              device_, egl_display_, egl_image));
     return;
   }
 
-  ScheduleDecodeBufferTaskIfNeeded();
+  OutputRecord& output_record = output_buffer_map_[buffer_index];
+  DCHECK_EQ(output_record.egl_image, EGL_NO_IMAGE_KHR);
+  DCHECK_EQ(output_record.egl_sync, EGL_NO_SYNC_KHR);
+  DCHECK_EQ(output_record.state, kFree);
+  DCHECK_EQ(std::count(free_output_buffers_.begin(), free_output_buffers_.end(),
+                       buffer_index),
+            0);
+  output_record.egl_image = egl_image;
+  free_output_buffers_.push_back(buffer_index);
+  if (decoder_state_ != kChangingResolution) {
+    Enqueue();
+    ScheduleDecodeBufferTaskIfNeeded();
+  }
+}
+
+void V4L2VideoDecodeAccelerator::ImportBufferForPicture(
+    int32_t picture_buffer_id,
+    const gfx::GpuMemoryBufferHandle& gpu_memory_buffer_handle) {
+  DVLOGF(3) << "picture_buffer_id=" << picture_buffer_id;
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
+
+  if (output_mode_ != Config::OutputMode::IMPORT) {
+    LOGF(ERROR) << "Cannot import in non-import mode";
+    NOTIFY_ERROR(INVALID_ARGUMENT);
+    return;
+  }
+
+  std::vector<base::ScopedFD> dmabuf_fds;
+  int32_t stride = 0;
+#if defined(USE_OZONE)
+  for (const auto& fd : gpu_memory_buffer_handle.native_pixmap_handle.fds) {
+    DCHECK_NE(fd.fd, -1);
+    dmabuf_fds.push_back(base::ScopedFD(fd.fd));
+  }
+  stride = gpu_memory_buffer_handle.native_pixmap_handle.planes[0].stride;
+  for (const auto& plane :
+       gpu_memory_buffer_handle.native_pixmap_handle.planes) {
+    DVLOGF(3) << ": offset=" << plane.offset << ", stride=" << plane.stride;
+  }
+#endif
+
+  decoder_thread_.task_runner()->PostTask(
+      FROM_HERE,
+      base::Bind(&V4L2VideoDecodeAccelerator::ImportBufferForPictureTask,
+                 base::Unretained(this), picture_buffer_id,
+                 base::Passed(&dmabuf_fds), stride));
+}
+
+void V4L2VideoDecodeAccelerator::ImportBufferForPictureTask(
+    int32_t picture_buffer_id,
+    std::vector<base::ScopedFD> dmabuf_fds,
+    int32_t stride) {
+  DVLOGF(3) << "picture_buffer_id=" << picture_buffer_id
+            << ", dmabuf_fds.size()=" << dmabuf_fds.size()
+            << ", stride=" << stride;
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
+
+  const auto iter =
+      std::find_if(output_buffer_map_.begin(), output_buffer_map_.end(),
+                   [picture_buffer_id](const OutputRecord& output_record) {
+                     return output_record.picture_id == picture_buffer_id;
+                   });
+  if (iter == output_buffer_map_.end()) {
+    // It's possible that we've already posted a DismissPictureBuffer for this
+    // picture, but it has not yet executed when this ImportBufferForPicture was
+    // posted to us by the client. In that case just ignore this (we've already
+    // dismissed it and accounted for that).
+    DVLOGF(3) << "got picture id=" << picture_buffer_id
+              << " not in use (anymore?).";
+    return;
+  }
+
+  if (iter->state != kAtClient) {
+    LOGF(ERROR) << "Cannot import buffer not owned by client";
+    NOTIFY_ERROR(INVALID_ARGUMENT);
+    return;
+  }
+
+  int plane_horiz_bits_per_pixel = VideoFrame::PlaneHorizontalBitsPerPixel(
+      V4L2Device::V4L2PixFmtToVideoPixelFormat(egl_image_format_fourcc_), 0);
+  if (plane_horiz_bits_per_pixel == 0 ||
+      (stride * 8) % plane_horiz_bits_per_pixel != 0) {
+    LOG(ERROR) << "Invalid format " << egl_image_format_fourcc_ << " or stride "
+               << stride;
+    NOTIFY_ERROR(INVALID_ARGUMENT);
+    return;
+  }
+  int adjusted_coded_width = stride * 8 / plane_horiz_bits_per_pixel;
+
+  if (image_processor_device_ && !image_processor_) {
+    // This is the first buffer import. Create the image processor and change
+    // the decoder state. The client may adjust the coded width. We don't have
+    // the final coded size in AssignPictureBuffers yet. Use the adjusted coded
+    // width to create the image processor.
+    DVLOGF(3) << "Original egl_image_size=" << egl_image_size_.ToString()
+              << ", adjusted coded width=" << adjusted_coded_width;
+    DCHECK_GE(adjusted_coded_width, egl_image_size_.width());
+    egl_image_size_.set_width(adjusted_coded_width);
+    if (!CreateImageProcessor())
+      return;
+    DCHECK_EQ(kAwaitingPictureBuffers, decoder_state_);
+    DVLOGF(1) << "Change state to kDecoding";
+    decoder_state_ = kDecoding;
+    if (reset_pending_) {
+      FinishReset();
+    }
+  } else {
+    DCHECK_EQ(egl_image_size_.width(), adjusted_coded_width);
+  }
+
+  size_t index = iter - output_buffer_map_.begin();
+  DCHECK_EQ(std::count(free_output_buffers_.begin(), free_output_buffers_.end(),
+                       index),
+            0);
+
+  iter->state = kFree;
+  if (iter->texture_id != 0) {
+    if (iter->egl_image != EGL_NO_IMAGE_KHR) {
+      child_task_runner_->PostTask(
+          FROM_HERE,
+          base::Bind(base::IgnoreResult(&V4L2Device::DestroyEGLImage), device_,
+                     egl_display_, iter->egl_image));
+    }
+
+    child_task_runner_->PostTask(
+        FROM_HERE, base::Bind(&V4L2VideoDecodeAccelerator::CreateEGLImageFor,
+                              weak_this_, index, picture_buffer_id,
+                              base::Passed(&dmabuf_fds), iter->texture_id,
+                              egl_image_size_, egl_image_format_fourcc_));
+  } else {
+    // No need for an EGLImage, start using this buffer now.
+    DCHECK_EQ(egl_image_planes_count_, dmabuf_fds.size());
+    iter->processor_output_fds.swap(dmabuf_fds);
+    free_output_buffers_.push_back(index);
+    if (decoder_state_ != kChangingResolution) {
+      Enqueue();
+      ScheduleDecodeBufferTaskIfNeeded();
+    }
+  }
 }
 
 void V4L2VideoDecodeAccelerator::ReusePictureBuffer(int32_t picture_buffer_id) {
   DVLOGF(3) << "picture_buffer_id=" << picture_buffer_id;
   // Must be run on child thread, as we'll insert a sync in the EGL context.
   DCHECK(child_task_runner_->BelongsToCurrentThread());
 
-  if (!make_context_current_cb_.Run()) {
-    LOGF(ERROR) << "could not make context current";
-    NOTIFY_ERROR(PLATFORM_FAILURE);
-    return;
-  }
+  std::unique_ptr<EGLSyncKHRRef> egl_sync_ref;
 
-  EGLSyncKHR egl_sync = EGL_NO_SYNC_KHR;
+  if (!make_context_current_cb_.is_null()) {
+    if (!make_context_current_cb_.Run()) {
+      LOGF(ERROR) << "could not make context current";
+      NOTIFY_ERROR(PLATFORM_FAILURE);
+      return;
+    }
+
+    EGLSyncKHR egl_sync = EGL_NO_SYNC_KHR;
 // TODO(posciak): crbug.com/450898.
 #if defined(ARCH_CPU_ARMEL)
-  egl_sync = eglCreateSyncKHR(egl_display_, EGL_SYNC_FENCE_KHR, NULL);
-  if (egl_sync == EGL_NO_SYNC_KHR) {
-    LOGF(ERROR) << "eglCreateSyncKHR() failed";
-    NOTIFY_ERROR(PLATFORM_FAILURE);
-    return;
-  }
+    egl_sync = eglCreateSyncKHR(egl_display_, EGL_SYNC_FENCE_KHR, NULL);
+    if (egl_sync == EGL_NO_SYNC_KHR) {
+      LOGF(ERROR) << "eglCreateSyncKHR() failed";
+      NOTIFY_ERROR(PLATFORM_FAILURE);
+      return;
+    }
 #endif
 
-  std::unique_ptr<EGLSyncKHRRef> egl_sync_ref(
-      new EGLSyncKHRRef(egl_display_, egl_sync));
+    egl_sync_ref.reset(new EGLSyncKHRRef(egl_display_, egl_sync));
+  }
 
   decoder_thread_.task_runner()->PostTask(
       FROM_HERE, base::Bind(&V4L2VideoDecodeAccelerator::ReusePictureBufferTask,
                             base::Unretained(this), picture_buffer_id,
                             base::Passed(&egl_sync_ref)));
 }
 
 void V4L2VideoDecodeAccelerator::Flush() {
   DVLOGF(3);
   DCHECK(child_task_runner_->BelongsToCurrentThread());
@@ skipping 663 matching lines @@
       if (errno == EAGAIN) {
         // EAGAIN if we're just out of buffers to dequeue.
         break;
       }
       PLOGF(ERROR) << "ioctl() failed: VIDIOC_DQBUF";
       NOTIFY_ERROR(PLATFORM_FAILURE);
       return;
     }
     OutputRecord& output_record = output_buffer_map_[dqbuf.index];
     DCHECK_EQ(output_record.state, kAtDevice);
-    DCHECK_NE(output_record.egl_image, EGL_NO_IMAGE_KHR);
     DCHECK_NE(output_record.picture_id, -1);
     output_buffer_queued_count_--;
     if (dqbuf.m.planes[0].bytesused == 0) {
       // This is an empty output buffer returned as part of a flush.
       output_record.state = kFree;
-      free_output_buffers_.push(dqbuf.index);
+      free_output_buffers_.push_back(dqbuf.index);
     } else {
       int32_t bitstream_buffer_id = dqbuf.timestamp.tv_sec;
       DCHECK_GE(bitstream_buffer_id, 0);
       DVLOGF(3) << "Dequeue output buffer: dqbuf index=" << dqbuf.index
                 << " bitstream input_id=" << bitstream_buffer_id;
       if (image_processor_device_) {
-        output_record.state = kAtProcessor;
-        image_processor_bitstream_buffer_ids_.push(bitstream_buffer_id);
-        std::vector<int> fds;
-        for (auto& fd : output_record.fds) {
-          fds.push_back(fd.get());
+        if (!ProcessFrame(bitstream_buffer_id, dqbuf.index)) {
+          DLOGF(ERROR) << "Processing frame failed";
+          NOTIFY_ERROR(PLATFORM_FAILURE);
+          return;
         }
-        scoped_refptr<VideoFrame> frame = VideoFrame::WrapExternalDmabufs(
-            V4L2Device::V4L2PixFmtToVideoPixelFormat(output_format_fourcc_),
-            coded_size_, gfx::Rect(visible_size_), visible_size_, fds,
-            base::TimeDelta());
-        // Unretained is safe because |this| owns image processor and there will
-        // be no callbacks after processor destroys.
-        image_processor_->Process(
-            frame, dqbuf.index,
-            base::Bind(&V4L2VideoDecodeAccelerator::FrameProcessed,
-                       base::Unretained(this), bitstream_buffer_id));
       } else {
         output_record.state = kAtClient;
         decoder_frames_at_client_++;
         const Picture picture(output_record.picture_id, bitstream_buffer_id,
                               gfx::Rect(visible_size_), false);
         pending_picture_ready_.push(
             PictureRecord(output_record.cleared, picture));
         SendPictureReady();
         output_record.cleared = true;
       }
@@ skipping 32 matching lines @@
 }
 
 bool V4L2VideoDecodeAccelerator::EnqueueOutputRecord() {
   DCHECK(!free_output_buffers_.empty());
 
   // Enqueue an output (VIDEO_CAPTURE) buffer.
   const int buffer = free_output_buffers_.front();
   DVLOGF(3) << "buffer " << buffer;
   OutputRecord& output_record = output_buffer_map_[buffer];
   DCHECK_EQ(output_record.state, kFree);
-  DCHECK_NE(output_record.egl_image, EGL_NO_IMAGE_KHR);
   DCHECK_NE(output_record.picture_id, -1);
   if (output_record.egl_sync != EGL_NO_SYNC_KHR) {
     TRACE_EVENT0("Video Decoder",
                  "V4L2VDA::EnqueueOutputRecord: eglClientWaitSyncKHR");
     // If we have to wait for completion, wait.  Note that
     // free_output_buffers_ is a FIFO queue, so we always wait on the
     // buffer that has been in the queue the longest.
     if (eglClientWaitSyncKHR(egl_display_, output_record.egl_sync, 0,
                              EGL_FOREVER_KHR) == EGL_FALSE) {
       // This will cause tearing, but is safe otherwise.
@@ skipping 10 matching lines @@
   std::unique_ptr<struct v4l2_plane[]> qbuf_planes(
       new v4l2_plane[output_planes_count_]);
   memset(&qbuf, 0, sizeof(qbuf));
   memset(qbuf_planes.get(), 0,
          sizeof(struct v4l2_plane) * output_planes_count_);
   qbuf.index = buffer;
   qbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   qbuf.memory = V4L2_MEMORY_MMAP;
   qbuf.m.planes = qbuf_planes.get();
   qbuf.length = output_planes_count_;
+  DVLOGF(2) << "qbuf.index=" << qbuf.index;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_QBUF, &qbuf);
-  free_output_buffers_.pop();
+  free_output_buffers_.pop_front();
   output_record.state = kAtDevice;
   output_buffer_queued_count_++;
   return true;
 }
 
 void V4L2VideoDecodeAccelerator::ReusePictureBufferTask(
     int32_t picture_buffer_id,
     std::unique_ptr<EGLSyncKHRRef> egl_sync_ref) {
   DVLOGF(3) << "picture_buffer_id=" << picture_buffer_id;
   DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
@@ skipping 27 matching lines @@
   }
 
   OutputRecord& output_record = output_buffer_map_[index];
   if (output_record.state != kAtClient) {
     LOGF(ERROR) << "picture_buffer_id not reusable";
     NOTIFY_ERROR(INVALID_ARGUMENT);
     return;
   }
 
   DCHECK_EQ(output_record.egl_sync, EGL_NO_SYNC_KHR);
-  output_record.egl_sync = egl_sync_ref->egl_sync;
   output_record.state = kFree;
-  free_output_buffers_.push(index);
+  free_output_buffers_.push_back(index);
   decoder_frames_at_client_--;
-  // Take ownership of the EGLSync.
-  egl_sync_ref->egl_sync = EGL_NO_SYNC_KHR;
+  if (egl_sync_ref) {
+    output_record.egl_sync = egl_sync_ref->egl_sync;
+    // Take ownership of the EGLSync.
+    egl_sync_ref->egl_sync = EGL_NO_SYNC_KHR;
+  }
   // We got a buffer back, so enqueue it back.
   Enqueue();
 }
 
 void V4L2VideoDecodeAccelerator::FlushTask() {
   DVLOGF(3);
   DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
   TRACE_EVENT0("Video Decoder", "V4L2VDA::FlushTask");
 
   // Flush outstanding buffers.
@@ skipping 251 matching lines @@
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_STREAMOFF, &type);
   output_streamon_ = false;
 
   for (size_t i = 0; i < output_buffer_map_.size(); ++i) {
     // After streamoff, the device drops ownership of all buffers, even if we
     // don't dequeue them explicitly. Some of them may still be owned by the
     // client however. Reuse only those that aren't.
     OutputRecord& output_record = output_buffer_map_[i];
     if (output_record.state == kAtDevice) {
       output_record.state = kFree;
-      free_output_buffers_.push(i);
+      free_output_buffers_.push_back(i);
       DCHECK_EQ(output_record.egl_sync, EGL_NO_SYNC_KHR);
     }
   }
   output_buffer_queued_count_ = 0;
   return true;
 }
 
 bool V4L2VideoDecodeAccelerator::StopInputStream() {
   DVLOGF(3);
   if (!input_streamon_)
@@ skipping 179 matching lines @@
                                    &egl_image_planes_count_)) {
       LOGF(ERROR) << "Fail to get output size and plane count of processor";
       return false;
     }
   } else {
     egl_image_size_ = coded_size_;
     egl_image_planes_count_ = output_planes_count_;
   }
   DVLOGF(3) << "new resolution: " << coded_size_.ToString()
             << ", visible size: " << visible_size_.ToString()
-            << ", EGLImage size: " << egl_image_size_.ToString();
+            << ", decoder output planes count: " << output_planes_count_
+            << ", EGLImage size: " << egl_image_size_.ToString()
+            << ", EGLImage plane count: " << egl_image_planes_count_;
 
   return CreateOutputBuffers();
 }
 
 gfx::Size V4L2VideoDecodeAccelerator::GetVisibleSize(
     const gfx::Size& coded_size) {
   DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
 
   struct v4l2_crop crop_arg;
   memset(&crop_arg, 0, sizeof(crop_arg));
@@ skipping 145 matching lines @@
       LOGF(ERROR) << "Can't find a usable input format from image processor";
       return false;
     }
     egl_image_format_fourcc_ = FindImageProcessorOutputFormat();
     if (egl_image_format_fourcc_ == 0) {
       LOGF(ERROR) << "Can't find a usable output format from image processor";
       return false;
     }
     egl_image_device_ = image_processor_device_;
   } else {
+    if (output_mode_ == Config::OutputMode::IMPORT) {
+      LOGF(ERROR) << "Import mode without image processor is not implemented "
+                  << "yet.";
+      return false;
+    }
     egl_image_format_fourcc_ = output_format_fourcc_;
     egl_image_device_ = device_;
   }
   DVLOGF(2) << "Output format=" << output_format_fourcc_;
 
   // Just set the fourcc for output; resolution, etc., will come from the
   // driver once it extracts it from the stream.
   memset(&format, 0, sizeof(format));
   format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   format.fmt.pix_mp.pixelformat = output_format_fourcc_;
@@ skipping 56 matching lines @@
 bool V4L2VideoDecodeAccelerator::ResetImageProcessor() {
   DVLOGF(3);
   DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
 
   if (!image_processor_->Reset())
     return false;
   for (size_t i = 0; i < output_buffer_map_.size(); ++i) {
     OutputRecord& output_record = output_buffer_map_[i];
     if (output_record.state == kAtProcessor) {
       output_record.state = kFree;
-      free_output_buffers_.push(i);
+      free_output_buffers_.push_back(i);
     }
   }
   while (!image_processor_bitstream_buffer_ids_.empty())
     image_processor_bitstream_buffer_ids_.pop();
 
   return true;
 }
 
+bool V4L2VideoDecodeAccelerator::CreateImageProcessor() {
+  DVLOGF(3);
+  DCHECK(!image_processor_);
+  image_processor_.reset(new V4L2ImageProcessor(image_processor_device_));
+  v4l2_memory output_memory_type =
+      (output_mode_ == Config::OutputMode::ALLOCATE ? V4L2_MEMORY_MMAP
+                                                    : V4L2_MEMORY_DMABUF);
+  // Unretained is safe because |this| owns image processor and there will be
+  // no callbacks after processor destroys.
+  if (!image_processor_->Initialize(
+          V4L2Device::V4L2PixFmtToVideoPixelFormat(output_format_fourcc_),
+          V4L2Device::V4L2PixFmtToVideoPixelFormat(egl_image_format_fourcc_),
+          V4L2_MEMORY_DMABUF, output_memory_type, visible_size_, coded_size_,
+          visible_size_, egl_image_size_, output_buffer_map_.size(),
+          base::Bind(&V4L2VideoDecodeAccelerator::ImageProcessorError,
+                     base::Unretained(this)))) {
+    LOGF(ERROR) << "Initialize image processor failed";
+    NOTIFY_ERROR(PLATFORM_FAILURE);
+    return false;
+  }
+  DVLOGF(3) << "image_processor_->output_allocated_size()="
+            << image_processor_->output_allocated_size().ToString();
+  DCHECK(image_processor_->output_allocated_size() == egl_image_size_);
+  if (image_processor_->input_allocated_size() != coded_size_) {
+    LOGF(ERROR) << "Image processor should be able to take the output coded "
+                << "size of decoder " << coded_size_.ToString()
+                << " without adjusting to "
+                << image_processor_->input_allocated_size().ToString();
+    NOTIFY_ERROR(PLATFORM_FAILURE);
+    return false;
+  }
+  return true;
+}
+
+bool V4L2VideoDecodeAccelerator::ProcessFrame(int32_t bitstream_buffer_id,
+                                              int output_buffer_index) {
+  DVLOGF(3);
+  DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
+
+  OutputRecord& output_record = output_buffer_map_[output_buffer_index];
+  DCHECK_EQ(output_record.state, kAtDevice);
+  output_record.state = kAtProcessor;
+  image_processor_bitstream_buffer_ids_.push(bitstream_buffer_id);
+  std::vector<int> processor_input_fds;
+  for (auto& fd : output_record.processor_input_fds) {
+    processor_input_fds.push_back(fd.get());
+  }
+  scoped_refptr<VideoFrame> input_frame = VideoFrame::WrapExternalDmabufs(
+      V4L2Device::V4L2PixFmtToVideoPixelFormat(output_format_fourcc_),
+      coded_size_, gfx::Rect(visible_size_), visible_size_, processor_input_fds,
+      base::TimeDelta());
+
+  std::vector<base::ScopedFD> processor_output_fds;
+  if (output_mode_ == Config::OutputMode::IMPORT) {
+    for (auto& fd : output_record.processor_output_fds) {
+      processor_output_fds.push_back(
+          base::ScopedFD(HANDLE_EINTR(dup(fd.get()))));
+      if (!processor_output_fds.back().is_valid()) {
+        PLOGF(ERROR) << "Failed duplicating a dmabuf fd";
+        return false;
+      }
+    }
+  }
+  // Unretained is safe because |this| owns image processor and there will
+  // be no callbacks after processor destroys.
+  image_processor_->Process(
+      input_frame, output_buffer_index, std::move(processor_output_fds),
+      base::Bind(&V4L2VideoDecodeAccelerator::FrameProcessed,
+                 base::Unretained(this), bitstream_buffer_id));
+  return true;
+}
+
 bool V4L2VideoDecodeAccelerator::CreateOutputBuffers() {
   DVLOGF(3);
   DCHECK(decoder_state_ == kInitialized ||
          decoder_state_ == kChangingResolution);
   DCHECK(!output_streamon_);
   DCHECK(output_buffer_map_.empty());
 
   // Number of output buffers we need.
   struct v4l2_control ctrl;
   memset(&ctrl, 0, sizeof(ctrl));
   ctrl.id = V4L2_CID_MIN_BUFFERS_FOR_CAPTURE;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_G_CTRL, &ctrl);
   output_dpb_size_ = ctrl.value;
 
   // Output format setup in Initialize().
 
   const uint32_t buffer_count = output_dpb_size_ + kDpbOutputBufferExtraCount;
   DVLOGF(3) << "buffer_count=" << buffer_count
             << ", coded_size=" << egl_image_size_.ToString();
 
+  // With ALLOCATE mode the client can sample it as RGB and doesn't need to
+  // know the precise format.
+  VideoPixelFormat pixel_format =
+      (output_mode_ == Config::OutputMode::IMPORT)
+          ? V4L2Device::V4L2PixFmtToVideoPixelFormat(egl_image_format_fourcc_)
+          : PIXEL_FORMAT_UNKNOWN;
+
   child_task_runner_->PostTask(
       FROM_HERE, base::Bind(&Client::ProvidePictureBuffers, client_,
-                            buffer_count, PIXEL_FORMAT_UNKNOWN, 1,
-                            egl_image_size_, device_->GetTextureTarget()));
+                            buffer_count, pixel_format, 1, egl_image_size_,
+                            device_->GetTextureTarget()));
 
   // Go into kAwaitingPictureBuffers to prevent us from doing any more decoding
   // or event handling while we are waiting for AssignPictureBuffers(). Not
   // having Pictures available would not have prevented us from making decoding
   // progress entirely e.g. in the case of H.264 where we could further decode
   // non-slice NALUs and could even get another resolution change before we were
   // done with this one. After we get the buffers, we'll go back into kIdle and
   // kick off further event processing, and eventually go back into kDecoding
   // once no more events are pending (if any).
   decoder_state_ = kAwaitingPictureBuffers;
@@ skipping 53 matching lines @@
                               output_record.picture_id));
   }
 
   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 (device_->Ioctl(VIDIOC_REQBUFS, &reqbufs) != 0) {
     PLOGF(ERROR) << "ioctl() failed: VIDIOC_REQBUFS";
+    NOTIFY_ERROR(PLATFORM_FAILURE);
     success = false;
   }
 
   output_buffer_map_.clear();
   while (!free_output_buffers_.empty())
-    free_output_buffers_.pop();
+    free_output_buffers_.pop_front();
   output_buffer_queued_count_ = 0;
   // The client may still hold some buffers. The texture holds a reference to
   // the buffer. It is OK to free the buffer and destroy EGLImage here.
   decoder_frames_at_client_ = 0;
 
   return success;
 }
 
 void V4L2VideoDecodeAccelerator::SendPictureReady() {
   DVLOGF(3);
@@ skipping 51 matching lines @@
             << ", bitstream_buffer_id=" << bitstream_buffer_id;
   DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
   DCHECK(!image_processor_bitstream_buffer_ids_.empty());
   DCHECK(image_processor_bitstream_buffer_ids_.front() == bitstream_buffer_id);
   DCHECK_GE(output_buffer_index, 0);
   DCHECK_LT(output_buffer_index, static_cast<int>(output_buffer_map_.size()));
 
   OutputRecord& output_record = output_buffer_map_[output_buffer_index];
   DVLOGF(3) << "picture_id=" << output_record.picture_id;
   DCHECK_EQ(output_record.state, kAtProcessor);
-  DCHECK_NE(output_record.egl_image, EGL_NO_IMAGE_KHR);
   DCHECK_NE(output_record.picture_id, -1);
 
   // Send the processed frame to render.
   output_record.state = kAtClient;
   decoder_frames_at_client_++;
   image_processor_bitstream_buffer_ids_.pop();
   const Picture picture(output_record.picture_id, bitstream_buffer_id,
                         gfx::Rect(visible_size_), false);
   pending_picture_ready_.push(PictureRecord(output_record.cleared, picture));
   SendPictureReady();
   output_record.cleared = true;
   // Flush or resolution change may be waiting image processor to finish.
   if (image_processor_bitstream_buffer_ids_.empty()) {
     NotifyFlushDoneIfNeeded();
     if (decoder_state_ == kChangingResolution)
       StartResolutionChange();
   }
 }
 
 void V4L2VideoDecodeAccelerator::ImageProcessorError() {
   LOGF(ERROR) << "Image processor error";
   NOTIFY_ERROR(PLATFORM_FAILURE);
 }
 
 }  // namespace media