Add CDM video decoder.

webkit/media/crypto/ppapi/clear_key_cdm.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 "webkit/media/crypto/ppapi/clear_key_cdm.h"
 
 #include <vector>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/time.h"
 #include "media/base/decoder_buffer.h"
 
+#if defined(CLEAR_KEY_CDM_USE_FFMPEG_DECODER)
+#include "base/at_exit.h"
+#include "base/file_path.h"
+#include "base/path_service.h"
+#include "media/base/media.h"
+#include "webkit/media/crypto/ppapi/ffmpeg_cdm_video_decoder.h"
+
+// TODO(tomfinegan): When COMPONENT_BUILD is not defined an AtExitManager must
+// exist before the call to InitializeFFmpegLibraries(). This should no longer
+// be required after http://crbug.com/91970 because we'll be able to get rid of
+// InitializeFFmpegLibraries().
+#if !defined COMPONENT_BUILD
+static base::AtExitManager g_at_exit_manager;
+#endif
+
+// TODO(tomfinegan): InitializeFFmpegLibraries() and |g_cdm_module_initialized|
+// are required for running in the sandbox, and should no longer be required
+// after http://crbug.com/91970 is fixed.
+static bool InitializeFFmpegLibraries() {
+  FilePath file_path;
+  CHECK(PathService::Get(base::DIR_EXE, &file_path));
+  CHECK(media::InitializeMediaLibrary(file_path));
+  return true;
+}
+
+static bool g_cdm_module_initialized = InitializeFFmpegLibraries();
+#endif  // CLEAR_KEY_CDM_USE_FFMPEG_DECODER
+
 static const char kClearKeyCdmVersion[] = "0.1.0.0";
 
 static scoped_refptr<media::DecoderBuffer> CopyDecoderBufferFrom(
     const cdm::InputBuffer& input_buffer) {
   DCHECK(input_buffer.data);
   // TODO(tomfinegan): Get rid of this copy.
   scoped_refptr<media::DecoderBuffer> output_buffer =
       media::DecoderBuffer::CopyFrom(input_buffer.data, input_buffer.data_size);
 
   std::vector<media::SubsampleEntry> subsamples;
@@ skipping 34 matching lines @@
 template<typename Type>
 static Type* AllocateAndCopy(const Type* data, int size) {
   COMPILE_ASSERT(sizeof(Type) == 1, type_size_is_not_one);
   Type* copy = new Type[size];
   memcpy(copy, data, size);
   return copy;
 }
 
 cdm::ContentDecryptionModule* CreateCdmInstance(
     cdm::Allocator* allocator, cdm::CdmHost* host) {
+  DVLOG(1) << "CreateCdmInstance()";
   return new webkit_media::ClearKeyCdm(allocator, host);
 }
 
 void DestroyCdmInstance(cdm::ContentDecryptionModule* instance) {
+  DVLOG(1) << "DestroyCdmInstance()";
   delete instance;
 }
 
 const char* GetCdmVersion() {
   return kClearKeyCdmVersion;
 }
 
 namespace webkit_media {
 
 ClearKeyCdm::Client::Client() : status_(kKeyError), key_message_length_(0) {}
@@ skipping 155 matching lines @@
 }
 
 cdm::Status ClearKeyCdm::InitializeAudioDecoder(
     const cdm::AudioDecoderConfig& audio_decoder_config) {
   NOTIMPLEMENTED();
   return cdm::kSessionError;
 }
 
 cdm::Status ClearKeyCdm::InitializeVideoDecoder(
     const cdm::VideoDecoderConfig& video_decoder_config) {
-#if !defined(CLEAR_KEY_CDM_USE_FAKE_VIDEO_DECODER)
+#if defined(CLEAR_KEY_CDM_USE_FFMPEG_DECODER)
+  if (!video_decoder_)
+    video_decoder_.reset(new webkit_media::FFmpegCdmVideoDecoder(allocator_));
+
+  if (!video_decoder_->Initialize(video_decoder_config))
+    return cdm::kSessionError;
+
+  return cdm::kSuccess;
+#elif defined(CLEAR_KEY_CDM_USE_FAKE_VIDEO_DECODER)
+  video_size_ = video_decoder_config.coded_size;
+  return cdm::kSuccess;
+#else
   NOTIMPLEMENTED();
   return cdm::kSessionError;
-#else
-  video_size_ = video_decoder_config.coded_size;
-  return cdm::kSuccess;
-#endif  // CLEAR_KEY_CDM_USE_FAKE_VIDEO_DECODER
+#endif  // CLEAR_KEY_CDM_USE_FFMPEG_DECODER
+
 }
 
-void ClearKeyCdm::ResetDecoder(cdm::StreamType) {
-  NOTIMPLEMENTED();
+void ClearKeyCdm::ResetDecoder(cdm::StreamType decoder_type) {
+#if defined(CLEAR_KEY_CDM_USE_FFMPEG_DECODER)
+  DCHECK(decoder_type == cdm::kStreamTypeVideo);
+  video_decoder_->Reset();
+#endif
 }
 
-void ClearKeyCdm::DeinitializeDecoder(cdm::StreamType) {
-  NOTIMPLEMENTED();
+void ClearKeyCdm::DeinitializeDecoder(cdm::StreamType decoder_type) {
+#if defined(CLEAR_KEY_CDM_USE_FFMPEG_DECODER)
+  DCHECK(decoder_type == cdm::kStreamTypeVideo);
+  video_decoder_->Deinitialize();
+#endif
 }
 
 cdm::Status ClearKeyCdm::DecryptAndDecodeFrame(
     const cdm::InputBuffer& encrypted_buffer,
-    cdm::VideoFrame* video_frame) {
+    cdm::VideoFrame* decoded_frame) {
   if (!encrypted_buffer.data) {
-    video_frame->set_format(cdm::kEmptyVideoFrame);
+    decoded_frame->set_format(cdm::kEmptyVideoFrame);
     return cdm::kSuccess;
   }
 
   scoped_refptr<media::DecoderBuffer> decoder_buffer =
       CopyDecoderBufferFrom(encrypted_buffer);
 
   // Callback is called synchronously, so we can use variables on the stack.
   media::Decryptor::Status status;
   scoped_refptr<media::DecoderBuffer> buffer;
   decryptor_.Decrypt(media::Decryptor::kVideo,
                      decoder_buffer,
                      base::Bind(&CopyDecryptResults, &status, &buffer));
 
   if (status == media::Decryptor::kError)
     return cdm::kDecryptError;
 
   if (status == media::Decryptor::kNoKey)
     return cdm::kNoKey;
 
-#if !defined(CLEAR_KEY_CDM_USE_FAKE_VIDEO_DECODER)
+#if defined(CLEAR_KEY_CDM_USE_FFMPEG_DECODER)
+  DCHECK(status == media::Decryptor::kSuccess);
+  DCHECK(buffer);
+  return video_decoder_->DecodeFrame(buffer.get()->GetData(),
+                                     buffer->GetDataSize(),
+                                     encrypted_buffer.timestamp,
+                                     decoded_frame);
+#elif defined(CLEAR_KEY_CDM_USE_FAKE_VIDEO_DECODER)
+  GenerateFakeVideoFrame(decoder_buffer->GetTimestamp(), decoded_frame);
+  return cdm::kSuccess;
+#else
   NOTIMPLEMENTED();
   return cdm::kDecodeError;
-#else
-  GenerateFakeVideoFrame(decoder_buffer->GetTimestamp(), video_frame);
-  return cdm::kSuccess;
-#endif  // CLEAR_KEY_CDM_USE_FAKE_VIDEO_DECODER
+#endif  // CLEAR_KEY_CDM_USE_FFMPEG_DECODER
 }
 
 #if defined(CLEAR_KEY_CDM_USE_FAKE_VIDEO_DECODER)
 void ClearKeyCdm::GenerateFakeVideoFrame(base::TimeDelta timestamp,
                                          cdm::VideoFrame* video_frame) {
   // Choose non-zero alignment and padding on purpose for testing.
   const int kAlignment = 8;
   const int kPadding = 16;
   const int kPlanePadding = 128;
 
@@ skipping 32 matching lines @@
 #endif  // CLEAR_KEY_CDM_USE_FAKE_VIDEO_DECODER
 
 cdm::Status ClearKeyCdm::DecryptAndDecodeSamples(
     const cdm::InputBuffer& encrypted_buffer,
     cdm::Buffer* sample_buffer) {
   NOTIMPLEMENTED();
   return cdm::kDecryptError;
 }
 
 }  // namespace webkit_media