Support (E)AC3 passthrough

media/base/audio_bus.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 "media/base/audio_bus.h"
 
 #include <stddef.h>
 #include <stdint.h>
 
 #include <limits>
@@ skipping 44 matching lines @@
 void AudioBus::CheckOverflow(int start_frame, int frames, int total_frames) {
   CHECK_GE(start_frame, 0);
   CHECK_GE(frames, 0);
   CHECK_GT(total_frames, 0);
   int sum = start_frame + frames;
   CHECK_LE(sum, total_frames);
   CHECK_GE(sum, 0);
 }
 
 AudioBus::AudioBus(int channels, int frames)
-    : frames_(frames),
+    : data_size_(0),
+      is_raw_format_(false),
+      frames_(frames),
       can_set_channel_data_(false) {
   ValidateConfig(channels, frames_);
 
   int aligned_frames = 0;
   int size = CalculateMemorySizeInternal(channels, frames, &aligned_frames);
 
   data_.reset(static_cast<float*>(base::AlignedAlloc(
       size, AudioBus::kChannelAlignment)));
 
   BuildChannelData(channels, aligned_frames, data_.get());
 }
 
 AudioBus::AudioBus(int channels, int frames, float* data)
-    : frames_(frames),
+    : data_size_(0),
+      is_raw_format_(false),
+      frames_(frames),
       can_set_channel_data_(false) {
   // Since |data| may have come from an external source, ensure it's valid.
   CHECK(data);
   ValidateConfig(channels, frames_);
 
   int aligned_frames = 0;
   CalculateMemorySizeInternal(channels, frames, &aligned_frames);
 
   BuildChannelData(channels, aligned_frames, data);
 }
 
 AudioBus::AudioBus(int frames, const std::vector<float*>& channel_data)
-    : channel_data_(channel_data),
+    : data_size_(0),
+      is_raw_format_(false),
+      channel_data_(channel_data),
       frames_(frames),
       can_set_channel_data_(false) {
   ValidateConfig(
       base::checked_cast<int>(channel_data_.size()), frames_);
 
   // Sanity check wrapped vector for alignment and channel count.
   for (size_t i = 0; i < channel_data_.size(); ++i)
     DCHECK(IsAligned(channel_data_[i]));
 }
 
 AudioBus::AudioBus(int channels)
-    : channel_data_(channels),
+    : data_size_(0),
+      is_raw_format_(false),
+      channel_data_(channels),
       frames_(0),
       can_set_channel_data_(true) {
   CHECK_GT(channels, 0);
   for (size_t i = 0; i < channel_data_.size(); ++i)
     channel_data_[i] = NULL;
 }
 
 AudioBus::~AudioBus() {}
 
 std::unique_ptr<AudioBus> AudioBus::Create(int channels, int frames) {
@@ skipping 35 matching lines @@
 
 void AudioBus::SetChannelData(int channel, float* data) {
   CHECK(can_set_channel_data_);
   CHECK(data);
   CHECK_GE(channel, 0);
   CHECK_LT(static_cast<size_t>(channel), channel_data_.size());
   DCHECK(IsAligned(data));
   channel_data_[channel] = data;
 }
 
+void AudioBus::set_data_size(int data_size) {
+  data_size_ = data_size;
+}
+
+void AudioBus::set_is_raw_format(bool is_raw_format) {
+  is_raw_format_ = is_raw_format;
+}
+
 void AudioBus::set_frames(int frames) {
-  CHECK(can_set_channel_data_);
-  ValidateConfig(static_cast<int>(channel_data_.size()), frames);
+  if (!is_raw_format()) {
+    CHECK(can_set_channel_data_);
+    ValidateConfig(static_cast<int>(channel_data_.size()), frames);
+  }
   frames_ = frames;
 }
 
 void AudioBus::ZeroFramesPartial(int start_frame, int frames) {
   CheckOverflow(start_frame, frames, frames_);
 
   if (frames <= 0)
     return;
 
   for (size_t i = 0; i < channel_data_.size(); ++i) {
@@ skipping 128 matching lines @@
       ToInterleavedPartial<SignedInt32SampleTypeTraits>(
           start_frame, frames, reinterpret_cast<int32_t*>(dest));
       break;
     default:
       NOTREACHED() << "Unsupported bytes per sample encountered: "
                    << bytes_per_sample;
   }
 }
 
 void AudioBus::CopyTo(AudioBus* dest) const {
+  dest->set_is_raw_format(is_raw_format());
+  if (is_raw_format()) {
+    dest->set_data_size(data_size());
+    dest->set_frames(frames());
+    memcpy(dest->channel(0), channel(0), data_size());
+    return;
+  }
+
   CopyPartialFramesTo(0, frames(), 0, dest);
 }
 
 void AudioBus::CopyPartialFramesTo(int source_start_frame,
                                    int frame_count,
                                    int dest_start_frame,
                                    AudioBus* dest) const {
   CHECK_EQ(channels(), dest->channels());
   CHECK_LE(source_start_frame + frame_count, frames());
   CHECK_LE(dest_start_frame + frame_count, dest->frames());
@@ skipping 28 matching lines @@
   return scoped_refptr<AudioBusRefCounted>(
       new AudioBusRefCounted(channels, frames));
 }
 
 AudioBusRefCounted::AudioBusRefCounted(int channels, int frames)
     : AudioBus(channels, frames) {}
 
 AudioBusRefCounted::~AudioBusRefCounted() {}
 
 }  // namespace media