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