Implement Pepper PPB_VideoDecoder interface.

ppapi/proxy/video_decoder_resource.cc

Index: ppapi/proxy/video_decoder_resource.cc
diff --git a/ppapi/proxy/video_decoder_resource.cc b/ppapi/proxy/video_decoder_resource.cc
new file mode 100644
index 0000000000000000000000000000000000000000..ff3566561a04104b0168aa88f3faea469f17497c
--- /dev/null
+++ b/ppapi/proxy/video_decoder_resource.cc
@@ -0,0 +1,488 @@
+// 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 "ppapi/proxy/video_decoder_resource.h"
+
+#include "base/bind.h"
+#include "gpu/command_buffer/client/gles2_cmd_helper.h"
+#include "gpu/command_buffer/client/gles2_implementation.h"
+#include "ipc/ipc_message.h"
+#include "ppapi/c/pp_errors.h"
+#include "ppapi/c/ppb_opengles2.h"
+#include "ppapi/proxy/plugin_dispatcher.h"
+#include "ppapi/proxy/ppapi_messages.h"
+#include "ppapi/proxy/ppb_graphics_3d_proxy.h"
+#include "ppapi/shared_impl/ppapi_globals.h"
+#include "ppapi/shared_impl/ppb_graphics_3d_shared.h"
+#include "ppapi/shared_impl/proxy_lock.h"
+#include "ppapi/shared_impl/resource_tracker.h"
+#include "ppapi/thunk/enter.h"
+
+using ppapi::thunk::EnterResourceNoLock;
+using ppapi::thunk::PPB_Graphics3D_API;
+using ppapi::thunk::PPB_VideoDecoder_API;
+
+namespace {
+
+// Maximum number of concurrent decodes which can be pending.
+const uint32_t kMaximumPendingDecodes = 8;
+
+// Minimum size of shared-memory buffers we allocate. Make them large since
+// we try to reuse them.
+const uint32_t kMinimumBitstreamBufferSize = 100 << 10;
+
+}  // namespace
+
+namespace ppapi {
+namespace proxy {
+
+VideoDecoderResource::ShmBuffer::ShmBuffer(base::SharedMemory* in_shm,

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

nit: scoped_ptr<> would make it clearer that this is taking ownership.

[bbudge, 2014/05/15 22:27:44]

Done.

+                                           uint32_t in_size,
+                                           uint32_t in_shm_id)
+    : shm(in_shm), size(in_size), addr(NULL), shm_id(in_shm_id) {

[piman, 2014/05/15 04:02:53]

nit: no need for in_ prefixes. For an initializer, shm(shm) works.

[bbudge, 2014/05/15 16:31:57]

Awesome. I didn't know that!
I'll fix this in the next upload.

[bbudge, 2014/05/15 22:27:44]

Done.

+  if (shm->Map(size))
+    addr = shm->memory();
+  DCHECK(addr);
+}
+
+VideoDecoderResource::ShmBuffer::~ShmBuffer() {
+}
+
+VideoDecoderResource::Texture::Texture(uint32_t in_texture_target,
+                                       const PP_Size& in_size)
+    : texture_target(in_texture_target), size(in_size) {
+}
+
+VideoDecoderResource::Texture::~Texture() {
+}
+
+VideoDecoderResource::Picture::Picture(int32_t in_decode_id,
+                                       uint32_t in_texture_id)
+    : decode_id( in_decode_id), texture_id(in_texture_id) {

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

nit: extra space before in_decode_id

[bbudge, 2014/05/15 22:27:44]

Done.

+}
+
+VideoDecoderResource::Picture::~Picture() {
+}
+
+VideoDecoderResource::VideoDecoderResource(Connection connection,
+                                           PP_Instance instance)
+    : PluginResource(connection, instance),
+      decode_id_(0),
+      decode_size_(0),
+      decode_buffer_(NULL),
+      pending_decode_count_(0),
+      get_shm_buffer_pending_(false),
+      get_picture_(NULL),
+      gles2_impl_(NULL),
+      initialized_(false),
+      testing_(false),
+      // Set |decoder_last_error_| to PP_OK after successful initialization.
+      // This makes error checking a little more concise, since we can check
+      // that the decoder has been initialized and hasn't returned an error by
+      // just testing |decoder_last_error_|.
+      decoder_last_error_(PP_ERROR_FAILED) {
+  SendCreate(RENDERER, PpapiHostMsg_VideoDecoder_Create());
+}
+
+VideoDecoderResource::~VideoDecoderResource() {
+  // Destroy any textures which haven't been dismissed.
+  TextureMap::iterator it = textures_.begin();
+  for (; it != textures_.end(); ++it)
+    DeleteGLTexture(it->first);
+}
+
+PPB_VideoDecoder_API* VideoDecoderResource::AsPPB_VideoDecoder_API() {
+  return this;
+}
+
+int32_t VideoDecoderResource::Initialize(
+    PP_Resource graphics_context,
+    PP_VideoProfile profile,
+    PP_Bool allow_software_fallback,
+    scoped_refptr<TrackedCallback> callback) {
+  if (initialized_)
+    return PP_ERROR_FAILED;
+  if (profile < 0 || profile > PP_VIDEOPROFILE_MAX)
+    return PP_ERROR_BADARGUMENT;
+  if (initialize_callback_)
+    return PP_ERROR_INPROGRESS;
+  if (!graphics_context)
+    return PP_ERROR_BADRESOURCE;
+
+  // Create a new Graphics3D resource that can create texture resources to share
+  // with the plugin. We can't use the plugin's Graphics3D, since we create
+  // textures on a proxy thread, and would interfere with the plugin.
+  thunk::EnterResourceCreationNoLock enter_create(pp_instance());
+  if (enter_create.failed())
+    return PP_ERROR_FAILED;
+  int32_t attrib_list[] = {PP_GRAPHICS3DATTRIB_NONE};
+  HostResource host_resource;
+  if (!testing_) {
+    graphics3d_ =
+        ScopedPPResource(ScopedPPResource::PassRef(),
+                         enter_create.functions()->CreateGraphics3D(
+                             pp_instance(), graphics_context, attrib_list));
+    EnterResourceNoLock<PPB_Graphics3D_API> enter_graphics(graphics3d_.get(),
+                                                           true);
+    if (enter_graphics.failed())
+      return PP_ERROR_BADRESOURCE;
+
+    PPB_Graphics3D_Shared* ppb_graphics3d_shared =
+        static_cast<PPB_Graphics3D_Shared*>(enter_graphics.object());
+    gles2_impl_ = ppb_graphics3d_shared->gles2_impl();
+    host_resource = ppb_graphics3d_shared->host_resource();
+  }
+
+  initialize_callback_ = callback;
+
+  Call<PpapiPluginMsg_VideoDecoder_InitializeReply>(
+      RENDERER,
+      PpapiHostMsg_VideoDecoder_Initialize(
+          host_resource, profile, PP_ToBool(allow_software_fallback)),
+      base::Bind(&VideoDecoderResource::OnPluginMsgInitializeComplete, this));
+
+  return PP_OK_COMPLETIONPENDING;
+}
+
+int32_t VideoDecoderResource::Decode(uint32_t decode_id,
+                                     uint32_t size,
+                                     const void* buffer,
+                                     scoped_refptr<TrackedCallback> callback) {
+  if (decoder_last_error_)
+    return decoder_last_error_;
+  if (flush_callback_ || reset_callback_)
+    return PP_ERROR_FAILED;
+  if (decode_callback_)
+    return PP_ERROR_INPROGRESS;

[piman, 2014/05/15 04:02:53]

This is actually very unfortunate. It means you can't pipeline decode calls and
keep the decoder busy, since you need a round-trip before being able to decode
more.

Since you will send at least one Decode per video frame, you can't afford a full
round trip every time if the renderer or GPU process is busy.

[bbudge, 2014/05/15 16:31:57]

It's not as bad as it looks. If a shared memory buffer is available, TryDecode
will return with PP_OK and the plugin can immediately call Decode again. In the
steady state, when there are > 8 shm buffers, the plugin will thus have 8
Decodes in flight if it is fast enough. The only exception is at start up, or if
a buffer is too large to fit in the last available shm buffer, in which case we
have to wait for a new buffer.

There is some complexity with the current code because we have to wait for the
asynchronous return of a shm buffer. Is there a way for plugin code to
synchronously request one from the browser without writing a browser host for
this resource? I'd like to avoid having two hosts for this class.

+
+  return TryDecode(decode_id, size, buffer, callback);
+}
+
+int32_t VideoDecoderResource::GetPicture(
+    PP_VideoPicture* picture,
+    scoped_refptr<TrackedCallback> callback) {
+  if (decoder_last_error_)
+    return decoder_last_error_;
+  if (reset_callback_)
+    return PP_ERROR_FAILED;
+  if (get_picture_callback_)
+    return PP_ERROR_INPROGRESS;
+
+  // If the next picture is ready, return it synchronously.
+  if (!received_pictures_.empty()) {
+    WriteNextPicture(picture);
+    return PP_OK;
+  }
+
+  get_picture_callback_ = callback;
+  get_picture_ = picture;
+  return PP_OK_COMPLETIONPENDING;
+}
+
+void VideoDecoderResource::RecyclePicture(const PP_VideoPicture* picture) {
+  if (decoder_last_error_)
+    return;
+  if (reset_callback_)
+    return;
+
+  Post(RENDERER, PpapiHostMsg_VideoDecoder_RecyclePicture(picture->texture_id));
+}
+
+int32_t VideoDecoderResource::Flush(scoped_refptr<TrackedCallback> callback) {
+  if (decoder_last_error_)
+    return decoder_last_error_;
+  if (reset_callback_)
+    return PP_ERROR_FAILED;
+  if (flush_callback_)
+    return PP_ERROR_INPROGRESS;
+  flush_callback_ = callback;
+
+  Call<PpapiPluginMsg_VideoDecoder_FlushReply>(
+      RENDERER,
+      PpapiHostMsg_VideoDecoder_Flush(),
+      base::Bind(&VideoDecoderResource::OnPluginMsgFlushComplete, this));
+
+  return PP_OK_COMPLETIONPENDING;
+}
+
+int32_t VideoDecoderResource::Reset(scoped_refptr<TrackedCallback> callback) {
+  if (decoder_last_error_)
+    return decoder_last_error_;
+  if (flush_callback_)
+    return PP_ERROR_FAILED;
+  if (reset_callback_)
+    return PP_ERROR_INPROGRESS;
+  reset_callback_ = callback;
+
+  // Cause any pending Decode or GetPicture callbacks to abort immediately.
+  // Reentrancy isn't a problem, since all calls fail until Reset completes.
+  if (TrackedCallback::IsPending(decode_callback_))
+    decode_callback_->Abort();
+  decode_callback_ = NULL;
+  if (TrackedCallback::IsPending(get_picture_callback_))
+    get_picture_callback_->Abort();
+  get_picture_callback_ = NULL;
+  Call<PpapiPluginMsg_VideoDecoder_ResetReply>(
+      RENDERER,
+      PpapiHostMsg_VideoDecoder_Reset(),
+      base::Bind(&VideoDecoderResource::OnPluginMsgResetComplete, this));
+
+  return PP_OK_COMPLETIONPENDING;
+}
+
+void VideoDecoderResource::OnReplyReceived(
+    const ResourceMessageReplyParams& params,
+    const IPC::Message& msg) {
+  PPAPI_BEGIN_MESSAGE_MAP(VideoDecoderResource, msg)
+    PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
+        PpapiPluginMsg_VideoDecoder_RequestTextures, OnPluginMsgRequestTextures)
+    PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
+        PpapiPluginMsg_VideoDecoder_PictureReady, OnPluginMsgPictureReady)
+    PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
+        PpapiPluginMsg_VideoDecoder_DismissPicture, OnPluginMsgDismissPicture)
+    PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
+        PpapiPluginMsg_VideoDecoder_NotifyError, OnPluginMsgNotifyError)
+    PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL_UNHANDLED(
+        PluginResource::OnReplyReceived(params, msg))
+  PPAPI_END_MESSAGE_MAP()
+}
+
+void VideoDecoderResource::SetForTest() {
+  testing_ = true;
+}
+
+void VideoDecoderResource::OnPluginMsgRequestTextures(
+    const ResourceMessageReplyParams& params,
+    uint32_t num_textures,
+    const PP_Size& size,
+    uint32_t texture_target) {
+  DCHECK(num_textures);
+  std::vector<uint32_t> texture_ids(num_textures);
+  if (gles2_impl_) {
+    gles2_impl_->GenTextures(num_textures, &texture_ids.front());
+    for (uint32_t i = 0; i < num_textures; ++i) {
+      gles2_impl_->ActiveTexture(GL_TEXTURE0);
+      gles2_impl_->BindTexture(texture_target, texture_ids[i]);
+      gles2_impl_->TexParameteri(
+          texture_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+      gles2_impl_->TexParameteri(
+          texture_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+      gles2_impl_->TexParameterf(
+          texture_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+      gles2_impl_->TexParameterf(
+          texture_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+      if (texture_target == GL_TEXTURE_2D) {
+        gles2_impl_->TexImage2D(texture_target,
+                                0,
+                                GL_RGBA,
+                                size.width,
+                                size.height,
+                                0,
+                                GL_RGBA,
+                                GL_UNSIGNED_BYTE,
+                                NULL);
+      }
+
+      textures_.insert(
+          std::make_pair(texture_ids[i], Texture(texture_target, size)));
+    }
+    gles2_impl_->Flush();
+  } else if (testing_) {
+    // Create some fake texture ids so we can test picture handling.
+    for (uint32_t i = 0; i < num_textures; ++i) {
+      texture_ids[i] = i + 1;
+      textures_.insert(
+          std::make_pair(texture_ids[i], Texture(texture_target, size)));
+    }
+  }
+
+  Post(RENDERER, PpapiHostMsg_VideoDecoder_AssignTextures(size, texture_ids));
+}
+
+void VideoDecoderResource::OnPluginMsgPictureReady(
+    const ResourceMessageReplyParams& params,
+    uint32_t decode_id,
+    uint32_t texture_id) {
+  received_pictures_.push(Picture(decode_id, texture_id));
+  // Prepare to accept another call to GetPicture in the callback.
+  scoped_refptr<TrackedCallback> callback;
+  callback.swap(get_picture_callback_);
+  PP_VideoPicture* picture = get_picture_;
+  get_picture_ = NULL;
+  if (TrackedCallback::IsPending(callback)) {
+    WriteNextPicture(picture);
+    callback->Run(PP_OK);
+  }
+}
+
+void VideoDecoderResource::OnPluginMsgDismissPicture(
+    const ResourceMessageReplyParams& params,
+    uint32_t texture_id) {
+  DeleteGLTexture(texture_id);
+  textures_.erase(texture_id);
+}
+
+void VideoDecoderResource::OnPluginMsgNotifyError(
+    const ResourceMessageReplyParams& params,
+    int32_t error) {
+  decoder_last_error_ = error;
+  // Cause any pending Decode or GetPicture callbacks to run immediately.
+  // Reentrancy isn't a problem, since the resource is unusable now.
+  if (TrackedCallback::IsPending(decode_callback_))
+    decode_callback_->Run(decoder_last_error_);
+  decode_callback_ = NULL;
+  if (TrackedCallback::IsPending(get_picture_callback_))
+    get_picture_callback_->Run(decoder_last_error_);
+  get_picture_callback_ = NULL;
+}
+
+void VideoDecoderResource::OnPluginMsgInitializeComplete(
+    const ResourceMessageReplyParams& params) {
+  decoder_last_error_ = params.result();
+  if (decoder_last_error_ == PP_OK)
+    initialized_ = true;
+
+  // Let the plugin call Initialize again from its callback in case of failure.
+  scoped_refptr<TrackedCallback> callback;
+  callback.swap(initialize_callback_);
+  callback->Run(decoder_last_error_);
+}
+
+void VideoDecoderResource::OnPluginMsgGetShmComplete(
+    const ResourceMessageReplyParams& params,
+    uint32_t size) {
+  get_shm_buffer_pending_ = false;
+  int32_t result = params.result();
+  if (result == PP_OK) {
+    base::SharedMemoryHandle shm_handle = base::SharedMemory::NULLHandle();
+    if (!params.TakeSharedMemoryHandleAtIndex(0, &shm_handle)) {
+      RunDecodeCallback(PP_ERROR_FAILED);
+      return;
+    }
+    uint32_t shm_id = static_cast<uint32_t>(shm_buffers_.size());
+    scoped_ptr<ShmBuffer> shm_buffer(
+        new ShmBuffer(new base::SharedMemory(shm_handle, false /* read_only */),
+                      size,
+                      shm_id));
+    if (!shm_buffer->addr) {
+      RunDecodeCallback(PP_ERROR_FAILED);
+      return;
+    }
+    shm_buffers_.push_back(shm_buffer.release());
+    SendDecodeMessage(shm_id);
+    RunDecodeCallback(PP_OK);
+  }
+}
+
+void VideoDecoderResource::OnPluginMsgDecodeComplete(
+    const ResourceMessageReplyParams& params,
+    uint32_t shm_id) {
+  pending_decode_count_--;
+  // Return the shm buffer to the available list.
+  if (shm_id < shm_buffers_.size())
+    available_shm_buffers_.push_back(shm_buffers_[shm_id]);
+  else
+    NOTREACHED();
+
+  // If a Decode is pending, and we're not waiting for a shm buffer, attempt
+  // the Decode again.
+  if (decode_callback_ && !get_shm_buffer_pending_) {
+    int32_t result =
+        TryDecode(decode_id_, decode_size_, decode_buffer_, decode_callback_);
+    if (result == PP_OK)
+      RunDecodeCallback(PP_OK);
+  }
+}
+
+void VideoDecoderResource::OnPluginMsgFlushComplete(
+    const ResourceMessageReplyParams& params) {
+  if (get_picture_callback_) {
+    scoped_refptr<TrackedCallback> callback;
+    callback.swap(get_picture_callback_);
+    callback->Abort();
+  }
+
+  scoped_refptr<TrackedCallback> callback;
+  callback.swap(flush_callback_);
+  callback->Run(params.result());
+}
+
+void VideoDecoderResource::OnPluginMsgResetComplete(
+    const ResourceMessageReplyParams& params) {
+  scoped_refptr<TrackedCallback> callback;
+  callback.swap(reset_callback_);
+  callback->Run(params.result());
+}
+
+int32_t VideoDecoderResource::TryDecode(
+    uint32_t decode_id,
+    uint32_t size,
+    const void* buffer,
+    scoped_refptr<TrackedCallback> callback) {
+  decode_id_ = decode_id;
+  decode_size_ = size;
+  decode_buffer_ = buffer;
+  if (available_shm_buffers_.empty() ||
+      available_shm_buffers_.back()->size < size) {

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

The way I'm reading this, it seems like you may or may not have a big enough
buffer inside available_shm_buffers_, but you only check the last one. And their
order is essentially arbitrary, I think.

You're on the edge of basically making an allocator here, and I think as
written, it's going to be a wasteful one. Can we consider a different way to do
this? I was going to suggest a circular buffer again, but then I saw that the
media backend works in terms of shmem ids :-/. (It seems like it would be nice
if maybe those could deal with shmem id + offset + size, so you could use share
a shmem buffer across decode calls).

In the absence of that, you might want to make the code a little smarter. E.g.,
use a container that's ordered by size (probably doesn't matter what kind, since
it's fairly small). You can then find the smallest available buffer that's big
enough and use it. (You can use lower_bound or upper_bound or jsut linear
search, since it should be a small list). Only if no buffers are big enough do
you request a new one.

You're also not bounding how many shmem buffers you have or expiring them. As a
first cut, would it make sense to set a limit on the number of buffers? You
might even reasonably cap it at kMaximumPendingDecodes. Any time you have
available buffers but none are large enough, take the smallest one and recycle
it and request a new, bigger one.

As a completely different idea, you could use 1 big circular buffer between the
plugin and renderer that is just for pushing "Decode" data to the renderer. I'm
guessing there's some reason the decode stuff in media can't use s circular
buffer, but you could conform to their API by keeping the pool of shmem blocks
in the renderer. That would just save you all this cross-process dancing with
the multiple shmem buffers. But it would cost you a copy in the renderer, to go
from the circular buffer in to the shmem block to pass to media decode API. So
perhaps it's not worth it.

[bbudge, 2014/05/15 22:27:44]

I've been worried about this too.

This technique is actually cribbed from media code. I think it works because it
makes sure the buffers are pretty big (100K bytes). I was hoping Ami can provide
some guidance here when he does his review. Here's an example of this:

https://code.google.com/p/chromium/codesearch#chromium/src/media/filters/gpu_...

I've considered being a little smarter about sizing and bounding the number of
the buffers, but trying to keep it simple until I know I need more.

+    decode_callback_ = callback;
+
+    if (pending_decode_count_ < kMaximumPendingDecodes) {
+      get_shm_buffer_pending_ = true;
+      uint32_t alloc_size = std::max(size, kMinimumBitstreamBufferSize);
+      Call<PpapiPluginMsg_VideoDecoder_GetShmReply>(
+          RENDERER,
+          PpapiHostMsg_VideoDecoder_GetShm(alloc_size),
+          base::Bind(&VideoDecoderResource::OnPluginMsgGetShmComplete, this));
+    }
+
+    return PP_OK_COMPLETIONPENDING;
+  }
+
+  ShmBuffer* shm_buffer = available_shm_buffers_.back();
+  available_shm_buffers_.pop_back();
+  SendDecodeMessage(shm_buffer->shm_id);
+  return PP_OK;
+}
+
+void VideoDecoderResource::SendDecodeMessage(uint32_t shm_id) {
+  DCHECK(shm_id < shm_buffers_.size());
+  ShmBuffer* shm_buffer = shm_buffers_[shm_id];
+  memcpy(shm_buffer->addr, decode_buffer_, decode_size_);
+  pending_decode_count_++;
+
+  Call<PpapiPluginMsg_VideoDecoder_DecodeReply>(
+      RENDERER,
+      PpapiHostMsg_VideoDecoder_Decode(shm_id, decode_id_, decode_size_),
+      base::Bind(&VideoDecoderResource::OnPluginMsgDecodeComplete, this));
+}
+
+void VideoDecoderResource::RunDecodeCallback(int32_t result) {
+  scoped_refptr<TrackedCallback> callback;
+  callback.swap(decode_callback_);
+  callback->Run(result);
+}
+
+void VideoDecoderResource::DeleteGLTexture(uint32_t id) {
+  if (gles2_impl_) {
+    gles2_impl_->DeleteTextures(1, &id);
+    gles2_impl_->Flush();
+  }
+}
+
+void VideoDecoderResource::WriteNextPicture(PP_VideoPicture* pp_picture) {
+  DCHECK(!received_pictures_.empty());
+  Picture& picture = received_pictures_.front();
+  uint32_t texture_id = picture.texture_id;
+  TextureMap::iterator it = textures_.find(texture_id);
+  DCHECK(it != textures_.end());
+  pp_picture->decode_id = picture.decode_id;
+  pp_picture->texture_id = texture_id;
+  pp_picture->texture_target = it->second.texture_target;
+  pp_picture->texture_size = it->second.size;
+  received_pictures_.pop();
+}
+
+}  // namespace proxy
+}  // namespace ppapi