Switch audio code from DataBuffer to AudioBuffer.

These are the changes to have the audio code use the new AudioBuffer and
AudioBufferQueue classes. The goal is to simplify the number of times the
audio data is copied and transformed.

BUG=248989

Review URL: https://chromiumcodereview.appspot.com/17737004

git-svn-id: svn://svn.chromium.org/chrome/trunk/src@210730 0039d316-1c4b-4281-b951-d872f2087c98

3 files changed, 90 insertions, 54 deletions

diff --git a/webkit/plugins/ppapi/content_decryptor_delegate.cc b/webkit/plugins/ppapi/content_decryptor_delegate.cc
index 1d3658a..6225a02 100644
--- a/webkit/plugins/ppapi/content_decryptor_delegate.cc
+++ b/webkit/plugins/ppapi/content_decryptor_delegate.cc
@@ -7,6 +7,8 @@
 #include "base/callback_helpers.h"
 #include "base/debug/trace_event.h"
 #include "base/message_loop/message_loop_proxy.h"
+#include "base/safe_numerics.h"
+#include "media/base/audio_buffer.h"
 #include "media/base/audio_decoder_config.h"
 #include "media/base/bind_to_loop.h"
 #include "media/base/channel_layout.h"
@@ -127,56 +129,6 @@ static bool MakeEncryptedBlockInfo(
   return true;
 }
 
-// Deserializes audio data stored in |audio_frames| into individual audio
-// buffers in |frames|. Returns true upon success.
-bool DeserializeAudioFrames(PP_Resource audio_frames,
-                            int data_size,
-                            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;
-
-  const uint8* cur = static_cast<uint8*>(mapper.data());
-  int bytes_left = data_size;
-
-  do {
-    int64 timestamp = 0;
-    int64 frame_size = -1;
-    const int 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 frame in the list.
-    if (frame_size <= 0 || bytes_left < frame_size)
-      return false;
-
-    scoped_refptr<media::DataBuffer> frame =
-        media::DataBuffer::CopyFrom(cur, frame_size);
-    frame->set_timestamp(base::TimeDelta::FromMicroseconds(timestamp));
-    frames->push_back(frame);
-
-    cur += frame_size;
-    bytes_left -= frame_size;
-  } while (bytes_left > 0);
-
-  return true;
-}
-
 PP_AudioCodec MediaAudioCodecToPpAudioCodec(media::AudioCodec codec) {
   switch (codec) {
     case media::kCodecVorbis:
@@ -282,7 +234,11 @@ ContentDecryptorDelegate::ContentDecryptorDelegate(
       pending_audio_decode_request_id_(0),
       pending_video_decode_request_id_(0),
       weak_ptr_factory_(this),
-      weak_this_(weak_ptr_factory_.GetWeakPtr()) {
+      weak_this_(weak_ptr_factory_.GetWeakPtr()),
+      audio_sample_format_(media::kUnknownSampleFormat),
+      audio_samples_per_second_(0),
+      audio_channel_count_(0),
+      audio_bytes_per_frame_(0) {
 }
 
 void ContentDecryptorDelegate::Initialize(const std::string& key_system) {
@@ -442,6 +398,11 @@ bool ContentDecryptorDelegate::InitializeAudioDecoder(
   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(),
@@ -1022,5 +983,66 @@ void ContentDecryptorDelegate::SetBufferToFreeInTrackingInfo(
   free_buffers_.pop();
 }
 
+bool ContentDecryptorDelegate::DeserializeAudioFrames(
+    PP_Resource audio_frames,
+    size_t data_size,
+    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;
+
+  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_;
+    scoped_refptr<media::AudioBuffer> frame = media::AudioBuffer::CopyFrom(
+        audio_sample_format_,
+        audio_channel_count_,
+        frame_count,
+        data,
+        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 ppapi
 }  // namespace webkit
diff --git a/webkit/plugins/ppapi/content_decryptor_delegate.h b/webkit/plugins/ppapi/content_decryptor_delegate.h
index 3653890..26b306b 100644
--- a/webkit/plugins/ppapi/content_decryptor_delegate.h
+++ b/webkit/plugins/ppapi/content_decryptor_delegate.h
@@ -14,6 +14,7 @@
 #include "base/memory/weak_ptr.h"
 #include "media/base/decryptor.h"
 #include "media/base/media_keys.h"
+#include "media/base/sample_format.h"
 #include "ppapi/c/private/pp_content_decryptor.h"
 #include "ppapi/c/private/ppp_content_decryptor_private.h"
 #include "ui/gfx/size.h"
@@ -127,6 +128,12 @@ class WEBKIT_PLUGINS_EXPORT ContentDecryptorDelegate {
 
   void SetBufferToFreeInTrackingInfo(PP_DecryptTrackingInfo* tracking_info);
 
+  // Deserializes audio data stored in |audio_frames| into individual audio
+  // buffers in |frames|. Returns true upon success.
+  bool DeserializeAudioFrames(PP_Resource audio_frames,
+                              size_t data_size,
+                              media::Decryptor::AudioBuffers* frames);
+
   const PP_Instance pp_instance_;
   const PPP_ContentDecryptor_Private* const plugin_decryption_interface_;
 
@@ -173,6 +180,12 @@ class WEBKIT_PLUGINS_EXPORT ContentDecryptorDelegate {
   base::WeakPtrFactory<ContentDecryptorDelegate> weak_ptr_factory_;
   base::WeakPtr<ContentDecryptorDelegate> weak_this_;
 
+  // Keep track of audio parameters.
+  media::SampleFormat audio_sample_format_;
+  int audio_samples_per_second_;
+  int audio_channel_count_;
+  int audio_bytes_per_frame_;
+
   DISALLOW_COPY_AND_ASSIGN(ContentDecryptorDelegate);
 };
 
diff --git a/webkit/renderer/media/crypto/ppapi/ffmpeg_cdm_audio_decoder.cc b/webkit/renderer/media/crypto/ppapi/ffmpeg_cdm_audio_decoder.cc
index 2019b3c..1391de8 100644
--- a/webkit/renderer/media/crypto/ppapi/ffmpeg_cdm_audio_decoder.cc
+++ b/webkit/renderer/media/crypto/ppapi/ffmpeg_cdm_audio_decoder.cc
@@ -151,8 +151,8 @@ bool FFmpegCdmAudioDecoder::Initialize(const cdm::AudioDecoderConfig& config) {
   bits_per_channel_ = config.bits_per_channel;
   samples_per_second_ = config.samples_per_second;
   bytes_per_frame_ = codec_context_->channels * bits_per_channel_ / 8;
-  output_timestamp_helper_.reset(new media::AudioTimestampHelper(
-      bytes_per_frame_, config.samples_per_second));
+  output_timestamp_helper_.reset(
+      new media::AudioTimestampHelper(config.samples_per_second));
   serialized_audio_frames_.reserve(bytes_per_frame_ * samples_per_second_);
   is_initialized_ = true;
 
@@ -351,7 +351,8 @@ cdm::Status FFmpegCdmAudioDecoder::DecodeBuffer(
 
       base::TimeDelta output_timestamp =
           output_timestamp_helper_->GetTimestamp();
-      output_timestamp_helper_->AddBytes(decoded_audio_size);
+      output_timestamp_helper_->AddFrames(decoded_audio_size /
+                                          bytes_per_frame_);
 
       // Serialize the audio samples into |serialized_audio_frames_|.
       SerializeInt64(output_timestamp.InMicroseconds());