Add CDM video decoder.

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"
 #include "ppapi/c/pp_errors.h"
 #include "ppapi/c/pp_stdint.h"
 #include "ppapi/c/private/pp_content_decryptor.h"
 #include "ppapi/cpp/completion_callback.h"
 #include "ppapi/cpp/core.h"
 #include "ppapi/cpp/instance.h"
 #include "ppapi/cpp/logging.h"
 #include "ppapi/cpp/module.h"
 #include "ppapi/cpp/pass_ref.h"
 #include "ppapi/cpp/resource.h"
 #include "ppapi/cpp/var.h"
 #include "ppapi/cpp/var_array_buffer.h"
 #include "ppapi/cpp/dev/buffer_dev.h"
 #include "ppapi/cpp/private/content_decryptor_private.h"
 #include "ppapi/utility/completion_callback_factory.h"
+#include "webkit/media/crypto/ppapi/content_decryption_module.h"
 #include "webkit/media/crypto/ppapi/linked_ptr.h"
-#include "webkit/media/crypto/ppapi/content_decryption_module.h"
 
 namespace {
 
 // This must be consistent with MediaKeyError defined in the spec:
 // http://goo.gl/rbdnR
 // TODO(xhwang): Add PP_MediaKeyError enum to avoid later static_cast in
 // PluginInstance.
 enum MediaKeyError {
   kUnknownError = 1,
   kClientError,
@@ skipping 81 matching lines @@
   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;
 }
 
+cdm::StreamType PpDecryptorStreamTypeToCdmStreamType(
+    PP_DecryptorStreamType stream_type) {
+  switch (stream_type) {
+    case PP_DECRYPTORSTREAMTYPE_AUDIO:
+      return cdm::kStreamTypeAudio;
+    case PP_DECRYPTORSTREAMTYPE_VIDEO:
+      return cdm::kStreamTypeVideo;
+  }
+
+  PP_NOTREACHED();
+  return cdm::kStreamTypeVideo;
+}
+
 }  // 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 {
  public:
   // cdm::Buffer methods.
@@ skipping 321 matching lines @@
 
 PpbBufferAllocator::PpbBufferAllocator(pp::Instance* instance)
     : instance_(instance) {
 }
 
 PpbBufferAllocator::~PpbBufferAllocator() {
 }
 
 cdm::Buffer* PpbBufferAllocator::Allocate(int32_t size) {
   PP_DCHECK(size > 0);
+  PP_DCHECK(IsMainThread());
 
   pp::Buffer_Dev buffer(instance_, size);
   if (buffer.is_null())
     return NULL;
 
   return new PpbBuffer(buffer);
 }
 
 CdmWrapper::CdmWrapper(PP_Instance instance, pp::Module* module)
     : pp::Instance(instance),
@@ skipping 115 matching lines @@
   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::DeinitializeDecoder(PP_DecryptorStreamType decoder_type,

[xhwang, 2012/10/16 21:59:53]

s/decoder_type/stream_type ?

[Tom Finegan, 2012/10/17 02:39:10]

I prefer decoder_type here. I think it fits better with DeinitializeDecoder...
if/when we add a stream_id to these methods stream_type might be better.

I also want the names to match the pepper API, and I used decoder_type
throughout. Do you feel really strongly about this?

[xhwang, 2012/10/17 18:43:00]

SG :)

                                      uint32_t request_id) {
-  // TODO(tomfinegan): Implement DeinitializeDecoder in clear key CDM, and call
-  // it here.
+  cdm_->DeinitializeDecoder(PpDecryptorStreamTypeToCdmStreamType(decoder_type));
   CallOnMain(callback_factory_.NewCallback(
       &CdmWrapper::DecoderDeinitializeDone,
       decoder_type,
       request_id));
 }
 
 void CdmWrapper::ResetDecoder(PP_DecryptorStreamType decoder_type,
                               uint32_t request_id) {
-  // TODO(tomfinegan): Implement ResetDecoder in clear key CDM, and call it
-  // here.
+  cdm_->ResetDecoder(PpDecryptorStreamTypeToCdmStreamType(decoder_type));
   CallOnMain(callback_factory_.NewCallback(&CdmWrapper::DecoderResetDone,
                                            decoder_type,
                                            request_id));
 }
 
 void CdmWrapper::DecryptAndDecode(
     PP_DecryptorStreamType decoder_type,
     pp::Buffer_Dev encrypted_buffer,
     const PP_EncryptedBlockInfo& encrypted_block_info) {
   // TODO(tomfinegan): Remove this check when audio decoding is added.
   PP_DCHECK(decoder_type == PP_DECRYPTORSTREAMTYPE_VIDEO);
 
-  PP_DCHECK(!encrypted_buffer.is_null());
   PP_DCHECK(cdm_);
 
   cdm::InputBuffer input_buffer;
   std::vector<cdm::SubsampleEntry> subsamples;
-  ConfigureInputBuffer(encrypted_buffer,
-                       encrypted_block_info,
-                       &subsamples,
-                       &input_buffer);
+  if (!encrypted_buffer.is_null()) {
+    ConfigureInputBuffer(encrypted_buffer,
+                         encrypted_block_info,
+                         &subsamples,
+                         &input_buffer);
+  }
 
   LinkedVideoFrame video_frame(new VideoFrameImpl());
   cdm::Status status = cdm_->DecryptAndDecodeFrame(input_buffer,
                                                    video_frame.get());
   CallOnMain(callback_factory_.NewCallback(
       &CdmWrapper::DeliverFrame,
       status,
       video_frame,
       encrypted_block_info.tracking_info));
 }
@@ skipping 175 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