Switch OnMoreData() to use AudioBus.

media/audio/win/audio_low_latency_output_win_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 <windows.h>
 #include <mmsystem.h>
 
 #include "base/basictypes.h"
 #include "base/environment.h"
 #include "base/file_util.h"
@@ skipping 26 matching lines @@
 using base::win::ScopedCOMInitializer;
 
 namespace media {
 
 static const char kSpeechFile_16b_s_48k[] = "speech_16b_stereo_48kHz.raw";
 static const char kSpeechFile_16b_s_44k[] = "speech_16b_stereo_44kHz.raw";
 static const char kSpeechFile_16b_m_48k[] = "speech_16b_mono_48kHz.raw";
 static const char kSpeechFile_16b_m_44k[] = "speech_16b_mono_44kHz.raw";
 static const size_t kFileDurationMs = 20000;
 static const size_t kNumFileSegments = 2;
+static const int kBitsPerSample = 16;
 
 static const size_t kMaxDeltaSamples = 1000;
 static const char* kDeltaTimeMsFileName = "delta_times_ms.txt";
 
 MATCHER_P(HasValidDelay, value, "") {
   // It is difficult to come up with a perfect test condition for the delay
   // estimation. For now, verify that the produced output delay is always
   // larger than the selected buffer size.
   return arg.hardware_delay_bytes > value.hardware_delay_bytes;
 }
 
 // Used to terminate a loop from a different thread than the loop belongs to.
 // |loop| should be a MessageLoopProxy.
 ACTION_P(QuitLoop, loop) {
   loop->PostTask(FROM_HERE, MessageLoop::QuitClosure());
 }
 
 class MockAudioSourceCallback : public AudioOutputStream::AudioSourceCallback {
  public:
-  MOCK_METHOD3(OnMoreData, uint32(uint8* dest,
-                                  uint32 max_size,
-                                  AudioBuffersState buffers_state));
+  MOCK_METHOD2(OnMoreData, int(AudioBus* audio_bus,
+                               AudioBuffersState buffers_state));
   MOCK_METHOD2(OnError, void(AudioOutputStream* stream, int code));
 };
 
 // This audio source implementation should be used for manual tests only since
 // it takes about 20 seconds to play out a file.
 class ReadFromFileAudioSource : public AudioOutputStream::AudioSourceCallback {
  public:
   explicit ReadFromFileAudioSource(const std::string& name)
     : pos_(0),
       previous_call_time_(base::Time::Now()),
@@ skipping 24 matching lines @@
     size_t elements_written = 0;
     while (elements_written < elements_to_write_) {
       fprintf(text_file_, "%d\n", delta_times_[elements_written]);
       ++elements_written;
     }
 
     file_util::CloseFile(text_file_);
   }
 
   // AudioOutputStream::AudioSourceCallback implementation.
-  virtual uint32 OnMoreData(uint8* dest,
-                            uint32 max_size,
-                            AudioBuffersState buffers_state) {
+  virtual int OnMoreData(AudioBus* audio_bus,
+                         AudioBuffersState buffers_state) {
     // Store time difference between two successive callbacks in an array.
     // These values will be written to a file in the destructor.
     int diff = (base::Time::Now() - previous_call_time_).InMilliseconds();
     previous_call_time_ = base::Time::Now();
     if (elements_to_write_ < kMaxDeltaSamples) {
       delta_times_[elements_to_write_] = diff;
       ++elements_to_write_;
     }
 
+    int max_size =
+        audio_bus->frames() * audio_bus->channels() * kBitsPerSample / 8;
+
     // Use samples read from a data file and fill up the audio buffer
     // provided to us in the callback.
     if (pos_ + static_cast<int>(max_size) > file_size())
       max_size = file_size() - pos_;
+    int frames = max_size / (audio_bus->channels() * kBitsPerSample / 8);
     if (max_size) {
-      memcpy(dest, file_->GetData() + pos_, max_size);
+      audio_bus->FromInterleaved(
+          file_->GetData() + pos_, frames, kBitsPerSample / 8);
       pos_ += max_size;
     }
-    return max_size;
+    return frames;
   }
 
   virtual void OnError(AudioOutputStream* stream, int code) {}
 
   int file_size() { return file_->GetDataSize(); }
 
  private:
   scoped_refptr<DecoderBuffer> file_;
   scoped_array<int> delta_times_;
   int pos_;
@@ skipping 25 matching lines @@
 
 // Convenience method which creates a default AudioOutputStream object but
 // also allows the user to modify the default settings.
 class AudioOutputStreamWrapper {
  public:
   explicit AudioOutputStreamWrapper(AudioManager* audio_manager)
       : com_init_(ScopedCOMInitializer::kMTA),
         audio_man_(audio_manager),
         format_(AudioParameters::AUDIO_PCM_LOW_LATENCY),
         channel_layout_(CHANNEL_LAYOUT_STEREO),
-        bits_per_sample_(16) {
+        bits_per_sample_(kBitsPerSample) {
     // Use native/mixing sample rate and 10ms frame size as default.
     sample_rate_ = static_cast<int>(
         WASAPIAudioOutputStream::HardwareSampleRate(eConsole));
     samples_per_packet_ = sample_rate_ / 100;
     DCHECK(sample_rate_);
   }
 
   ~AudioOutputStreamWrapper() {}
 
   // Creates AudioOutputStream object using default parameters.
@@ skipping 264 matching lines @@
   EXPECT_TRUE(aos->Open());
 
   // Derive the expected size in bytes of each packet.
   uint32 bytes_per_packet = aosw.channels() * aosw.samples_per_packet() *
                            (aosw.bits_per_sample() / 8);
 
   // Set up expected minimum delay estimation.
   AudioBuffersState state(0, bytes_per_packet);
 
   // Wait for the first callback and verify its parameters.
-  EXPECT_CALL(source, OnMoreData(NotNull(), bytes_per_packet,
-                                 HasValidDelay(state)))
+  EXPECT_CALL(source, OnMoreData(NotNull(), HasValidDelay(state)))
       .WillOnce(DoAll(
           QuitLoop(loop.message_loop_proxy()),
-          Return(bytes_per_packet)));
+          Return(aosw.samples_per_packet())));
 
   aos->Start(&source);
   loop.PostDelayedTask(FROM_HERE, MessageLoop::QuitClosure(),
                        TestTimeouts::action_timeout());
   loop.Run();
   aos->Stop();
   aos->Close();
 }
 
 // Use a fixed packets size (independent of sample rate) and verify
@@ skipping 14 matching lines @@
   EXPECT_TRUE(aos->Open());
 
   // Derive the expected size in bytes of each packet.
   uint32 bytes_per_packet = aosw.channels() * aosw.samples_per_packet() *
                            (aosw.bits_per_sample() / 8);
 
   // Set up expected minimum delay estimation.
   AudioBuffersState state(0, bytes_per_packet);
 
   // Ensure that callbacks start correctly.
-  EXPECT_CALL(source, OnMoreData(NotNull(), bytes_per_packet,
-                                 HasValidDelay(state)))
+  EXPECT_CALL(source, OnMoreData(NotNull(), HasValidDelay(state)))
       .WillOnce(DoAll(
           QuitLoop(loop.message_loop_proxy()),
-          Return(bytes_per_packet)))
-      .WillRepeatedly(Return(bytes_per_packet));
+          Return(aosw.samples_per_packet())))
+      .WillRepeatedly(Return(aosw.samples_per_packet()));
 
   aos->Start(&source);
   loop.PostDelayedTask(FROM_HERE, MessageLoop::QuitClosure(),
                        TestTimeouts::action_timeout());
   loop.Run();
   aos->Stop();
   aos->Close();
 }
 
 TEST(WASAPIAudioOutputStreamTest, Mono) {
@@ skipping 10 matching lines @@
   AudioOutputStream* aos = aosw.Create(CHANNEL_LAYOUT_MONO);
   EXPECT_TRUE(aos->Open());
 
   // Derive the expected size in bytes of each packet.
   uint32 bytes_per_packet = aosw.channels() * aosw.samples_per_packet() *
                            (aosw.bits_per_sample() / 8);
 
   // Set up expected minimum delay estimation.
   AudioBuffersState state(0, bytes_per_packet);
 
-  EXPECT_CALL(source, OnMoreData(NotNull(), bytes_per_packet,
-                                 HasValidDelay(state)))
+  EXPECT_CALL(source, OnMoreData(NotNull(), HasValidDelay(state)))
       .WillOnce(DoAll(
           QuitLoop(loop.message_loop_proxy()),
-          Return(bytes_per_packet)))
-      .WillRepeatedly(Return(bytes_per_packet));
+          Return(aosw.samples_per_packet())))
+      .WillRepeatedly(Return(aosw.samples_per_packet()));
 
   aos->Start(&source);
   loop.PostDelayedTask(FROM_HERE, MessageLoop::QuitClosure(),
                        TestTimeouts::action_timeout());
   loop.Run();
   aos->Stop();
   aos->Close();
 }
 
 // This test is intended for manual tests and should only be enabled
@@ skipping 227 matching lines @@
   EXPECT_TRUE(aos->Open());
 
   // Derive the expected size in bytes of each packet.
   uint32 bytes_per_packet = aosw.channels() * aosw.samples_per_packet() *
       (aosw.bits_per_sample() / 8);
 
   // Set up expected minimum delay estimation.
   AudioBuffersState state(0, bytes_per_packet);
 
   // Wait for the first callback and verify its parameters.
-  EXPECT_CALL(source, OnMoreData(NotNull(), bytes_per_packet,
-                                 HasValidDelay(state)))
+  EXPECT_CALL(source, OnMoreData(NotNull(), HasValidDelay(state)))
       .WillOnce(DoAll(
           QuitLoop(loop.message_loop_proxy()),
-          Return(bytes_per_packet)))
-      .WillRepeatedly(Return(bytes_per_packet));
+          Return(aosw.samples_per_packet())))
+      .WillRepeatedly(Return(aosw.samples_per_packet()));
 
   aos->Start(&source);
   loop.PostDelayedTask(FROM_HERE, MessageLoop::QuitClosure(),
                        TestTimeouts::action_timeout());
   loop.Run();
   aos->Stop();
   aos->Close();
 }
 
 // Verify that we can open and start the output stream in exclusive mode at
@@ skipping 16 matching lines @@
   EXPECT_TRUE(aos->Open());
 
   // Derive the expected size in bytes of each packet.
   uint32 bytes_per_packet = aosw.channels() * aosw.samples_per_packet() *
       (aosw.bits_per_sample() / 8);
 
   // Set up expected minimum delay estimation.
   AudioBuffersState state(0, bytes_per_packet);
 
   // Wait for the first callback and verify its parameters.
-  EXPECT_CALL(source, OnMoreData(NotNull(), bytes_per_packet,
-                                 HasValidDelay(state)))
+  EXPECT_CALL(source, OnMoreData(NotNull(), HasValidDelay(state)))
     .WillOnce(DoAll(
         QuitLoop(loop.message_loop_proxy()),
-        Return(bytes_per_packet)))
-    .WillRepeatedly(Return(bytes_per_packet));
+        Return(aosw.samples_per_packet())))
+    .WillRepeatedly(Return(aosw.samples_per_packet()));
 
   aos->Start(&source);
   loop.PostDelayedTask(FROM_HERE, MessageLoop::QuitClosure(),
                         TestTimeouts::action_timeout());
   loop.Run();
   aos->Stop();
   aos->Close();
 }
 
 }  // namespace media