content/renderer/pepper/ppb_video_decoder_impl.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 "content/renderer/pepper/ppb_video_decoder_impl.h"
   6
   7 #include <string>
   8
   9 #include "base/logging.h"
  10 #include "base/message_loop/message_loop.h"
  11 #include "base/metrics/histogram.h"
  12 #include "content/renderer/media/pepper_platform_video_decoder.h"
  13 #include "content/renderer/pepper/common.h"
  14 #include "content/renderer/pepper/host_globals.h"
  15 #include "content/renderer/pepper/pepper_platform_context_3d.h"
  16 #include "content/renderer/pepper/pepper_plugin_instance_impl.h"
  17 #include "content/renderer/pepper/plugin_module.h"
  18 #include "content/renderer/pepper/ppb_buffer_impl.h"
  19 #include "content/renderer/pepper/ppb_graphics_3d_impl.h"
  20 #include "gpu/command_buffer/client/gles2_implementation.h"
  21 #include "media/video/picture.h"
  22 #include "media/video/video_decode_accelerator.h"
  23 #include "ppapi/c/dev/pp_video_dev.h"
  24 #include "ppapi/c/dev/ppb_video_decoder_dev.h"
  25 #include "ppapi/c/dev/ppp_video_decoder_dev.h"
  26 #include "ppapi/c/pp_completion_callback.h"
  27 #include "ppapi/c/pp_errors.h"
  28 #include "ppapi/shared_impl/resource_tracker.h"
  29 #include "ppapi/thunk/enter.h"
  30
  31 using ppapi::TrackedCallback;
  32 using ppapi::thunk::EnterResourceNoLock;
  33 using ppapi::thunk::PPB_Buffer_API;
  34 using ppapi::thunk::PPB_Graphics3D_API;
  35 using ppapi::thunk::PPB_VideoDecoder_API;
  36
  37 namespace {
  38
  39 // Convert PP_VideoDecoder_Profile to media::VideoCodecProfile.
  40 media::VideoCodecProfile PPToMediaProfile(
  41     const PP_VideoDecoder_Profile pp_profile) {
  42   switch (pp_profile) {
  43     case PP_VIDEODECODER_H264PROFILE_NONE:
  44       // HACK: PPAPI contains a bogus "none" h264 profile that doesn't
  45       // correspond to anything in h.264; but a number of released chromium
  46       // versions silently promoted this to Baseline profile, so we retain that
  47       // behavior here.  Fall through.
  48     case PP_VIDEODECODER_H264PROFILE_BASELINE:
  49       return media::H264PROFILE_BASELINE;
  50     case PP_VIDEODECODER_H264PROFILE_MAIN:
  51       return media::H264PROFILE_MAIN;
  52     case PP_VIDEODECODER_H264PROFILE_EXTENDED:
  53       return media::H264PROFILE_EXTENDED;
  54     case PP_VIDEODECODER_H264PROFILE_HIGH:
  55       return media::H264PROFILE_HIGH;
  56     case PP_VIDEODECODER_H264PROFILE_HIGH10PROFILE:
  57       return media::H264PROFILE_HIGH10PROFILE;
  58     case PP_VIDEODECODER_H264PROFILE_HIGH422PROFILE:
  59       return media::H264PROFILE_HIGH422PROFILE;
  60     case PP_VIDEODECODER_H264PROFILE_HIGH444PREDICTIVEPROFILE:
  61       return media::H264PROFILE_HIGH444PREDICTIVEPROFILE;
  62     case PP_VIDEODECODER_H264PROFILE_SCALABLEBASELINE:
  63       return media::H264PROFILE_SCALABLEBASELINE;
  64     case PP_VIDEODECODER_H264PROFILE_SCALABLEHIGH:
  65       return media::H264PROFILE_SCALABLEHIGH;
  66     case PP_VIDEODECODER_H264PROFILE_STEREOHIGH:
  67       return media::H264PROFILE_STEREOHIGH;
  68     case PP_VIDEODECODER_H264PROFILE_MULTIVIEWHIGH:
  69       return media::H264PROFILE_MULTIVIEWHIGH;
  70     case PP_VIDEODECODER_VP8PROFILE_MAIN:
  71       return media::VP8PROFILE_MAIN;
  72     default:
  73       return media::VIDEO_CODEC_PROFILE_UNKNOWN;
  74   }
  75 }
  76
  77 PP_VideoDecodeError_Dev MediaToPPError(
  78     media::VideoDecodeAccelerator::Error error) {
  79   switch (error) {
  80     case media::VideoDecodeAccelerator::ILLEGAL_STATE :
  81       return PP_VIDEODECODERERROR_ILLEGAL_STATE;
  82     case media::VideoDecodeAccelerator::INVALID_ARGUMENT :
  83       return PP_VIDEODECODERERROR_INVALID_ARGUMENT;
  84     case media::VideoDecodeAccelerator::UNREADABLE_INPUT :
  85       return PP_VIDEODECODERERROR_UNREADABLE_INPUT;
  86     case media::VideoDecodeAccelerator::PLATFORM_FAILURE :
  87       return PP_VIDEODECODERERROR_PLATFORM_FAILURE;
  88     default:
  89       NOTREACHED();
  90       return PP_VIDEODECODERERROR_ILLEGAL_STATE;
  91   }
  92 }
  93
  94 }  // namespace
  95
  96 namespace content {
  97
  98 PPB_VideoDecoder_Impl::PPB_VideoDecoder_Impl(PP_Instance instance)
  99     : PPB_VideoDecoder_Shared(instance),
 100       ppp_videodecoder_(NULL) {
 101   PluginModule* plugin_module =
 102       HostGlobals::Get()->GetInstance(pp_instance())->module();
 103   if (plugin_module) {
 104     ppp_videodecoder_ = static_cast<const PPP_VideoDecoder_Dev*>(
 105         plugin_module->GetPluginInterface(PPP_VIDEODECODER_DEV_INTERFACE));
 106   }
 107 }
 108
 109 PPB_VideoDecoder_Impl::~PPB_VideoDecoder_Impl() {
 110   Destroy();
 111 }
 112
 113 // static
 114 PP_Resource PPB_VideoDecoder_Impl::Create(
 115     PP_Instance instance,
 116     PP_Resource graphics_context,
 117     PP_VideoDecoder_Profile profile) {
 118   EnterResourceNoLock<PPB_Graphics3D_API> enter_context(graphics_context, true);
 119   if (enter_context.failed())
 120     return 0;
 121   PPB_Graphics3D_Impl* graphics3d_impl =
 122       static_cast<PPB_Graphics3D_Impl*>(enter_context.object());
 123
 124   scoped_refptr<PPB_VideoDecoder_Impl> decoder(
 125       new PPB_VideoDecoder_Impl(instance));
 126   if (decoder->Init(graphics_context, graphics3d_impl->platform_context(),
 127                     graphics3d_impl->gles2_impl(), profile))
 128     return decoder->GetReference();
 129   return 0;
 130 }
 131
 132 bool PPB_VideoDecoder_Impl::Init(
 133     PP_Resource graphics_context,
 134     PlatformContext3D* context,
 135     gpu::gles2::GLES2Implementation* gles2_impl,
 136     PP_VideoDecoder_Profile profile) {
 137   InitCommon(graphics_context, gles2_impl);
 138
 139   int command_buffer_route_id = context->GetCommandBufferRouteId();
 140   if (command_buffer_route_id == 0)
 141     return false;
 142
 143   platform_video_decoder_.reset(new PlatformVideoDecoder(
 144       this, command_buffer_route_id));
 145   if (!platform_video_decoder_)
 146     return false;
 147
 148   FlushCommandBuffer();
 149   return platform_video_decoder_->Initialize(PPToMediaProfile(profile));
 150 }
 151
 152 int32_t PPB_VideoDecoder_Impl::Decode(
 153     const PP_VideoBitstreamBuffer_Dev* bitstream_buffer,
 154     scoped_refptr<TrackedCallback> callback) {
 155   if (!platform_video_decoder_)
 156     return PP_ERROR_BADRESOURCE;
 157
 158   EnterResourceNoLock<PPB_Buffer_API> enter(bitstream_buffer->data, true);
 159   if (enter.failed())
 160     return PP_ERROR_FAILED;
 161
 162   PPB_Buffer_Impl* buffer = static_cast<PPB_Buffer_Impl*>(enter.object());
 163   DCHECK_GE(bitstream_buffer->id, 0);
 164   media::BitstreamBuffer decode_buffer(
 165       bitstream_buffer->id,
 166       buffer->shared_memory()->handle(),
 167       bitstream_buffer->size);
 168   if (!SetBitstreamBufferCallback(bitstream_buffer->id, callback))
 169     return PP_ERROR_BADARGUMENT;
 170
 171   FlushCommandBuffer();
 172   platform_video_decoder_->Decode(decode_buffer);
 173   return PP_OK_COMPLETIONPENDING;
 174 }
 175
 176 void PPB_VideoDecoder_Impl::AssignPictureBuffers(
 177     uint32_t no_of_buffers,
 178     const PP_PictureBuffer_Dev* buffers) {
 179   if (!platform_video_decoder_)
 180     return;
 181   UMA_HISTOGRAM_COUNTS_100("Media.PepperVideoDecoderPictureCount",
 182                            no_of_buffers);
 183
 184   std::vector<media::PictureBuffer> wrapped_buffers;
 185   for (uint32 i = 0; i < no_of_buffers; i++) {
 186     PP_PictureBuffer_Dev in_buf = buffers[i];
 187     DCHECK_GE(in_buf.id, 0);
 188     media::PictureBuffer buffer(
 189         in_buf.id,
 190         gfx::Size(in_buf.size.width, in_buf.size.height),
 191         in_buf.texture_id);
 192     wrapped_buffers.push_back(buffer);
 193     UMA_HISTOGRAM_COUNTS_10000("Media.PepperVideoDecoderPictureHeight",
 194                                in_buf.size.height);
 195   }
 196
 197   FlushCommandBuffer();
 198   platform_video_decoder_->AssignPictureBuffers(wrapped_buffers);
 199 }
 200
 201 void PPB_VideoDecoder_Impl::ReusePictureBuffer(int32_t picture_buffer_id) {
 202   if (!platform_video_decoder_)
 203     return;
 204
 205   FlushCommandBuffer();
 206   platform_video_decoder_->ReusePictureBuffer(picture_buffer_id);
 207 }
 208
 209 int32_t PPB_VideoDecoder_Impl::Flush(scoped_refptr<TrackedCallback> callback) {
 210   if (!platform_video_decoder_)
 211     return PP_ERROR_BADRESOURCE;
 212
 213   if (!SetFlushCallback(callback))
 214     return PP_ERROR_INPROGRESS;
 215
 216   FlushCommandBuffer();
 217   platform_video_decoder_->Flush();
 218   return PP_OK_COMPLETIONPENDING;
 219 }
 220
 221 int32_t PPB_VideoDecoder_Impl::Reset(scoped_refptr<TrackedCallback> callback) {
 222   if (!platform_video_decoder_)
 223     return PP_ERROR_BADRESOURCE;
 224
 225   if (!SetResetCallback(callback))
 226     return PP_ERROR_INPROGRESS;
 227
 228   FlushCommandBuffer();
 229   platform_video_decoder_->Reset();
 230   return PP_OK_COMPLETIONPENDING;
 231 }
 232
 233 void PPB_VideoDecoder_Impl::Destroy() {
 234   FlushCommandBuffer();
 235
 236   if (platform_video_decoder_)
 237     platform_video_decoder_.release()->Destroy();
 238   ppp_videodecoder_ = NULL;
 239
 240   ::ppapi::PPB_VideoDecoder_Shared::Destroy();
 241 }
 242
 243 void PPB_VideoDecoder_Impl::ProvidePictureBuffers(
 244     uint32 requested_num_of_buffers,
 245     const gfx::Size& dimensions,
 246     uint32 texture_target) {
 247   if (!ppp_videodecoder_)
 248     return;
 249
 250   PP_Size out_dim = PP_MakeSize(dimensions.width(), dimensions.height());
 251   ppp_videodecoder_->ProvidePictureBuffers(pp_instance(), pp_resource(),
 252       requested_num_of_buffers, &out_dim, texture_target);
 253 }
 254
 255 void PPB_VideoDecoder_Impl::PictureReady(const media::Picture& picture) {
 256   if (!ppp_videodecoder_)
 257     return;
 258
 259   PP_Picture_Dev output;
 260   output.picture_buffer_id = picture.picture_buffer_id();
 261   output.bitstream_buffer_id = picture.bitstream_buffer_id();
 262   ppp_videodecoder_->PictureReady(pp_instance(), pp_resource(), &output);
 263 }
 264
 265 void PPB_VideoDecoder_Impl::DismissPictureBuffer(int32 picture_buffer_id) {
 266   if (!ppp_videodecoder_)
 267     return;
 268   ppp_videodecoder_->DismissPictureBuffer(pp_instance(), pp_resource(),
 269                                           picture_buffer_id);
 270 }
 271
 272 void PPB_VideoDecoder_Impl::NotifyError(
 273     media::VideoDecodeAccelerator::Error error) {
 274   if (!ppp_videodecoder_)
 275     return;
 276
 277   PP_VideoDecodeError_Dev pp_error = MediaToPPError(error);
 278   ppp_videodecoder_->NotifyError(pp_instance(), pp_resource(), pp_error);
 279   UMA_HISTOGRAM_ENUMERATION(
 280       "Media.PepperVideoDecoderError", error,
 281       media::VideoDecodeAccelerator::LARGEST_ERROR_ENUM);
 282 }
 283
 284 void PPB_VideoDecoder_Impl::NotifyResetDone() {
 285   RunResetCallback(PP_OK);
 286 }
 287
 288 void PPB_VideoDecoder_Impl::NotifyEndOfBitstreamBuffer(
 289     int32 bitstream_buffer_id) {
 290   RunBitstreamBufferCallback(bitstream_buffer_id, PP_OK);
 291 }
 292
 293 void PPB_VideoDecoder_Impl::NotifyFlushDone() {
 294   RunFlushCallback(PP_OK);
 295 }
 296
 297 void PPB_VideoDecoder_Impl::NotifyInitializeDone() {
 298   NOTREACHED() << "PlatformVideoDecoder::Initialize() is synchronous!";
 299 }
 300
 301 }  // namespace content