Update PluginInstance for audio support for content decryption.

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 423 matching lines @@
 }
 
 void VideoFrameImpl::set_timestamp(int64_t timestamp) {
   timestamp_ = timestamp;
 }
 
 int64_t VideoFrameImpl::timestamp() const {
   return timestamp_;
 }
 
+class AudioFramesImpl : public cdm::AudioFrames {
+ public:
+  AudioFramesImpl() : buffer_(NULL) {}
+  virtual ~AudioFramesImpl() {
+    if (buffer_)
+      buffer_->Destroy();
+  }
+
+  // AudioFrames implementation.
+  virtual void set_buffer(cdm::Buffer* buffer) OVERRIDE {
+    buffer_ = static_cast<PpbBuffer*>(buffer);
+  }
+  virtual cdm::Buffer* buffer() OVERRIDE {
+    return buffer_;
+  }
+
+ private:
+  PpbBuffer* buffer_;
+
+  DISALLOW_COPY_AND_ASSIGN(AudioFramesImpl);
+};
+
 // A wrapper class for abstracting away PPAPI interaction and threading for a
 // Content Decryption Module (CDM).
 class CdmWrapper : public pp::Instance,
                    public pp::ContentDecryptor_Private,
                    public cdm::CdmHost {
  public:
   CdmWrapper(PP_Instance instance, pp::Module* module);
   virtual ~CdmWrapper();
   virtual bool Init(uint32_t argc, const char* argn[], const char* argv[]) {
     return true;
@@ skipping 27 matching lines @@
       const PP_EncryptedBlockInfo& encrypted_block_info) OVERRIDE;
 
   // CdmHost methods.
   virtual void SetTimer(int64 delay_ms) OVERRIDE;
   virtual double GetCurrentWallTimeMs() OVERRIDE;
 
  private:
   typedef linked_ptr<DecryptedBlockImpl> LinkedDecryptedBlock;
   typedef linked_ptr<KeyMessageImpl> LinkedKeyMessage;
   typedef linked_ptr<VideoFrameImpl> LinkedVideoFrame;
+  typedef linked_ptr<AudioFramesImpl> LinkedAudioFrames;
 
   // <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 DecoderInitializeDone(int32_t result,
                              PP_DecryptorStreamType decoder_type,
                              uint32_t request_id,
                              bool success);
   void DecoderDeinitializeDone(int32_t result,
                                PP_DecryptorStreamType decoder_type,
                                uint32_t request_id);
   void DecoderResetDone(int32_t result,
                         PP_DecryptorStreamType decoder_type,
                         uint32_t request_id);
   void DeliverFrame(int32_t result,
                     const cdm::Status& status,
                     const LinkedVideoFrame& video_frame,
                     const PP_DecryptTrackingInfo& tracking_info);
+  void DeliverSamples(int32_t result,
+                      const cdm::Status& status,
+                      const LinkedAudioFrames& audio_frames,
+                      const PP_DecryptTrackingInfo& tracking_info);
 
   // Helper for SetTimer().
   void TimerExpired(int32 result);
 
   PpbBufferAllocator allocator_;
   pp::CompletionCallbackFactory<CdmWrapper> callback_factory_;
   cdm::ContentDecryptionModule* cdm_;
   std::string key_system_;
 };
 
@@ skipping 181 matching lines @@
   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(cdm_);
 
   cdm::InputBuffer input_buffer;
   std::vector<cdm::SubsampleEntry> subsamples;
   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));
+  cdm::Status status = cdm::kDecodeError;
+  switch (decoder_type) {
+    case PP_DECRYPTORSTREAMTYPE_VIDEO: {
+      LinkedVideoFrame video_frame(new VideoFrameImpl());
+      status = cdm_->DecryptAndDecodeFrame(input_buffer, video_frame.get());
+      CallOnMain(callback_factory_.NewCallback(
+          &CdmWrapper::DeliverFrame,
+          status,
+          video_frame,
+          encrypted_block_info.tracking_info));
+      return;
+    }
+
+    case PP_DECRYPTORSTREAMTYPE_AUDIO: {
+      LinkedAudioFrames audio_frames(new AudioFramesImpl());
+      status = cdm_->DecryptAndDecodeSamples(input_buffer, audio_frames.get());
+      CallOnMain(callback_factory_.NewCallback(
+          &CdmWrapper::DeliverSamples,
+          status,
+          audio_frames,
+          encrypted_block_info.tracking_info));
+      return;
+    }
+
+    default:
+      PP_NOTREACHED();
+      return;
+  }
 }
 
 void CdmWrapper::SetTimer(int64 delay_ms) {
   // NOTE: doesn't really need to run on the main thread; could just as well run
   // on a helper thread if |cdm_| were thread-friendly and care was taken.  We
   // only use CallOnMainThread() here to get delayed-execution behavior.
   pp::Module::Get()->core()->CallOnMainThread(
       delay_ms,
       callback_factory_.NewCallback(&CdmWrapper::TimerExpired),
       PP_OK);
@@ skipping 53 matching lines @@
   PP_DecryptedBlockInfo decrypted_block_info;
   decrypted_block_info.tracking_info = tracking_info;
   decrypted_block_info.tracking_info.timestamp = decrypted_block->timestamp();
   decrypted_block_info.result = CdmStatusToPpDecryptResult(status);
 
   pp::Buffer_Dev buffer;
 
   if (decrypted_block_info.result == PP_DECRYPTRESULT_SUCCESS) {
     PP_DCHECK(decrypted_block.get() && decrypted_block->buffer());
     if (!decrypted_block.get() || !decrypted_block->buffer()) {
+      PP_NOTREACHED();
       decrypted_block_info.result = PP_DECRYPTRESULT_DECRYPT_ERROR;
     } else {
       buffer = static_cast<PpbBuffer*>(decrypted_block->buffer())->buffer_dev();
     }
   }
 
   pp::ContentDecryptor_Private::DeliverBlock(buffer, decrypted_block_info);
 }
 
 void CdmWrapper::DecoderInitializeDone(int32_t result,
@@ skipping 36 matching lines @@
     PP_DCHECK(video_frame->format() == cdm::kI420 ||
               video_frame->format() == cdm::kYv12);
 
     decrypted_frame_info.format =
         CdmVideoFormatToPpDecryptedFrameFormat(video_frame->format());
 
     if (!video_frame.get() ||
         !video_frame->frame_buffer() ||
         (decrypted_frame_info.format != PP_DECRYPTEDFRAMEFORMAT_YV12 &&
          decrypted_frame_info.format != PP_DECRYPTEDFRAMEFORMAT_I420)) {
+      PP_NOTREACHED();
       decrypted_frame_info.result = PP_DECRYPTRESULT_DECODE_ERROR;
     } else {
       buffer = static_cast<PpbBuffer*>(
           video_frame->frame_buffer())->buffer_dev();
       decrypted_frame_info.width = video_frame->size().width;
       decrypted_frame_info.height = video_frame->size().height;
       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);
       decrypted_frame_info.strides[PP_DECRYPTEDFRAMEPLANES_V] =
           video_frame->stride(cdm::VideoFrame::kVPlane);
     }
   }
 
   pp::ContentDecryptor_Private::DeliverFrame(buffer, decrypted_frame_info);
 }
 
+void CdmWrapper::DeliverSamples(int32_t result,
+                                const cdm::Status& status,
+                                const LinkedAudioFrames& audio_frames,
+                                const PP_DecryptTrackingInfo& tracking_info) {
+  PP_DCHECK(result == PP_OK);
+  // TODO(tomfinegan): Add PP_DecryptedSamplesInfo (or better name) for
+  // cdm::AudioFrames.
+  PP_DecryptedBlockInfo decrypted_block_info;
+  decrypted_block_info.tracking_info = tracking_info;
+  // TODO(tomfinegan): Remove this after PP_DecryptedSamplesInfo is added.
+  decrypted_block_info.tracking_info.timestamp = 0;
+  decrypted_block_info.result = CdmStatusToPpDecryptResult(status);
+
+  pp::Buffer_Dev buffer;
+
+  if (decrypted_block_info.result == PP_DECRYPTRESULT_SUCCESS) {
+    PP_DCHECK(audio_frames.get() && audio_frames->buffer());
+    if (!audio_frames.get() || !audio_frames->buffer()) {
+      PP_NOTREACHED();
+      decrypted_block_info.result = PP_DECRYPTRESULT_DECRYPT_ERROR;
+    } else {
+      buffer = static_cast<PpbBuffer*>(audio_frames->buffer())->buffer_dev();
+    }
+  }
+
+  pp::ContentDecryptor_Private::DeliverSamples(buffer, decrypted_block_info);
+}
 
 // This object is the global object representing this plugin library as long
 // as it is loaded.
 class CdmWrapperModule : public pp::Module {
  public:
   CdmWrapperModule() : pp::Module() {}
   virtual ~CdmWrapperModule() {}
 
   virtual pp::Instance* CreateInstance(PP_Instance instance) {
     return new CdmWrapper(instance, this);
   }
 };
 
 }  // namespace webkit_media
 
 namespace pp {
 
 // Factory function for your specialization of the Module object.
 Module* CreateModule() {
   return new webkit_media::CdmWrapperModule();
 }
 
 }  // namespace pp