Run VDA::Decode on GPU IO thread if VDA supports it.

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 187 matching lines @@
       picture_id(-1) {
 }
 
 ExynosVideoDecodeAccelerator::GscOutputRecord::~GscOutputRecord() {
 }
 
 ExynosVideoDecodeAccelerator::ExynosVideoDecodeAccelerator(
     EGLDisplay egl_display,
     EGLContext egl_context,
     Client* client,
-    const base::Callback<bool(void)>& make_context_current)
+    const base::Callback<bool(void)>& make_context_current,
+    const scoped_refptr<base::MessageLoopProxy>& io_message_loop_proxy)
     : child_message_loop_proxy_(base::MessageLoopProxy::current()),
+      io_message_loop_proxy_(io_message_loop_proxy),
       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),
@@ skipping 188 matching lines @@
 
   child_message_loop_proxy_->PostTask(FROM_HERE, base::Bind(
       &Client::NotifyInitializeDone, client_));
   return true;
 }
 
 void ExynosVideoDecodeAccelerator::Decode(
     const media::BitstreamBuffer& bitstream_buffer) {
   DVLOG(1) << "Decode(): input_id=" << bitstream_buffer.id()
            << ", size=" << bitstream_buffer.size();
-  DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
-
-  scoped_ptr<BitstreamBufferRef> bitstream_record(new BitstreamBufferRef(
-      client_, child_message_loop_proxy_,
-      new base::SharedMemory(bitstream_buffer.handle(), true),
-      bitstream_buffer.size(), bitstream_buffer.id()));
-  if (!bitstream_record->shm->Map(bitstream_buffer.size())) {
-    DLOG(ERROR) << "Decode(): could not map bitstream_buffer";
-    NOTIFY_ERROR(UNREADABLE_INPUT);
-    return;
-  }
-  DVLOG(3) << "Decode(): mapped to addr=" << bitstream_record->shm->memory();
+  DCHECK(io_message_loop_proxy_->BelongsToCurrentThread());
 
   // DecodeTask() will take care of running a DecodeBufferTask().
   decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
       &ExynosVideoDecodeAccelerator::DecodeTask, base::Unretained(this),
-      base::Passed(&bitstream_record)));
+      bitstream_buffer));
 }
 
 void ExynosVideoDecodeAccelerator::AssignPictureBuffers(
     const std::vector<media::PictureBuffer>& buffers) {
   DVLOG(3) << "AssignPictureBuffers(): buffer_count=" << buffers.size();
   DCHECK(child_message_loop_proxy_->BelongsToCurrentThread());
 
   if (buffers.size() != gsc_output_buffer_map_.size()) {
     DLOG(ERROR) << "AssignPictureBuffers(): Failed to provide requested picture"
       " buffers. (Got " << buffers.size() << ", requested " <<
@@ skipping 124 matching lines @@
     // Otherwise, call the destroy task directly.
     DestroyTask();
   }
 
   // Set to kError state just in case.
   SetDecoderState(kError);
 
   delete this;
 }
 
+bool ExynosVideoDecodeAccelerator::CanDecodeOnIOThread() { return true; }
+
 // static
 void ExynosVideoDecodeAccelerator::PreSandboxInitialization() {
   DVLOG(3) << "PreSandboxInitialization()";
   dlerror();
 
   libmali_handle = dlopen(kMaliDriver, RTLD_LAZY | RTLD_LOCAL);
   if (libmali_handle == NULL) {
     DPLOG(ERROR) << "failed to dlopen() " << kMaliDriver << ": " << dlerror();
   }
 }
@@ skipping 14 matching lines @@
   if (mali_egl_image_get_buffer_ext_phandle == NULL) {
     DPLOG(ERROR) << "PostSandboxInitialization(): failed to dlsym() "
                  << "mali_egl_image_get_buffer_ext_phandle: " << dlerror();
     return false;
   }
 
   return true;
 }
 
 void ExynosVideoDecodeAccelerator::DecodeTask(
-    scoped_ptr<BitstreamBufferRef> bitstream_record) {
-  DVLOG(3) << "DecodeTask(): input_id=" << bitstream_record->input_id;
+    const media::BitstreamBuffer& bitstream_buffer) {
+  DVLOG(3) << "DecodeTask(): input_id=" << bitstream_buffer.id();
   DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
   DCHECK_NE(decoder_state_, kUninitialized);
   TRACE_EVENT1("Video Decoder", "EVDA::DecodeTask", "input_id",
-               bitstream_record->input_id);
+               bitstream_buffer.id());
+
+  scoped_ptr<BitstreamBufferRef> bitstream_record(new BitstreamBufferRef(
+      client_, child_message_loop_proxy_,
+      new base::SharedMemory(bitstream_buffer.handle(), true),
+      bitstream_buffer.size(), bitstream_buffer.id()));
+  if (!bitstream_record->shm->Map(bitstream_buffer.size())) {
+    DLOG(ERROR) << "Decode(): could not map bitstream_buffer";
+    NOTIFY_ERROR(UNREADABLE_INPUT);
+    return;
+  }
+  DVLOG(3) << "Decode(): mapped to addr=" << bitstream_record->shm->memory();
 
   if (decoder_state_ == kResetting || decoder_flushing_) {
     // In the case that we're resetting or flushing, we need to delay decoding
     // the BitstreamBuffers that come after the Reset() or Flush() call.  When
     // we're here, we know that this DecodeTask() was scheduled by a Decode()
     // call that came after (in the client thread) the Reset() or Flush() call;
     // thus set up the delay if necessary.
     if (decoder_delay_bitstream_buffer_id_ == -1)
       decoder_delay_bitstream_buffer_id_ = bitstream_record->input_id;
   } else if (decoder_state_ == kError) {
@@ skipping 1814 matching lines @@
   DestroyGscOutputBuffers();
   DestroyMfcOutputBuffers();
 
   // Finish resolution change on decoder thread.
   decoder_thread_.message_loop()->PostTask(FROM_HERE, base::Bind(
       &ExynosVideoDecodeAccelerator::FinishResolutionChange,
       base::Unretained(this)));
 }
 
 }  // namespace content