Implement Pepper PPB_VideoDecoder interface.

content/renderer/pepper/pepper_video_decoder_host.cc

+// Copyright (c) 2014 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/renderer/pepper/pepper_video_decoder_host.h"
+
+#include "base/bind.h"
+#include "base/memory/shared_memory.h"
+#include "content/common/gpu/client/gpu_channel_host.h"
+#include "content/public/renderer/render_thread.h"
+#include "content/public/renderer/renderer_ppapi_host.h"
+#include "content/renderer/pepper/ppb_graphics_3d_impl.h"
+#include "content/renderer/render_thread_impl.h"
+#include "content/renderer/render_view_impl.h"
+#include "media/video/picture.h"
+#include "media/video/video_decode_accelerator.h"
+#include "ppapi/c/pp_completion_callback.h"
+#include "ppapi/c/pp_errors.h"
+#include "ppapi/host/dispatch_host_message.h"
+#include "ppapi/host/ppapi_host.h"
+#include "ppapi/proxy/ppapi_messages.h"
+#include "ppapi/thunk/enter.h"
+#include "ppapi/thunk/ppb_graphics_3d_api.h"
+
+using ppapi::proxy::SerializedHandle;
+using ppapi::thunk::EnterResourceNoLock;
+using ppapi::thunk::PPB_Graphics3D_API;
+
+namespace content {
+
+namespace {
+
+#define COMPILE_ASSERT_MATCHING_ENUM(media_name, np_name)               \
+  COMPILE_ASSERT(                                                       \
+      static_cast<int>(media::media_name) == static_cast<int>(np_name), \
+      mismatching_enums)
+
+COMPILE_ASSERT_MATCHING_ENUM(H264PROFILE_BASELINE,
+                             PP_VIDEOPROFILE_H264BASELINE);
+COMPILE_ASSERT_MATCHING_ENUM(H264PROFILE_MAIN, PP_VIDEOPROFILE_H264MAIN);
+COMPILE_ASSERT_MATCHING_ENUM(H264PROFILE_EXTENDED,
+                             PP_VIDEOPROFILE_H264EXTENDED);
+COMPILE_ASSERT_MATCHING_ENUM(H264PROFILE_HIGH, PP_VIDEOPROFILE_H264HIGH);
+COMPILE_ASSERT_MATCHING_ENUM(H264PROFILE_HIGH10PROFILE,
+                             PP_VIDEOPROFILE_H264HIGH10PROFILE);
+COMPILE_ASSERT_MATCHING_ENUM(H264PROFILE_HIGH422PROFILE,
+                             PP_VIDEOPROFILE_H264HIGH422PROFILE);
+COMPILE_ASSERT_MATCHING_ENUM(H264PROFILE_HIGH444PREDICTIVEPROFILE,
+                             PP_VIDEOPROFILE_H264HIGH444PREDICTIVEPROFILE);
+COMPILE_ASSERT_MATCHING_ENUM(H264PROFILE_SCALABLEBASELINE,
+                             PP_VIDEOPROFILE_H264SCALABLEBASELINE);
+COMPILE_ASSERT_MATCHING_ENUM(H264PROFILE_SCALABLEHIGH,
+                             PP_VIDEOPROFILE_H264SCALABLEHIGH);
+COMPILE_ASSERT_MATCHING_ENUM(H264PROFILE_STEREOHIGH,
+                             PP_VIDEOPROFILE_H264STEREOHIGH);
+COMPILE_ASSERT_MATCHING_ENUM(H264PROFILE_MULTIVIEWHIGH,
+                             PP_VIDEOPROFILE_H264MULTIVIEWHIGH);
+COMPILE_ASSERT_MATCHING_ENUM(VP8PROFILE_MAIN, PP_VIDEOPROFILE_VP8MAIN);
+
+}  // namespace
+
+PepperVideoDecoderHost::PendingDecode::PendingDecode(
+    uint32_t shm_id,
+    const ppapi::host::ReplyMessageContext& reply_context)
+    : shm_id_(shm_id), reply_context_(reply_context) {
+}
+
+PepperVideoDecoderHost::PendingDecode::~PendingDecode() {
+}
+
+PepperVideoDecoderHost::PepperVideoDecoderHost(RendererPpapiHost* host,
+                                               PP_Instance instance,
+                                               PP_Resource resource)
+    : ResourceHost(host->GetPpapiHost(), instance, resource),
+      renderer_ppapi_host_(host),
+      initialized_(false) {
+}
+
+PepperVideoDecoderHost::~PepperVideoDecoderHost() {
+  if (decoder_) {
+    decoder_->Destroy();
+    decoder_.reset();
+  }
+}
+
+int32_t PepperVideoDecoderHost::OnResourceMessageReceived(
+    const IPC::Message& msg,
+    ppapi::host::HostMessageContext* context) {
+  PPAPI_BEGIN_MESSAGE_MAP(PepperVideoDecoderHost, msg)
+  PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_VideoDecoder_Initialize,
+                                    OnHostMsgInitialize)
+  PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_VideoDecoder_GetShm,
+                                    OnHostMsgGetShm)
+  PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_VideoDecoder_AssignTextures,
+                                    OnHostMsgAssignTextures)
+  PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_VideoDecoder_Decode,
+                                    OnHostMsgDecode)
+  PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_VideoDecoder_RecyclePicture,
+                                    OnHostMsgRecyclePicture)
+  PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(PpapiHostMsg_VideoDecoder_Flush,
+                                      OnHostMsgFlush)
+  PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(PpapiHostMsg_VideoDecoder_Reset,
+                                      OnHostMsgReset)
+  PPAPI_END_MESSAGE_MAP()
+  return PP_ERROR_FAILED;
+}
+
+int32_t PepperVideoDecoderHost::OnHostMsgInitialize(
+    ppapi::host::HostMessageContext* context,
+    ppapi::HostResource graphics_context,
+    PP_VideoProfile profile,
+    bool allow_software_fallback) {
+  if (initialized_)
+    return PP_ERROR_FAILED;
+
+  EnterResourceNoLock<PPB_Graphics3D_API> enter_graphics(
+      graphics_context.host_resource(), true);
+  if (enter_graphics.failed())
+    return PP_ERROR_FAILED;

[yzshen1, 2014/05/14 18:08:23]

Maybe we could consider PP_ERROR_BADRESOURCE?

[bbudge, 2014/05/14 19:35:04]

It's actually our own Graphics3D, created by the resource, that we use to create
textures to share with the plugin. So it might be misleading.

[yzshen1, 2014/05/14 22:58:16]

Okay. I see.
On 2014/05/14 19:35:04, bbudge wrote:

+  graphics3d_ = static_cast<PPB_Graphics3D_Impl*>(enter_graphics.object());
+
+  int command_buffer_route_id = graphics3d_->GetCommandBufferRouteId();
+  if (!command_buffer_route_id)
+    return PP_ERROR_FAILED;
+
+  media::VideoCodecProfile media_profile =
+      static_cast<media::VideoCodecProfile>(profile);

[yzshen1, 2014/05/14 18:08:23]

If we add new values to PP_VideoProfile but forget to update the compiler
asserts at the top of the file, it may cause problem. Maybe we could consider a
conversion function (and intentionally omit 'default' for 'switch') instead.

[bbudge, 2014/05/14 19:35:04]

Done.

+
+  // This is not synchronous, but subsequent IPC messages will be buffered, so
+  // it is okay to immediately send IPC messages through the returned channel.
+  GpuChannelHost* channel = graphics3d_->channel();
+  DCHECK(channel);
+
+  if (channel) {
+    decoder_ = channel->CreateVideoDecoder(command_buffer_route_id);
+    if (decoder_ && decoder_->Initialize(media_profile, this)) {
+      initialized_ = true;
+      return PP_OK;
+    }
+    decoder_.reset();
+  }
+
+  // TODO(bbudge) Implement software fallback.
+  return PP_ERROR_NOTSUPPORTED;
+}
+
+int32_t PepperVideoDecoderHost::OnHostMsgGetShm(
+    ppapi::host::HostMessageContext* context,
+    uint32_t size) {
+  if (!initialized_)
+    return PP_ERROR_FAILED;
+
+  content::RenderThread* render_thread = content::RenderThread::Get();
+  scoped_ptr<base::SharedMemory> shm(
+      render_thread->HostAllocateSharedMemoryBuffer(size).Pass());
+  if (!shm)
+    return PP_ERROR_FAILED;
+  if (!shm->Map(size))
+    return PP_ERROR_FAILED;
+
+  base::SharedMemoryHandle shm_handle = shm->handle();
+  shm_buffers_.push_back(shm.release());
+
+  base::PlatformFile platform_file =
+#if defined(OS_WIN)

[yzshen1, 2014/05/14 18:08:23]

I think it is recommended to use #XXX around complete statements.

[bbudge, 2014/05/14 19:35:04]

Done.

+      shm_handle;
+#elif defined(OS_POSIX)
+      shm_handle.fd;
+#else
+#error Not implemented.
+#endif
+  SerializedHandle handle(
+      renderer_ppapi_host_->ShareHandleWithRemote(platform_file, false), size);
+  ppapi::host::ReplyMessageContext reply_context =
+      context->MakeReplyMessageContext();
+  reply_context.params.AppendHandle(handle);
+  host()->SendReply(reply_context,
+                    PpapiPluginMsg_VideoDecoder_GetShmReply(size));
+  return PP_OK_COMPLETIONPENDING;
+}
+
+int32_t PepperVideoDecoderHost::OnHostMsgAssignTextures(
+    ppapi::host::HostMessageContext* context,
+    PP_Size size,
+    const std::vector<uint32_t>& texture_ids) {
+  if (!initialized_)
+    return PP_ERROR_FAILED;
+  if (!decoder_) {

[yzshen1, 2014/05/14 18:08:23]

I think as long as |initialized_| is true, |decoder_| is never NULL. Maybe we
could simply use DCHECK(decoder_). (here and elsewhere)

[bbudge, 2014/05/14 19:35:04]

Done.

+    NOTREACHED();
+    return PP_ERROR_FAILED;
+  }
+
+  std::vector<media::PictureBuffer> picture_buffers;
+  for (uint32 i = 0; i < texture_ids.size(); i++) {
+    media::PictureBuffer buffer(
+        texture_ids[i],  // Use the texture_id to identify the buffer.
+        gfx::Size(size.width, size.height),
+        texture_ids[i]);
+    picture_buffers.push_back(buffer);
+  }
+  decoder_->AssignPictureBuffers(picture_buffers);
+  return PP_OK;
+}
+
+int32_t PepperVideoDecoderHost::OnHostMsgDecode(
+    ppapi::host::HostMessageContext* context,
+    uint32_t shm_id,
+    uint32_t decode_id,
+    uint32_t size) {
+  if (!initialized_)
+    return PP_ERROR_FAILED;
+  // |shm_id| is just an index into shm_buffers_. Make sure it's in range.
+  if (static_cast<size_t>(shm_id) >= shm_buffers_.size())
+    return PP_ERROR_FAILED;
+
+  pending_decodes_.insert(std::make_pair(

[yzshen1, 2014/05/14 18:08:23]

It seems this code allows multiple in-flight Decode requests. The IDL says "The
plugin should maintain the buffer and not call Decode() again until the decoder
signals completion by returning PP_OK or by running |callback|."

[bbudge, 2014/05/14 19:35:04]

It's true that multiple decodes can be in-flight simultaneously. That's because
we have several shm buffers that can be filled and awaiting decode. From the
plugin's point of view, it can only call Decode once until completion. We signal
completion after we have copied the plugin's buffer to the shm buffer. If there
is a shm buffer available, we immediately copy the data and return PP_OK,
otherwise, we return PP_OK_COMPLETIONPENDING and signal completion when a buffer
becomes available.

[dmichael (off chromium), 2014/05/15 21:18:22]

This confused me at first as well. It seems piman and yzshen were also expecting
Decode to mean something different. In particular, the completion callback
doesn't indicate that the _Decode_ is complete, it just means that the system is
finished writing it to shmem. Maybe there's a less confusing way to name Decode?
Like...  "EnqueueDecode" or something?

+      decode_id, PendingDecode(shm_id, context->MakeReplyMessageContext())));
+
+  base::SharedMemory* shm = shm_buffers_[shm_id];
+  DCHECK(decoder_);
+  if (decoder_)
+    decoder_->Decode(media::BitstreamBuffer(decode_id, shm->handle(), size));
+
+  return PP_OK_COMPLETIONPENDING;
+}
+
+int32_t PepperVideoDecoderHost::OnHostMsgRecyclePicture(
+    ppapi::host::HostMessageContext* context,
+    uint32_t texture_id) {
+  if (!initialized_)
+    return PP_ERROR_FAILED;
+  DCHECK(decoder_);
+  if (decoder_)
+    decoder_->ReusePictureBuffer(texture_id);
+
+  return PP_OK;
+}
+
+int32_t PepperVideoDecoderHost::OnHostMsgFlush(
+    ppapi::host::HostMessageContext* context) {
+  if (!initialized_)
+    return PP_ERROR_FAILED;
+
+  flush_reply_context_ = context->MakeReplyMessageContext();

[yzshen1, 2014/05/14 18:08:23]

If there is a pending Flush, this will rewrite the existing context.
Besides, the IDL says "The plugin should make no further calls to the decoder
other than GetPicture() and RecyclePicture() until the decoder signals
completion by running the callback". Shall we directly fail calls to the decoder
other than GetPicture() and RecyclePicture() while Flush is pending?

(I understand that the proxy side has relevant checks. But we might receive
malicious messages. If we don't do such checks at the renderer side, we need to
be sure that |decoder_| won't be confused by unexpected Flush calls.)

[bbudge, 2014/05/14 19:35:04]

The IDL is correct. I'll add checks here as well, return PP_ERROR_FAILED (not
PP_ERROR_INPROGRESS). Done.

+  DCHECK(decoder_);
+  if (decoder_)
+    decoder_->Flush();
+
+  return PP_OK_COMPLETIONPENDING;
+}
+
+int32_t PepperVideoDecoderHost::OnHostMsgReset(
+    ppapi::host::HostMessageContext* context) {
+  if (!initialized_)
+    return PP_ERROR_FAILED;
+
+  reset_reply_context_ = context->MakeReplyMessageContext();

[yzshen1, 2014/05/14 18:08:23]

If there is a pending Reset, this will rewrite the existing context.

Besides, the IDL says "The plugin should not make any further calls to the
decoder until the decoder signals completion by running |callback|". Shall we
directly fail calls while Reset is pending?

[bbudge, 2014/05/14 19:35:04]

Done.

+  DCHECK(decoder_);
+  if (decoder_)
+    decoder_->Reset();
+
+  return PP_OK_COMPLETIONPENDING;
+}
+
+void PepperVideoDecoderHost::ProvidePictureBuffers(
+    uint32 requested_num_of_buffers,
+    const gfx::Size& dimensions,
+    uint32 texture_target) {
+  RequestTextures(requested_num_of_buffers, dimensions, texture_target);
+}
+
+void PepperVideoDecoderHost::RequestTextures(uint32 requested_num_of_buffers,
+                                             const gfx::Size& dimensions,
+                                             uint32 texture_target) {
+  DCHECK(RenderThreadImpl::current());
+  host()->SendUnsolicitedReply(
+      pp_resource(),
+      PpapiPluginMsg_VideoDecoder_RequestTextures(
+          requested_num_of_buffers,
+          PP_MakeSize(dimensions.width(), dimensions.height()),
+          texture_target));
+}
+
+void PepperVideoDecoderHost::PictureReady(const media::Picture& picture) {
+  DCHECK(RenderThreadImpl::current());
+  host()->SendUnsolicitedReply(
+      pp_resource(),
+      PpapiPluginMsg_VideoDecoder_PictureReady(picture.bitstream_buffer_id(),
+                                               picture.picture_buffer_id()));
+}
+
+void PepperVideoDecoderHost::DismissPictureBuffer(int32 picture_buffer_id) {
+  DCHECK(RenderThreadImpl::current());
+  host()->SendUnsolicitedReply(
+      pp_resource(),
+      PpapiPluginMsg_VideoDecoder_DismissPicture(picture_buffer_id));
+}
+
+void PepperVideoDecoderHost::NotifyError(
+    media::VideoDecodeAccelerator::Error error) {
+  DCHECK(RenderThreadImpl::current());
+  int32_t pp_error = PP_ERROR_FAILED;
+  switch (error) {
+    case media::VideoDecodeAccelerator::UNREADABLE_INPUT:
+      pp_error = PP_ERROR_UNREADABLE_INPUT;
+      break;
+    case media::VideoDecodeAccelerator::ILLEGAL_STATE:
+    case media::VideoDecodeAccelerator::INVALID_ARGUMENT:
+    case media::VideoDecodeAccelerator::PLATFORM_FAILURE:
+      pp_error = PP_ERROR_PLATFORM_FAILED;
+      break;
+    default:
+      NOTREACHED();
+      break;
+  }
+  host()->SendUnsolicitedReply(
+      pp_resource(), PpapiPluginMsg_VideoDecoder_NotifyError(pp_error));
+}
+
+void PepperVideoDecoderHost::NotifyResetDone() {
+  DCHECK(RenderThreadImpl::current());
+  host()->SendReply(reset_reply_context_,
+                    PpapiPluginMsg_VideoDecoder_ResetReply());
+  reset_reply_context_ = ppapi::host::ReplyMessageContext();
+}
+
+void PepperVideoDecoderHost::NotifyEndOfBitstreamBuffer(
+    int32 bitstream_buffer_id) {
+  DCHECK(RenderThreadImpl::current());
+  uint32_t decode_id = static_cast<uint32_t>(bitstream_buffer_id);
+  PendingDecodeMap::iterator it = pending_decodes_.find(decode_id);
+  if (it == pending_decodes_.end()) {
+    NOTREACHED();
+    return;
+  }
+  const PendingDecode& pending_decode = it->second;
+  host()->SendReply(
+      pending_decode.reply_context_,
+      PpapiPluginMsg_VideoDecoder_DecodeReply(pending_decode.shm_id_));
+  pending_decodes_.erase(it);
+}
+
+void PepperVideoDecoderHost::NotifyFlushDone() {
+  DCHECK(RenderThreadImpl::current());
+  host()->SendReply(flush_reply_context_,
+                    PpapiPluginMsg_VideoDecoder_FlushReply());
+  flush_reply_context_ = ppapi::host::ReplyMessageContext();
+}
+
+}  // namespace content