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 "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)
+    : channel_(channel), client_(nullptr), decoder_route_id_(route_id) {
+  DCHECK(channel_);
+}
+
+GpuJpegDecodeAcceleratorHost::~GpuJpegDecodeAcceleratorHost() {
+  DCHECK(CalledOnValidThread());
+  Send(new AcceleratedJpegDecoderMsg_Destroy(decoder_route_id_));
+
+  if (channel_) {
+    if (decoder_route_id_ != MSG_ROUTING_NONE)
+      channel_->RemoveRoute(decoder_route_id_);
+    channel_ = nullptr;
+  }
+}
+
+bool GpuJpegDecodeAcceleratorHost::OnMessageReceived(const IPC::Message& msg) {
+  DCHECK(CalledOnValidThread());
+  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() {
+  DVLOG(3) << __func__;
+  DCHECK(CalledOnValidThread());
+
+  channel_ = nullptr;
+  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());
+  if (!channel_)
+    return;
+
+  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) {
+  DVLOG(3) << __func__;

[Pawel Osciak, 2015/05/28 09:13:17]

Nit: I'd remove this.

[kcwu, 2015/05/28 12:10:27]

Done.

+  DCHECK(CalledOnValidThread());
+
+  if (!channel_)
+    return;
+  if (!channel_->Send(message)) {
+    DLOG(ERROR) << "Send(" << message->type() << ") failed";
+  }

[Pawel Osciak, 2015/05/28 09:13:17]

If it's possible for channel to be null at 115, it'd be nice to have a messsage
for that as well. Perhaps if (!channel_ || !channel_->Send()) ?

[kcwu, 2015/05/28 12:10:27]

I'm revisiting the life cycle relation between |channel_| and |this| and not
sure channel could be null or not.
I will address this later.

+}
+
+void GpuJpegDecodeAcceleratorHost::OnDecodeAck(int32_t bitstream_buffer_id,
+                                               Error error) {
+  DCHECK(CalledOnValidThread());
+
+  if (!client_)
+    return;
+
+  if (error == media::JpegDecodeAccelerator::NO_ERROR) {
+    client_->VideoFrameReady(bitstream_buffer_id);
+  } else {

[Pawel Osciak, 2015/05/28 09:13:17]

What if the error is not critical, e.g. UNSUPPORTED_JPEG or PARSE_JPEG_FAILED?
Could we continue instead of dying here?

[kcwu, 2015/05/28 12:10:27]

On earlier review, wuchengli suggest to error out for any errors in order to
find issues (in early stage, say canary). Otherwise we may not notice something
broken.
And for camera case, if there is UNSUPPORTED_JPEG or PARSE_JPEG_FAILED error, it
probably has the same error for next frame.

+    // Only NotifyError once.
+    client_->NotifyError(bitstream_buffer_id, error);
+    client_ = nullptr;
+  }
+}
+
+}  // namespace content