Add PPAPI CDM video decoder initialization.

webkit/media/crypto/ppapi/cdm_wrapper.cc

 // Copyright (c) 2012 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 <cstring>
 #include <string>
 #include <vector>
 
 #include "base/basictypes.h"
 #include "base/compiler_specific.h"
@@ skipping 68 matching lines @@
           encrypted_block_info.subsamples[i].clear_bytes,
           encrypted_block_info.subsamples[i].cipher_bytes));
     }
 
     input_buffer->subsamples = &(*subsamples)[0];
   }
 
   input_buffer->timestamp = encrypted_block_info.tracking_info.timestamp;
 }
 
-PP_DecryptedFrameFormat VideoFormatToPpDecryptedFrameFormat(
+PP_DecryptedFrameFormat CdmVideoFormatToPpDecryptedFrameFormat(
     cdm::VideoFormat format) {
-  switch(format) {
-    case cdm::kEmptyVideoFrame:
-      return PP_DECRYPTEDFRAMEFORMAT_EMPTY;
-    case cdm::kYv12:
-      return PP_DECRYPTEDFRAMEFORMAT_YV12;
-    case cdm::kI420:
-      return PP_DECRYPTEDFRAMEFORMAT_I420;
-    case cdm::kUnknownVideoFormat:
-    default:
-      return PP_DECRYPTEDFRAMEFORMAT_UNKNOWN;
-  }
+  if (format == cdm::kEmptyVideoFrame)
+    return PP_DECRYPTEDFRAMEFORMAT_EMPTY;
+  else if (format == cdm::kYv12)
+    return PP_DECRYPTEDFRAMEFORMAT_YV12;
+  else if (format == cdm::kI420)
+    return PP_DECRYPTEDFRAMEFORMAT_I420;
+
+  return PP_DECRYPTEDFRAMEFORMAT_UNKNOWN;
+}
+
+cdm::VideoDecoderConfig::VideoCodec PpVideoCodecToCdmVideoCodec(
+    PP_VideoCodec codec) {
+  if (codec == PP_VIDEOCODEC_VP8)
+    return cdm::VideoDecoderConfig::kCodecVP8;
+
+  return cdm::VideoDecoderConfig::kUnknownVideoCodec;
+}
+
+cdm::VideoDecoderConfig::VideoCodecProfile PpVCProfileToCdmVCProfile(
+    PP_VideoCodecProfile profile) {
+  if (profile == PP_VIDEOCODECPROFILE_VP8_MAIN)
+    return cdm::VideoDecoderConfig::kVp8ProfileMain;
+
+  return cdm::VideoDecoderConfig::kUnknownVideoCodecProfile;
+}
+
+cdm::VideoFormat PpDecryptedFrameFormatToCdmVideoFormat(
+    PP_DecryptedFrameFormat format) {
+  if (format == PP_DECRYPTEDFRAMEFORMAT_YV12)
+    return cdm::kYv12;
+  else if (format == PP_DECRYPTEDFRAMEFORMAT_I420)
+    return cdm::kI420;
+  else if (format == PP_DECRYPTEDFRAMEFORMAT_EMPTY)
+    return cdm::kEmptyVideoFrame;
+
+  return cdm::kUnknownVideoFormat;
 }
 
 }  // namespace
 
 namespace webkit_media {
 
 // Provides access to memory owned by a pp::Buffer_Dev created by
 // PpbBufferAllocator::Allocate(). This class holds a reference to the
 // Buffer_Dev throughout its lifetime.
 class PpbBuffer : public cdm::Buffer {
@@ skipping 259 matching lines @@
   // PPB_ContentDecryptor_Private interface.
   virtual void GenerateKeyRequest(const std::string& key_system,
                                   pp::VarArrayBuffer init_data) OVERRIDE;
   virtual void AddKey(const std::string& session_id,
                       pp::VarArrayBuffer key,
                       pp::VarArrayBuffer init_data) OVERRIDE;
   virtual void CancelKeyRequest(const std::string& session_id) OVERRIDE;
   virtual void Decrypt(
       pp::Buffer_Dev encrypted_buffer,
       const PP_EncryptedBlockInfo& encrypted_block_info) OVERRIDE;
+  virtual void InitializeVideoDecoder(
+      const PP_VideoDecoderConfig& decoder_config,
+      pp::Buffer_Dev extra_data_buffer) OVERRIDE;
   virtual void DecryptAndDecodeFrame(
       pp::Buffer_Dev encrypted_frame,
       const PP_EncryptedVideoFrameInfo& encrypted_video_frame_info) OVERRIDE;
 
  private:
   typedef linked_ptr<DecryptedBlockImpl> LinkedDecryptedBlock;
   typedef linked_ptr<KeyMessageImpl> LinkedKeyMessage;
   typedef linked_ptr<VideoFrameImpl> LinkedVideoFrame;
 
   // <code>PPB_ContentDecryptor_Private</code> dispatchers. These are passed to
   // <code>callback_factory_</code> to ensure that calls into
   // <code>PPP_ContentDecryptor_Private</code> are asynchronous.
   void KeyAdded(int32_t result, const std::string& session_id);
   void KeyMessage(int32_t result, const LinkedKeyMessage& message);
   void KeyError(int32_t result, const std::string& session_id);
   void DeliverBlock(int32_t result,
                     const cdm::Status& status,
                     const LinkedDecryptedBlock& decrypted_block,
                     const PP_DecryptTrackingInfo& tracking_info);
+  void DecoderInitialized(int32_t result,
+                          bool success,
+                          uint32_t request_id);
   void DeliverFrame(int32_t result,
                     const cdm::Status& status,
                     const LinkedVideoFrame& video_frame,
                     const PP_DecryptTrackingInfo& tracking_info);
 
   PpbBufferAllocator allocator_;
   pp::CompletionCallbackFactory<CdmWrapper> callback_factory_;
   cdm::ContentDecryptionModule* cdm_;
   std::string key_system_;
 };
@@ skipping 113 matching lines @@
   LinkedDecryptedBlock decrypted_block(new DecryptedBlockImpl());
   cdm::Status status = cdm_->Decrypt(input_buffer, decrypted_block.get());
 
   CallOnMain(callback_factory_.NewCallback(
       &CdmWrapper::DeliverBlock,
       status,
       decrypted_block,
       encrypted_block_info.tracking_info));
 }
 
+void CdmWrapper::InitializeVideoDecoder(
+    const PP_VideoDecoderConfig& decoder_config,
+    pp::Buffer_Dev extra_data_buffer) {
+  PP_DCHECK(cdm_);
+  cdm::VideoDecoderConfig cdm_decoder_config;
+  cdm_decoder_config.codec = PpVideoCodecToCdmVideoCodec(decoder_config.codec);
+  cdm_decoder_config.profile =
+      PpVCProfileToCdmVCProfile(decoder_config.profile);
+  cdm_decoder_config.format =
+      PpDecryptedFrameFormatToCdmVideoFormat(decoder_config.format);
+  cdm_decoder_config.coded_size.width = decoder_config.width;
+  cdm_decoder_config.coded_size.height = decoder_config.height;
+  cdm_decoder_config.extra_data =
+      static_cast<uint8_t*>(extra_data_buffer.data());
+  cdm_decoder_config.extra_data_size =
+      static_cast<int32_t>(extra_data_buffer.size());
+  cdm::Status status = cdm_->InitializeVideoDecoder(cdm_decoder_config);
+
+  CallOnMain(callback_factory_.NewCallback(
+      &CdmWrapper::DecoderInitialized,
+      status == cdm::kSuccess,
+      decoder_config.request_id));
+
+}
+
 void CdmWrapper::DecryptAndDecodeFrame(
     pp::Buffer_Dev encrypted_frame,
     const PP_EncryptedVideoFrameInfo& encrypted_video_frame_info) {
   PP_DCHECK(!encrypted_frame.is_null());
   PP_DCHECK(cdm_);
 
   cdm::InputBuffer input_buffer;
   std::vector<cdm::SubsampleEntry> subsamples;
   ConfigureInputBuffer(encrypted_frame,
                        encrypted_video_frame_info.encryption_info,
@@ skipping 57 matching lines @@
   }
 
   const pp::Buffer_Dev& buffer =
       decrypted_block.get() && decrypted_block->buffer() ?
       static_cast<PpbBuffer*>(decrypted_block->buffer())->buffer_dev() :
           pp::Buffer_Dev();
 
   pp::ContentDecryptor_Private::DeliverBlock(buffer, decrypted_block_info);
 }
 
+void CdmWrapper::DecoderInitialized(int32_t result,
+                                    bool success,
+                                    uint32_t request_id) {
+  pp::ContentDecryptor_Private::DecoderInitialized(success, request_id);
+}
+
 void CdmWrapper::DeliverFrame(
     int32_t result,
     const cdm::Status& status,
     const LinkedVideoFrame& video_frame,
     const PP_DecryptTrackingInfo& tracking_info) {
   PP_DecryptedFrameInfo decrypted_frame_info;
   decrypted_frame_info.tracking_info = tracking_info;
 
   switch (status) {
     case cdm::kSuccess:
       PP_DCHECK(video_frame->format() == cdm::kI420 ||
                 video_frame->format() == cdm::kYv12);
       PP_DCHECK(video_frame.get() && video_frame->frame_buffer());
       decrypted_frame_info.result = PP_DECRYPTRESULT_SUCCESS;
       decrypted_frame_info.format =
-          VideoFormatToPpDecryptedFrameFormat(video_frame->format());
+          CdmVideoFormatToPpDecryptedFrameFormat(video_frame->format());
       decrypted_frame_info.plane_offsets[PP_DECRYPTEDFRAMEPLANES_Y] =
         video_frame->plane_offset(cdm::VideoFrame::kYPlane);
       decrypted_frame_info.plane_offsets[PP_DECRYPTEDFRAMEPLANES_U] =
         video_frame->plane_offset(cdm::VideoFrame::kUPlane);
       decrypted_frame_info.plane_offsets[PP_DECRYPTEDFRAMEPLANES_V] =
         video_frame->plane_offset(cdm::VideoFrame::kVPlane);
       decrypted_frame_info.strides[PP_DECRYPTEDFRAMEPLANES_Y] =
         video_frame->stride(cdm::VideoFrame::kYPlane);
       decrypted_frame_info.strides[PP_DECRYPTEDFRAMEPLANES_U] =
         video_frame->stride(cdm::VideoFrame::kUPlane);
@@ skipping 39 matching lines @@
 }  // namespace webkit_media
 
 namespace pp {
 
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new webkit_media::CdmWrapperModule();
 }
 
 }  // namespace pp