ppapi/proxy/video_decoder_resource.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "ppapi/proxy/video_decoder_resource.h"
   6
   7 #include "base/bind.h"
   8 #include "gpu/command_buffer/client/gles2_cmd_helper.h"
   9 #include "gpu/command_buffer/client/gles2_implementation.h"
  10 #include "ipc/ipc_message.h"
  11 #include "ppapi/c/pp_errors.h"
  12 #include "ppapi/c/ppb_opengles2.h"
  13 #include "ppapi/proxy/plugin_dispatcher.h"
  14 #include "ppapi/proxy/ppapi_messages.h"
  15 #include "ppapi/proxy/ppb_graphics_3d_proxy.h"
  16 #include "ppapi/proxy/serialized_handle.h"
  17 #include "ppapi/proxy/video_decoder_constants.h"
  18 #include "ppapi/shared_impl/ppapi_globals.h"
  19 #include "ppapi/shared_impl/ppb_graphics_3d_shared.h"
  20 #include "ppapi/shared_impl/proxy_lock.h"
  21 #include "ppapi/shared_impl/resource_tracker.h"
  22 #include "ppapi/thunk/enter.h"
  23
  24 using ppapi::thunk::EnterResourceNoLock;
  25 using ppapi::thunk::PPB_Graphics3D_API;
  26 using ppapi::thunk::PPB_VideoDecoder_API;
  27
  28 namespace ppapi {
  29 namespace proxy {
  30
  31 VideoDecoderResource::ShmBuffer::ShmBuffer(
  32     scoped_ptr<base::SharedMemory> shm_ptr,
  33     uint32_t size,
  34     uint32_t shm_id)
  35     : shm(shm_ptr.Pass()), addr(NULL), shm_id(shm_id) {
  36   if (shm->Map(size))
  37     addr = shm->memory();
  38 }
  39
  40 VideoDecoderResource::ShmBuffer::~ShmBuffer() {
  41 }
  42
  43 VideoDecoderResource::Texture::Texture(uint32_t texture_target,
  44                                        const PP_Size& size)
  45     : texture_target(texture_target), size(size) {
  46 }
  47
  48 VideoDecoderResource::Texture::~Texture() {
  49 }
  50
  51 VideoDecoderResource::Picture::Picture(int32_t decode_id, uint32_t texture_id)
  52     : decode_id(decode_id), texture_id(texture_id) {
  53 }
  54
  55 VideoDecoderResource::Picture::~Picture() {
  56 }
  57
  58 VideoDecoderResource::VideoDecoderResource(Connection connection,
  59                                            PP_Instance instance)
  60     : PluginResource(connection, instance),
  61       num_decodes_(0),
  62       get_picture_(NULL),
  63       gles2_impl_(NULL),
  64       initialized_(false),
  65       testing_(false),
  66       // Set |decoder_last_error_| to PP_OK after successful initialization.
  67       // This makes error checking a little more concise, since we can check
  68       // that the decoder has been initialized and hasn't returned an error by
  69       // just testing |decoder_last_error_|.
  70       decoder_last_error_(PP_ERROR_FAILED) {
  71   // Clear the decode_ids_ array.
  72   memset(decode_ids_, 0, arraysize(decode_ids_));
  73   SendCreate(RENDERER, PpapiHostMsg_VideoDecoder_Create());
  74 }
  75
  76 VideoDecoderResource::~VideoDecoderResource() {
  77   // Destroy any textures which haven't been dismissed.
  78   TextureMap::iterator it = textures_.begin();
  79   for (; it != textures_.end(); ++it)
  80     DeleteGLTexture(it->first);
  81 }
  82
  83 PPB_VideoDecoder_API* VideoDecoderResource::AsPPB_VideoDecoder_API() {
  84   return this;
  85 }
  86
  87 int32_t VideoDecoderResource::Initialize(
  88     PP_Resource graphics_context,
  89     PP_VideoProfile profile,
  90     PP_Bool allow_software_fallback,
  91     scoped_refptr<TrackedCallback> callback) {
  92   if (initialized_)
  93     return PP_ERROR_FAILED;
  94   if (profile < 0 || profile > PP_VIDEOPROFILE_MAX)
  95     return PP_ERROR_BADARGUMENT;
  96   if (initialize_callback_)
  97     return PP_ERROR_INPROGRESS;
  98   if (!graphics_context)
  99     return PP_ERROR_BADRESOURCE;
 100
 101   HostResource host_resource;
 102   if (!testing_) {
 103     // Create a new Graphics3D resource that can create texture resources to
 104     // share with the plugin. We can't use the plugin's Graphics3D, since we
 105     // create textures on a proxy thread, and would interfere with the plugin.
 106     thunk::EnterResourceCreationNoLock enter_create(pp_instance());
 107     if (enter_create.failed())
 108       return PP_ERROR_FAILED;
 109     int32_t attrib_list[] = {PP_GRAPHICS3DATTRIB_NONE};
 110     graphics3d_ =
 111         ScopedPPResource(ScopedPPResource::PassRef(),
 112                          enter_create.functions()->CreateGraphics3D(
 113                              pp_instance(), graphics_context, attrib_list));
 114     EnterResourceNoLock<PPB_Graphics3D_API> enter_graphics(graphics3d_.get(),
 115                                                            true);
 116     if (enter_graphics.failed())
 117       return PP_ERROR_BADRESOURCE;
 118
 119     PPB_Graphics3D_Shared* ppb_graphics3d_shared =
 120         static_cast<PPB_Graphics3D_Shared*>(enter_graphics.object());
 121     gles2_impl_ = ppb_graphics3d_shared->gles2_impl();
 122     host_resource = ppb_graphics3d_shared->host_resource();
 123   }
 124
 125   initialize_callback_ = callback;
 126
 127   Call<PpapiPluginMsg_VideoDecoder_InitializeReply>(
 128       RENDERER,
 129       PpapiHostMsg_VideoDecoder_Initialize(
 130           host_resource, profile, PP_ToBool(allow_software_fallback)),
 131       base::Bind(&VideoDecoderResource::OnPluginMsgInitializeComplete, this));
 132
 133   return PP_OK_COMPLETIONPENDING;
 134 }
 135
 136 int32_t VideoDecoderResource::Decode(uint32_t decode_id,
 137                                      uint32_t size,
 138                                      const void* buffer,
 139                                      scoped_refptr<TrackedCallback> callback) {
 140   if (decoder_last_error_)
 141     return decoder_last_error_;
 142   if (flush_callback_ || reset_callback_)
 143     return PP_ERROR_FAILED;
 144   if (decode_callback_)
 145     return PP_ERROR_INPROGRESS;
 146   if (size > kMaximumBitstreamBufferSize)
 147     return PP_ERROR_NOMEMORY;
 148
 149   // If we allow the plugin to call Decode again, we must have somewhere to
 150   // copy their buffer.
 151   DCHECK(!available_shm_buffers_.empty() ||
 152          shm_buffers_.size() < kMaximumPendingDecodes);
 153
 154   // Count up, wrapping back to 0 before overflowing.
 155   int32_t uid = ++num_decodes_;
 156   if (uid == std::numeric_limits<int32_t>::max())
 157     num_decodes_ = 0;
 158
 159   // Save decode_id in a ring buffer. The ring buffer is sized to store
 160   // decode_id for the maximum picture delay.
 161   decode_ids_[uid % kMaximumPictureDelay] = decode_id;
 162
 163   if (available_shm_buffers_.empty() ||
 164       available_shm_buffers_.back()->shm->mapped_size() < size) {
 165     uint32_t shm_id;
 166     if (shm_buffers_.size() < kMaximumPendingDecodes) {
 167       // Signal the host to create a new shm buffer by passing an index outside
 168       // the legal range.
 169       shm_id = static_cast<uint32_t>(shm_buffers_.size());
 170     } else {
 171       // Signal the host to grow a buffer by passing a legal index. Choose the
 172       // last available shm buffer for simplicity.
 173       shm_id = available_shm_buffers_.back()->shm_id;
 174       available_shm_buffers_.pop_back();
 175     }
 176
 177     // Synchronously get shared memory. Use GenericSyncCall so we can get the
 178     // reply params, which contain the handle.
 179     uint32_t shm_size = 0;
 180     IPC::Message reply;
 181     ResourceMessageReplyParams reply_params;
 182     int32_t result =
 183         GenericSyncCall(RENDERER,
 184                         PpapiHostMsg_VideoDecoder_GetShm(shm_id, size),
 185                         &reply,
 186                         &reply_params);
 187     if (result != PP_OK)
 188       return PP_ERROR_FAILED;
 189     if (!UnpackMessage<PpapiPluginMsg_VideoDecoder_GetShmReply>(reply,
 190                                                                 &shm_size))
 191       return PP_ERROR_FAILED;
 192     base::SharedMemoryHandle shm_handle = base::SharedMemory::NULLHandle();
 193     if (!reply_params.TakeSharedMemoryHandleAtIndex(0, &shm_handle))
 194       return PP_ERROR_NOMEMORY;
 195     scoped_ptr<base::SharedMemory> shm(
 196         new base::SharedMemory(shm_handle, false /* read_only */));
 197     scoped_ptr<ShmBuffer> shm_buffer(
 198         new ShmBuffer(shm.Pass(), shm_size, shm_id));
 199     if (!shm_buffer->addr)
 200       return PP_ERROR_NOMEMORY;
 201
 202     available_shm_buffers_.push_back(shm_buffer.get());
 203     if (shm_buffers_.size() < kMaximumPendingDecodes) {
 204       shm_buffers_.push_back(shm_buffer.release());
 205     } else {
 206       // Delete manually since ScopedVector won't delete the existing element if
 207       // we just assign it.
 208       delete shm_buffers_[shm_id];
 209       shm_buffers_[shm_id] = shm_buffer.release();
 210     }
 211   }
 212
 213   // At this point we should have shared memory to hold the plugin's buffer.
 214   DCHECK(!available_shm_buffers_.empty() &&
 215          available_shm_buffers_.back()->shm->mapped_size() >= size);
 216
 217   ShmBuffer* shm_buffer = available_shm_buffers_.back();
 218   available_shm_buffers_.pop_back();
 219   memcpy(shm_buffer->addr, buffer, size);
 220
 221   Call<PpapiPluginMsg_VideoDecoder_DecodeReply>(
 222       RENDERER,
 223       PpapiHostMsg_VideoDecoder_Decode(shm_buffer->shm_id, size, uid),
 224       base::Bind(&VideoDecoderResource::OnPluginMsgDecodeComplete, this));
 225
 226   // If we have another free buffer, or we can still create new buffers, let
 227   // the plugin call Decode again.
 228   if (!available_shm_buffers_.empty() ||
 229       shm_buffers_.size() < kMaximumPendingDecodes)
 230     return PP_OK;
 231
 232   // All buffers are busy and we can't create more. Delay completion until a
 233   // buffer is available.
 234   decode_callback_ = callback;
 235   return PP_OK_COMPLETIONPENDING;
 236 }
 237
 238 int32_t VideoDecoderResource::GetPicture(
 239     PP_VideoPicture* picture,
 240     scoped_refptr<TrackedCallback> callback) {
 241   if (decoder_last_error_)
 242     return decoder_last_error_;
 243   if (reset_callback_)
 244     return PP_ERROR_FAILED;
 245   if (get_picture_callback_)
 246     return PP_ERROR_INPROGRESS;
 247
 248   // If the next picture is ready, return it synchronously.
 249   if (!received_pictures_.empty()) {
 250     WriteNextPicture(picture);
 251     return PP_OK;
 252   }
 253
 254   get_picture_callback_ = callback;
 255   get_picture_ = picture;
 256   return PP_OK_COMPLETIONPENDING;
 257 }
 258
 259 void VideoDecoderResource::RecyclePicture(const PP_VideoPicture* picture) {
 260   if (decoder_last_error_)
 261     return;
 262   if (reset_callback_)
 263     return;
 264
 265   Post(RENDERER, PpapiHostMsg_VideoDecoder_RecyclePicture(picture->texture_id));
 266 }
 267
 268 int32_t VideoDecoderResource::Flush(scoped_refptr<TrackedCallback> callback) {
 269   if (decoder_last_error_)
 270     return decoder_last_error_;
 271   if (reset_callback_)
 272     return PP_ERROR_FAILED;
 273   if (flush_callback_)
 274     return PP_ERROR_INPROGRESS;
 275   flush_callback_ = callback;
 276
 277   Call<PpapiPluginMsg_VideoDecoder_FlushReply>(
 278       RENDERER,
 279       PpapiHostMsg_VideoDecoder_Flush(),
 280       base::Bind(&VideoDecoderResource::OnPluginMsgFlushComplete, this));
 281
 282   return PP_OK_COMPLETIONPENDING;
 283 }
 284
 285 int32_t VideoDecoderResource::Reset(scoped_refptr<TrackedCallback> callback) {
 286   if (decoder_last_error_)
 287     return decoder_last_error_;
 288   if (flush_callback_)
 289     return PP_ERROR_FAILED;
 290   if (reset_callback_)
 291     return PP_ERROR_INPROGRESS;
 292   reset_callback_ = callback;
 293
 294   // Cause any pending Decode or GetPicture callbacks to abort after we return,
 295   // to avoid reentering the plugin.
 296   if (TrackedCallback::IsPending(decode_callback_))
 297     decode_callback_->PostAbort();
 298   decode_callback_ = NULL;
 299   if (TrackedCallback::IsPending(get_picture_callback_))
 300     get_picture_callback_->PostAbort();
 301   get_picture_callback_ = NULL;
 302   Call<PpapiPluginMsg_VideoDecoder_ResetReply>(
 303       RENDERER,
 304       PpapiHostMsg_VideoDecoder_Reset(),
 305       base::Bind(&VideoDecoderResource::OnPluginMsgResetComplete, this));
 306
 307   return PP_OK_COMPLETIONPENDING;
 308 }
 309
 310 void VideoDecoderResource::OnReplyReceived(
 311     const ResourceMessageReplyParams& params,
 312     const IPC::Message& msg) {
 313   PPAPI_BEGIN_MESSAGE_MAP(VideoDecoderResource, msg)
 314     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
 315         PpapiPluginMsg_VideoDecoder_RequestTextures, OnPluginMsgRequestTextures)
 316     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
 317         PpapiPluginMsg_VideoDecoder_PictureReady, OnPluginMsgPictureReady)
 318     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
 319         PpapiPluginMsg_VideoDecoder_DismissPicture, OnPluginMsgDismissPicture)
 320     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL(
 321         PpapiPluginMsg_VideoDecoder_NotifyError, OnPluginMsgNotifyError)
 322     PPAPI_DISPATCH_PLUGIN_RESOURCE_CALL_UNHANDLED(
 323         PluginResource::OnReplyReceived(params, msg))
 324   PPAPI_END_MESSAGE_MAP()
 325 }
 326
 327 void VideoDecoderResource::SetForTest() {
 328   testing_ = true;
 329 }
 330
 331 void VideoDecoderResource::OnPluginMsgRequestTextures(
 332     const ResourceMessageReplyParams& params,
 333     uint32_t num_textures,
 334     const PP_Size& size,
 335     uint32_t texture_target) {
 336   DCHECK(num_textures);
 337   std::vector<uint32_t> texture_ids(num_textures);
 338   if (gles2_impl_) {
 339     gles2_impl_->GenTextures(num_textures, &texture_ids.front());
 340     for (uint32_t i = 0; i < num_textures; ++i) {
 341       gles2_impl_->ActiveTexture(GL_TEXTURE0);
 342       gles2_impl_->BindTexture(texture_target, texture_ids[i]);
 343       gles2_impl_->TexParameteri(
 344           texture_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 345       gles2_impl_->TexParameteri(
 346           texture_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 347       gles2_impl_->TexParameterf(
 348           texture_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 349       gles2_impl_->TexParameterf(
 350           texture_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 351
 352       if (texture_target == GL_TEXTURE_2D) {
 353         gles2_impl_->TexImage2D(texture_target,
 354                                 0,
 355                                 GL_RGBA,
 356                                 size.width,
 357                                 size.height,
 358                                 0,
 359                                 GL_RGBA,
 360                                 GL_UNSIGNED_BYTE,
 361                                 NULL);
 362       }
 363
 364       textures_.insert(
 365           std::make_pair(texture_ids[i], Texture(texture_target, size)));
 366     }
 367     gles2_impl_->Flush();
 368   } else {
 369     DCHECK(testing_);
 370     // Create some fake texture ids so we can test picture handling.
 371     for (uint32_t i = 0; i < num_textures; ++i) {
 372       texture_ids[i] = i + 1;
 373       textures_.insert(
 374           std::make_pair(texture_ids[i], Texture(texture_target, size)));
 375     }
 376   }
 377
 378   Post(RENDERER, PpapiHostMsg_VideoDecoder_AssignTextures(size, texture_ids));
 379 }
 380
 381 void VideoDecoderResource::OnPluginMsgPictureReady(
 382     const ResourceMessageReplyParams& params,
 383     int32_t decode_id,
 384     uint32_t texture_id) {
 385   received_pictures_.push(Picture(decode_id, texture_id));
 386
 387   if (TrackedCallback::IsPending(get_picture_callback_)) {
 388     // The plugin may call GetPicture in its callback.
 389     scoped_refptr<TrackedCallback> callback;
 390     callback.swap(get_picture_callback_);
 391     PP_VideoPicture* picture = get_picture_;
 392     get_picture_ = NULL;
 393     WriteNextPicture(picture);
 394     callback->Run(PP_OK);
 395   }
 396 }
 397
 398 void VideoDecoderResource::OnPluginMsgDismissPicture(
 399     const ResourceMessageReplyParams& params,
 400     uint32_t texture_id) {
 401   DeleteGLTexture(texture_id);
 402   textures_.erase(texture_id);
 403 }
 404
 405 void VideoDecoderResource::OnPluginMsgNotifyError(
 406     const ResourceMessageReplyParams& params,
 407     int32_t error) {
 408   decoder_last_error_ = error;
 409   // Cause any pending callbacks to run immediately. Reentrancy isn't a problem,
 410   // since the plugin wasn't calling us.
 411   RunCallbackWithError(&initialize_callback_);
 412   RunCallbackWithError(&decode_callback_);
 413   RunCallbackWithError(&get_picture_callback_);
 414   RunCallbackWithError(&flush_callback_);
 415   RunCallbackWithError(&reset_callback_);
 416 }
 417
 418 void VideoDecoderResource::OnPluginMsgInitializeComplete(
 419     const ResourceMessageReplyParams& params) {
 420   decoder_last_error_ = params.result();
 421   if (decoder_last_error_ == PP_OK)
 422     initialized_ = true;
 423
 424   // Let the plugin call Initialize again from its callback in case of failure.
 425   scoped_refptr<TrackedCallback> callback;
 426   callback.swap(initialize_callback_);
 427   callback->Run(decoder_last_error_);
 428 }
 429
 430 void VideoDecoderResource::OnPluginMsgDecodeComplete(
 431     const ResourceMessageReplyParams& params,
 432     uint32_t shm_id) {
 433   if (shm_id >= shm_buffers_.size()) {
 434     NOTREACHED();
 435     return;
 436   }
 437   // Make the shm buffer available.
 438   available_shm_buffers_.push_back(shm_buffers_[shm_id]);
 439   // If the plugin is waiting, let it call Decode again.
 440   if (decode_callback_) {
 441     scoped_refptr<TrackedCallback> callback;
 442     callback.swap(decode_callback_);
 443     callback->Run(PP_OK);
 444   }
 445 }
 446
 447 void VideoDecoderResource::OnPluginMsgFlushComplete(
 448     const ResourceMessageReplyParams& params) {
 449   // All shm buffers should have been made available by now.
 450   DCHECK_EQ(shm_buffers_.size(), available_shm_buffers_.size());
 451
 452   if (get_picture_callback_) {
 453     scoped_refptr<TrackedCallback> callback;
 454     callback.swap(get_picture_callback_);
 455     callback->Abort();
 456   }
 457
 458   scoped_refptr<TrackedCallback> callback;
 459   callback.swap(flush_callback_);
 460   callback->Run(params.result());
 461 }
 462
 463 void VideoDecoderResource::OnPluginMsgResetComplete(
 464     const ResourceMessageReplyParams& params) {
 465   // All shm buffers should have been made available by now.
 466   DCHECK_EQ(shm_buffers_.size(), available_shm_buffers_.size());
 467   scoped_refptr<TrackedCallback> callback;
 468   callback.swap(reset_callback_);
 469   callback->Run(params.result());
 470 }
 471
 472 void VideoDecoderResource::RunCallbackWithError(
 473     scoped_refptr<TrackedCallback>* callback) {
 474   if (TrackedCallback::IsPending(*callback)) {
 475     scoped_refptr<TrackedCallback> temp;
 476     callback->swap(temp);
 477     temp->Run(decoder_last_error_);
 478   }
 479 }
 480
 481 void VideoDecoderResource::DeleteGLTexture(uint32_t id) {
 482   if (gles2_impl_) {
 483     gles2_impl_->DeleteTextures(1, &id);
 484     gles2_impl_->Flush();
 485   }
 486 }
 487
 488 void VideoDecoderResource::WriteNextPicture(PP_VideoPicture* pp_picture) {
 489   DCHECK(!received_pictures_.empty());
 490   Picture& picture = received_pictures_.front();
 491   // Internally, we identify decodes by a unique id, which the host returns
 492   // to us in the picture. Use this to get the plugin's decode_id.
 493   pp_picture->decode_id = decode_ids_[picture.decode_id % kMaximumPictureDelay];
 494   pp_picture->texture_id = picture.texture_id;
 495   TextureMap::iterator it = textures_.find(picture.texture_id);
 496   if (it != textures_.end()) {
 497     pp_picture->texture_target = it->second.texture_target;
 498     pp_picture->texture_size = it->second.size;
 499   } else {
 500     NOTREACHED();
 501   }
 502   received_pictures_.pop();
 503 }
 504
 505 }  // namespace proxy
 506 }  // namespace ppapi