Fake clear key CDM audio 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/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_video_decoder.h"
 
 // TODO(tomfinegan): When COMPONENT_BUILD is not defined an AtExitManager must
@@ skipping 52 matching lines @@
   output_buffer->SetTimestamp(
       base::TimeDelta::FromMicroseconds(input_buffer.timestamp));
 
   return output_buffer;
 }
 
 template<typename Type>
 class ScopedResetter {
  public:
   explicit ScopedResetter(Type* object) : object_(object) {}
-  ~ScopedResetter() {
-    object_->Reset();
-  }
+  ~ScopedResetter() { object_->Reset(); }
 
  private:
   Type* const object_;
 };
 
 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);
@@ skipping 58 matching lines @@
                                   const std::string& session_id,
                                   scoped_array<uint8> init_data,
                                   int init_data_length) {
   // In the current implementation of AesDecryptor, NeedKey is not used.
   // If no key is available to decrypt an input buffer, it returns kNoKey to
   // the caller instead of firing NeedKey.
   NOTREACHED();
 }
 
 ClearKeyCdm::ClearKeyCdm(cdm::Allocator* allocator, cdm::CdmHost*)
-    : decryptor_(&client_), allocator_(allocator) {
+    : decryptor_(&client_),
+      allocator_(allocator) {
   DCHECK(allocator_);
+#if defined(CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER)
+  channel_count_ = 0;
+  bits_per_channel_ = 0;
+  samples_per_second_ = 0;
+  last_timestamp_ = media::kNoTimestamp();
+  last_duration_ = media::kInfiniteDuration();
+#endif  // CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER
 }
 
 ClearKeyCdm::~ClearKeyCdm() {}
 
 cdm::Status ClearKeyCdm::GenerateKeyRequest(const uint8_t* init_data,
                                             int init_data_size,
                                             cdm::KeyMessage* key_request) {
   DVLOG(1) << "GenerateKeyRequest()";
   base::AutoLock auto_lock(client_lock_);
   ScopedResetter<Client> auto_resetter(&client_);
@@ skipping 78 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
+  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
 }
 
 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)
+  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
 }
 
 void ClearKeyCdm::DeinitializeDecoder(cdm::StreamType decoder_type) {
+#if 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
 }
 
 cdm::Status ClearKeyCdm::DecryptAndDecodeFrame(
     const cdm::InputBuffer& encrypted_buffer,
     cdm::VideoFrame* decoded_frame) {
   DVLOG(1) << "DecryptAndDecodeFrame()";
@@ skipping 18 matching lines @@
     return cdm::kNeedMoreData;
 
   GenerateFakeVideoFrame(buffer->GetTimestamp(), decoded_frame);
   return cdm::kSuccess;
 #else
   NOTIMPLEMENTED();
   return cdm::kDecodeError;
 #endif  // CLEAR_KEY_CDM_USE_FFMPEG_DECODER
 }
 
+cdm::Status ClearKeyCdm::DecryptAndDecodeSamples(
+    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 (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;
+    }
+
+    last_timestamp_ = media::kNoTimestamp();
+    return cdm::kNeedMoreData;
+  }
+
+  base::TimeDelta cur_timestamp = buffer->GetTimestamp();
+  DCHECK(cur_timestamp != media::kNoTimestamp());
+
+  // Return kNeedMoreData for the first frame because duration is unknown.
+  if (last_timestamp_ == media::kNoTimestamp()) {
+    last_timestamp_ = cur_timestamp;
+    return cdm::kNeedMoreData;
+  }
+
+  DCHECK(cur_timestamp > last_timestamp_);
+  last_duration_ = cur_timestamp - last_timestamp_;
+  last_timestamp_ = cur_timestamp;
+
+  GenerateFakeAudioFrames(audio_frames);
+  return cdm::kSuccess;
+#endif  // CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER
+}
+
 cdm::Status ClearKeyCdm::DecryptToMediaDecoderBuffer(
     const cdm::InputBuffer& encrypted_buffer,
     scoped_refptr<media::DecoderBuffer>* decrypted_buffer) {
   DCHECK(decrypted_buffer);
   scoped_refptr<media::DecoderBuffer> buffer =
       CopyDecoderBufferFrom(encrypted_buffer);
 
   if (buffer->IsEndOfStream()) {
     *decrypted_buffer = buffer;
     return cdm::kSuccess;
@@ skipping 11 matching lines @@
   if (status == media::Decryptor::kError)
     return cdm::kDecryptError;
 
   if (status == media::Decryptor::kNoKey)
     return cdm::kNoKey;
 
   DCHECK_EQ(status, media::Decryptor::kSuccess);
   return cdm::kSuccess;
 }
 
+#if defined(CLEAR_KEY_CDM_USE_FAKE_AUDIO_DECODER)
+void ClearKeyCdm::GenerateFakeAudioFrames(cdm::AudioFrames* audio_frames) {
+  // For now we only generate one audio frame for the whole duration.
+  // TODO(xhwang): Generate multiple audio frames for testing purposes.
+  DCHECK(last_duration_ != media::kInfiniteDuration());
+  int64 duration_in_microseconds = last_duration_.InMicroseconds();
+  DCHECK_GT(duration_in_microseconds, 0);
+
+  int64 timestamp = last_timestamp_.InMicroseconds();
+  int64 bytes_per_sample = channel_count_ * bits_per_channel_ / 8;
+  int64 frame_size = bytes_per_sample * samples_per_second_ *
+      duration_in_microseconds / base::Time::kMicrosecondsPerSecond;
+
+  const int kHeaderSize = sizeof(timestamp) + sizeof(frame_size);
+  audio_frames->set_buffer(allocator_->Allocate(kHeaderSize + frame_size));
+  int64* data = reinterpret_cast<int64*>(audio_frames->buffer()->data());
+  *(data++) = timestamp;
+  *(data++) = frame_size;
+  // You won't hear anything because we have all zeros here. But the video
+  // should play just fine!
+  memset(data, 0, frame_size);
+}
+#endif  // CLEAR_KEY_CDM_USE_FAKE_AUDIO_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;
 
   int width = video_size_.width;
   int height = video_size_.height;
@@ skipping 22 matching lines @@
   video_frame->set_timestamp(timestamp.InMicroseconds());
 
   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
 
-cdm::Status ClearKeyCdm::DecryptAndDecodeSamples(
-    const cdm::InputBuffer& encrypted_buffer,
-    cdm::AudioFrames* audio_frames) {
-  NOTIMPLEMENTED();
-  return cdm::kDecryptError;
-}
-
 }  // namespace webkit_media