Add an additional VDA::Flush() mode to return all allocated buffers.

content/common/gpu/media/v4l2_slice_video_decode_accelerator.cc

 // Copyright 2015 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <errno.h>
 #include <fcntl.h>
 #include <linux/videodev2.h>
 #include <poll.h>
 #include <string.h>
 #include <sys/eventfd.h>
@@ skipping 1605 matching lines @@
 
   DCHECK_EQ(output_record.egl_sync, EGL_NO_SYNC_KHR);
   DCHECK(!output_record.at_device);
   output_record.at_client = false;
   output_record.egl_sync = egl_sync_ref->egl_sync;
   // Take ownership of the EGLSync.
   egl_sync_ref->egl_sync = EGL_NO_SYNC_KHR;
   surfaces_at_display_.erase(it);
 }
 
-void V4L2SliceVideoDecodeAccelerator::Flush() {
+void V4L2SliceVideoDecodeAccelerator::Flush(bool return_buffers) {
   DVLOGF(3);
   DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   decoder_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&V4L2SliceVideoDecodeAccelerator::FlushTask,
-                            base::Unretained(this)));
+                            base::Unretained(this), return_buffers));
 }
 
-void V4L2SliceVideoDecodeAccelerator::FlushTask() {
+void V4L2SliceVideoDecodeAccelerator::FlushTask(bool return_buffers) {
   DVLOGF(3);
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
+  flush_return_all_buffers_ = return_buffers;
+
   if (!decoder_input_queue_.empty()) {
     // We are not done with pending inputs, so queue an empty buffer,
     // which - when reached - will trigger flush sequence.
     decoder_input_queue_.push(
         linked_ptr<BitstreamBufferRef>(new BitstreamBufferRef(
             io_client_, io_task_runner_, nullptr, kFlushBufferId)));
     return;
   }
 
   // No more inputs pending, so just finish flushing here.
@@ skipping 41 matching lines @@
   // respective PictureReady calls have been posted (or they have been queued on
   // pending_picture_ready_). So at this time, once we SendPictureReady(),
   // we will have all remaining PictureReady() posted to the client and we
   // can post NotifyFlushDone().
   DCHECK(decoder_display_queue_.empty());
 
   // Decoder should have already returned all surfaces and all surfaces are
   // out of hardware. There can be no other owners of input buffers.
   DCHECK_EQ(free_input_buffers_.size(), input_buffer_map_.size());
 
-  SendPictureReady();
+  if (flush_return_all_buffers_) {
+    for (auto& output : free_output_buffers_) {
+      scoped_refptr<V4L2DecodeSurface> dec_surface = new V4L2DecodeSurface(
+          -1, -1, output,
+          base::Bind(&V4L2SliceVideoDecodeAccelerator::ReuseOutputBuffer,
+                     base::Unretained(this)));
+      OutputSurface(dec_surface);
+    }
+
+    free_output_buffers_.clear();
+  }
 
   decoder_flushing_ = false;
+  flush_return_all_buffers_ = false;
+
   DVLOGF(3) << "Flush finished";
 
   child_task_runner_->PostTask(FROM_HERE,
                                base::Bind(&Client::NotifyFlushDone, client_));
-
   return true;
 }
 
 void V4L2SliceVideoDecodeAccelerator::Reset() {
   DVLOGF(3);
   DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   decoder_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&V4L2SliceVideoDecodeAccelerator::ResetTask,
                             base::Unretained(this)));
@@ skipping 778 matching lines @@
       surfaces_at_display_.insert(std::make_pair(output_record.picture_id,
                                                  dec_surface)).second;
   DCHECK(inserted);
 
   DCHECK(!output_record.at_client);
   DCHECK(!output_record.at_device);
   DCHECK_NE(output_record.egl_image, EGL_NO_IMAGE_KHR);
   DCHECK_NE(output_record.picture_id, -1);
   output_record.at_client = true;
 
+  // If the surface still has a sync object assigned, destroy it. This means
+  // we didn't use this buffer for decode and we did not need to wait on it
+  // before enqueuing the buffer to the device.
+  if (output_record.egl_sync != EGL_NO_SYNC_KHR) {
+    if (eglDestroySyncKHR(egl_display_, output_record.egl_sync) != EGL_TRUE) {
+      LOGF(ERROR) << "eglDestroySyncKHR failed!";
+      NOTIFY_ERROR(PLATFORM_FAILURE);
+      return;
+    }
+    output_record.egl_sync = EGL_NO_SYNC_KHR;
+  }
+
   // TODO(posciak): Use visible size from decoder here instead
   // (crbug.com/402760). Passing (0, 0) results in the client using the
   // visible size extracted from the container instead.
   media::Picture picture(output_record.picture_id, dec_surface->bitstream_id(),
                          gfx::Rect(0, 0), false);
   DVLOGF(3) << dec_surface->ToString()
             << ", bitstream_id: " << picture.bitstream_buffer_id()
             << ", picture_id: " << picture.picture_buffer_id();
   pending_picture_ready_.push(PictureRecord(output_record.cleared, picture));
   SendPictureReady();
@@ skipping 88 matching lines @@
 V4L2SliceVideoDecodeAccelerator::GetSupportedProfiles() {
   scoped_refptr<V4L2Device> device = V4L2Device::Create(V4L2Device::kDecoder);
   if (!device)
     return SupportedProfiles();
 
   return device->GetSupportedDecodeProfiles(arraysize(supported_input_fourccs_),
                                             supported_input_fourccs_);
 }
 
 }  // namespace content