EVDA: Add support for dynamic resolution change and MSE players.

content/common/gpu/media/exynos_video_decode_accelerator.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <dlfcn.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <sys/eventfd.h>
@@ skipping 32 matching lines @@
   do {                                                                \
     if (HANDLE_EINTR(ioctl(fd, type, arg) != 0)) {                    \
       DPLOG(ERROR) << __func__ << "(): ioctl() failed: " << #type;    \
       NOTIFY_ERROR(PLATFORM_FAILURE);                                 \
       return false;                                                   \
     }                                                                 \
   } while (0)
 
 namespace {
 
+// TODO(posciak): remove once we update linux-headers.
+#ifndef V4L2_EVENT_RESOLUTION_CHANGE
+#define V4L2_EVENT_RESOLUTION_CHANGE 5
+#endif
+
 const char kExynosMfcDevice[] = "/dev/mfc-dec";
 const char kExynosGscDevice[] = "/dev/gsc1";
 const char kMaliDriver[] = "libmali.so";
 
 typedef EGLBoolean (*MaliEglImageGetBufferExtPhandleFunc)(EGLImageKHR, EGLint*,
                                                           void*);
 
 void* libmali_handle = NULL;
 MaliEglImageGetBufferExtPhandleFunc
     mali_egl_image_get_buffer_ext_phandle = NULL;
@@ skipping 142 matching lines @@
       weak_this_(base::AsWeakPtr(this)),
       client_ptr_factory_(client),
       client_(client_ptr_factory_.GetWeakPtr()),
       decoder_thread_("ExynosDecoderThread"),
       decoder_state_(kUninitialized),
       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),
+      resolution_change_pending_(false),
+      resolution_change_reset_pending_(false),
       decoder_partial_frame_pending_(false),
       mfc_fd_(-1),
       mfc_input_streamon_(false),
       mfc_input_buffer_queued_count_(0),
       mfc_output_streamon_(false),
       mfc_output_buffer_queued_count_(0),
       mfc_output_buffer_pixelformat_(0),
       mfc_output_dpb_size_(0),
       gsc_fd_(-1),
       gsc_input_streamon_(false),
@@ skipping 147 matching lines @@
   if (!CreateMfcInputBuffers())
     return false;
 
   // MFC output format has to be setup before streaming starts.
   struct v4l2_format format;
   memset(&format, 0, sizeof(format));
   format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   format.fmt.pix_mp.pixelformat = V4L2_PIX_FMT_NV12MT_16X16;
   IOCTL_OR_ERROR_RETURN_FALSE(mfc_fd_, VIDIOC_S_FMT, &format);
 
+  // Subscribe to the resolution change event.
+  struct v4l2_event_subscription sub;
+  memset(&sub, 0, sizeof(sub));
+  sub.type = V4L2_EVENT_RESOLUTION_CHANGE;
+  IOCTL_OR_ERROR_RETURN_FALSE(mfc_fd_, VIDIOC_SUBSCRIBE_EVENT, &sub);
+
   // Initialize format-specific bits.
   if (video_profile_ >= media::H264PROFILE_MIN &&
       video_profile_ <= media::H264PROFILE_MAX) {
     decoder_h264_parser_.reset(new content::H264Parser());
   }
 
   if (!decoder_thread_.Start()) {
     DLOG(ERROR) << "Initialize(): decoder thread failed to start";
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return false;
@@ skipping 238 matching lines @@
   TRACE_EVENT0("Video Decoder", "EVDA::DecodeBufferTask");
 
   decoder_decode_buffer_tasks_scheduled_--;
 
   if (decoder_state_ == kResetting) {
     DVLOG(2) << "DecodeBufferTask(): early out: kResetting state";
     return;
   } else if (decoder_state_ == kError) {
     DVLOG(2) << "DecodeBufferTask(): early out: kError state";
     return;
+  } else if (decoder_state_ == kChangingResolution) {
+    DVLOG(2) << "DecodeBufferTask(): early out: resolution change pending";
+    return;
   }
 
   if (decoder_current_bitstream_buffer_ == NULL) {
     if (decoder_input_queue_.empty()) {
       // We're waiting for a new buffer -- exit without scheduling a new task.
       return;
     }
     linked_ptr<BitstreamBufferRef>& buffer_ref = decoder_input_queue_.front();
     if (decoder_delay_bitstream_buffer_id_ == buffer_ref->input_id) {
       // We're asked to delay decoding on this and subsequent buffers.
@@ skipping 205 matching lines @@
     return true;
 
   if (!FlushInputFrame())
     return false;
 
   // Recycle buffers.
   DequeueMfc();
 
   // Check and see if we have format info yet.
   struct v4l2_format format;
-  format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
-  if (ioctl(mfc_fd_, VIDIOC_G_FMT, &format) != 0) {
-    if (errno == EINVAL) {
-      // We will get EINVAL if we haven't seen sufficient stream to decode the
-      // format.  Return true and schedule the next buffer.
-      *endpos = size;
-      return true;
-    } else {
-      DPLOG(ERROR) << "DecodeBufferInitial(): ioctl() failed: VIDIOC_G_FMT";
-      NOTIFY_ERROR(PLATFORM_FAILURE);
-      return false;
-    }
+  bool again = false;
+  if (!GetFormatInfo(&format, &again))
+    return false;
+
+  if (again) {
+    // Need more stream to decode format, return true and schedule next buffer.
+    *endpos = size;
+    return true;
   }
 
   // Run this initialization only on first startup.
   if (decoder_state_ == kInitialized) {
-    DVLOG(3) << "DecodeBufferInitial(): running one-time initialization";
+    DVLOG(3) << "DecodeBufferInitial(): running initialization";
     // Success! Setup our parameters.
-    CHECK_EQ(format.fmt.pix_mp.num_planes, 2);
-    frame_buffer_size_.SetSize(
-        format.fmt.pix_mp.width, format.fmt.pix_mp.height);
-    mfc_output_buffer_size_[0] = format.fmt.pix_mp.plane_fmt[0].sizeimage;
-    mfc_output_buffer_size_[1] = format.fmt.pix_mp.plane_fmt[1].sizeimage;
-    mfc_output_buffer_pixelformat_ = format.fmt.pix_mp.pixelformat;
-    DCHECK_EQ(mfc_output_buffer_pixelformat_, V4L2_PIX_FMT_NV12MT_16X16);
-
-    // Create our other buffers.
-    if (!CreateMfcOutputBuffers() || !CreateGscInputBuffers() ||
-        !CreateGscOutputBuffers())
+    if (!CreateBuffersForFormat(format))
       return false;
 
     // MFC expects to process the initial buffer once during stream init to
     // configure stream parameters, but will not consume the steam data on that
     // iteration.  Subsequent iterations (including after reset) do not require
     // the stream init step.
     *endpos = 0;
   } else {
     *endpos = size;
   }
@@ skipping 153 matching lines @@
 
     // Take ownership of the EGLImage and fd.
     buffer.egl_image = EGL_NO_IMAGE_KHR;
     buffer.egl_image_fd = -1;
     // And add this buffer to the free list.
     gsc_free_output_buffers_.push_back(i);
   }
 
   // We got buffers!  Kick the GSC.
   EnqueueGsc();
+
+  if (decoder_state_ == kChangingResolution)
+    ResumeAfterResolutionChange();
 }
 
-void ExynosVideoDecodeAccelerator::ServiceDeviceTask() {
+void ExynosVideoDecodeAccelerator::ServiceDeviceTask(bool mfc_event_pending) {
   DVLOG(3) << "ServiceDeviceTask()";
   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
   DCHECK_NE(decoder_state_, kUninitialized);
   DCHECK_NE(decoder_state_, kInitialized);
   DCHECK_NE(decoder_state_, kAfterReset);
   TRACE_EVENT0("Video Decoder", "EVDA::ServiceDeviceTask");
 
   if (decoder_state_ == kResetting) {
     DVLOG(2) << "ServiceDeviceTask(): early out: kResetting state";
     return;
   } else if (decoder_state_ == kError) {
     DVLOG(2) << "ServiceDeviceTask(): early out: kError state";
     return;
+  } else if (decoder_state_ == kChangingResolution) {
+    DVLOG(2) << "ServiceDeviceTask(): early out: kChangingResolution state";
+    return;
   }
 
+  if (mfc_event_pending)
+    DequeueMfcEvents();
   DequeueMfc();
   DequeueGsc();
   EnqueueMfc();
   EnqueueGsc();
 
   // Clear the interrupt fd.
   if (!ClearDevicePollInterrupt())
     return;
 
   unsigned int poll_fds = 0;
@@ skipping 31 matching lines @@
            << mfc_output_gsc_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()  << "] => VDA["
            << decoder_frames_at_client_ << "]";
 
   ScheduleDecodeBufferTaskIfNeeded();
+  StartResolutionChangeIfNeeded();
 }
 
 void ExynosVideoDecodeAccelerator::EnqueueMfc() {
   DVLOG(3) << "EnqueueMfc()";
   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
   DCHECK_NE(decoder_state_, kUninitialized);
   TRACE_EVENT0("Video Decoder", "EVDA::EnqueueMfc");
 
   // Drain the pipe of completed decode buffers.
   const int old_mfc_inputs_queued = mfc_input_buffer_queued_count_;
@@ skipping 27 matching lines @@
       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 ExynosVideoDecodeAccelerator::DequeueMfcEvents() {
+  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK_EQ(decoder_state_, kDecoding);
+  DVLOG(3) << "DequeueMfcEvents()";

[Ami GONE FROM CHROMIUM, 2013/08/12 03:46:19]

Is there some reason you (and your kind, who enjoy these sort of tracer DVLOGs,
apparently) use explicit strings instead of __FUNCTION__ / __func__ ?

[Pawel Osciak, 2013/08/12 04:07:45]

I do enjoy those traces and they help a lot when debugging, and I'm  surprised
you apparently seem to dislike them :) I agree that using macros is better and I
debated using them, but I didn't want to break this class' conventions, which is
to spell out the names.

In any case, not sure if you are asking me to convert this class to using
__FUNCTION__ or even __PRETTY_FUNCTION__ in this CL, or just making a general
remark? :)

[sheu, 2013/08/12 04:49:20]

My fault.  I just started doing it this way, and haven't stopped.  I don't have
any particular objection to switching if it feels necessary.

+
+  struct v4l2_event ev;
+  memset(&ev, 0, sizeof(ev));
+
+  while (ioctl(mfc_fd_, VIDIOC_DQEVENT, &ev) == 0) {
+    if (ev.type == V4L2_EVENT_RESOLUTION_CHANGE) {
+      DVLOG(3) << "DequeueMfcEvents(): got resolution change event.";
+      DCHECK(!resolution_change_pending_);
+      resolution_change_pending_ = true;
+    } else {
+      DLOG(FATAL) << "DequeueMfcEvents(): got an event (" << ev.type
+                  << ") we haven't subscribed to.";
+    }
+  }
+}
+
 void ExynosVideoDecodeAccelerator::DequeueMfc() {
   DVLOG(3) << "DequeueMfc()";
   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
   DCHECK_NE(decoder_state_, kUninitialized);
   TRACE_EVENT0("Video Decoder", "EVDA::DequeueMfc");
 
   // Dequeue completed MFC input (VIDEO_OUTPUT) buffers, and recycle to the free
   // list.
   struct v4l2_buffer dqbuf;
   struct v4l2_plane planes[2];
@@ skipping 338 matching lines @@
            << picture_buffer_id;
   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
   TRACE_EVENT0("Video Decoder", "EVDA::ReusePictureBufferTask");
 
   // We run ReusePictureBufferTask even if we're in kResetting.
   if (decoder_state_ == kError) {
     DVLOG(2) << "ReusePictureBufferTask(): early out: kError state";
     return;
   }
 
+  if (decoder_state_ == kChangingResolution) {
+    DVLOG(2) << "ReusePictureBufferTask(): early out: kChangingResolution";
+    return;
+  }
+
   size_t index;
   for (index = 0; index < gsc_output_buffer_map_.size(); ++index)
     if (gsc_output_buffer_map_[index].picture_id == picture_buffer_id)
       break;
 
   if (index >= gsc_output_buffer_map_.size()) {
     DLOG(ERROR) << "ReusePictureBufferTask(): picture_buffer_id not found";
     NOTIFY_ERROR(INVALID_ARGUMENT);
     return;
   }
@@ skipping 61 matching lines @@
         decoder_delay_bitstream_buffer_id_)
       return;
   }
   if (decoder_current_input_buffer_ != -1)
     return;
   if ((mfc_input_ready_queue_.size() +
        mfc_input_buffer_queued_count_ + mfc_output_gsc_input_queue_.size() +
        gsc_input_buffer_queued_count_ + gsc_output_buffer_queued_count_ ) != 0)
     return;
 
+  // TODO(posciak): crbug.com/270039. MFC requires a streamoff-streamon
+  // sequence after flush to continue, even if we are not resetting. This would
+  // make sense, because we don't really want to resume from a non-resume point
+  // (e.g. not from an IDR) if we are flushed.
+  // MSE player however triggers a Flush() on chunk end, but never Reset(). One
+  // could argue either way, or even say that Flush() is not needed/harmful when
+  // transitioning to next chunk.
+  // For now, do the streamoff-streamon cycle to satisfy MFC and not freeze when
+  // doing MSE. This should be harmless otherwise.
+  if (!StopDevicePoll(false))
+    return;
+
+  if (!StartDevicePoll())
+    return;
+
   decoder_delay_bitstream_buffer_id_ = -1;
   decoder_flushing_ = false;
   DVLOG(3) << "NotifyFlushDoneIfNeeded(): returning flush";
   child_message_loop_proxy_->PostTask(FROM_HERE, base::Bind(
     &Client::NotifyFlushDone, client_));
 
   // While we were flushing, we early-outed DecodeBufferTask()s.
   ScheduleDecodeBufferTaskIfNeeded();
 }
 
 void ExynosVideoDecodeAccelerator::ResetTask() {
   DVLOG(3) << "ResetTask()";
   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
   TRACE_EVENT0("Video Decoder", "EVDA::ResetTask");
 
   if (decoder_state_ == kError) {
     DVLOG(2) << "ResetTask(): early out: kError state";
     return;
   }
 
-  // We stop streaming, but we _don't_ destroy our buffers.
-  if (!StopDevicePoll())
+  // If we are in the middle of switching resolutions, postpone reset until
+  // it's done. We don't have to worry about timing of this wrt to decoding,
+  // because MFC input pipe is already stopped if we are changing resolution.
+  // We will come back here after we are done with the resolution change.
+  DCHECK(!resolution_change_reset_pending_);
+  if (resolution_change_pending_ || decoder_state_ == kChangingResolution) {
+    resolution_change_reset_pending_ = true;
+    return;
+  }
+
+  // We stop streaming and clear buffer tracking info (not preserving
+  // MFC inputs).
+  // StopDevicePoll() unconditionally does _not_ destroy buffers, however.
+  if (!StopDevicePoll(false))
     return;
 
+  DequeueMfcEvents();
+
+  resolution_change_pending_ = false;
   decoder_current_bitstream_buffer_.reset();
   decoder_input_queue_.clear();
 
   decoder_current_input_buffer_ = -1;
 
   // If we were flushing, we'll never return any more BitstreamBuffers or
   // PictureBuffers; they have all been dropped and returned by now.
   NotifyFlushDoneIfNeeded();
 
   // Mark that we're resetting, then enqueue a ResetDoneTask().  All intervening
@@ skipping 31 matching lines @@
   ScheduleDecodeBufferTaskIfNeeded();
 }
 
 void ExynosVideoDecodeAccelerator::DestroyTask() {
   DVLOG(3) << "DestroyTask()";
   TRACE_EVENT0("Video Decoder", "EVDA::DestroyTask");
 
   // DestroyTask() should run regardless of decoder_state_.
 
   // Stop streaming and the device_poll_thread_.
-  StopDevicePoll();
+  StopDevicePoll(false);
 
   decoder_current_bitstream_buffer_.reset();
   decoder_current_input_buffer_ = -1;
   decoder_decode_buffer_tasks_scheduled_ = 0;
   decoder_frames_at_client_ = 0;
   decoder_input_queue_.clear();
   decoder_flushing_ = false;
 
   // Set our state to kError.  Just in case.
   decoder_state_ = kError;
@@ skipping 11 matching lines @@
     return false;
   }
   device_poll_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
       &ExynosVideoDecodeAccelerator::DevicePollTask,
       base::Unretained(this),
       0));
 
   return true;
 }
 
-bool ExynosVideoDecodeAccelerator::StopDevicePoll() {
+bool ExynosVideoDecodeAccelerator::StopDevicePoll(bool keep_mfc_input_state) {
   DVLOG(3) << "StopDevicePoll()";
   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
 
   // 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 (mfc_input_streamon_) {
-    __u32 type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
-    IOCTL_OR_ERROR_RETURN_FALSE(mfc_fd_, VIDIOC_STREAMOFF, &type);
+  if (!keep_mfc_input_state) {
+    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;
   }
-  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;
   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;
 
   // Reset all our accounting info.
-  mfc_input_ready_queue_.clear();
-  mfc_free_input_buffers_.clear();
-  for (size_t i = 0; i < mfc_input_buffer_map_.size(); ++i) {
-    mfc_free_input_buffers_.push_back(i);
-    mfc_input_buffer_map_[i].at_device = false;
-    mfc_input_buffer_map_[i].bytes_used = 0;
-    mfc_input_buffer_map_[i].input_id = -1;
+  if (!keep_mfc_input_state) {
+    mfc_input_ready_queue_.clear();
+    mfc_free_input_buffers_.clear();
+    for (size_t i = 0; i < mfc_input_buffer_map_.size(); ++i) {
+      mfc_free_input_buffers_.push_back(i);
+      mfc_input_buffer_map_[i].at_device = false;
+      mfc_input_buffer_map_[i].bytes_used = 0;
+      mfc_input_buffer_map_[i].input_id = -1;
+    }
+    mfc_input_buffer_queued_count_ = 0;
   }
-  mfc_input_buffer_queued_count_ = 0;
   mfc_free_output_buffers_.clear();
   for (size_t i = 0; i < mfc_output_buffer_map_.size(); ++i) {
     mfc_free_output_buffers_.push_back(i);
     mfc_output_buffer_map_[i].at_device = false;
     mfc_output_buffer_map_[i].input_id = -1;
   }
   mfc_output_buffer_queued_count_ = 0;
   mfc_output_gsc_input_queue_.clear();
   gsc_free_input_buffers_.clear();
   for (size_t i = 0; i < gsc_input_buffer_map_.size(); ++i) {
@@ skipping 40 matching lines @@
       return true;
     } else {
       DPLOG(ERROR) << "ClearDevicePollInterrupt(): read() failed";
       NOTIFY_ERROR(PLATFORM_FAILURE);
       return false;
     }
   }
   return true;
 }
 
+void ExynosVideoDecodeAccelerator::StartResolutionChangeIfNeeded() {
+  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK_EQ(decoder_state_, kDecoding);
+
+  if (!resolution_change_pending_)
+    return;
+
+  if (!mfc_output_gsc_input_queue_.empty() ||
+      gsc_input_buffer_queued_count_ + gsc_output_buffer_queued_count_ > 0) {
+    DVLOG(3) << "StartResolutionChangeIfNeeded(): waiting for GSC to finish.";
+    return;
+  }
+
+  DVLOG(3) << "No more work for GSC, initiate resolution change";
+
+  // Keep MFC input queue.
+  if (!StopDevicePoll(true))
+    return;
+
+  decoder_state_ = kChangingResolution;
+  DCHECK(resolution_change_pending_);
+  resolution_change_pending_ = false;
+
+  // Post a task to clean up buffers on child thread. This will also ensure
+  // that we won't accept ReusePictureBuffer() anymore after that.
+  child_message_loop_proxy_->PostTask(FROM_HERE, base::Bind(
+      &ExynosVideoDecodeAccelerator::ResolutionChangeDestroyBuffers,
+      weak_this_));
+}
+
+void ExynosVideoDecodeAccelerator::FinishResolutionChange() {
+  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DVLOG(3) << "FinishResolutionChange()";
+
+  if (decoder_state_ == kError) {
+    DVLOG(2) << "FinishResolutionChange(): early out: kError state";
+    return;
+  }
+
+  struct v4l2_format format;
+  bool again;
+  bool ret = GetFormatInfo(&format, &again);
+  if (!ret || again) {
+    DVLOG(3) << "Couldn't get format information after resolution change";
+    NOTIFY_ERROR(PLATFORM_FAILURE);
+    return;
+  }
+
+  if (!CreateBuffersForFormat(format)) {
+    DVLOG(3) << "Couldn't reallocate buffers after resolution change";
+    NOTIFY_ERROR(PLATFORM_FAILURE);
+    return;
+  }
+
+  // From here we stay in kChangingResolution and wait for
+  // AssignPictureBuffers() before we can resume.
+}
+
+void ExynosVideoDecodeAccelerator::ResumeAfterResolutionChange() {
+  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DVLOG(3) << "ResumeAfterResolutionChange()";
+
+  decoder_state_ = kDecoding;
+
+  if (resolution_change_reset_pending_) {
+    resolution_change_reset_pending_ = false;
+    ResetTask();
+    return;
+  }
+
+  if (!StartDevicePoll())
+    return;
+
+  EnqueueMfc();
+  // Gsc will get enqueued in AssignPictureBuffersTask().
+  ScheduleDecodeBufferTaskIfNeeded();
+}
+
 void ExynosVideoDecodeAccelerator::DevicePollTask(unsigned int poll_fds) {
   DVLOG(3) << "DevicePollTask()";
   DCHECK_EQ(device_poll_thread_.message_loop(), base::MessageLoop::current());
   TRACE_EVENT0("Video Decoder", "EVDA::DevicePollTask");
 
   // This routine just polls the set of device fds, and schedules a
   // ServiceDeviceTask() on decoder_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;
+  int mfc_pollfd = -1;
 
   // Add device_poll_interrupt_fd_;
   pollfds[0].fd = device_poll_interrupt_fd_;
   pollfds[0].events = POLLIN | POLLERR;
   nfds = 1;
 
   if (poll_fds & kPollMfc) {
     DVLOG(3) << "DevicePollTask(): adding MFC to poll() set";
     pollfds[nfds].fd = mfc_fd_;
-    pollfds[nfds].events = POLLIN | POLLOUT | POLLERR;
+    pollfds[nfds].events = POLLIN | POLLOUT | POLLERR | POLLPRI;
+    mfc_pollfd = nfds;
     nfds++;
   }
   // 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++;
   }
 
   // Poll it!
   if (HANDLE_EINTR(poll(pollfds, nfds, -1)) == -1) {
     DPLOG(ERROR) << "DevicePollTask(): poll() failed";
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return;
   }
 
+  bool mfc_event_pending = (mfc_pollfd != -1 &&
+                            pollfds[mfc_pollfd].revents & POLLPRI);
+
   // All processing should happen on ServiceDeviceTask(), since we shouldn't
   // touch decoder state from this thread.
   decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
       &ExynosVideoDecodeAccelerator::ServiceDeviceTask,
-      base::Unretained(this)));
+      base::Unretained(this), mfc_event_pending));
 }
 
 void ExynosVideoDecodeAccelerator::NotifyError(Error error) {
   DVLOG(2) << "NotifyError()";
 
   if (!child_message_loop_proxy_->BelongsToCurrentThread()) {
     child_message_loop_proxy_->PostTask(FROM_HERE, base::Bind(
         &ExynosVideoDecodeAccelerator::NotifyError, weak_this_, error));
     return;
   }
@@ skipping 12 matching lines @@
   if (decoder_thread_.message_loop() != NULL &&
       decoder_thread_.message_loop() != base::MessageLoop::current()) {
     decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
         &ExynosVideoDecodeAccelerator::SetDecoderState,
         base::Unretained(this), state));
   } else {
     decoder_state_ = state;
   }
 }
 
+bool ExynosVideoDecodeAccelerator::GetFormatInfo(struct v4l2_format* format,
+                                                 bool* again) {
+  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+
+  *again = false;
+  memset(format, 0, sizeof(*format));
+  format->type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
+  if (HANDLE_EINTR(ioctl(mfc_fd_, VIDIOC_G_FMT, format)) != 0) {
+    if (errno == EINVAL) {
+      // EINVAL means we haven't seen sufficient stream to decode the format.
+      *again = true;
+      return true;
+    } else {
+      DPLOG(ERROR) << "DecodeBufferInitial(): ioctl() failed: VIDIOC_G_FMT";
+      NOTIFY_ERROR(PLATFORM_FAILURE);
+      return false;
+    }
+  }
+
+  return true;
+}
+
+bool ExynosVideoDecodeAccelerator::CreateBuffersForFormat(
+    const struct v4l2_format& format) {
+  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  CHECK_EQ(format.fmt.pix_mp.num_planes, 2);
+  frame_buffer_size_.SetSize(
+      format.fmt.pix_mp.width, format.fmt.pix_mp.height);
+  mfc_output_buffer_size_[0] = format.fmt.pix_mp.plane_fmt[0].sizeimage;
+  mfc_output_buffer_size_[1] = format.fmt.pix_mp.plane_fmt[1].sizeimage;
+  mfc_output_buffer_pixelformat_ = format.fmt.pix_mp.pixelformat;
+  DCHECK_EQ(mfc_output_buffer_pixelformat_, V4L2_PIX_FMT_NV12MT_16X16);
+  DVLOG(3) << "CreateBuffersForFormat(): new resolution: "
+           << frame_buffer_size_.ToString();
+
+  if (!CreateMfcOutputBuffers() || !CreateGscInputBuffers() ||
+      !CreateGscOutputBuffers())
+    return false;
+
+  return true;
+}
+
 bool ExynosVideoDecodeAccelerator::CreateMfcInputBuffers() {
   DVLOG(3) << "CreateMfcInputBuffers()";
   // We always run this as we prepare to initialize.
   DCHECK_EQ(decoder_state_, kUninitialized);
   DCHECK(!mfc_input_streamon_);
   DCHECK(mfc_input_buffer_map_.empty());
 
   __u32 pixelformat = 0;
   if (video_profile_ >= media::H264PROFILE_MIN &&
       video_profile_ <= media::H264PROFILE_MAX) {
@@ skipping 43 matching lines @@
     }
     mfc_input_buffer_map_[i].address = address;
     mfc_input_buffer_map_[i].length = buffer.m.planes[0].length;
   }
 
   return true;
 }
 
 bool ExynosVideoDecodeAccelerator::CreateMfcOutputBuffers() {
   DVLOG(3) << "CreateMfcOutputBuffers()";
-  DCHECK_EQ(decoder_state_, kInitialized);
+  DCHECK(decoder_state_ == kInitialized ||
+         decoder_state_ == kChangingResolution);
   DCHECK(!mfc_output_streamon_);
   DCHECK(mfc_output_buffer_map_.empty());
 
   // Number of MFC 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(mfc_fd_, VIDIOC_G_CTRL, &ctrl);
   mfc_output_dpb_size_ = ctrl.value;
 
@@ skipping 36 matching lines @@
       mfc_output_buffer_map_[i].address[j] = address;
       mfc_output_buffer_map_[i].length[j] = buffer.m.planes[j].length;
     }
   }
 
   return true;
 }
 
 bool ExynosVideoDecodeAccelerator::CreateGscInputBuffers() {
   DVLOG(3) << "CreateGscInputBuffers()";
-  DCHECK_EQ(decoder_state_, kInitialized);
+  DCHECK(decoder_state_ == kInitialized ||
+         decoder_state_ == kChangingResolution);
   DCHECK(!gsc_input_streamon_);
   DCHECK(gsc_input_buffer_map_.empty());
 
   struct v4l2_format format;
   memset(&format, 0, sizeof(format));
   format.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
   format.fmt.pix_mp.width  = frame_buffer_size_.width();
   format.fmt.pix_mp.height = frame_buffer_size_.height();
   format.fmt.pix_mp.pixelformat = mfc_output_buffer_pixelformat_;
   format.fmt.pix_mp.plane_fmt[0].sizeimage = mfc_output_buffer_size_[0];
@@ skipping 42 matching lines @@
   for (size_t i = 0; i < gsc_input_buffer_map_.size(); ++i) {
     gsc_free_input_buffers_.push_back(i);
     gsc_input_buffer_map_[i].mfc_output = -1;
   }
 
   return true;
 }
 
 bool ExynosVideoDecodeAccelerator::CreateGscOutputBuffers() {
   DVLOG(3) << "CreateGscOutputBuffers()";
-  DCHECK_EQ(decoder_state_, kInitialized);
+  DCHECK(decoder_state_ == kInitialized ||
+         decoder_state_ == kChangingResolution);
   DCHECK(!gsc_output_streamon_);
   DCHECK(gsc_output_buffer_map_.empty());
 
   // GSC outputs into the EGLImages we create from the textures we are
   // assigned.  Assume RGBA8888 format.
   struct v4l2_format format;
   memset(&format, 0, sizeof(format));
   format.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   format.fmt.pix_mp.width  = frame_buffer_size_.width();
   format.fmt.pix_mp.height = frame_buffer_size_.height();
@@ skipping 106 matching lines @@
 
     size_t i = 0;
     do {
       GscOutputRecord& output_record = gsc_output_buffer_map_[i];
       if (output_record.fd != -1)
         HANDLE_EINTR(close(output_record.fd));
       if (output_record.egl_image != EGL_NO_IMAGE_KHR)
         eglDestroyImageKHR(egl_display_, output_record.egl_image);
       if (output_record.egl_sync != EGL_NO_SYNC_KHR)
         eglDestroySyncKHR(egl_display_, output_record.egl_sync);
-      if (client_)
+      if (client_) {
+        DVLOG(1) << "DestroyGscOutputBuffers(): "
+                 << "dismissing PictureBuffer id=" << output_record.picture_id;
         client_->DismissPictureBuffer(output_record.picture_id);
+      }
       ++i;
     } while (i < gsc_output_buffer_map_.size());
   }
 
   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 (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 ExynosVideoDecodeAccelerator::ResolutionChangeDestroyBuffers() {
+  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
+  DVLOG(3) << "ResolutionChangeDestroyBuffers()";
+
+  DestroyGscInputBuffers();
+  DestroyGscOutputBuffers();
+  DestroyMfcOutputBuffers();
+
+  // Finish resolution change on decoder thread.
+  decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
+      &ExynosVideoDecodeAccelerator::FinishResolutionChange,
+      base::Unretained(this)));
+}
+
 }  // namespace content