MJPEG acceleration for video capture using VAAPI, the GPU and IPC part

content/common/gpu/client/gpu_jpeg_decode_accelerator_host.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 "content/common/gpu/client/gpu_jpeg_decode_accelerator_host.h"
+
+#include "base/bind.h"
+#include "base/logging.h"
+#include "base/synchronization/waitable_event.h"
+#include "content/common/gpu/client/gpu_channel_host.h"
+#include "content/common/gpu/gpu_messages.h"
+#include "ipc/ipc_message_macros.h"
+#include "ipc/ipc_message_utils.h"
+
+using media::JpegDecodeAccelerator;
+namespace content {
+
+GpuJpegDecodeAcceleratorHost::GpuJpegDecodeAcceleratorHost(
+    GpuChannelHost* channel,
+    int32 route_id,
+    const scoped_refptr<base::SingleThreadTaskRunner>& io_task_runner)
+    : channel_(channel),
+      client_(nullptr),
+      decoder_route_id_(route_id),
+      io_task_runner_(io_task_runner) {
+  DCHECK(channel_);
+  DCHECK_NE(decoder_route_id_, MSG_ROUTING_NONE);
+}
+
+GpuJpegDecodeAcceleratorHost::~GpuJpegDecodeAcceleratorHost() {
+  DCHECK(CalledOnValidThread());
+  Send(new AcceleratedJpegDecoderMsg_Destroy(decoder_route_id_));
+
+  channel_->RemoveRoute(decoder_route_id_);
+
+  // No callback from RemoveRoute, so we just post a task to IO thread to make
+  // sure IO thread is done.
+  base::WaitableEvent event(false, false);
+  io_task_runner_->PostTask(FROM_HERE, base::Bind(&base::WaitableEvent::Signal,
+                                                  base::Unretained(&event)));
+  event.Wait();

[piman, 2015/06/05 21:49:40]

I don't think this is enough, you could still have a race, because the code on
the IO thread posts a task to call OnMessageReceived/OnChannelError.

So on the IO thread you could end up with the task queue with the RemoveRoute
task and the WaitableEvent::Signal task, but if an IPC message is received
before the RemoveRoute task is handled, then the filter will handle the message
and post another task to do the OnMessageReceived, that will be queued *after*
the WaitableEvent::Signal task.


I think to solve this and the problem mentioned in GpuChannelHost, you may want
to separate a "receiver" object which purely lives on the IO thread and has its
own weakptr.

[kcwu, 2015/06/08 19:28:48]

Done.

+}
+
+bool GpuJpegDecodeAcceleratorHost::OnMessageReceived(const IPC::Message& msg) {
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
+
+  bool handled = true;
+  IPC_BEGIN_MESSAGE_MAP(GpuJpegDecodeAcceleratorHost, msg)
+    IPC_MESSAGE_HANDLER(AcceleratedJpegDecoderHostMsg_DecodeAck, OnDecodeAck)
+    IPC_MESSAGE_UNHANDLED(handled = false)
+  IPC_END_MESSAGE_MAP()
+  DCHECK(handled);
+  return handled;
+}
+
+void GpuJpegDecodeAcceleratorHost::OnChannelError() {
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
+
+  OnDecodeAck(kInvalidBitstreamBufferId, PLATFORM_FAILURE);
+}
+
+bool GpuJpegDecodeAcceleratorHost::Initialize(
+    media::JpegDecodeAccelerator::Client* client) {
+  DCHECK(CalledOnValidThread());
+
+  bool succeeded = false;
+  // This cannot be on IO thread because the msg is synchronous.
+  Send(new GpuMsg_CreateJpegDecoder(decoder_route_id_, &succeeded));
+
+  if (!succeeded) {
+    DLOG(ERROR) << "Send(GpuMsg_CreateJpegDecoder()) failed";
+    return false;
+  }
+  client_ = client;
+
+  return true;
+}
+
+void GpuJpegDecodeAcceleratorHost::Decode(
+    const media::BitstreamBuffer& bitstream_buffer,
+    const scoped_refptr<media::VideoFrame>& video_frame) {
+  DCHECK(CalledOnValidThread());
+
+  DCHECK(
+      base::SharedMemory::IsHandleValid(video_frame->shared_memory_handle()));
+
+  base::SharedMemoryHandle input_handle =
+      channel_->ShareToGpuProcess(bitstream_buffer.handle());
+  if (!base::SharedMemory::IsHandleValid(input_handle)) {
+    DLOG(ERROR) << "Failed to duplicate handle of BitstreamBuffer";
+    return;
+  }
+  base::SharedMemoryHandle output_handle =
+      channel_->ShareToGpuProcess(video_frame->shared_memory_handle());
+  if (!base::SharedMemory::IsHandleValid(output_handle)) {
+    DLOG(ERROR) << "Failed to duplicate handle of VideoFrame";
+    if (input_handle.auto_close) {
+      // Defer closing task to the ScopedFD.
+      base::ScopedFD(input_handle.fd);
+    }
+    return;
+  }
+
+  size_t output_buffer_size = media::VideoFrame::AllocationSize(
+      video_frame->format(), video_frame->coded_size());
+
+  AcceleratedJpegDecoderMsg_Decode_Params decode_params;
+  decode_params.coded_size = video_frame->coded_size();
+  decode_params.input_buffer_id = bitstream_buffer.id();
+  decode_params.input_buffer_handle = input_handle;
+  decode_params.input_buffer_size = bitstream_buffer.size();
+  decode_params.output_video_frame_handle = output_handle;
+  decode_params.output_buffer_size = output_buffer_size;
+  Send(new AcceleratedJpegDecoderMsg_Decode(decoder_route_id_, decode_params));
+}
+
+void GpuJpegDecodeAcceleratorHost::Send(IPC::Message* message) {
+  DCHECK(CalledOnValidThread());
+
+  if (!channel_->Send(message)) {
+    DLOG(ERROR) << "Send(" << message->type() << ") failed";
+  }
+}
+
+void GpuJpegDecodeAcceleratorHost::OnDecodeAck(int32_t bitstream_buffer_id,
+                                               Error error) {
+  DCHECK(io_task_runner_->BelongsToCurrentThread());
+
+  if (!client_)
+    return;
+
+  if (error == media::JpegDecodeAccelerator::NO_ERROR) {
+    client_->VideoFrameReady(bitstream_buffer_id);
+  } else {
+    // Only NotifyError once.
+    // Client::NotifyError() may delete |this|, so calling it needs to be the
+    // last thing done on this stack!
+    media::JpegDecodeAccelerator::Client* client = nullptr;
+    std::swap(client, client_);
+    client->NotifyError(bitstream_buffer_id, error);
+  }
+}
+
+}  // namespace content