Use passthrough decoder for (E)AC3 formats

media/base/audio_buffer.cc

 // Copyright 2013 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 "media/base/audio_buffer.h"
 
 #include <cmath>
 
 #include "base/logging.h"
 #include "media/base/audio_bus.h"
@@ skipping 31 matching lines @@
   entries_.emplace_back(std::move(memory), size);
 }
 
 AudioBuffer::AudioBuffer(SampleFormat sample_format,
                          ChannelLayout channel_layout,
                          int channel_count,
                          int sample_rate,
                          int frame_count,
                          bool create_buffer,
                          const uint8_t* const* data,
+                         const size_t data_size,
                          const base::TimeDelta timestamp,
                          scoped_refptr<AudioBufferMemoryPool> pool)
     : sample_format_(sample_format),
       channel_layout_(channel_layout),
       channel_count_(channel_count),
       sample_rate_(sample_rate),
       adjusted_frame_count_(frame_count),
       end_of_stream_(!create_buffer && !data && !frame_count),
       timestamp_(timestamp),
       duration_(end_of_stream_
                     ? base::TimeDelta()
                     : CalculateDuration(adjusted_frame_count_, sample_rate_)),
-      data_size_(0),
+      data_size_(data_size),
       pool_(std::move(pool)) {
   CHECK_GE(channel_count_, 0);
   CHECK_LE(channel_count_, limits::kMaxChannels);
   CHECK_GE(frame_count, 0);
   DCHECK(channel_layout == CHANNEL_LAYOUT_DISCRETE ||
          ChannelLayoutToChannelCount(channel_layout) == channel_count);
 
   int bytes_per_channel = SampleFormatToBytesPerChannel(sample_format);
   DCHECK_LE(bytes_per_channel, kChannelAlignment);
 
   // Empty buffer?
   if (!create_buffer)
     return;
 
   int data_size_per_channel = frame_count * bytes_per_channel;
   if (IsPlanar(sample_format)) {
     // Planar data, so need to allocate buffer for each channel.

[chcunningham, 2017/05/05 01:14:12]

DCHECK(!IsBitstreamFormat(...))

[AndyWu, 2017/05/06 01:46:48]

Done.

     // Determine per channel data size, taking into account alignment.
     int block_size_per_channel =
         (data_size_per_channel + kChannelAlignment - 1) &
         ~(kChannelAlignment - 1);
     DCHECK_GE(block_size_per_channel, data_size_per_channel);
 
     // Allocate a contiguous buffer for all the channel data.
     data_size_ = channel_count_ * block_size_per_channel;
     if (pool_) {
       data_ = pool_->CreateBuffer(data_size_);
     } else {
       data_.reset(static_cast<uint8_t*>(
           base::AlignedAlloc(data_size_, kChannelAlignment)));
     }
     channel_data_.reserve(channel_count_);
 
     // Copy each channel's data into the appropriate spot.
     for (int i = 0; i < channel_count_; ++i) {
       channel_data_.push_back(data_.get() + i * block_size_per_channel);
       if (data)
         memcpy(channel_data_[i], data[i], data_size_per_channel);
     }
     return;
   }
 
   // Remaining formats are interleaved data.
   DCHECK(IsInterleaved(sample_format)) << sample_format_;
   // Allocate our own buffer and copy the supplied data into it. Buffer must
   // contain the data for all channels.
-  data_size_ = data_size_per_channel * channel_count_;
+  if (!IsBitstream(sample_format))
+    data_size_ = data_size_per_channel * channel_count_;

[chcunningham, 2017/05/05 01:14:12]

else DCHECK(data_size_ > 0)?

[AndyWu, 2017/05/06 01:46:48]

Done.

 
   if (pool_) {
     data_ = pool_->CreateBuffer(data_size_);
   } else {
     data_.reset(static_cast<uint8_t*>(
         base::AlignedAlloc(data_size_, kChannelAlignment)));
   }
 
   channel_data_.reserve(1);
   channel_data_.push_back(data_.get());
@@ skipping 14 matching lines @@
     int sample_rate,
     int frame_count,
     const uint8_t* const* data,
     const base::TimeDelta timestamp,
     scoped_refptr<AudioBufferMemoryPool> pool) {
   // If you hit this CHECK you likely have a bug in a demuxer. Go fix it.
   CHECK_GT(frame_count, 0);  // Otherwise looks like an EOF buffer.
   CHECK(data[0]);
   return make_scoped_refptr(
       new AudioBuffer(sample_format, channel_layout, channel_count, sample_rate,
-                      frame_count, true, data, timestamp, std::move(pool)));
+                      frame_count, true, data, 0, timestamp, std::move(pool)));
 }
 
 // static
+scoped_refptr<AudioBuffer> AudioBuffer::CopyBitstreamFrom(
+    SampleFormat sample_format,
+    ChannelLayout channel_layout,
+    int channel_count,
+    int sample_rate,
+    int frame_count,
+    const uint8_t* const* data,
+    const size_t data_size,
+    const base::TimeDelta timestamp,
+    scoped_refptr<AudioBufferMemoryPool> pool) {
+  // If you hit this CHECK you likely have a bug in a demuxer. Go fix it.
+  CHECK_GT(frame_count, 0);  // Otherwise looks like an EOF buffer.
+  CHECK(data[0]);
+  return make_scoped_refptr(new AudioBuffer(
+      sample_format, channel_layout, channel_count, sample_rate, frame_count,
+      true, data, data_size, timestamp, std::move(pool)));
+}
+
+// static
 scoped_refptr<AudioBuffer> AudioBuffer::CreateBuffer(
     SampleFormat sample_format,
     ChannelLayout channel_layout,
     int channel_count,
     int sample_rate,
     int frame_count,
     scoped_refptr<AudioBufferMemoryPool> pool) {
   CHECK_GT(frame_count, 0);  // Otherwise looks like an EOF buffer.
   return make_scoped_refptr(new AudioBuffer(
       sample_format, channel_layout, channel_count, sample_rate, frame_count,
-      true, nullptr, kNoTimestamp, std::move(pool)));
+      true, nullptr, 0, kNoTimestamp, std::move(pool)));
 }
 
 // static
+scoped_refptr<AudioBuffer> AudioBuffer::CreateBitstreamBuffer(
+    SampleFormat sample_format,
+    ChannelLayout channel_layout,
+    int channel_count,
+    int sample_rate,
+    int frame_count,
+    size_t data_size,
+    scoped_refptr<AudioBufferMemoryPool> pool) {
+  CHECK_GT(frame_count, 0);  // Otherwise looks like an EOF buffer.
+  return make_scoped_refptr(new AudioBuffer(
+      sample_format, channel_layout, channel_count, sample_rate, frame_count,
+      true, nullptr, data_size, kNoTimestamp, std::move(pool)));
+}
+
+// static
 scoped_refptr<AudioBuffer> AudioBuffer::CreateEmptyBuffer(
     ChannelLayout channel_layout,
     int channel_count,
     int sample_rate,
     int frame_count,
     const base::TimeDelta timestamp) {
   CHECK_GT(frame_count, 0);  // Otherwise looks like an EOF buffer.
   // Since data == nullptr, format doesn't matter.
   return make_scoped_refptr(new AudioBuffer(
       kSampleFormatF32, channel_layout, channel_count, sample_rate, frame_count,
-      false, nullptr, timestamp, nullptr));
+      false, nullptr, 0, timestamp, nullptr));
 }
 
 // static
 scoped_refptr<AudioBuffer> AudioBuffer::CreateEOSBuffer() {
   return make_scoped_refptr(new AudioBuffer(kUnknownSampleFormat,
                                             CHANNEL_LAYOUT_NONE, 0, 0, 0, false,
-                                            nullptr, kNoTimestamp, nullptr));
+                                            nullptr, 0, kNoTimestamp, nullptr));
 }
 
 // Convert int16_t values in the range [INT16_MIN, INT16_MAX] to [-1.0, 1.0].
 inline float ConvertSample(int16_t value) {
   return value * (value < 0 ? -1.0f / std::numeric_limits<int16_t>::min()
                             : 1.0f / std::numeric_limits<int16_t>::max());
 }
 
 void AudioBuffer::AdjustSampleRate(int sample_rate) {
   DCHECK(!end_of_stream_);
   sample_rate_ = sample_rate;
   duration_ = CalculateDuration(adjusted_frame_count_, sample_rate_);
 }
 
 void AudioBuffer::ReadFrames(int frames_to_copy,
                              int source_frame_offset,
                              int dest_frame_offset,
                              AudioBus* dest) {
   // Deinterleave each channel (if necessary) and convert to 32bit
   // floating-point with nominal range -1.0 -> +1.0 (if necessary).
 
   // |dest| must have the same number of channels, and the number of frames
   // specified must be in range.
   DCHECK(!end_of_stream());
   DCHECK_EQ(dest->channels(), channel_count_);
   DCHECK_LE(source_frame_offset + frames_to_copy, adjusted_frame_count_);
+
+  bool is_compressed_format = IsBitstream(sample_format_);
+  dest->set_is_compressed_format(is_compressed_format);

[chcunningham, 2017/05/05 01:14:11]

is_compressed_format is slightly different name from IsBitstream. Can you use
one or the other everywhere? 

[AndyWu, 2017/05/06 01:46:48]

Sorry, this change should not be included in this CL. Will implement it along
with AudioBus changes.

+
+  if (is_compressed_format) {
+    DCHECK(!source_frame_offset);
+    uint8_t* dest_data =
+        reinterpret_cast<uint8_t*>(dest->channel(0)) + dest->data_size();
+
+    memcpy(dest_data, channel_data_[0], data_size());
+    dest->set_data_size(dest_frame_offset + data_size());
+    dest->set_frames(dest->frames() + frame_count());
+    return;
+  }
+
   DCHECK_LE(dest_frame_offset + frames_to_copy, dest->frames());
 
   if (!data_) {
     // Special case for an empty buffer.
     dest->ZeroFramesPartial(dest_frame_offset, frames_to_copy);
     return;
   }
 
   if (sample_format_ == kSampleFormatPlanarF32) {
     // Format is planar float32. Copy the data from each channel as a block.
@@ skipping 44 matching lines @@
   int bytes_per_channel = SampleFormatToBytesPerChannel(sample_format_);
   int frame_size = channel_count_ * bytes_per_channel;
   const uint8_t* source_data = data_.get() + source_frame_offset * frame_size;
   dest->FromInterleavedPartial(source_data, dest_frame_offset, frames_to_copy,
                                bytes_per_channel);
 }
 
 void AudioBuffer::TrimStart(int frames_to_trim) {
   CHECK_GE(frames_to_trim, 0);
   CHECK_LE(frames_to_trim, adjusted_frame_count_);
+  DCHECK(!IsBitstream(sample_format_));

[chcunningham, 2017/05/05 01:14:11]

These methods are called in frame_processor as part of append window trimming.
Remind me, what is the plan for that API? It obviously won't work, but AFIACT
people aren't prevented from trying to use it (and doing so will just mangle the
data). Perhaps we should turn this DCHECK into a LOG(ERROR) and make it a no-op?

[AndyWu, 2017/05/06 01:46:48]

Done. However, we really should prevent trimming calls on bitstream format.

[chcunningham, 2017/05/08 20:01:02]

They current MediaSource API doesn't really afford us a way to disable that
feature (other than internally making it a no-op). 

Perhaps (E)AC3 should be registered among the other MSE codecs and in its
registry documentation we can include a disclaimer that appendWindowStart/End
may not be supported. 

None of this blocks landing.

 
   TrimRange(0, frames_to_trim);
 }
 
 void AudioBuffer::TrimEnd(int frames_to_trim) {
   CHECK_GE(frames_to_trim, 0);
   CHECK_LE(frames_to_trim, adjusted_frame_count_);
+  DCHECK(!IsBitstream(sample_format_));
 
   // Adjust the number of frames and duration for this buffer.
   adjusted_frame_count_ -= frames_to_trim;
   duration_ = CalculateDuration(adjusted_frame_count_, sample_rate_);
 }
 
 void AudioBuffer::TrimRange(int start, int end) {
   CHECK_GE(start, 0);
   CHECK_LE(end, adjusted_frame_count_);
+  DCHECK(!IsBitstream(sample_format_));
 
   const int frames_to_trim = end - start;
   CHECK_GE(frames_to_trim, 0);
   CHECK_LE(frames_to_trim, adjusted_frame_count_);
 
   const int bytes_per_channel = SampleFormatToBytesPerChannel(sample_format_);
   const int frames_to_copy = adjusted_frame_count_ - end;
   if (frames_to_copy > 0) {
     switch (sample_format_) {
       case kSampleFormatPlanarS16:
@@ skipping 25 matching lines @@
     }
   } else {
     CHECK_EQ(frames_to_copy, 0);
   }
 
   // Trim the leftover data off the end of the buffer and update duration.
   TrimEnd(frames_to_trim);
 }
 
 }  // namespace media