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

content/common/gpu/media/gpu_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 "content/common/gpu/media/gpu_video_decode_accelerator.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
+#include "base/message_loop/message_loop_proxy.h"
 #include "base/stl_util.h"
 
 #include "content/common/gpu/gpu_channel.h"
 #include "content/common/gpu/gpu_messages.h"
 #include "content/public/common/content_switches.h"
 #include "gpu/command_buffer/common/command_buffer.h"
 #include "ipc/ipc_message_macros.h"
 #include "ipc/ipc_message_utils.h"
 #include "ui/gl/gl_context.h"
 #include "ui/gl/gl_surface_egl.h"
@@ skipping 25 matching lines @@
   }
 
   if (!stub->decoder()->MakeCurrent()) {
     DLOG(ERROR) << "Failed to MakeCurrent()";
     return false;
   }
 
   return true;
 }
 
+// A message filter to run VDA::Decode in IO thread to reduce decode latency.
+class GpuVideoDecodeAccelerator::GvdaMessageFilter
+    : public IPC::ChannelProxy::MessageFilter {
+ public:
+  GvdaMessageFilter(GpuVideoDecodeAccelerator* gvda,

[Ami GONE FROM CHROMIUM, 2013/08/26 17:20:03]

virtual dtor please

[Ami GONE FROM CHROMIUM, 2013/08/26 17:20:03]

s/gvda/owner/ here and in the member declaration at l.70 would make the comment
unnecessary. 

BUT, it is also misleading, because while GVDA "owns" the filter, it is actually
the filter's OnFilterRemoved method that deletes the GVDA.  The comment in
OnDestroy is good, but I think a further comment to this effect on (the newly
renamed) owner_ would also be good.

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

Done.

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

Done.

+                    int32 host_route_id,
+                    scoped_refptr<base::MessageLoopProxy> message_loop);

[Ami GONE FROM CHROMIUM, 2013/08/26 17:20:03]

"message_loop" is an uninformative name.

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

Changed to child_message_loop.

+  virtual void OnFilterRemoved() OVERRIDE;
+  virtual bool OnMessageReceived(const IPC::Message& msg) OVERRIDE;
+  void OnDecode(base::SharedMemoryHandle handle, int32 id, uint32 size);

[Ami GONE FROM CHROMIUM, 2013/08/26 17:20:03]

private?

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

Done.

+
+ private:
+  GpuVideoDecodeAccelerator* gvda_;  // GpuVideoDecodeAccelerator owns this.
+  int32 host_route_id_;
+  scoped_refptr<base::MessageLoopProxy> message_loop_;
+};
+
+GpuVideoDecodeAccelerator::GvdaMessageFilter::GvdaMessageFilter(
+    GpuVideoDecodeAccelerator* gvda,
+    int32 host_route_id,
+    scoped_refptr<base::MessageLoopProxy> message_loop)
+    : gvda_(gvda), host_route_id_(host_route_id), message_loop_(message_loop) {}
+
+void GpuVideoDecodeAccelerator::GvdaMessageFilter::OnFilterRemoved() {
+  message_loop_->DeleteSoon(FROM_HERE, gvda_);
+}
+
+bool GpuVideoDecodeAccelerator::GvdaMessageFilter::OnMessageReceived(
+    const IPC::Message& msg) {
+  if (msg.routing_id() != host_route_id_)
+    return false;
+
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(GvdaMessageFilter, msg)
+    IPC_MESSAGE_HANDLER(AcceleratedVideoDecoderMsg_Decode, OnDecode)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  return handled;
+}
+
+void GpuVideoDecodeAccelerator::GvdaMessageFilter::OnDecode(
+    base::SharedMemoryHandle handle,
+    int32 id,
+    uint32 size) {
+  if (id < 0) {
+    DLOG(FATAL) << "BitstreamBuffer id " << id << " out of range";
+    message_loop_->PostTask(
+        FROM_HERE,
+        base::Bind(&GpuVideoDecodeAccelerator::NotifyError,
+                   base::Unretained(gvda_),
+                   media::VideoDecodeAccelerator::INVALID_ARGUMENT));
+    return;
+  }
+  gvda_->OnDecode(handle, id, size);
+}
+
 GpuVideoDecodeAccelerator::GpuVideoDecodeAccelerator(int32 host_route_id,
                                                      GpuCommandBufferStub* stub)
     : init_done_msg_(NULL),
       host_route_id_(host_route_id),
       stub_(stub),
       texture_target_(0) {
   DCHECK(stub_);
   stub_->AddDestructionObserver(this);
   stub_->channel()->AddRoute(host_route_id_, this);
+  filter_.reset(new GvdaMessageFilter(
+      this, host_route_id, base::MessageLoopProxy::current()));
+  stub_->channel()->AddFilter(filter_.get());
   make_context_current_ =
       base::Bind(&MakeDecoderContextCurrent, stub_->AsWeakPtr());
 }
 
 GpuVideoDecodeAccelerator::~GpuVideoDecodeAccelerator() {
-  DCHECK(stub_);
   if (video_decode_accelerator_)
     video_decode_accelerator_.release()->Destroy();
-
-  stub_->channel()->RemoveRoute(host_route_id_);
-  stub_->RemoveDestructionObserver(this);
 }
 
 bool GpuVideoDecodeAccelerator::OnMessageReceived(const IPC::Message& msg) {
   DCHECK(stub_);
   if (!video_decode_accelerator_)
     return false;
   bool handled = true;
   IPC_BEGIN_MESSAGE_MAP(GpuVideoDecodeAccelerator, msg)
-    IPC_MESSAGE_HANDLER(AcceleratedVideoDecoderMsg_Decode, OnDecode)
     IPC_MESSAGE_HANDLER(AcceleratedVideoDecoderMsg_AssignPictureBuffers,
                         OnAssignPictureBuffers)
     IPC_MESSAGE_HANDLER(AcceleratedVideoDecoderMsg_ReusePictureBuffer,
                         OnReusePictureBuffer)
     IPC_MESSAGE_HANDLER(AcceleratedVideoDecoderMsg_Flush, OnFlush)
     IPC_MESSAGE_HANDLER(AcceleratedVideoDecoderMsg_Reset, OnReset)
     IPC_MESSAGE_HANDLER(AcceleratedVideoDecoderMsg_Destroy, OnDestroy)
     IPC_MESSAGE_UNHANDLED(handled = false)
   IPC_END_MESSAGE_MAP()
   return handled;
@@ skipping 46 matching lines @@
   }
   if (!Send(new AcceleratedVideoDecoderHostMsg_ErrorNotification(
           host_route_id_, error))) {
     DLOG(ERROR) << "Send(AcceleratedVideoDecoderHostMsg_ErrorNotification) "
                 << "failed";
   }
 }
 
 void GpuVideoDecodeAccelerator::Initialize(
     const media::VideoCodecProfile profile,
-    IPC::Message* init_done_msg) {
+    IPC::Message* init_done_msg,
+    const scoped_refptr<base::MessageLoopProxy>& io_message_loop) {
   DCHECK(stub_);
   DCHECK(!video_decode_accelerator_.get());
   DCHECK(!init_done_msg_);
   DCHECK(init_done_msg);
   init_done_msg_ = init_done_msg;
 
 #if !defined(OS_WIN)
   // Ensure we will be able to get a GL context at all before initializing
   // non-Windows VDAs.
   if (!make_context_current_.Run()) {
     NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
     return;
   }
 #endif
 
 #if defined(OS_WIN)
   if (base::win::GetVersion() < base::win::VERSION_WIN7) {
     NOTIMPLEMENTED() << "HW video decode acceleration not available.";
     NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
     return;
   }
   DLOG(INFO) << "Initializing DXVA HW decoder for windows.";
   video_decode_accelerator_.reset(new DXVAVideoDecodeAccelerator(
       this, make_context_current_));
 #elif defined(OS_CHROMEOS) && defined(ARCH_CPU_ARMEL) && defined(USE_X11)
   video_decode_accelerator_.reset(new ExynosVideoDecodeAccelerator(
       gfx::GLSurfaceEGL::GetHardwareDisplay(),
       stub_->decoder()->GetGLContext()->GetHandle(),
       this,
-      make_context_current_));
+      make_context_current_,
+      io_message_loop));
 #elif defined(OS_CHROMEOS) && defined(ARCH_CPU_X86_FAMILY) && defined(USE_X11)
   gfx::GLContextGLX* glx_context =
       static_cast<gfx::GLContextGLX*>(stub_->decoder()->GetGLContext());
   GLXContext glx_context_handle =
       static_cast<GLXContext>(glx_context->GetHandle());
   video_decode_accelerator_.reset(new VaapiVideoDecodeAccelerator(
       glx_context->display(), glx_context_handle, this,
-      make_context_current_));
+      make_context_current_, io_message_loop));
 #elif defined(OS_ANDROID)
   video_decode_accelerator_.reset(new AndroidVideoDecodeAccelerator(
       this,
       stub_->decoder()->AsWeakPtr(),
       make_context_current_));
 #else
   NOTIMPLEMENTED() << "HW video decode acceleration not available.";
   NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
   return;
 #endif
 
   if (!video_decode_accelerator_->Initialize(profile))
     NotifyError(media::VideoDecodeAccelerator::PLATFORM_FAILURE);
 }
 
 void GpuVideoDecodeAccelerator::OnDecode(
     base::SharedMemoryHandle handle, int32 id, uint32 size) {
   DCHECK(video_decode_accelerator_.get());
-  if (id < 0) {
-    DLOG(FATAL) << "BitstreamBuffer id " << id << " out of range";
-    NotifyError(media::VideoDecodeAccelerator::INVALID_ARGUMENT);
-    return;
-  }
   video_decode_accelerator_->Decode(media::BitstreamBuffer(id, handle, size));
 }
 
 void GpuVideoDecodeAccelerator::OnAssignPictureBuffers(
       const std::vector<int32>& buffer_ids,
       const std::vector<uint32>& texture_ids,
       const std::vector<gfx::Size>& sizes) {
   DCHECK(stub_);
   if (buffer_ids.size() != texture_ids.size() ||
       buffer_ids.size() != sizes.size()) {
@@ skipping 66 matching lines @@
   video_decode_accelerator_->Flush();
 }
 
 void GpuVideoDecodeAccelerator::OnReset() {
   DCHECK(video_decode_accelerator_.get());
   video_decode_accelerator_->Reset();
 }
 
 void GpuVideoDecodeAccelerator::OnDestroy() {
   DCHECK(video_decode_accelerator_.get());
-  delete this;
+  DCHECK(stub_);
+  stub_->channel()->RemoveRoute(host_route_id_);
+  stub_->RemoveDestructionObserver(this);
+  // Remove the filter first because it can access the member variables on IO
+  // thread. When filter is removed, OnFilterRemoved will delete |this|.
+  stub_->channel()->RemoveFilter(filter_.get());
 }
 
 void GpuVideoDecodeAccelerator::NotifyEndOfBitstreamBuffer(
     int32 bitstream_buffer_id) {
   if (!Send(new AcceleratedVideoDecoderHostMsg_BitstreamBufferProcessed(
           host_route_id_, bitstream_buffer_id))) {
     DLOG(ERROR)
         << "Send(AcceleratedVideoDecoderHostMsg_BitstreamBufferProcessed) "
         << "failed";
   }
@@ skipping 10 matching lines @@
 void GpuVideoDecodeAccelerator::NotifyFlushDone() {
   if (!Send(new AcceleratedVideoDecoderHostMsg_FlushDone(host_route_id_)))
     DLOG(ERROR) << "Send(AcceleratedVideoDecoderHostMsg_FlushDone) failed";
 }
 
 void GpuVideoDecodeAccelerator::NotifyResetDone() {
   if (!Send(new AcceleratedVideoDecoderHostMsg_ResetDone(host_route_id_)))
     DLOG(ERROR) << "Send(AcceleratedVideoDecoderHostMsg_ResetDone) failed";
 }
 
-void GpuVideoDecodeAccelerator::OnWillDestroyStub() {
-  delete this;
-}
+void GpuVideoDecodeAccelerator::OnWillDestroyStub() { OnDestroy(); }
 
 bool GpuVideoDecodeAccelerator::Send(IPC::Message* message) {
   DCHECK(stub_);
   return stub_->channel()->Send(message);
 }
 
 }  // namespace content