Get PulseAudio implementation working.

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 <limits>
 
 #include "base/logging.h"
 #include "media/audio/audio_parameters.h"
@@ skipping 43 matching lines @@
          ++i, offset += channels) {
       Fixed v = static_cast<Fixed>(source[offset]) - kBias;
       channel_data[i] = v * (v < 0 ? kMinScale : kMaxScale);
     }
   }
 }
 
 // |Format| is the destination type, |Fixed| is a type larger than |Format|
 // such that operations can be made without overflowing.
 template<class Format, class Fixed>
-static void ToInterleavedInternal(const AudioBus* source, int frames,
-                                  void* dst) {
+static void ToInterleavedInternal(const AudioBus* source, int start_frame,
+                                  int frames, void* dst) {
   Format* dest = static_cast<Format*>(dst);
 
   static const Format kBias = std::numeric_limits<Format>::is_signed ? 0 :
       std::numeric_limits<Format>::max() / 2 + 1;
   static const Fixed kMaxValue = kBias ? kBias - 1 :
       std::numeric_limits<Format>::max();
   static const Fixed kMinValue = kBias ? -kBias :
       std::numeric_limits<Format>::min();
 
   int channels = source->channels();
   for (int ch = 0; ch < channels; ++ch) {
     const float* channel_data = source->channel(ch);
-    for (int i = 0, offset = ch; i < frames; ++i, offset += channels) {
+    for (int i = start_frame, offset = ch; i < frames;
+         ++i, offset += channels) {
       float v = channel_data[i];
       Fixed sample = v * (v < 0 ? -kMinValue : kMaxValue);
 
       if (sample > kMaxValue)
         sample = kMaxValue;
       else if (sample < kMinValue)
         sample = kMinValue;
 
       dest[offset] = static_cast<Format>(sample) + kBias;
     }
@@ skipping 172 matching lines @@
     // Zero any remaining frames.
     ZeroFramesPartial(frames, frames_ - frames);
   }
 }
 
 void AudioBus::FromInterleaved(const void* source, int frames,
                                int bytes_per_sample) {
   FromInterleavedPartial(source, 0, frames, bytes_per_sample);
 }
 
-// TODO(dalecurtis): See if intrinsic optimizations help any here.
 void AudioBus::ToInterleaved(int frames, int bytes_per_sample,
                              void* dest) const {
-  CheckOverflow(0, frames, frames_);
+  ToInterleavedPartial(0, frames, bytes_per_sample, dest);
+}
+
+// TODO(dalecurtis): See if intrinsic optimizations help any here.
+void AudioBus::ToInterleavedPartial(int start_frame, int frames,
+                                    int bytes_per_sample, void* dest) const {
+  CheckOverflow(start_frame, frames, frames_);
   switch (bytes_per_sample) {
     case 1:
-      ToInterleavedInternal<uint8, int16>(this, frames, dest);
+      ToInterleavedInternal<uint8, int16>(this, start_frame, frames, dest);
       break;
     case 2:
-      ToInterleavedInternal<int16, int32>(this, frames, dest);
+      ToInterleavedInternal<int16, int32>(this, start_frame, frames, dest);
       break;
     case 4:
-      ToInterleavedInternal<int32, int64>(this, frames, dest);
+      ToInterleavedInternal<int32, int64>(this, start_frame, frames, dest);
       break;
     default:
       NOTREACHED() << "Unsupported bytes per sample encountered.";
       memset(dest, 0, frames * bytes_per_sample);
       return;
   }
 }
 
 void AudioBus::CopyTo(AudioBus* dest) const {
   CHECK_EQ(channels(), dest->channels());
   CHECK_EQ(frames(), dest->frames());
 
   // Since we don't know if the other AudioBus is wrapped or not (and we don't
   // want to care), just copy using the public channel() accessors.
   for (int i = 0; i < channels(); ++i)
     memcpy(dest->channel(i), channel(i), sizeof(*channel(i)) * frames());
 }
 
 }  // namespace media