V4L2VideoDecodeAccelerator: implement flush by VIDIOC_DECODER_CMD.

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>
@@ skipping 146 matching lines @@
     : 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),
+      decoder_cmd_supported_(false),
+      flush_waiting_last_output_buffer_(false),
       reset_pending_(false),
       decoder_partial_frame_pending_(false),
       input_streamon_(false),
       input_buffer_queued_count_(0),
       output_streamon_(false),
       output_buffer_queued_count_(0),
       output_dpb_size_(0),
       output_planes_count_(0),
       picture_clearing_count_(0),
       device_poll_thread_("V4L2DevicePollThread"),
@@ skipping 103 matching lines @@
   }
 
   if (!CreateInputBuffers())
     return false;
 
   if (!decoder_thread_.Start()) {
     LOGF(ERROR) << "decoder thread failed to start";
     return false;
   }
 
+  decoder_cmd_supported_ = IsDecoderCmdSupported();
+
   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 517 matching lines @@
     // This is a dummy buffer, queued to flush the pipe.  Flush.
     DCHECK_EQ(decoder_current_bitstream_buffer_->input_id, kFlushBufferId);
     // Enqueue a buffer guaranteed to be empty.  To do that, we flush the
     // current input, enqueue no data to the next frame, then flush that down.
     schedule_task = true;
     if (decoder_current_input_buffer_ != -1 &&
         input_buffer_map_[decoder_current_input_buffer_].input_id !=
             kFlushBufferId)
       schedule_task = FlushInputFrame();
 
-    if (schedule_task && AppendToInputFrame(NULL, 0) && FlushInputFrame()) {
+    if (decoder_cmd_supported_) {
+      DVLOGF(2) << "sending decoder cmd to flush";
+      DCHECK(!flush_waiting_last_output_buffer_);
+      struct v4l2_decoder_cmd cmd;
+      memset(&cmd, 0, sizeof(cmd));
+      cmd.cmd = V4L2_DEC_CMD_STOP;
+      IOCTL_OR_ERROR_RETURN(VIDIOC_DECODER_CMD, &cmd);
+      flush_waiting_last_output_buffer_ = true;
+    } else if (schedule_task && AppendToInputFrame(NULL, 0) &&
+               FlushInputFrame()) {
       DVLOGF(2) << "enqueued flush buffer";
       decoder_partial_frame_pending_ = false;
       schedule_task = true;
     } else {
       // If we failed to enqueue the empty buffer (due to pipeline
       // backpressure), don't advance the bitstream buffer queue, and don't
       // schedule the next task.  This bitstream buffer queue entry will get
       // reprocessed when the pipeline frees up.
       schedule_task = false;
     }
@@ skipping 514 matching lines @@
   memset(planes.get(), 0, sizeof(struct v4l2_plane) * output_planes_count_);
   dqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   dqbuf.memory = V4L2_MEMORY_MMAP;
   dqbuf.m.planes = planes.get();
   dqbuf.length = output_planes_count_;
   if (device_->Ioctl(VIDIOC_DQBUF, &dqbuf) != 0) {
     if (errno == EAGAIN) {
       // EAGAIN if we're just out of buffers to dequeue.
       return false;
     }
+    if (errno == EPIPE) {

[wuchengli, 2016/10/17 16:18:59]

We need this because this is not an error. It means no more output buffers can
be dequeued.

+      DVLOGF(3) << "Got EPIPE. Last output buffer was already dequeued.";
+      return false;
+    }
     PLOGF(ERROR) << "ioctl() failed: VIDIOC_DQBUF";
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return false;
   }
   OutputRecord& output_record = output_buffer_map_[dqbuf.index];
   DCHECK_EQ(output_record.state, kAtDevice);
   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.
@@ skipping 15 matching lines @@
       decoder_frames_at_client_++;
       // TODO(hubbe): Insert correct color space. http://crbug.com/647725
       const Picture picture(output_record.picture_id, bitstream_buffer_id,
                             gfx::Rect(visible_size_), gfx::ColorSpace(), false);
       pending_picture_ready_.push(
           PictureRecord(output_record.cleared, picture));
       SendPictureReady();
       output_record.cleared = true;
     }
   }
+  if ((dqbuf.flags & V4L2_BUF_FLAG_LAST)) {
+    DVLOGF(3) << "Got last output buffer. Waiting last buffer="
+              << flush_waiting_last_output_buffer_;
+    if (flush_waiting_last_output_buffer_) {
+      // TODO(wuchengli): use V4L2_DEC_CMD_START when v4l2 core issue is
+      // addressed.
+      if (!(StopDevicePoll() && StopOutputStream() && StartDevicePoll()))
+        return false;
+      flush_waiting_last_output_buffer_ = false;
+    }
+  }
   return true;
 }
 
 bool V4L2VideoDecodeAccelerator::EnqueueInputRecord() {
   DVLOGF(3);
   DCHECK(!input_ready_queue_.empty());
 
   // Enqueue an input (VIDEO_OUTPUT) buffer.
   const int buffer = input_ready_queue_.front();
   InputRecord& input_record = input_buffer_map_[buffer];
@@ skipping 117 matching lines @@
   // 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.
-  if (decoder_state_ == kInitialized) {
-    // There's nothing in the pipe, so return done immediately.
+  if (!output_streamon_) {
+    // If output stream is off, output buffers are not allocated. Or the decoder
+    // is initialized, resetting or changing resolution. There's nothing in the
+    // pipe, so return done immediately.
     DVLOGF(3) << "returning flush";
     child_task_runner_->PostTask(FROM_HERE,
                                  base::Bind(&Client::NotifyFlushDone, client_));
     return;
   } else if (decoder_state_ == kError) {
     DVLOGF(2) << "early out: kError state";
     return;
   }
 
   // We don't support stacked flushing.
@@ skipping 15 matching lines @@
     return;
 
   // Pipeline is empty when:
   // * Decoder input queue is empty of non-delayed buffers.
   // * There is no currently filling input buffer.
   // * Input holding queue is empty.
   // * All input (VIDEO_OUTPUT) buffers are returned.
   // * All image processor buffers are returned.
   if (!decoder_input_queue_.empty()) {
     if (decoder_input_queue_.front()->input_id !=
-        decoder_delay_bitstream_buffer_id_)
+        decoder_delay_bitstream_buffer_id_) {
+      DVLOGF(3) << "Some input bitstream buffers are not queued.";
       return;
+    }
   }
-  if (decoder_current_input_buffer_ != -1)
+  if (decoder_current_input_buffer_ != -1) {
+    DVLOGF(3) << "Current input buffer != -1";
     return;
-  if ((input_ready_queue_.size() + input_buffer_queued_count_) != 0)
+  }
+  if ((input_ready_queue_.size() + input_buffer_queued_count_) != 0) {
+    DVLOGF(3) << "Some input buffers are not dequeued.";
     return;
-  if (image_processor_bitstream_buffer_ids_.size() != 0)
+  }
+  if (image_processor_bitstream_buffer_ids_.size() != 0) {
+    DVLOGF(3) << "Waiting for image processor to complete.";
     return;
+  }
+  if (flush_waiting_last_output_buffer_) {
+    DVLOGF(3) << "Waiting for last output buffer.";
+    return;
+  }
 
   // TODO(posciak): crbug.com/270039. Exynos 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 Exynos and not freeze
   // when doing MSE. This should be harmless otherwise.
   if (!(StopDevicePoll() && StopOutputStream() && StopInputStream()))
     return;
 
   if (!StartDevicePoll())
     return;
 
   decoder_delay_bitstream_buffer_id_ = -1;
   decoder_flushing_ = false;
   DVLOGF(3) << "returning flush";
   child_task_runner_->PostTask(FROM_HERE,
                                base::Bind(&Client::NotifyFlushDone, client_));
 
   // While we were flushing, we early-outed DecodeBufferTask()s.
   ScheduleDecodeBufferTaskIfNeeded();
 }
 
+bool V4L2VideoDecodeAccelerator::IsDecoderCmdSupported() {
+  struct v4l2_decoder_cmd cmd;
+  memset(&cmd, 0, sizeof(cmd));
+  cmd.cmd = V4L2_DEC_CMD_STOP;
+  if (device_->Ioctl(VIDIOC_TRY_DECODER_CMD, &cmd) != 0) {
+    DVLOGF(3) "V4L2_DEC_CMD_STOP is not supported.";
+    return false;
+  }
+
+  return true;
+}
+
 void V4L2VideoDecodeAccelerator::ResetTask() {
   DVLOGF(3);
   DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
   TRACE_EVENT0("Video Decoder", "V4L2VDA::ResetTask");
 
   if (decoder_state_ == kError) {
     DVLOGF(2) << "early out: kError state";
     return;
   }
   decoder_current_bitstream_buffer_.reset();
@@ skipping 99 matching lines @@
   StopOutputStream();
   StopInputStream();
 
   decoder_current_bitstream_buffer_.reset();
   decoder_current_input_buffer_ = -1;
   decoder_decode_buffer_tasks_scheduled_ = 0;
   decoder_frames_at_client_ = 0;
   while (!decoder_input_queue_.empty())
     decoder_input_queue_.pop();
   decoder_flushing_ = false;
+  flush_waiting_last_output_buffer_ = false;
 
   if (image_processor_)
     image_processor_.release()->Destroy();
 
   // Set our state to kError.  Just in case.
   decoder_state_ = kError;
 
   DestroyInputBuffers();
   DestroyOutputBuffers();
 }
@@ skipping 43 matching lines @@
 
 bool V4L2VideoDecodeAccelerator::StopOutputStream() {
   DVLOGF(3);
   if (!output_streamon_)
     return true;
 
   __u32 type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_STREAMOFF, &type);
   output_streamon_ = false;
 
+  // Output stream is stopped. No need to wait the buffer anymore.
+  flush_waiting_last_output_buffer_ = 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_back(i);
       DCHECK_EQ(output_record.egl_sync, EGL_NO_SYNC_KHR);
     }
@@ skipping 725 matching lines @@
       StartResolutionChange();
   }
 }
 
 void V4L2VideoDecodeAccelerator::ImageProcessorError() {
   LOGF(ERROR) << "Image processor error";
   NOTIFY_ERROR(PLATFORM_FAILURE);
 }
 
 }  // namespace media