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 378 matching lines @@
       device_(device),
       decoder_thread_("V4L2SliceVideoDecodeAcceleratorThread"),
       device_poll_thread_("V4L2SliceVideoDecodeAcceleratorDevicePollThread"),
       input_streamon_(false),
       input_buffer_queued_count_(0),
       output_streamon_(false),
       output_buffer_queued_count_(0),
       video_profile_(media::VIDEO_CODEC_PROFILE_UNKNOWN),
       output_format_fourcc_(0),
       state_(kUninitialized),
-      output_mode_(Config::OutputMode::ALLOCATE),
       decoder_flushing_(false),
       decoder_resetting_(false),
       surface_set_change_pending_(false),
       picture_clearing_count_(0),
       egl_display_(egl_display),
       get_gl_context_cb_(get_gl_context_cb),
       make_context_current_cb_(make_context_current_cb),
       weak_this_factory_(this) {
   weak_this_ = weak_this_factory_.GetWeakPtr();
 }
@@ skipping 40 matching lines @@
     NOTREACHED() << "Encrypted streams are not supported for this VDA";
     return false;
   }
 
   if (config.output_mode != Config::OutputMode::ALLOCATE &&
       config.output_mode != Config::OutputMode::IMPORT) {
     NOTREACHED() << "Only ALLOCATE and IMPORT OutputModes are supported";
     return false;
   }
 
+  if (config.flush_mode != Config::FlushMode::KEEP_OUTPUT_BUFFERS &&
+      config.flush_mode != Config::FlushMode::RETURN_OUTPUT_BUFFERS) {
+    NOTIMPLEMENTED() << "Unsupported Config::FlushMode";
+    return false;
+  }
+
   client_ptr_factory_.reset(
       new base::WeakPtrFactory<VideoDecodeAccelerator::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_;
@@ skipping 51 matching lines @@
   if (!SetupFormats())
     return false;
 
   if (!decoder_thread_.Start()) {
     DLOG(ERROR) << "Initialize(): device thread failed to start";
     return false;
   }
   decoder_thread_task_runner_ = decoder_thread_.task_runner();
 
   state_ = kInitialized;
-  output_mode_ = config.output_mode;
+  config_ = config;
 
   // InitializeTask will NOTIFY_ERROR on failure.
   decoder_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&V4L2SliceVideoDecodeAccelerator::InitializeTask,
                             base::Unretained(this)));
 
   DVLOGF(1) << "V4L2SliceVideoDecodeAccelerator initialized";
   return true;
 }
 
@@ skipping 380 matching lines @@
     input_buffer_queued_count_--;
     DVLOGF(4) << "Dequeued input=" << dqbuf.index
               << " count: " << input_buffer_queued_count_;
   }
 
   while (output_buffer_queued_count_ > 0) {
     DCHECK(output_streamon_);
     memset(&dqbuf, 0, sizeof(dqbuf));
     memset(&planes, 0, sizeof(planes));
     dqbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
-    dqbuf.memory =
-        (output_mode_ == Config::OutputMode::ALLOCATE ? V4L2_MEMORY_MMAP
-                                                      : V4L2_MEMORY_DMABUF);
+    dqbuf.memory = (config_.output_mode == Config::OutputMode::ALLOCATE
+                        ? V4L2_MEMORY_MMAP
+                        : V4L2_MEMORY_DMABUF);
     dqbuf.m.planes = planes;
     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.
         break;
       }
       PLOG(ERROR) << "ioctl() failed: VIDIOC_DQBUF";
       NOTIFY_ERROR(PLATFORM_FAILURE);
       return;
@@ skipping 153 matching lines @@
     }
     output_record.egl_sync = EGL_NO_SYNC_KHR;
   }
 
   struct v4l2_buffer qbuf;
   struct v4l2_plane qbuf_planes[VIDEO_MAX_PLANES];
   memset(&qbuf, 0, sizeof(qbuf));
   memset(qbuf_planes, 0, sizeof(qbuf_planes));
   qbuf.index = index;
   qbuf.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
-  if (output_mode_ == Config::OutputMode::ALLOCATE) {
+  if (config_.output_mode == Config::OutputMode::ALLOCATE) {
     qbuf.memory = V4L2_MEMORY_MMAP;
   } else {
     qbuf.memory = V4L2_MEMORY_DMABUF;
     DCHECK_EQ(output_planes_count_, output_record.dmabuf_fds.size());
     for (size_t i = 0; i < output_record.dmabuf_fds.size(); ++i) {
       DCHECK(output_record.dmabuf_fds[i].is_valid());
       qbuf_planes[i].m.fd = output_record.dmabuf_fds[i].get();
     }
   }
   qbuf.m.planes = qbuf_planes;
@@ skipping 377 matching lines @@
                 << ", requested " << req_buffer_count << ")";
     NOTIFY_ERROR(INVALID_ARGUMENT);
     return;
   }
 
   // Allocate the output buffers.
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count = buffers.size();
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE;
-  reqbufs.memory =
-      (output_mode_ == Config::OutputMode::ALLOCATE ? V4L2_MEMORY_MMAP
-                                                    : V4L2_MEMORY_DMABUF);
+  reqbufs.memory = (config_.output_mode == Config::OutputMode::ALLOCATE
+                        ? V4L2_MEMORY_MMAP
+                        : V4L2_MEMORY_DMABUF);
   IOCTL_OR_ERROR_RETURN(VIDIOC_REQBUFS, &reqbufs);
 
   if (reqbufs.count != buffers.size()) {
     DLOG(ERROR) << "Could not allocate enough output buffers";
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return;
   }
 
   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() == coded_size_);
     DCHECK_EQ(1u, buffers[i].texture_ids().size());
 
     OutputRecord& output_record = output_buffer_map_[i];
     DCHECK(!output_record.at_device);
     DCHECK(!output_record.at_client);
     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(output_record.dmabuf_fds.empty());
     DCHECK_EQ(output_record.cleared, false);
 
     output_record.picture_id = buffers[i].id();
     output_record.texture_id = buffers[i].texture_ids()[0];
     // This will remain true until ImportBufferForPicture is called, either by
     // the client, or by ourselves, if we are allocating.
     output_record.at_client = true;
-    if (output_mode_ == Config::OutputMode::ALLOCATE) {
+    if (config_.output_mode == Config::OutputMode::ALLOCATE) {
       std::vector<base::ScopedFD> dmabuf_fds =
           std::move(device_->GetDmabufsForV4L2Buffer(
               i, output_planes_count_, V4L2_BUF_TYPE_VIDEO_CAPTURE_MPLANE));
       if (dmabuf_fds.empty()) {
         NOTIFY_ERROR(PLATFORM_FAILURE);
         return;
       }
 
       auto passed_dmabuf_fds(base::WrapUnique(
           new std::vector<base::ScopedFD>(std::move(dmabuf_fds))));
@@ skipping 81 matching lines @@
     return;
   }
 
   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(!output_record.at_client);
   DCHECK(!output_record.at_device);
 
   output_record.egl_image = egl_image;
-  if (output_mode_ == Config::OutputMode::IMPORT) {
+  if (config_.output_mode == Config::OutputMode::IMPORT) {
     DCHECK(output_record.dmabuf_fds.empty());
     output_record.dmabuf_fds = std::move(*passed_dmabuf_fds);
   }
 
   DCHECK_EQ(std::count(free_output_buffers_.begin(), free_output_buffers_.end(),
                        buffer_index),
             0);
   free_output_buffers_.push_back(buffer_index);
   ScheduleDecodeBufferTaskIfNeeded();
 }
 
 void V4L2SliceVideoDecodeAccelerator::ImportBufferForPicture(
     int32_t picture_buffer_id,
     const std::vector<gfx::GpuMemoryBufferHandle>& gpu_memory_buffer_handles) {
   DVLOGF(3) << "picture_buffer_id=" << picture_buffer_id;
   DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   auto passed_dmabuf_fds(base::WrapUnique(new std::vector<base::ScopedFD>()));
   for (const auto& handle : gpu_memory_buffer_handles) {
     int fd = -1;
 #if defined(USE_OZONE)
     fd = handle.native_pixmap_handle.fd.fd;
 #endif
     DCHECK_NE(fd, -1);
     passed_dmabuf_fds->push_back(base::ScopedFD(fd));
   }
 
-  if (output_mode_ != Config::OutputMode::IMPORT) {
+  if (config_.output_mode != Config::OutputMode::IMPORT) {
     LOGF(ERROR) << "Cannot import in non-import mode";
     NOTIFY_ERROR(INVALID_ARGUMENT);
     return;
   }
 
   decoder_thread_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&V4L2SliceVideoDecodeAccelerator::ImportBufferForPictureTask,
                  base::Unretained(this), picture_buffer_id,
                  base::Passed(&passed_dmabuf_fds)));
@@ skipping 186 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 (config_.flush_mode == Config::FlushMode::RETURN_OUTPUT_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;
+
   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 775 matching lines @@
   bool inserted =
       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.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 99 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