Home | History | Annotate | Download | only in pepper 
      1 // Copyright (c) 2014 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 "content/renderer/pepper/pepper_video_decoder_host.h"
      6 
      7 #include "base/bind.h"
      8 #include "base/memory/shared_memory.h"
      9 #include "content/common/gpu/client/gpu_channel_host.h"
     10 #include "content/public/renderer/render_thread.h"
     11 #include "content/public/renderer/renderer_ppapi_host.h"
     12 #include "content/renderer/pepper/ppb_graphics_3d_impl.h"
     13 #include "content/renderer/pepper/video_decoder_shim.h"
     14 #include "media/video/video_decode_accelerator.h"
     15 #include "ppapi/c/pp_completion_callback.h"
     16 #include "ppapi/c/pp_errors.h"
     17 #include "ppapi/host/dispatch_host_message.h"
     18 #include "ppapi/host/ppapi_host.h"
     19 #include "ppapi/proxy/ppapi_messages.h"
     20 #include "ppapi/proxy/video_decoder_constants.h"
     21 #include "ppapi/thunk/enter.h"
     22 #include "ppapi/thunk/ppb_graphics_3d_api.h"
     23 
     24 using ppapi::proxy::SerializedHandle;
     25 using ppapi::thunk::EnterResourceNoLock;
     26 using ppapi::thunk::PPB_Graphics3D_API;
     27 
     28 namespace content {
     29 
     30 namespace {
     31 
     32 media::VideoCodecProfile PepperToMediaVideoProfile(PP_VideoProfile profile) {
     33   switch (profile) {
     34     case PP_VIDEOPROFILE_H264BASELINE:
     35       return media::H264PROFILE_BASELINE;
     36     case PP_VIDEOPROFILE_H264MAIN:
     37       return media::H264PROFILE_MAIN;
     38     case PP_VIDEOPROFILE_H264EXTENDED:
     39       return media::H264PROFILE_EXTENDED;
     40     case PP_VIDEOPROFILE_H264HIGH:
     41       return media::H264PROFILE_HIGH;
     42     case PP_VIDEOPROFILE_H264HIGH10PROFILE:
     43       return media::H264PROFILE_HIGH10PROFILE;
     44     case PP_VIDEOPROFILE_H264HIGH422PROFILE:
     45       return media::H264PROFILE_HIGH422PROFILE;
     46     case PP_VIDEOPROFILE_H264HIGH444PREDICTIVEPROFILE:
     47       return media::H264PROFILE_HIGH444PREDICTIVEPROFILE;
     48     case PP_VIDEOPROFILE_H264SCALABLEBASELINE:
     49       return media::H264PROFILE_SCALABLEBASELINE;
     50     case PP_VIDEOPROFILE_H264SCALABLEHIGH:
     51       return media::H264PROFILE_SCALABLEHIGH;
     52     case PP_VIDEOPROFILE_H264STEREOHIGH:
     53       return media::H264PROFILE_STEREOHIGH;
     54     case PP_VIDEOPROFILE_H264MULTIVIEWHIGH:
     55       return media::H264PROFILE_MULTIVIEWHIGH;
     56     case PP_VIDEOPROFILE_VP8MAIN:
     57       return media::VP8PROFILE_MAIN;
     58     case PP_VIDEOPROFILE_VP9MAIN:
     59       return media::VP9PROFILE_MAIN;
     60     // No default case, to catch unhandled PP_VideoProfile values.
     61   }
     62 
     63   return media::VIDEO_CODEC_PROFILE_UNKNOWN;
     64 }
     65 
     66 }  // namespace
     67 
     68 PepperVideoDecoderHost::PendingDecode::PendingDecode(
     69     uint32_t shm_id,
     70     const ppapi::host::ReplyMessageContext& reply_context)
     71     : shm_id(shm_id), reply_context(reply_context) {
     72 }
     73 
     74 PepperVideoDecoderHost::PendingDecode::~PendingDecode() {
     75 }
     76 
     77 PepperVideoDecoderHost::PepperVideoDecoderHost(RendererPpapiHost* host,
     78                                                PP_Instance instance,
     79                                                PP_Resource resource)
     80     : ResourceHost(host->GetPpapiHost(), instance, resource),
     81       renderer_ppapi_host_(host),
     82       initialized_(false) {
     83 }
     84 
     85 PepperVideoDecoderHost::~PepperVideoDecoderHost() {
     86 }
     87 
     88 int32_t PepperVideoDecoderHost::OnResourceMessageReceived(
     89     const IPC::Message& msg,
     90     ppapi::host::HostMessageContext* context) {
     91   PPAPI_BEGIN_MESSAGE_MAP(PepperVideoDecoderHost, msg)
     92     PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_VideoDecoder_Initialize,
     93                                       OnHostMsgInitialize)
     94     PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_VideoDecoder_GetShm,
     95                                       OnHostMsgGetShm)
     96     PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_VideoDecoder_Decode,
     97                                       OnHostMsgDecode)
     98     PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_VideoDecoder_AssignTextures,
     99                                       OnHostMsgAssignTextures)
    100     PPAPI_DISPATCH_HOST_RESOURCE_CALL(PpapiHostMsg_VideoDecoder_RecyclePicture,
    101                                       OnHostMsgRecyclePicture)
    102     PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(PpapiHostMsg_VideoDecoder_Flush,
    103                                         OnHostMsgFlush)
    104     PPAPI_DISPATCH_HOST_RESOURCE_CALL_0(PpapiHostMsg_VideoDecoder_Reset,
    105                                         OnHostMsgReset)
    106   PPAPI_END_MESSAGE_MAP()
    107   return PP_ERROR_FAILED;
    108 }
    109 
    110 int32_t PepperVideoDecoderHost::OnHostMsgInitialize(
    111     ppapi::host::HostMessageContext* context,
    112     const ppapi::HostResource& graphics_context,
    113     PP_VideoProfile profile,
    114     bool allow_software_fallback) {
    115   if (initialized_)
    116     return PP_ERROR_FAILED;
    117 
    118   EnterResourceNoLock<PPB_Graphics3D_API> enter_graphics(
    119       graphics_context.host_resource(), true);
    120   if (enter_graphics.failed())
    121     return PP_ERROR_FAILED;
    122   PPB_Graphics3D_Impl* graphics3d =
    123       static_cast<PPB_Graphics3D_Impl*>(enter_graphics.object());
    124 
    125   int command_buffer_route_id = graphics3d->GetCommandBufferRouteId();
    126   if (!command_buffer_route_id)
    127     return PP_ERROR_FAILED;
    128 
    129   media::VideoCodecProfile media_profile = PepperToMediaVideoProfile(profile);
    130 
    131   // This is not synchronous, but subsequent IPC messages will be buffered, so
    132   // it is okay to immediately send IPC messages through the returned channel.
    133   GpuChannelHost* channel = graphics3d->channel();
    134   DCHECK(channel);
    135   decoder_ = channel->CreateVideoDecoder(command_buffer_route_id);
    136   if (decoder_ && decoder_->Initialize(media_profile, this)) {
    137     initialized_ = true;
    138     return PP_OK;
    139   }
    140   decoder_.reset();
    141 
    142   if (!allow_software_fallback)
    143     return PP_ERROR_NOTSUPPORTED;
    144 
    145   decoder_.reset(new VideoDecoderShim(this));
    146   initialize_reply_context_ = context->MakeReplyMessageContext();
    147   decoder_->Initialize(media_profile, this);
    148 
    149   return PP_OK_COMPLETIONPENDING;
    150 }
    151 
    152 int32_t PepperVideoDecoderHost::OnHostMsgGetShm(
    153     ppapi::host::HostMessageContext* context,
    154     uint32_t shm_id,
    155     uint32_t shm_size) {
    156   if (!initialized_)
    157     return PP_ERROR_FAILED;
    158 
    159   // Make the buffers larger since we hope to reuse them.
    160   shm_size = std::max(
    161       shm_size,
    162       static_cast<uint32_t>(ppapi::proxy::kMinimumBitstreamBufferSize));
    163   if (shm_size > ppapi::proxy::kMaximumBitstreamBufferSize)
    164     return PP_ERROR_FAILED;
    165 
    166   if (shm_id >= ppapi::proxy::kMaximumPendingDecodes)
    167     return PP_ERROR_FAILED;
    168   // The shm_id must be inside or at the end of shm_buffers_.
    169   if (shm_id > shm_buffers_.size())
    170     return PP_ERROR_FAILED;
    171   // Reject an attempt to reallocate a busy shm buffer.
    172   if (shm_id < shm_buffers_.size() && shm_buffer_busy_[shm_id])
    173     return PP_ERROR_FAILED;
    174 
    175   content::RenderThread* render_thread = content::RenderThread::Get();
    176   scoped_ptr<base::SharedMemory> shm(
    177       render_thread->HostAllocateSharedMemoryBuffer(shm_size).Pass());
    178   if (!shm || !shm->Map(shm_size))
    179     return PP_ERROR_FAILED;
    180 
    181   base::SharedMemoryHandle shm_handle = shm->handle();
    182   if (shm_id == shm_buffers_.size()) {
    183     shm_buffers_.push_back(shm.release());
    184     shm_buffer_busy_.push_back(false);
    185   } else {
    186     // Remove the old buffer. Delete manually since ScopedVector won't delete
    187     // the existing element if we just assign over it.
    188     delete shm_buffers_[shm_id];
    189     shm_buffers_[shm_id] = shm.release();
    190   }
    191 
    192 #if defined(OS_WIN)
    193   base::PlatformFile platform_file = shm_handle;
    194 #elif defined(OS_POSIX)
    195   base::PlatformFile platform_file = shm_handle.fd;
    196 #else
    197 #error Not implemented.
    198 #endif
    199   SerializedHandle handle(
    200       renderer_ppapi_host_->ShareHandleWithRemote(platform_file, false),
    201       shm_size);
    202   ppapi::host::ReplyMessageContext reply_context =
    203       context->MakeReplyMessageContext();
    204   reply_context.params.AppendHandle(handle);
    205   host()->SendReply(reply_context,
    206                     PpapiPluginMsg_VideoDecoder_GetShmReply(shm_size));
    207 
    208   return PP_OK_COMPLETIONPENDING;
    209 }
    210 
    211 int32_t PepperVideoDecoderHost::OnHostMsgDecode(
    212     ppapi::host::HostMessageContext* context,
    213     uint32_t shm_id,
    214     uint32_t size,
    215     int32_t decode_id) {
    216   if (!initialized_)
    217     return PP_ERROR_FAILED;
    218   DCHECK(decoder_);
    219   // |shm_id| is just an index into shm_buffers_. Make sure it's in range.
    220   if (static_cast<size_t>(shm_id) >= shm_buffers_.size())
    221     return PP_ERROR_FAILED;
    222   // Reject an attempt to pass a busy buffer to the decoder again.
    223   if (shm_buffer_busy_[shm_id])
    224     return PP_ERROR_FAILED;
    225   // Reject non-unique decode_id values.
    226   if (pending_decodes_.find(decode_id) != pending_decodes_.end())
    227     return PP_ERROR_FAILED;
    228 
    229   if (flush_reply_context_.is_valid() || reset_reply_context_.is_valid())
    230     return PP_ERROR_FAILED;
    231 
    232   pending_decodes_.insert(std::make_pair(
    233       decode_id, PendingDecode(shm_id, context->MakeReplyMessageContext())));
    234 
    235   shm_buffer_busy_[shm_id] = true;
    236   decoder_->Decode(
    237       media::BitstreamBuffer(decode_id, shm_buffers_[shm_id]->handle(), size));
    238 
    239   return PP_OK_COMPLETIONPENDING;
    240 }
    241 
    242 int32_t PepperVideoDecoderHost::OnHostMsgAssignTextures(
    243     ppapi::host::HostMessageContext* context,
    244     const PP_Size& size,
    245     const std::vector<uint32_t>& texture_ids) {
    246   if (!initialized_)
    247     return PP_ERROR_FAILED;
    248   DCHECK(decoder_);
    249 
    250   std::vector<media::PictureBuffer> picture_buffers;
    251   for (uint32 i = 0; i < texture_ids.size(); i++) {
    252     media::PictureBuffer buffer(
    253         texture_ids[i],  // Use the texture_id to identify the buffer.
    254         gfx::Size(size.width, size.height),
    255         texture_ids[i]);
    256     picture_buffers.push_back(buffer);
    257   }
    258   decoder_->AssignPictureBuffers(picture_buffers);
    259   return PP_OK;
    260 }
    261 
    262 int32_t PepperVideoDecoderHost::OnHostMsgRecyclePicture(
    263     ppapi::host::HostMessageContext* context,
    264     uint32_t texture_id) {
    265   if (!initialized_)
    266     return PP_ERROR_FAILED;
    267   DCHECK(decoder_);
    268 
    269   decoder_->ReusePictureBuffer(texture_id);
    270   return PP_OK;
    271 }
    272 
    273 int32_t PepperVideoDecoderHost::OnHostMsgFlush(
    274     ppapi::host::HostMessageContext* context) {
    275   if (!initialized_)
    276     return PP_ERROR_FAILED;
    277   DCHECK(decoder_);
    278   if (flush_reply_context_.is_valid() || reset_reply_context_.is_valid())
    279     return PP_ERROR_FAILED;
    280 
    281   flush_reply_context_ = context->MakeReplyMessageContext();
    282   decoder_->Flush();
    283 
    284   return PP_OK_COMPLETIONPENDING;
    285 }
    286 
    287 int32_t PepperVideoDecoderHost::OnHostMsgReset(
    288     ppapi::host::HostMessageContext* context) {
    289   if (!initialized_)
    290     return PP_ERROR_FAILED;
    291   DCHECK(decoder_);
    292   if (flush_reply_context_.is_valid() || reset_reply_context_.is_valid())
    293     return PP_ERROR_FAILED;
    294 
    295   reset_reply_context_ = context->MakeReplyMessageContext();
    296   decoder_->Reset();
    297 
    298   return PP_OK_COMPLETIONPENDING;
    299 }
    300 
    301 void PepperVideoDecoderHost::ProvidePictureBuffers(
    302     uint32 requested_num_of_buffers,
    303     const gfx::Size& dimensions,
    304     uint32 texture_target) {
    305   RequestTextures(requested_num_of_buffers,
    306                   dimensions,
    307                   texture_target,
    308                   std::vector<gpu::Mailbox>());
    309 }
    310 
    311 void PepperVideoDecoderHost::PictureReady(const media::Picture& picture) {
    312   host()->SendUnsolicitedReply(
    313       pp_resource(),
    314       PpapiPluginMsg_VideoDecoder_PictureReady(picture.bitstream_buffer_id(),
    315                                                picture.picture_buffer_id()));
    316 }
    317 
    318 void PepperVideoDecoderHost::DismissPictureBuffer(int32 picture_buffer_id) {
    319   host()->SendUnsolicitedReply(
    320       pp_resource(),
    321       PpapiPluginMsg_VideoDecoder_DismissPicture(picture_buffer_id));
    322 }
    323 
    324 void PepperVideoDecoderHost::NotifyEndOfBitstreamBuffer(
    325     int32 bitstream_buffer_id) {
    326   PendingDecodeMap::iterator it = pending_decodes_.find(bitstream_buffer_id);
    327   if (it == pending_decodes_.end()) {
    328     NOTREACHED();
    329     return;
    330   }
    331   const PendingDecode& pending_decode = it->second;
    332   host()->SendReply(
    333       pending_decode.reply_context,
    334       PpapiPluginMsg_VideoDecoder_DecodeReply(pending_decode.shm_id));
    335   shm_buffer_busy_[pending_decode.shm_id] = false;
    336   pending_decodes_.erase(it);
    337 }
    338 
    339 void PepperVideoDecoderHost::NotifyFlushDone() {
    340   DCHECK(pending_decodes_.empty());
    341   host()->SendReply(flush_reply_context_,
    342                     PpapiPluginMsg_VideoDecoder_FlushReply());
    343   flush_reply_context_ = ppapi::host::ReplyMessageContext();
    344 }
    345 
    346 void PepperVideoDecoderHost::NotifyResetDone() {
    347   DCHECK(pending_decodes_.empty());
    348   host()->SendReply(reset_reply_context_,
    349                     PpapiPluginMsg_VideoDecoder_ResetReply());
    350   reset_reply_context_ = ppapi::host::ReplyMessageContext();
    351 }
    352 
    353 void PepperVideoDecoderHost::NotifyError(
    354     media::VideoDecodeAccelerator::Error error) {
    355   int32_t pp_error = PP_ERROR_FAILED;
    356   switch (error) {
    357     case media::VideoDecodeAccelerator::UNREADABLE_INPUT:
    358       pp_error = PP_ERROR_MALFORMED_INPUT;
    359       break;
    360     case media::VideoDecodeAccelerator::ILLEGAL_STATE:
    361     case media::VideoDecodeAccelerator::INVALID_ARGUMENT:
    362     case media::VideoDecodeAccelerator::PLATFORM_FAILURE:
    363     case media::VideoDecodeAccelerator::LARGEST_ERROR_ENUM:
    364       pp_error = PP_ERROR_RESOURCE_FAILED;
    365       break;
    366     // No default case, to catch unhandled enum values.
    367   }
    368   host()->SendUnsolicitedReply(
    369       pp_resource(), PpapiPluginMsg_VideoDecoder_NotifyError(pp_error));
    370 }
    371 
    372 void PepperVideoDecoderHost::OnInitializeComplete(int32_t result) {
    373   if (!initialized_) {
    374     if (result == PP_OK)
    375       initialized_ = true;
    376     initialize_reply_context_.params.set_result(result);
    377     host()->SendReply(initialize_reply_context_,
    378                       PpapiPluginMsg_VideoDecoder_InitializeReply());
    379   }
    380 }
    381 
    382 const uint8_t* PepperVideoDecoderHost::DecodeIdToAddress(uint32_t decode_id) {
    383   PendingDecodeMap::const_iterator it = pending_decodes_.find(decode_id);
    384   DCHECK(it != pending_decodes_.end());
    385   uint32_t shm_id = it->second.shm_id;
    386   return static_cast<uint8_t*>(shm_buffers_[shm_id]->memory());
    387 }
    388 
    389 void PepperVideoDecoderHost::RequestTextures(
    390     uint32 requested_num_of_buffers,
    391     const gfx::Size& dimensions,
    392     uint32 texture_target,
    393     const std::vector<gpu::Mailbox>& mailboxes) {
    394   host()->SendUnsolicitedReply(
    395       pp_resource(),
    396       PpapiPluginMsg_VideoDecoder_RequestTextures(
    397           requested_num_of_buffers,
    398           PP_MakeSize(dimensions.width(), dimensions.height()),
    399           texture_target,
    400           mailboxes));
    401 }
    402 
    403 }  // namespace content
    404