Add FFmpeg audio decoder for the clear key CDM.

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/buffers.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_audio_decoder.h"
 #include "webkit/media/crypto/ppapi/ffmpeg_cdm_video_decoder.h"
 
+// Include FFmpeg avformat.h for av_register_all().
+extern "C" {
+// Temporarily disable possible loss of data warning.
+MSVC_PUSH_DISABLE_WARNING(4244);
+#include <libavformat/avformat.h>
+MSVC_POP_WARNING();
+}  // extern "C"
+
 // 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));
+
+  // TODO(tomfinegan): Add and implement cdm::InitializeCdmModule(),
+  // and call |av_register_all()| from there.
+  av_register_all();
+
   return true;
 }
 
 static bool g_cdm_module_initialized = InitializeFFmpegLibraries();
 #endif  // CLEAR_KEY_CDM_USE_FFMPEG_DECODER
 
 static const char kClearKeyCdmVersion[] = "0.1.0.0";
 
 // Copies |input_buffer| into a media::DecoderBuffer. If the |input_buffer| is
 // empty, an empty (end-of-stream) media::DecoderBuffer is returned.
@@ skipping 215 matching lines @@
   memcpy(reinterpret_cast<void*>(decrypted_block->buffer()->data()),
          buffer->GetData(),
          buffer->GetDataSize());
   decrypted_block->set_timestamp(buffer->GetTimestamp().InMicroseconds());
 
   return cdm::kSuccess;
 }
 
 cdm::Status ClearKeyCdm::InitializeAudioDecoder(
     const cdm::AudioDecoderConfig& audio_decoder_config) {
-#if !defined(CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER)
-  NOTIMPLEMENTED();
-  return cdm::kSessionError;
-#else
+#if defined(CLEAR_KEY_CDM_USE_FFMPEG_DECODER)
+  if (!audio_decoder_)
+    audio_decoder_.reset(new webkit_media::FFmpegCdmAudioDecoder(allocator_));
+
+  if (!audio_decoder_->Initialize(audio_decoder_config))
+    return cdm::kSessionError;
+
+  return cdm::kSuccess;
+#elif defined(CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER)
   channel_count_ = audio_decoder_config.channel_count;
   bits_per_channel_ = audio_decoder_config.bits_per_channel;
   samples_per_second_ = audio_decoder_config.samples_per_second;
   return cdm::kSuccess;
-#endif  // CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER
+#else
+  NOTIMPLEMENTED();
+  return cdm::kSessionError;
+#endif  // CLEAR_KEY_CDM_USE_FFMPEG_DECODER
 }
 
 cdm::Status ClearKeyCdm::InitializeVideoDecoder(
     const cdm::VideoDecoderConfig& video_decoder_config) {
 #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;
 #endif  // CLEAR_KEY_CDM_USE_FFMPEG_DECODER
 }
 
 void ClearKeyCdm::ResetDecoder(cdm::StreamType decoder_type) {
-#if defined(CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER)
+  DVLOG(1) << "ResetDecoder()";
+#if defined(CLEAR_KEY_CDM_USE_FFMPEG_DECODER)
+  switch (decoder_type) {
+    case cdm::kStreamTypeVideo:
+      video_decoder_->Reset();
+      break;
+    case cdm::kStreamTypeAudio:
+      audio_decoder_->Reset();
+      break;
+    default:
+      NOTREACHED() << "ResetDecoder(): invalid cdm::StreamType";
+  }
+#elif defined(CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER)
   if (decoder_type == cdm::kStreamTypeAudio) {
     last_timestamp_ = media::kNoTimestamp();
     last_duration_ = media::kInfiniteDuration();
   }
-#endif  // CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER
-
-#if defined(CLEAR_KEY_CDM_USE_FFMPEG_DECODER)
-  if (decoder_type == cdm::kStreamTypeVideo)
-    video_decoder_->Reset();
-#endif
+#endif  // CLEAR_KEY_CDM_USE_FFMPEG_DECODER
 }
 
 void ClearKeyCdm::DeinitializeDecoder(cdm::StreamType decoder_type) {
-#if defined(CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER)
+  DVLOG(1) << "DeinitializeDecoder()";
+#if defined(CLEAR_KEY_CDM_USE_FFMPEG_DECODER)
+  switch (decoder_type) {
+    case cdm::kStreamTypeVideo:
+      video_decoder_->Deinitialize();
+      break;
+    case cdm::kStreamTypeAudio:
+      audio_decoder_->Deinitialize();
+      break;
+    default:
+      NOTREACHED() << "DeinitializeDecoder(): invalid cdm::StreamType";
+  }
+#elif defined(CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER)
   if (decoder_type == cdm::kStreamTypeAudio) {
     last_timestamp_ = media::kNoTimestamp();
     last_duration_ = media::kInfiniteDuration();
   }
-#endif  // CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER
-
-#if defined(CLEAR_KEY_CDM_USE_FFMPEG_DECODER)
-  if (decoder_type == cdm::kStreamTypeVideo)
-    video_decoder_->Deinitialize();
-#endif
+#endif  // CLEAR_KEY_CDM_USE_FFMPEG_DECODER
 }
 
 cdm::Status ClearKeyCdm::DecryptAndDecodeFrame(
     const cdm::InputBuffer& encrypted_buffer,
     cdm::VideoFrame* decoded_frame) {
   DVLOG(1) << "DecryptAndDecodeFrame()";
 
   scoped_refptr<media::DecoderBuffer> buffer;
   cdm::Status status = DecryptToMediaDecoderBuffer(encrypted_buffer, &buffer);
 
@@ skipping 25 matching lines @@
     const cdm::InputBuffer& encrypted_buffer,
     cdm::AudioFrames* audio_frames) {
   DVLOG(1) << "DecryptAndDecodeSamples()";
 
   scoped_refptr<media::DecoderBuffer> buffer;
   cdm::Status status = DecryptToMediaDecoderBuffer(encrypted_buffer, &buffer);
 
   if (status != cdm::kSuccess)
     return status;
 
-#if !defined(CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER)
-  NOTIMPLEMENTED();
-  return cdm::kDecodeError;
-#else
+#if defined(CLEAR_KEY_CDM_USE_FFMPEG_DECODER)
+  DCHECK(status == cdm::kSuccess);
+  DCHECK(buffer);
+  return audio_decoder_->DecodeBuffer(buffer.get()->GetData(),
+                                      buffer->GetDataSize(),
+                                      encrypted_buffer.timestamp,
+                                      audio_frames);
+#elif defined(CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER)
   if (buffer->IsEndOfStream()) {
     // Upon the first EOS frame, return a frame with |last_duration_|.
     if (last_duration_ != media::kInfiniteDuration()) {
       DCHECK(last_timestamp_ != media::kNoTimestamp());
       GenerateFakeAudioFrames(audio_frames);
       last_timestamp_ = media::kNoTimestamp();
       last_duration_ = media::kInfiniteDuration();
       return cdm::kSuccess;
     }
 
@@ skipping 110 matching lines @@
 
   static unsigned char color = 0;
   color += 10;
 
   memset(reinterpret_cast<void*>(video_frame->frame_buffer()->data()),
          color, frame_size);
 }
 #endif  // CLEAR_KEY_CDM_USE_FAKE_VIDEO_DECODER
 
 }  // namespace webkit_media