Plumb support for audio sample formats.

content/renderer/pepper/content_decryptor_delegate.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 "content/renderer/pepper/content_decryptor_delegate.h"
 
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop/message_loop_proxy.h"
 #include "base/safe_numerics.h"
@@ skipping 200 matching lines @@
     case media::Decryptor::kAudio:
       return PP_DECRYPTORSTREAMTYPE_AUDIO;
     case media::Decryptor::kVideo:
       return PP_DECRYPTORSTREAMTYPE_VIDEO;
     default:
       NOTREACHED();
       return PP_DECRYPTORSTREAMTYPE_VIDEO;
   }
 }
 
+media::SampleFormat PpDecryptedSampleFormatToMediaSampleFormat(
+    PP_DecryptedSampleFormat result) {
+  switch (result) {
+    case PP_DECRYPTEDSAMPLEFORMAT_U8:
+      return media::kSampleFormatU8;
+    case PP_DECRYPTEDSAMPLEFORMAT_S16:
+      return media::kSampleFormatS16;
+    case PP_DECRYPTEDSAMPLEFORMAT_S32:
+      return media::kSampleFormatS32;
+    case PP_DECRYPTEDSAMPLEFORMAT_F32:
+      return media::kSampleFormatF32;
+    case PP_DECRYPTEDSAMPLEFORMAT_PLANAR_S16:
+      return media::kSampleFormatPlanarS16;
+    case PP_DECRYPTEDSAMPLEFORMAT_PLANAR_F32:
+      return media::kSampleFormatPlanarF32;
+    default:
+      NOTREACHED();
+      return media::kUnknownSampleFormat;
+  }
+}
+
 }  // namespace
 
 ContentDecryptorDelegate::ContentDecryptorDelegate(
     PP_Instance pp_instance,
     const PPP_ContentDecryptor_Private* plugin_decryption_interface)
     : pp_instance_(pp_instance),
       plugin_decryption_interface_(plugin_decryption_interface),
       next_decryption_request_id_(1),
       pending_audio_decrypt_request_id_(0),
       pending_video_decrypt_request_id_(0),
       pending_audio_decoder_init_request_id_(0),
       pending_video_decoder_init_request_id_(0),
       pending_audio_decode_request_id_(0),
       pending_video_decode_request_id_(0),
-      audio_sample_format_(media::kUnknownSampleFormat),
       audio_samples_per_second_(0),
       audio_channel_count_(0),
-      audio_bytes_per_frame_(0),
       weak_ptr_factory_(this) {
   weak_this_ = weak_ptr_factory_.GetWeakPtr();
 }
 
 ContentDecryptorDelegate::~ContentDecryptorDelegate() {
 }
 
 void ContentDecryptorDelegate::Initialize(const std::string& key_system,
                                           bool can_challenge_platform) {
   DCHECK(!key_system.empty());
@@ skipping 149 matching lines @@
     const media::Decryptor::DecoderInitCB& init_cb) {
   PP_AudioDecoderConfig pp_decoder_config;
   pp_decoder_config.codec =
       MediaAudioCodecToPpAudioCodec(decoder_config.codec());
   pp_decoder_config.channel_count =
       media::ChannelLayoutToChannelCount(decoder_config.channel_layout());
   pp_decoder_config.bits_per_channel = decoder_config.bits_per_channel();
   pp_decoder_config.samples_per_second = decoder_config.samples_per_second();
   pp_decoder_config.request_id = next_decryption_request_id_++;
 
-  audio_sample_format_ = decoder_config.sample_format();
   audio_samples_per_second_ = pp_decoder_config.samples_per_second;
   audio_channel_count_ = pp_decoder_config.channel_count;
-  audio_bytes_per_frame_ = decoder_config.bytes_per_frame();
 
   scoped_refptr<PPB_Buffer_Impl> extra_data_resource;
   if (!MakeBufferResource(pp_instance_,
                           decoder_config.extra_data(),
                           decoder_config.extra_data_size(),
                           &extra_data_resource)) {
     return false;
   }
   ScopedPPResource pp_resource(extra_data_resource.get());
 
@@ skipping 423 matching lines @@
                          ppb_buffer,
                          base::Bind(&ContentDecryptorDelegate::FreeBuffer,
                                     weak_this_,
                                     frame_info->tracking_info.buffer_id))));
 
   video_decode_cb.Run(media::Decryptor::kSuccess, decoded_frame);
 }
 
 void ContentDecryptorDelegate::DeliverSamples(
     PP_Resource audio_frames,
-    const PP_DecryptedBlockInfo* block_info) {
-  DCHECK(block_info);
+    const PP_DecryptedSampleInfo* sample_info) {
+  DCHECK(sample_info);
 
-  FreeBuffer(block_info->tracking_info.buffer_id);
+  FreeBuffer(sample_info->tracking_info.buffer_id);
 
-  const uint32_t request_id = block_info->tracking_info.request_id;
+  const uint32_t request_id = sample_info->tracking_info.request_id;
   DVLOG(2) << "DeliverSamples() - request_id: " << request_id;
 
   // If the request ID is not valid or does not match what's saved, do nothing.
   if (request_id == 0 || request_id != pending_audio_decode_request_id_) {
     DVLOG(1) << "DeliverSamples() - request_id " << request_id << " not found";
     return;
   }
 
   DCHECK(!pending_audio_decode_cb_.is_null());
   pending_audio_decode_request_id_ = 0;
   media::Decryptor::AudioDecodeCB audio_decode_cb =
       base::ResetAndReturn(&pending_audio_decode_cb_);
 
   const media::Decryptor::AudioBuffers empty_frames;
 
   media::Decryptor::Status status =
-      PpDecryptResultToMediaDecryptorStatus(block_info->result);
+      PpDecryptResultToMediaDecryptorStatus(sample_info->result);
   if (status != media::Decryptor::kSuccess) {
     audio_decode_cb.Run(status, empty_frames);
     return;
   }
 
+  media::SampleFormat sample_format =
+      PpDecryptedSampleFormatToMediaSampleFormat(sample_info->format);
+
   media::Decryptor::AudioBuffers audio_frame_list;
   if (!DeserializeAudioFrames(audio_frames,
-                              block_info->data_size,
+                              sample_info->data_size,
+                              sample_format,
                               &audio_frame_list)) {
     NOTREACHED() << "CDM did not serialize the buffer correctly.";
     audio_decode_cb.Run(media::Decryptor::kError, empty_frames);
     return;
   }
 
   audio_decode_cb.Run(media::Decryptor::kSuccess, audio_frame_list);
 }
 
 // TODO(xhwang): Try to remove duplicate logic here and in CancelDecrypt().
@@ skipping 92 matching lines @@
   if (free_buffers_.empty())
     return;
 
   tracking_info->buffer_id = free_buffers_.front();
   free_buffers_.pop();
 }
 
 bool ContentDecryptorDelegate::DeserializeAudioFrames(
     PP_Resource audio_frames,
     size_t data_size,
+    media::SampleFormat sample_format,
     media::Decryptor::AudioBuffers* frames) {
   DCHECK(frames);
   EnterResourceNoLock<PPB_Buffer_API> enter(audio_frames, true);
   if (!enter.succeeded())
     return false;
 
   BufferAutoMapper mapper(enter.object());
   if (!mapper.data() || !mapper.size() ||
       mapper.size() < static_cast<uint32_t>(data_size))
     return false;
 
   // TODO(jrummell): Pass ownership of data() directly to AudioBuffer to avoid
   // the copy. Since it is possible to get multiple buffers, it would need to be
   // sliced and ref counted appropriately. http://crbug.com/255576.
   const uint8* cur = static_cast<uint8*>(mapper.data());
   size_t bytes_left = data_size;
 
+  const int audio_bytes_per_frame =
+      media::SampleFormatToBytesPerChannel(sample_format) *
+      audio_channel_count_;
+
+  // Allocate space for the channel pointers given to AudioBuffer.
+  int num_channel_ptrs = 1;

[xhwang, 2013/10/11 22:45:16]

A brief comment why the default is 1? Interleaved bla bla..

[DaleCurtis, 2013/10/12 01:51:05]

Removed in favor of letting CopyFrom() handle sample format specifics.

+  if (sample_format == media::kSampleFormatPlanarS16 ||
+      sample_format == media::kSampleFormatPlanarF32) {
+    num_channel_ptrs = audio_channel_count_;
+  }
+  scoped_ptr<const uint8*[]> channel_ptrs(new const uint8*[num_channel_ptrs]);
+
   do {
     int64 timestamp = 0;
     int64 frame_size = -1;
     const size_t kHeaderSize = sizeof(timestamp) + sizeof(frame_size);
 
     if (bytes_left < kHeaderSize)
       return false;
 
     memcpy(&timestamp, cur, sizeof(timestamp));
     cur += sizeof(timestamp);
     bytes_left -= sizeof(timestamp);
 
     memcpy(&frame_size, cur, sizeof(frame_size));
     cur += sizeof(frame_size);
     bytes_left -= sizeof(frame_size);
 
     // We should *not* have empty frames in the list.
     if (frame_size <= 0 ||
         bytes_left < base::checked_numeric_cast<size_t>(frame_size)) {
       return false;
     }
 
-    const uint8* data[] = {cur};
-    int frame_count = frame_size / audio_bytes_per_frame_;
+    // Setup channel pointers.
+    const int size_per_channel = frame_size / audio_channel_count_;
+    for (int i = 0; i < num_channel_ptrs; ++i)
+      channel_ptrs[i] = cur + i * size_per_channel;
+
+    const int frame_count = frame_size / audio_bytes_per_frame;
     scoped_refptr<media::AudioBuffer> frame = media::AudioBuffer::CopyFrom(
-        audio_sample_format_,
+        sample_format,
         audio_channel_count_,
         frame_count,
-        data,
+        channel_ptrs.get(),
         base::TimeDelta::FromMicroseconds(timestamp),
         base::TimeDelta::FromMicroseconds(audio_samples_per_second_ /
                                           frame_count));
     frames->push_back(frame);
 
     cur += frame_size;
     bytes_left -= frame_size;
   } while (bytes_left > 0);
 
   return true;
 }
 
 }  // namespace content