Support (E)AC3 passthrough

media/base/audio_buffer_queue.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_queue.h"
 
 #include <algorithm>
 
 #include "base/logging.h"
 #include "media/base/audio_bus.h"
@@ skipping 17 matching lines @@
   current_buffer_ = buffers_.begin();
 
   // Update the |frames_| counter since we have added frames.
   frames_ += buffer_in->frame_count();
   CHECK_GT(frames_, 0);  // make sure it doesn't overflow.
 }
 
 int AudioBufferQueue::ReadFrames(int frames,
                                  int dest_frame_offset,
                                  AudioBus* dest) {
-  DCHECK_GE(dest->frames(), frames + dest_frame_offset);
+  if (!dest->is_raw_format())
+    DCHECK_GE(dest->frames(), frames + dest_frame_offset);
   return InternalRead(frames, true, 0, dest_frame_offset, dest);
 }
 
 int AudioBufferQueue::PeekFrames(int frames,
                                  int source_frame_offset,
                                  int dest_frame_offset,
                                  AudioBus* dest) {
   DCHECK_GE(dest->frames(), frames);
   return InternalRead(
       frames, false, source_frame_offset, dest_frame_offset, dest);
 }
 
 void AudioBufferQueue::SeekFrames(int frames) {
   // Perform seek only if we have enough bytes in the queue.
   CHECK_LE(frames, frames_);
   int taken = InternalRead(frames, true, 0, 0, NULL);
   DCHECK_EQ(taken, frames);
 }
 
 int AudioBufferQueue::InternalRead(int frames,
                                    bool advance_position,
                                    int source_frame_offset,
                                    int dest_frame_offset,
                                    AudioBus* dest) {
+  if (!buffers_.size())
+    return 0;
+
+  if ((*buffers_.begin())->sample_format() == kSampleFormatRaw) {
+    DCHECK(!dest_frame_offset);
+    DCHECK(!source_frame_offset);
+
+    scoped_refptr<AudioBuffer> buffer = buffers_.front();
+    int taken = buffer->frame_count();
+
+    // if |dest| is NULL, there's no need to copy.
+    if (dest)
+      buffer->ReadFrames(buffer->frame_count(), 0, dest->data_size(), dest);
+
+    if (advance_position) {
+      // Update the appropriate values since |taken| frames have been copied
+      // out.
+      frames_ -= taken;
+      DCHECK_GE(frames_, 0);
+
+      // Remove any buffers before the current buffer as there is no going
+      // backwards.
+      buffers_.pop_front();
+      current_buffer_ = buffers_.begin();
+    }
+
+    return taken;
+  }
+
   // Counts how many frames are actually read from the buffer queue.
   int taken = 0;
   BufferQueue::iterator current_buffer = current_buffer_;
   int current_buffer_offset = current_buffer_offset_;
 
   int frames_to_skip = source_frame_offset;
   while (taken < frames) {
     // |current_buffer| is valid since the first time this buffer is appended
     // with data. Make sure there is data to be processed.
     if (current_buffer == buffers_.end())
@@ skipping 54 matching lines @@
     // backwards.
     buffers_.erase(buffers_.begin(), current_buffer);
     current_buffer_ = buffers_.begin();
     current_buffer_offset_ = current_buffer_offset;
   }
 
   return taken;
 }
 
 }  // namespace media