Switch OnMoreData() to use AudioBus.

media/audio/audio_low_latency_input_output_unittest.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 "base/basictypes.h"
 #include "base/environment.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop.h"
 #include "base/path_service.h"
@@ skipping 200 matching lines @@
       // enough to handle the current sample test scenario.
       buffer_->set_forward_capacity(2 * buffer_->forward_capacity());
       buffer_->Clear();
     }
   }
 
   virtual void OnClose(AudioInputStream* stream) OVERRIDE {}
   virtual void OnError(AudioInputStream* stream, int code) OVERRIDE {}
 
   // AudioOutputStream::AudioSourceCallback.
-  virtual uint32 OnMoreData(uint8* dest,
-                            uint32 max_size,
-                            AudioBuffersState buffers_state) OVERRIDE {
+  virtual int OnMoreData(AudioBus* audio_bus,
+                         AudioBuffersState buffers_state) OVERRIDE {
     base::AutoLock lock(lock_);
 
     // Update one component in the AudioDelayState for the packet
     // which is about to be played out.
     if (output_elements_to_write_ < kMaxDelayMeasurements) {
       int output_delay_bytes = buffers_state.hardware_delay_bytes;
 #if defined(OS_WIN)
       // Special fix for Windows in combination with Wave where the
       // pending bytes field of the audio buffer state is used to
       // report the delay.
       if (!media::IsWASAPISupported()) {
         output_delay_bytes = buffers_state.pending_bytes;
       }
 #endif
       delay_states_[output_elements_to_write_].output_delay_ms =
           BytesToMilliseconds(output_delay_bytes);
       ++output_elements_to_write_;
     }
 
+    int size;
+    const uint8* source;
     // Read the data from the seekable media buffer which contains
     // captured data at the same size and sample rate as the output side.
-    return buffer_->Read(dest, max_size);
+    if (buffer_->GetCurrentChunk(&source, &size) && size > 0) {
+      EXPECT_EQ(channels_, audio_bus->channels());
+      size = std::min(audio_bus->frames() * frame_size_, size);
+      EXPECT_EQ(static_cast<size_t>(size) % sizeof(*audio_bus->channel(0)), 0U);
+      audio_bus->FromInterleaved(
+          source, size / frame_size_, frame_size_ / channels_);
+      buffer_->Seek(size);
+      return size / frame_size_;
+    }
+
+    return 0;
   }
 
   virtual void OnError(AudioOutputStream* stream, int code) OVERRIDE {}
   virtual void WaitTillDataReady() OVERRIDE {}
 
  protected:
   // Converts from bytes to milliseconds taking the sample rate and size
   // of an audio frame into account.
   int BytesToMilliseconds(uint32 delay_bytes) const {
     return static_cast<int>((delay_bytes / frame_size_) * frames_to_ms_ + 0.5);
   }
 
  private:
   base::Lock lock_;
   scoped_ptr<media::SeekableBuffer> buffer_;
   int sample_rate_;
   int samples_per_packet_;
   int channels_;
-  size_t frame_size_;
+  int frame_size_;
   double frames_to_ms_;
   scoped_array<AudioDelayState> delay_states_;
   size_t input_elements_to_write_;
   size_t output_elements_to_write_;
   base::Time previous_write_time_;
 };
 
 class AudioInputStreamTraits {
  public:
   typedef AudioInputStream StreamType;
@@ skipping 174 matching lines @@
 
   // All Close() operations that run on the mocked audio thread,
   // should be synchronous and not post additional close tasks to
   // mocked the audio thread. Hence, there is no need to call
   // message_loop()->RunAllPending() after the Close() methods.
   aos->Close();
   ais->Close();
 }
 
 }  // namespace media