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

content/common/gpu/media/vaapi_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 "base/bind.h"
 #include "base/debug/trace_event.h"
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/stl_util.h"
 #include "base/strings/string_util.h"
@@ skipping 26 matching lines @@
   } while (0)
 
 VaapiVideoDecodeAccelerator::InputBuffer::InputBuffer() : id(0), size(0) {
 }
 
 VaapiVideoDecodeAccelerator::InputBuffer::~InputBuffer() {
 }
 
 void VaapiVideoDecodeAccelerator::NotifyError(Error error) {
   if (message_loop_ != base::MessageLoop::current()) {
-    DCHECK_EQ(decoder_thread_.message_loop(), base::MessageLoop::current());
     message_loop_->PostTask(FROM_HERE, base::Bind(
         &VaapiVideoDecodeAccelerator::NotifyError, weak_this_, error));
     return;
   }
 
   // Post Cleanup() as a task so we don't recursively acquire lock_.
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &VaapiVideoDecodeAccelerator::Cleanup, weak_this_));
 
   DVLOG(1) << "Notifying of error " << error;
@@ skipping 177 matching lines @@
     DVLOG(1) << "Picture id " << picture_buffer_id << " does not exist";
     return NULL;
   }
 
   return it->second.get();
 }
 
 VaapiVideoDecodeAccelerator::VaapiVideoDecodeAccelerator(
     Display* x_display, GLXContext glx_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);
     : x_display_(x_display),
       glx_context_(glx_context),
       make_context_current_(make_context_current),
       state_(kUninitialized),
       input_ready_(&lock_),
       surfaces_available_(&lock_),
       message_loop_(base::MessageLoop::current()),
+      io_message_loop_(io_message_loop),
       weak_this_(base::AsWeakPtr(this)),
       client_ptr_factory_(client),
       client_(client_ptr_factory_.GetWeakPtr()),
       decoder_thread_("VaapiDecoderThread"),
       num_frames_at_client_(0),
       num_stream_bufs_at_decoder_(0),
       finish_flush_pending_(false),
       awaiting_va_surfaces_recycle_(false),
       requested_num_pics_(0) {
   DCHECK(client);
@@ skipping 141 matching lines @@
   output_buffers_.pop();
 
   output_cb.Run(tfp_picture);
 
   if (finish_flush_pending_ && pending_output_cbs_.empty())
     FinishFlush();
 }
 
 void VaapiVideoDecodeAccelerator::MapAndQueueNewInputBuffer(
     const media::BitstreamBuffer& bitstream_buffer) {
-  DCHECK_EQ(message_loop_, base::MessageLoop::current());
+  DCHECK_EQ(io_message_loop_, base::MessageLoop::current());
   TRACE_EVENT1("Video Decoder", "MapAndQueueNewInputBuffer", "input_id",
       bitstream_buffer.id());
 
   DVLOG(4) << "Mapping new input buffer id: " << bitstream_buffer.id()
            << " size: " << (int)bitstream_buffer.size();
 
   scoped_ptr<base::SharedMemory> shm(
       new base::SharedMemory(bitstream_buffer.handle(), true));
   RETURN_AND_NOTIFY_ON_FAILURE(shm->Map(bitstream_buffer.size()),

[piman, 2013/08/27 04:01:20]

The Map() can take a long time. Can you move it to the decoding thread?

[wuchengli, 2013/08/27 12:32:24]

I reverted this and let CanDecodeOnIOThread return false for VaapiVDA.

                               "Failed to map input buffer", UNREADABLE_INPUT,);
 
   base::AutoLock auto_lock(lock_);

[piman, 2013/08/27 04:01:20]

What else takes this lock? Can it be held for a long time?

[wuchengli, 2013/08/27 12:32:24]

I reverted this and let CanDecodeOnIOThread return false for VaapiVDA.

 
   // Set up a new input buffer and queue it for later.
   linked_ptr<InputBuffer> input_buffer(new InputBuffer());
   input_buffer->shm.reset(shm.release());
   input_buffer->id = bitstream_buffer.id();
   input_buffer->size = bitstream_buffer.size();
 
   ++num_stream_bufs_at_decoder_;
   TRACE_COUNTER1("Video Decoder", "Stream buffers at decoder",
                  num_stream_bufs_at_decoder_);
@@ skipping 202 matching lines @@
   DVLOG(1) << "Requesting " << requested_num_pics_ << " pictures of size: "
            << requested_pic_size_.ToString();
 
   message_loop_->PostTask(FROM_HERE, base::Bind(
       &Client::ProvidePictureBuffers, client_,
       requested_num_pics_, requested_pic_size_, GL_TEXTURE_2D));
 }
 
 void VaapiVideoDecodeAccelerator::Decode(
     const media::BitstreamBuffer& bitstream_buffer) {
-  DCHECK_EQ(message_loop_, base::MessageLoop::current());
+  DCHECK_EQ(io_message_loop_, base::MessageLoop::current());
 
   TRACE_EVENT1("Video Decoder", "VAVDA::Decode", "Buffer id",
                bitstream_buffer.id());
 
   // We got a new input buffer from the client, map it and queue for later use.
   MapAndQueueNewInputBuffer(bitstream_buffer);
 
   base::AutoLock auto_lock(lock_);
   switch (state_) {
     case kIdle:
@@ skipping 265 matching lines @@
   state_ = kUninitialized;
 }
 
 void VaapiVideoDecodeAccelerator::Destroy() {
   DCHECK_EQ(message_loop_, base::MessageLoop::current());
   Cleanup();
   delete this;
 }
 
 }  // namespace content