Support (E)AC3 passthrough

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"
 #include "media/base/limits.h"
 #include "media/base/timestamp_constants.h"
 
 namespace media {
 
 static base::TimeDelta CalculateDuration(int frames, double sample_rate) {
   DCHECK_GT(sample_rate, 0);
   return base::TimeDelta::FromMicroseconds(
       frames * base::Time::kMicrosecondsPerSecond / sample_rate);
 }
 
 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,
+                         size_t data_size,
                          const base::TimeDelta timestamp)
     : 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 == NULL && frame_count == 0),
       timestamp_(timestamp),
       duration_(end_of_stream_
                     ? base::TimeDelta()
                     : CalculateDuration(adjusted_frame_count_, sample_rate_)),
-      data_size_(0) {
+      data_size_(data_size) {
   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;
 
+  if (sample_format == kSampleFormatRaw) {

[AndyWu, 2016/11/04 18:04:24]

I refactored the code a little to avoid code duplication.

+    if (data_size_) {
+      data_.reset(static_cast<uint8_t*>(
+          base::AlignedAlloc(data_size_, kChannelAlignment)));

[DaleCurtis, 2016/11/01 23:05:13]

AlignedAlloc shouldn't be necessary in this case.

[AndyWu, 2016/11/04 18:04:24]

|data_| is defined as:
std::unique_ptr<uint8_t, base::AlignedFreeDeleter> data_;
Thus, AlignedAlloc is necessary, but kChannelAlignment isn't. However, the
minimum alignment is sizeof(void*), not 1. Not sure we really prefer this
alignment instead.

+      channel_data_.reserve(1);

[DaleCurtis, 2016/11/01 23:05:13]

Just channel_data_ = std::vector(1, data_.get()) ?

[AndyWu, 2016/11/04 18:04:24]

Yes, it should work. It's better in terms of line of code, but I can't say the
same thing about performance.

+      channel_data_.push_back(data_.get());
+      if (data)

[DaleCurtis, 2016/11/01 23:05:13]

This should never be null now right?

[AndyWu, 2016/11/04 18:04:24]

In current use cases, yes. But I would prefer to keep the behavior in sync with
PCM cases below.

+        memcpy(data_.get(), data[0], data_size_);
+    }
+    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.
     // 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.
@@ skipping 27 matching lines @@
 AudioBuffer::~AudioBuffer() {}
 
 // static
 scoped_refptr<AudioBuffer> AudioBuffer::CopyFrom(
     SampleFormat sample_format,
     ChannelLayout channel_layout,
     int channel_count,
     int sample_rate,
     int frame_count,
     const uint8_t* const* data,
-    const base::TimeDelta timestamp) {
+    const base::TimeDelta timestamp,
+    const size_t data_size) {

[DaleCurtis, 2016/11/01 23:05:13]

Instead of adding this, if you specify the appropriate frame size per sample
format then this works naturally in the existing code.

[AndyWu, 2016/11/04 18:04:24]

I see your point, but it would also introduce another parameter.
Also, some calculations would become floating numbers, and we have to round
these results to avoid precision issues.

[DaleCurtis, 2016/11/04 19:48:29]

Hmm, I guess you're saying that we don't always end up with a multiple of 4 for
the buffer size?

[DaleCurtis, 2016/11/04 21:17:33]

Actually, why can't you just define these sample formats to be 1 byte per frame,
so the frame_count == byte count. The rest of the code should be correct w/o
modification then.

[AndyWu, 2016/11/08 00:04:21]

The |data_size_| calculation is based on
https://cs.chromium.org/chromium/src/media/base/audio_buffer.cc?l=47
https://cs.chromium.org/chromium/src/media/base/audio_buffer.cc?l=82
In order to make byte per frame to be 1, SampleFormatToBytesPerChannel() has to
return floating number, not integer anymore. Thus, the derived calculations have
to handle precision issues. We also have to fake the frame_count. That may
create issues in audio clock or duration calculations.

Thus, providing data_size here seems more straightforward and unambiguous.

   // 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));
+  return make_scoped_refptr(
+      new AudioBuffer(sample_format, channel_layout, channel_count, sample_rate,
+                      frame_count, true, data, data_size, timestamp));
 }
 
 // static
 scoped_refptr<AudioBuffer> AudioBuffer::CreateBuffer(
     SampleFormat sample_format,
     ChannelLayout channel_layout,
     int channel_count,
     int sample_rate,
-    int frame_count) {
+    int frame_count,
+    size_t data_size) {
   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, NULL, kNoTimestamp));
+                      frame_count, true, NULL, data_size, kNoTimestamp));
 }
 
 // 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 == NULL, format doesn't matter.
-  return make_scoped_refptr(new AudioBuffer(kSampleFormatF32,
-                                            channel_layout,
-                                            channel_count,
-                                            sample_rate,
-                                            frame_count,
-                                            false,
-                                            NULL,
-                                            timestamp));
+  return make_scoped_refptr(
+      new AudioBuffer(kSampleFormatF32, channel_layout, channel_count,
+                      sample_rate, frame_count, false, NULL, 0, timestamp));
 }
 
 // static
 scoped_refptr<AudioBuffer> AudioBuffer::CreateEOSBuffer() {
   return make_scoped_refptr(new AudioBuffer(kUnknownSampleFormat,
                                             CHANNEL_LAYOUT_NONE, 0, 0, 0, false,
-                                            NULL, kNoTimestamp));
+                                            NULL, 0, kNoTimestamp));
 }
 
 // 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_raw_format = (sample_format_ == kSampleFormatRaw);
+  dest->set_is_raw_format(is_raw_format);
+
+  if (is_raw_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 92 matching lines @@
       case kSampleFormatS24:
       case kSampleFormatS32:
       case kSampleFormatF32: {
         // Interleaved data can be shifted all at once.
         const int frame_size = channel_count_ * bytes_per_channel;
         memmove(channel_data_[0] + start * frame_size,
                 channel_data_[0] + end * frame_size,
                 frame_size * frames_to_copy);
         break;
       }
+      case kSampleFormatRaw:
       case kUnknownSampleFormat:
         NOTREACHED() << "Invalid sample format!";
     }
   } 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