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),
       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 for 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 179 matching lines @@
   if (decoder_current_bitstream_buffer_ != NULL)
     buffers_to_decode++;
   if (decoder_decode_buffer_tasks_scheduled_ < buffers_to_decode) {
     decoder_decode_buffer_tasks_scheduled_++;
     decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
         &ExynosVideoDecodeAccelerator::DecodeBufferTask,
         base::Unretained(this)));
   }
 }
 
+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 (ioctl(mfc_fd_, VIDIOC_G_FMT, format) != 0) {

[sheu, 2013/08/09 09:23:16]

I should have probably wrapped this in HANDLE_EINTR the first time.

[Pawel Osciak, 2013/08/09 10:22:59]

Done.

+    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) << "New resolution: " << frame_buffer_size_.ToString();

[sheu, 2013/08/09 09:23:16]

I got in the habit of "CreateBuffersForFormat(): BLAH BLAH BLAH" for comments. 
Keep it up here?

yay linebreaks

[Pawel Osciak, 2013/08/09 10:22:59]

Done.

+
+  if (!CreateMfcOutputBuffers() || !CreateGscInputBuffers() ||
+      !CreateGscOutputBuffers())
+    return false;
+
+  return true;
+}
+
 bool ExynosVideoDecodeAccelerator::DecodeBufferInitial(
     const void* data, size_t size, size_t* endpos) {
   DVLOG(3) << "DecodeBufferInitial(): data=" << data << ", size=" << size;
   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
   DCHECK_NE(decoder_state_, kUninitialized);
   DCHECK_NE(decoder_state_, kDecoding);
   DCHECK(!device_poll_thread_.IsRunning());
   // Initial decode.  We haven't been able to get output stream format info yet.
   // Get it, and start decoding.
 
   // Copy in and send to HW.
   if (!AppendToInputFrame(data, size))
     return false;
 
   // If we only have a partial frame, don't flush and process yet.
   if (decoder_partial_frame_pending_)
     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";

[sheu, 2013/08/09 09:23:16]

It's not one-time anymore.

[Pawel Osciak, 2013/08/09 10:22:59]

Done.

     // 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)
+    ResumeAfterResolutionChangeTask();
 }
 
-void ExynosVideoDecodeAccelerator::ServiceDeviceTask() {
+void ExynosVideoDecodeAccelerator::ServiceDeviceTask(bool 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 (event_pending)
+    DequeueEvents();
   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::StartResolutionChangeIfNeeded() {
+  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK_NE(decoder_state_, kUninitialized);

[sheu, 2013/08/09 09:23:16]

DCHECK_EQ(decoder_state_, kDecoding)

[Pawel Osciak, 2013/08/09 10:22:59]

Done.

+
+  if (!resolution_change_pending_)
+    return;
+
+  if (!mfc_output_gsc_input_queue_.empty() ||

[sheu, 2013/08/09 09:23:16]

Do we need to wait for mfc_output_buffer_queued_count_ to drain too?  Does
resolution change force DPB flush?

If we assume that resolution change is only tagged on the last MFC output buffer
out of the device, it would be nice to DCHECK the count.

[Pawel Osciak, 2013/08/09 10:22:59]

The event will happen after MFC internal queues are drained and are ready to
DQBUF. We do that in DequeueMfc() immediately after DequeueEvents() in
ServiceDeviceTask().

Good idea to dcheck though.

+      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";
+  decoder_state_ = kChangingResolution;
+
+  // Keep MFC input queue.
+  if (!StopDevicePoll(true))
+    return;
+
+  // 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::ResolutionChangeDestroyBuffers() {

[sheu, 2013/08/09 09:23:16]

We should run this on the decoder_thread_, since the decoder_thread_ is still
outstanding (and to avoid icky touching of state from two threads). 
DestroyGscOutputBuffers() should be safe to call from this thread, since
eglDestroyImageKHR and eglDestroySyncKHR should be safe from any thread, even if
there is no current EGLContext.

That would actually allow us to do all three of the ResolutionChange tasks at
once.  Sweet!

[Pawel Osciak, 2013/08/09 10:22:59]

As per offline chat, we'll do this in a separate CL in order not to have to
revert this if anything explodes after move to decoder thread, and to make it
easier to isolate in case of any problems after both CLs.

+  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::FinishResolutionChangeTask,
+      base::Unretained(this)));
+}
+
+void ExynosVideoDecodeAccelerator::FinishResolutionChangeTask() {
+  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DVLOG(3) << "FinishResolutionChangeTask()";
+
+  DCHECK(resolution_change_pending_);
+  resolution_change_pending_ = false;
+
+  struct v4l2_format format;
+  bool again;
+  bool ret = GetFormatInfo(&format, &again);
+  if (!ret || again) {
+    DVLOG(3) << "Couldn't get format information after resolution change";
+    return;
+  }
+
+  if (!CreateBuffersForFormat(format))
+    DVLOG(3) << "Couldn't reallocate buffers after resolution change";
+
+  // From here we stay in kChangingResolution and wait for
+  // AssignPictureBuffers() before we can resume.
+}
+
+void ExynosVideoDecodeAccelerator::ResumeAfterResolutionChangeTask() {
+  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DVLOG(3) << "ResumeAfterResolutionChangeTask()";
+
+  if (!StartDevicePoll())
+    return;
+
+  decoder_state_ = kDecoding;
+  EnqueueMfc();
+  // Gsc will get enqueued in AssignPictureBuffersTask().
+  ScheduleDecodeBufferTaskIfNeeded();
 }
 
 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::DequeueEvents() {
+  DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
+  DCHECK_NE(decoder_state_, kUninitialized);

[sheu, 2013/08/09 09:23:16]

this really should just be DCHECK_EQ(decoder_state_, kDecoding)

[Pawel Osciak, 2013/08/09 10:22:59]

Done.

+  DVLOG(3) << "DequeueEvents()";
+
+  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) << "DequeueEvents(): got resolution change event.";
+      DCHECK(!resolution_change_pending_);
+      resolution_change_pending_ = true;
+    }
+  }
+}
+
 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() {

[sheu, 2013/08/09 09:23:16]

Drain the V4L2 event queue and reset resolution_change_pending_

[Pawel Osciak, 2013/08/09 10:22:59]

Done.

   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 (!StopDevicePoll(false))
     return;
 
   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();
@@ skipping 33 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) {
   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) {
+    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) {
+    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 51 matching lines @@
   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 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), 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 75 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) << "Dismissing PictureBuffer id=" << output_record.picture_id;

[sheu, 2013/08/09 09:23:16]

(same as above)  "DestroyGscOutputBuffers(): XXX " ?

[Pawel Osciak, 2013/08/09 10:22:59]

Done.

         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();
 }
 
 }  // namespace content