V4L2SVDA: Move allocation from GPU Child thread to decoder thread.

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 387 matching lines @@
       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),
       decoder_flushing_(false),
       decoder_resetting_(false),
       surface_set_change_pending_(false),
       picture_clearing_count_(0),
-      pictures_assigned_(false, false),
       make_context_current_(make_context_current),
       egl_display_(egl_display),
       egl_context_(egl_context),
       weak_this_factory_(this) {
   weak_this_ = weak_this_factory_.GetWeakPtr();
 }
 
 V4L2SliceVideoDecodeAccelerator::~V4L2SliceVideoDecodeAccelerator() {
   DVLOGF(2);
 
@@ skipping 121 matching lines @@
 
 void V4L2SliceVideoDecodeAccelerator::Destroy() {
   DVLOGF(3);
   DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   if (decoder_thread_.IsRunning()) {
     decoder_thread_task_runner_->PostTask(
         FROM_HERE, base::Bind(&V4L2SliceVideoDecodeAccelerator::DestroyTask,
                               base::Unretained(this)));
 
-    // Wake up decoder thread in case we are waiting in CreateOutputBuffers
-    // for client to provide pictures. Since this is Destroy, we won't be
-    // getting them anymore (AssignPictureBuffers won't be called).
-    pictures_assigned_.Signal();
-
     // Wait for tasks to finish/early-exit.
     decoder_thread_.Stop();
   }
 
   delete this;
   DVLOGF(3) << "Destroyed";
 }
 
 void V4L2SliceVideoDecodeAccelerator::DestroyTask() {
   DVLOGF(3);
@@ skipping 181 matching lines @@
   DVLOGF(3) << "buffer_count=" << num_pictures
             << ", visible size=" << visible_size_.ToString()
             << ", coded size=" << coded_size_.ToString();
 
   child_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&VideoDecodeAccelerator::Client::ProvidePictureBuffers,
                  client_, num_pictures, coded_size_,
                  device_->GetTextureTarget()));
 
-  // Wait for the client to call AssignPictureBuffers() on the Child thread.
-  // We do this, because if we continue decoding without finishing buffer
-  // allocation, we may end up Resetting before AssignPictureBuffers arrives,
-  // resulting in unnecessary complications and subtle bugs.
-  pictures_assigned_.Wait();
-
   return true;
 }
 
 void V4L2SliceVideoDecodeAccelerator::DestroyInputBuffers() {
   DVLOGF(3);
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread() ||
          !decoder_thread_.IsRunning());
   DCHECK(!input_streamon_);
 
   for (auto& input_record : input_buffer_map_) {
     if (input_record.address != nullptr)
       device_->Munmap(input_record.address, input_record.length);
   }
 
   struct v4l2_requestbuffers reqbufs;
   memset(&reqbufs, 0, sizeof(reqbufs));
   reqbufs.count = 0;
   reqbufs.type = V4L2_BUF_TYPE_VIDEO_OUTPUT_MPLANE;
   reqbufs.memory = V4L2_MEMORY_MMAP;
   IOCTL_OR_LOG_ERROR(VIDIOC_REQBUFS, &reqbufs);
 
   input_buffer_map_.clear();
   free_input_buffers_.clear();
 }
 
 void V4L2SliceVideoDecodeAccelerator::DismissPictures(
-    std::vector<int32_t> picture_buffer_ids,
+    const std::vector<int32_t>& picture_buffer_ids,
     base::WaitableEvent* done) {
   DVLOGF(3);
   DCHECK(child_task_runner_->BelongsToCurrentThread());
 
   for (auto picture_buffer_id : picture_buffer_ids) {
     DVLOGF(1) << "dismissing PictureBuffer id=" << picture_buffer_id;
     client_->DismissPictureBuffer(picture_buffer_id);
   }
 
   done->Signal();
@@ skipping 160 matching lines @@
   TryOutputSurfaces();
 
   ProcessPendingEventsIfNeeded();
 }
 
 void V4L2SliceVideoDecodeAccelerator::ProcessPendingEventsIfNeeded() {
   // Process pending events, if any, in the correct order.
   // We always first process the surface set change, as it is an internal
   // event from the decoder and interleaving it with external requests would
   // put the decoder in an undefined state.
-  FinishSurfaceSetChangeIfNeeded();
+  if (surface_set_change_pending_) {
+    if (!FinishSurfaceSetChange())
+      return;
+  }
+  DCHECK(!surface_set_change_pending_);
 
   // Process external (client) requests.
-  FinishFlushIfNeeded();
-  FinishResetIfNeeded();
+  if (decoder_flushing_) {
+    if (!FinishFlush())
+      return;
+  }
+  DCHECK(!decoder_flushing_);
+
+  if (decoder_resetting_) {
+    if (!FinishReset())
+      return;
+  }
+  DCHECK(!decoder_resetting_);
+
+  if (state_ == kIdle)
+    state_ = kDecoding;
+
+  ScheduleDecodeBufferTaskIfNeeded();

[wuchengli, 2016/02/18 08:06:47]

I asked offline about why we need line 976-99 now and not before. The reason is
because we removed it from each Finish*().

 }
 
 void V4L2SliceVideoDecodeAccelerator::ReuseInputBuffer(int index) {
   DVLOGF(4) << "Reusing input buffer, index=" << index;
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
   DCHECK_LT(index, static_cast<int>(input_buffer_map_.size()));
   InputRecord& input_record = input_buffer_map_[index];
 
   DCHECK(!input_record.at_device);
@@ skipping 298 matching lines @@
         NOTIFY_ERROR(PLATFORM_FAILURE);
         return;
     }
   }
 }
 
 void V4L2SliceVideoDecodeAccelerator::InitiateSurfaceSetChange() {
   DVLOGF(2);
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
-  DCHECK_EQ(state_, kDecoding);
   state_ = kIdle;
 
   DCHECK(!surface_set_change_pending_);
   surface_set_change_pending_ = true;
 
-  FinishSurfaceSetChangeIfNeeded();
+  ProcessPendingEventsIfNeeded();
 }
 
-void V4L2SliceVideoDecodeAccelerator::FinishSurfaceSetChangeIfNeeded() {
+bool V4L2SliceVideoDecodeAccelerator::FinishSurfaceSetChange() {
   DVLOGF(2);
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
-  if (!surface_set_change_pending_ || !surfaces_at_device_.empty())
-    return;
+  DCHECK(surface_set_change_pending_);
+  if (!surfaces_at_device_.empty())
+    return false;
 
   DCHECK_EQ(state_, kIdle);
   DCHECK(decoder_display_queue_.empty());
   // All output buffers should've been returned from decoder and device by now.
   // The only remaining owner of surfaces may be display (client), and we will
   // dismiss them when destroying output buffers below.
   DCHECK_EQ(free_output_buffers_.size() + surfaces_at_display_.size(),
             output_buffer_map_.size());
 
   // Keep input queue running while we switch outputs.
   if (!StopDevicePoll(true)) {
     NOTIFY_ERROR(PLATFORM_FAILURE);
-    return;
+    return false;
   }
 
   // This will return only once all buffers are dismissed and destroyed.
   // This does not wait until they are displayed however, as display retains
   // references to the buffers bound to textures and will release them
   // after displaying.
   if (!DestroyOutputs(true)) {
     NOTIFY_ERROR(PLATFORM_FAILURE);
-    return;
+    return false;
   }
 
   if (!CreateOutputBuffers()) {
     NOTIFY_ERROR(PLATFORM_FAILURE);
-    return;
+    return false;
   }
 
-  if (!StartDevicePoll()) {
-    NOTIFY_ERROR(PLATFORM_FAILURE);
-    return;
-  }
-
-  DVLOGF(3) << "Surface set change finished";
-
+  // At this point we can safely say the surface set has been changed, even
+  // though we haven't received the actual buffers via AssignPictureBuffers()
+  // yet. We will not start decoding without having surfaces available,
+  // and will schedule a decode task once the client provides the buffers.
   surface_set_change_pending_ = false;
-  state_ = kDecoding;
-  ScheduleDecodeBufferTaskIfNeeded();
+  DVLOG(3) << "Surface set change finished";
+  return true;
 }
 
 bool V4L2SliceVideoDecodeAccelerator::DestroyOutputs(bool dismiss) {
   DVLOGF(3);
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
   std::vector<EGLImageKHR> egl_images_to_destroy;
   std::vector<int32_t> picture_buffers_to_dismiss;
 
   if (output_buffer_map_.empty())
     return true;
@@ skipping 69 matching lines @@
   IOCTL_OR_ERROR_RETURN_FALSE(VIDIOC_REQBUFS, &reqbufs);
 
   return true;
 }
 
 void V4L2SliceVideoDecodeAccelerator::AssignPictureBuffers(
     const std::vector<media::PictureBuffer>& buffers) {
   DVLOGF(3);
   DCHECK(child_task_runner_->BelongsToCurrentThread());
 
+  decoder_thread_task_runner_->PostTask(
+      FROM_HERE, base::Bind(
+          &V4L2SliceVideoDecodeAccelerator::AssignPictureBuffersTask,

[wuchengli, 2016/02/18 08:06:47]

For the record, we had an offline discussion. I asked if we can call
CreateEGLImages here so we can save a roundtrip from child thread to decode
thread. The answer is no because CreateEGLImage needs the fds from
AssignPictureBuffersTask.

+          base::Unretained(this), buffers));
+}
+
+void V4L2SliceVideoDecodeAccelerator::AssignPictureBuffersTask(
+    const std::vector<media::PictureBuffer>& buffers) {
+  DVLOGF(3);
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
+  DCHECK_EQ(state_, kDecoding);
+
   const uint32_t req_buffer_count = decoder_->GetRequiredNumOfPictures();
 
   if (buffers.size() < req_buffer_count) {
     DLOG(ERROR) << "Failed to provide requested picture buffers. "
                 << "(Got " << buffers.size()
                 << ", requested " << req_buffer_count << ")";
     NOTIFY_ERROR(INVALID_ARGUMENT);
     return;
   }
 
-  if (!make_context_current_.Run()) {
-    DLOG(ERROR) << "could not make context current";
-    NOTIFY_ERROR(PLATFORM_FAILURE);
-    return;
-  }
-
-  gfx::ScopedTextureBinder bind_restore(GL_TEXTURE_EXTERNAL_OES, 0);
-
-  // It's safe to manipulate all the buffer state here, because the decoder
-  // thread is waiting on pictures_assigned_.
-
   // 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 = V4L2_MEMORY_MMAP;
   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;
   }
 
+  child_task_runner_->PostTask(
+      FROM_HERE, base::Bind(&V4L2SliceVideoDecodeAccelerator::CreateEGLImages,
+                            weak_this_, buffers, output_format_fourcc_,
+                            output_planes_count_));
+}
+
+void V4L2SliceVideoDecodeAccelerator::CreateEGLImages(
+    const std::vector<media::PictureBuffer>& buffers,
+    uint32_t output_format_fourcc,
+    size_t output_planes_count) {
+  DVLOGF(3);
+  DCHECK(child_task_runner_->BelongsToCurrentThread());
+
+  if (!make_context_current_.Run()) {
+    DLOG(ERROR) << "could not make context current";
+    NOTIFY_ERROR(PLATFORM_FAILURE);
+    return;
+  }
+
+  gfx::ScopedTextureBinder bind_restore(GL_TEXTURE_EXTERNAL_OES, 0);
+
+  std::vector<EGLImageKHR> egl_images;
+  for (size_t i = 0; i < buffers.size(); ++i) {
+    EGLImageKHR egl_image = device_->CreateEGLImage(egl_display_,
+                                                    egl_context_,
+                                                    buffers[i].texture_id(),
+                                                    buffers[i].size(),
+                                                    i,
+                                                    output_format_fourcc,
+                                                    output_planes_count);
+    if (egl_image == EGL_NO_IMAGE_KHR) {
+      LOGF(ERROR) << "Could not create EGLImageKHR";
+      for (const auto& image_to_destroy : egl_images)
+        device_->DestroyEGLImage(egl_display_, image_to_destroy);
+
+      NOTIFY_ERROR(PLATFORM_FAILURE);
+      return;
+    }
+
+    egl_images.push_back(egl_image);
+  }
+
+  decoder_thread_task_runner_->PostTask(
+      FROM_HERE, base::Bind(
+          &V4L2SliceVideoDecodeAccelerator::AssignEGLImages,
+          base::Unretained(this), buffers, egl_images));
+}
+
+void V4L2SliceVideoDecodeAccelerator::AssignEGLImages(
+    const std::vector<media::PictureBuffer>& buffers,
+    const std::vector<EGLImageKHR>& egl_images) {
+  DVLOGF(3);
+  DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
+  DCHECK_EQ(buffers.size(), egl_images.size());
+
+  DCHECK(free_output_buffers_.empty());
+  DCHECK(output_buffer_map_.empty());
+
   output_buffer_map_.resize(buffers.size());
 
-  DCHECK(free_output_buffers_.empty());
   for (size_t i = 0; i < output_buffer_map_.size(); ++i) {
     DCHECK(buffers[i].size() == coded_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_EQ(output_record.cleared, false);
 
-    EGLImageKHR egl_image = device_->CreateEGLImage(egl_display_,
-                                                    egl_context_,
-                                                    buffers[i].texture_id(),
-                                                    coded_size_,
-                                                    i,
-                                                    output_format_fourcc_,
-                                                    output_planes_count_);
-    if (egl_image == EGL_NO_IMAGE_KHR) {
-      LOGF(ERROR) << "Could not create EGLImageKHR";
-      // Ownership of EGLImages allocated in previous iterations of this loop
-      // has been transferred to output_buffer_map_. After we error-out here
-      // the destructor will handle their cleanup.
-      NOTIFY_ERROR(PLATFORM_FAILURE);
-      return;
-    }
-
-    output_record.egl_image = egl_image;
+    output_record.egl_image = egl_images[i];
     output_record.picture_id = buffers[i].id();
     free_output_buffers_.push_back(i);
     DVLOGF(3) << "buffer[" << i << "]: picture_id=" << output_record.picture_id;
   }
 
-  pictures_assigned_.Signal();
+  if (!StartDevicePoll()) {
+    NOTIFY_ERROR(PLATFORM_FAILURE);
+    return;
+  }
+
+  ProcessPendingEventsIfNeeded();
 }
 
 void V4L2SliceVideoDecodeAccelerator::ReusePictureBuffer(
     int32_t picture_buffer_id) {
   DCHECK(child_task_runner_->BelongsToCurrentThread());
   DVLOGF(4) << "picture_buffer_id=" << picture_buffer_id;
 
   if (!make_context_current_.Run()) {
     LOGF(ERROR) << "could not make context current";
     NOTIFY_ERROR(PLATFORM_FAILURE);
@@ skipping 93 matching lines @@
     DVLOGF(1) << "Failed flushing the decoder.";
     NOTIFY_ERROR(PLATFORM_FAILURE);
     return;
   }
 
   // Put the decoder in an idle state, ready to resume.
   decoder_->Reset();
 
   decoder_flushing_ = true;
 
-  decoder_thread_task_runner_->PostTask(
-      FROM_HERE,
-      base::Bind(&V4L2SliceVideoDecodeAccelerator::FinishFlushIfNeeded,
-                 base::Unretained(this)));
+  ProcessPendingEventsIfNeeded();
 }
 
-void V4L2SliceVideoDecodeAccelerator::FinishFlushIfNeeded() {
+bool V4L2SliceVideoDecodeAccelerator::FinishFlush() {
   DVLOGF(3);
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
-  if (!decoder_flushing_ || !surfaces_at_device_.empty())
-    return;
+  DCHECK(decoder_flushing_);
+
+  if (!surfaces_at_device_.empty())
+    return false;
 
   DCHECK_EQ(state_, kIdle);
 
   // At this point, all remaining surfaces are decoded and dequeued, and since
   // we have already scheduled output for them in InitiateFlush(), their
   // 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();
 
+  decoder_flushing_ = false;
+  DVLOGF(3) << "Flush finished";
+
   child_task_runner_->PostTask(FROM_HERE,
                                base::Bind(&Client::NotifyFlushDone, client_));
 
-  decoder_flushing_ = false;
-
-  DVLOGF(3) << "Flush finished";
-  state_ = kDecoding;
-  ScheduleDecodeBufferTaskIfNeeded();
+  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 15 matching lines @@
   // Put the decoder in an idle state, ready to resume.
   decoder_->Reset();
 
   decoder_resetting_ = true;
 
   // Drop all remaining inputs.
   decoder_current_bitstream_buffer_.reset();
   while (!decoder_input_queue_.empty())
     decoder_input_queue_.pop();
 
-  FinishResetIfNeeded();
+  ProcessPendingEventsIfNeeded();
 }
 
-void V4L2SliceVideoDecodeAccelerator::FinishResetIfNeeded() {
+bool V4L2SliceVideoDecodeAccelerator::FinishReset() {
   DVLOGF(3);
   DCHECK(decoder_thread_task_runner_->BelongsToCurrentThread());
 
-  if (!decoder_resetting_ || !surfaces_at_device_.empty())
-    return;
+  DCHECK(decoder_resetting_);
+  if (!surfaces_at_device_.empty())
+    return false;
 
   DCHECK_EQ(state_, kIdle);
   DCHECK(!decoder_flushing_);
   SendPictureReady();
 
   // Drop any pending outputs.
   while (!decoder_display_queue_.empty())
     decoder_display_queue_.pop();
 
   // At this point we can have no input buffers in the decoder, because we
   // Reset()ed it in ResetTask(), and have not scheduled any new Decode()s
   // having been in kIdle since. We don't have any surfaces in the HW either -
   // we just checked that surfaces_at_device_.empty(), and inputs are tied
   // to surfaces. Since there can be no other owners of input buffers, we can
   // simply mark them all as available.
   DCHECK_EQ(input_buffer_queued_count_, 0);
   free_input_buffers_.clear();
   for (size_t i = 0; i < input_buffer_map_.size(); ++i) {
     DCHECK(!input_buffer_map_[i].at_device);
     ReuseInputBuffer(i);
   }
 
   decoder_resetting_ = false;
+  DVLOGF(3) << "Reset finished";
 
   child_task_runner_->PostTask(FROM_HERE,
                                base::Bind(&Client::NotifyResetDone, client_));
 
-  DVLOGF(3) << "Reset finished";
-
-  state_ = kDecoding;
-  ScheduleDecodeBufferTaskIfNeeded();
+  return true;
 }
 
 void V4L2SliceVideoDecodeAccelerator::SetErrorState(Error error) {
   // We can touch decoder_state_ only if this is the decoder thread or the
   // decoder thread isn't running.
   if (decoder_thread_.IsRunning() &&
       !decoder_thread_task_runner_->BelongsToCurrentThread()) {
     decoder_thread_task_runner_->PostTask(
         FROM_HERE, base::Bind(&V4L2SliceVideoDecodeAccelerator::SetErrorState,
                               base::Unretained(this), error));
@@ skipping 811 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