Implementation for Pepper C++ Video Decoder API (wrapper on top of C API).

webkit/plugins/ppapi/ppb_video_decoder_impl.cc

 // Copyright (c) 2011 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 "webkit/plugins/ppapi/ppb_video_decoder_impl.h"
 
 #include <string>
 
 #include "base/logging.h"
 #include "media/video/picture.h"
 #include "ppapi/c/dev/pp_video_dev.h"
 #include "ppapi/c/dev/ppb_video_decoder_dev.h"
 #include "ppapi/c/dev/ppp_video_decoder_dev.h"
 #include "ppapi/c/pp_completion_callback.h"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/thunk/enter.h"
 #include "webkit/plugins/ppapi/common.h"
 #include "webkit/plugins/ppapi/plugin_module.h"
 #include "webkit/plugins/ppapi/ppapi_plugin_instance.h"
 #include "webkit/plugins/ppapi/ppb_buffer_impl.h"
 #include "webkit/plugins/ppapi/resource_tracker.h"
 #include "webkit/plugins/ppapi/var.h"
 
 namespace webkit {
 namespace ppapi {
 
 namespace {
 
 PP_Bool GetConfigs(PP_Instance instance_id,
-                   PP_VideoConfigElement* proto_config,
+                   const PP_VideoConfigElement* proto_config,
                    PP_VideoConfigElement* matching_configs,
                    uint32_t matching_configs_size,
                    uint32_t* num_of_matching_configs) {
   PluginInstance* instance = ResourceTracker::Get()->GetInstance(instance_id);
   if (!instance)
     return PP_FALSE;
 
   scoped_refptr<PPB_VideoDecoder_Impl> decoder(
       new PPB_VideoDecoder_Impl(instance));
 
   return BoolToPPBool(decoder->GetConfigs(proto_config,
                                           matching_configs,
                                           matching_configs_size,
                                           num_of_matching_configs));
 }
 
 PP_Resource Create(PP_Instance instance_id,
-                   PP_VideoConfigElement* decoder_config,
+                   const PP_VideoConfigElement* decoder_config,
                    PP_CompletionCallback callback) {
   PluginInstance* instance = ResourceTracker::Get()->GetInstance(instance_id);
   if (!instance)
     return 0;
 
   scoped_refptr<PPB_VideoDecoder_Impl> decoder(
       new PPB_VideoDecoder_Impl(instance));
 
   if (!decoder->Init(
       const_cast<PP_VideoConfigElement*>(decoder_config), callback)) {
     return 0;
   }
 
   return decoder->GetReference();
 }
 
 PP_Bool IsVideoDecoder(PP_Resource resource) {
   return BoolToPPBool(!!Resource::GetAs<PPB_VideoDecoder_Impl>(resource));
 }
 
 PP_Bool Decode(PP_Resource decoder_id,
-               PP_VideoBitstreamBuffer_Dev* bitstream_buffer,
+               const PP_VideoBitstreamBuffer_Dev* bitstream_buffer,
                PP_CompletionCallback callback) {
   scoped_refptr<PPB_VideoDecoder_Impl> decoder(
       Resource::GetAs<PPB_VideoDecoder_Impl>(decoder_id));
   if (!decoder)
     return PP_FALSE;
 
   return BoolToPPBool(decoder->Decode(bitstream_buffer, callback));
 }
 
 void AssignGLESBuffers(PP_Resource video_decoder,
                        uint32_t no_of_buffers,
-                       PP_GLESBuffer_Dev* buffers) {
+                       const PP_GLESBuffer_Dev* buffers) {
   scoped_refptr<PPB_VideoDecoder_Impl> decoder(
       Resource::GetAs<PPB_VideoDecoder_Impl>(video_decoder));
   if (!decoder)
     return;
 
   decoder->AssignGLESBuffers(no_of_buffers, buffers);
 }
 
 void AssignSysmemBuffers(PP_Resource video_decoder,
                          uint32_t no_of_buffers,
-                         PP_SysmemBuffer_Dev* buffers) {
+                         const PP_SysmemBuffer_Dev* buffers) {
   scoped_refptr<PPB_VideoDecoder_Impl> decoder(
       Resource::GetAs<PPB_VideoDecoder_Impl>(video_decoder));
   if (!decoder)
     return;
 
   decoder->AssignSysmemBuffers(no_of_buffers, buffers);
 }
 
 void ReusePictureBuffer(PP_Resource video_decoder, int32_t picture_buffer_id) {
   scoped_refptr<PPB_VideoDecoder_Impl> decoder(
@@ skipping 81 matching lines @@
 // static
 const PPB_VideoDecoder_Dev* PPB_VideoDecoder_Impl::GetInterface() {
   return &ppb_videodecoder;
 }
 
 PPB_VideoDecoder_Impl* PPB_VideoDecoder_Impl::AsPPB_VideoDecoder_Impl() {
   return this;
 }
 
 bool PPB_VideoDecoder_Impl::GetConfigs(
-    PP_VideoConfigElement* requested_configs,
+    const PP_VideoConfigElement* requested_configs,
     PP_VideoConfigElement* matching_configs,
     uint32_t matching_configs_size,
     uint32_t* num_of_matching_configs) {
   if (!instance())
     return false;
   if (!platform_video_decoder_.get())
     return false;
   if (!matching_configs)
     return false;
 
   std::vector<uint32> requested;
   CopyToConfigList(requested_configs, &requested);
   std::vector<uint32> matched;
   platform_video_decoder_->GetConfigs(requested, &matched);
 
   uint32 i;
   for (i = 0; i < matched.size() && i < matching_configs_size; i++)
     matching_configs[i] = matched[i];
   *num_of_matching_configs = i;
 
   return true;
 }
 
-bool PPB_VideoDecoder_Impl::Init(PP_VideoConfigElement* decoder_config,
+bool PPB_VideoDecoder_Impl::Init(const PP_VideoConfigElement* decoder_config,
                                  PP_CompletionCallback callback) {
   if (!instance())
     return false;
 
   platform_video_decoder_.reset(
       instance()->delegate()->CreateVideoDecoder(this));
 
   std::vector<uint32> copied;
   // TODO(vrk): Validate configs before copy.
   CopyToConfigList(decoder_config, &copied);
   platform_video_decoder_->Initialize(copied);
 
   initialization_callback_ = callback;
 
   return platform_video_decoder_.get()? true : false;
 }
 
 bool PPB_VideoDecoder_Impl::Decode(
-    PP_VideoBitstreamBuffer_Dev* bitstream_buffer,
+    const PP_VideoBitstreamBuffer_Dev* bitstream_buffer,
     PP_CompletionCallback callback) {
   if (!platform_video_decoder_.get())
     return false;
 
   ::ppapi::thunk::EnterResourceNoLock< ::ppapi::thunk::PPB_Buffer_API>
       enter(bitstream_buffer->data, true);
   if (enter.failed())
     return false;
 
   PPB_Buffer_Impl* buffer = static_cast<PPB_Buffer_Impl*>(enter.object());
   media::BitstreamBuffer decode_buffer(bitstream_buffer->id,
                                        buffer->shared_memory()->handle(),
                                        static_cast<size_t>(buffer->size()));
 
   // Store the callback to inform when bitstream buffer has been processed.
   // TODO(vmr): handle simultaneous decodes + callbacks.
   bitstream_buffer_callback_ = callback;
 
   return platform_video_decoder_->Decode(decode_buffer);
 }
 
 void PPB_VideoDecoder_Impl::AssignGLESBuffers(
     uint32_t no_of_buffers,
-    PP_GLESBuffer_Dev* buffers) {
+    const PP_GLESBuffer_Dev* buffers) {
   if (!platform_video_decoder_.get())
     return;
 
   std::vector<media::GLESBuffer> wrapped_buffers;
   for (uint32 i = 0; i < no_of_buffers; i++) {
     PP_GLESBuffer_Dev in_buf = buffers[i];
     media::GLESBuffer buffer(in_buf);
     wrapped_buffers.push_back(buffer);
   }
   platform_video_decoder_->AssignGLESBuffers(wrapped_buffers);
 }
 
 void PPB_VideoDecoder_Impl::AssignSysmemBuffers(
     uint32_t no_of_buffers,
-    PP_SysmemBuffer_Dev* buffers) {
+    const PP_SysmemBuffer_Dev* buffers) {
   if (!platform_video_decoder_.get())
     return;
 
   std::vector<media::SysmemBuffer> wrapped_buffers;
   for (uint32 i = 0; i < no_of_buffers; i++) {
     PP_SysmemBuffer_Dev in_buf = buffers[i];
     media::SysmemBuffer buffer(in_buf);
     wrapped_buffers.push_back(buffer);
   }
   platform_video_decoder_->AssignSysmemBuffers(wrapped_buffers);
@@ skipping 146 matching lines @@
 }
 
 Picture::Picture(const PP_Picture_Dev& picture)
     : picture_buffer_id_(picture.picture_buffer_id),
       bitstream_buffer_id_(picture.bitstream_buffer_id),
       visible_size_(picture.visible_size.width, picture.visible_size.height),
       decoded_size_(picture.decoded_size.width, picture.decoded_size.height) {
 }
 
 }  // namespace media