Modifies AudioInputCallback::OnData and use media::AudioBus instead of plain byte vector

media/audio/android/audio_android_unittest.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 "base/android/build_info.h"
 #include "base/basictypes.h"
 #include "base/file_util.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/message_loop/message_loop.h"
 #include "base/path_service.h"
@@ skipping 130 matching lines @@
      << "bytes per frame: " << params.GetBytesPerFrame() << endl
      << "chunk size in ms: " << ExpectedTimeBetweenCallbacks(params) << endl
      << "echo_canceller: "
      << (params.effects() & AudioParameters::ECHO_CANCELLER);
   return os;
 }
 
 // Gmock implementation of AudioInputStream::AudioInputCallback.
 class MockAudioInputCallback : public AudioInputStream::AudioInputCallback {
  public:
-  MOCK_METHOD5(OnData,
+  MOCK_METHOD4(OnData,
                void(AudioInputStream* stream,
-                    const uint8* src,
-                    uint32 size,
+                    const AudioBus* src,
                     uint32 hardware_delay_bytes,
                     double volume));
   MOCK_METHOD1(OnError, void(AudioInputStream* stream));
 };
 
 // Implements AudioOutputStream::AudioSourceCallback and provides audio data
 // by reading from a data file.
 class FileAudioSource : public AudioOutputStream::AudioSourceCallback {
  public:
   explicit FileAudioSource(base::WaitableEvent* event, const std::string& name)
@@ skipping 92 matching lines @@
       // TODO(henrika): use file_util:: instead.
       fwrite(chunk, 1, chunk_size, binary_file_);
       buffer_->Seek(chunk_size);
       bytes_written += chunk_size;
     }
     base::CloseFile(binary_file_);
   }
 
   // AudioInputStream::AudioInputCallback implementation.
   virtual void OnData(AudioInputStream* stream,
-                      const uint8* src,
-                      uint32 size,
+                      const AudioBus* src,
                       uint32 hardware_delay_bytes,
                       double volume) OVERRIDE {
+    const int num_samples = src->frames() * src->channels();
+    scoped_ptr<int16> interleaved(new int16[num_samples]);
+    const int bytes_per_sample = sizeof(*interleaved);
+    src->ToInterleaved(src->frames(), bytes_per_sample, interleaved.get());
+
     // Store data data in a temporary buffer to avoid making blocking
     // fwrite() calls in the audio callback. The complete buffer will be
     // written to file in the destructor.
-    if (!buffer_->Append(src, size))
+    const int size = bytes_per_sample * num_samples;
+    if (!buffer_->Append((const uint8*)interleaved.get(), size))
       event_->Signal();
   }
 
   virtual void OnError(AudioInputStream* stream) OVERRIDE {}
 
  private:
   base::WaitableEvent* event_;
   AudioParameters params_;
   scoped_ptr<media::SeekableBuffer> buffer_;
   FILE* binary_file_;
@@ skipping 15 matching lines @@
     // Start with a reasonably small FIFO size. It will be increased
     // dynamically during the test if required.
     fifo_.reset(new media::SeekableBuffer(0, 2 * params.GetBytesPerBuffer()));
     buffer_.reset(new uint8[params_.GetBytesPerBuffer()]);
   }
 
   virtual ~FullDuplexAudioSinkSource() {}
 
   // AudioInputStream::AudioInputCallback implementation
   virtual void OnData(AudioInputStream* stream,
-                      const uint8* src,
-                      uint32 size,
+                      const AudioBus* src,
                       uint32 hardware_delay_bytes,
                       double volume) OVERRIDE {
     const base::TimeTicks now_time = base::TimeTicks::Now();
     const int diff = (now_time - previous_time_).InMilliseconds();
 
+    EXPECT_EQ(params_.bits_per_sample(), 16);
+    const int num_samples = src->frames() * src->channels();
+    scoped_ptr<int16> interleaved(new int16[num_samples]);
+    const int bytes_per_sample = sizeof(*interleaved);
+    src->ToInterleaved(src->frames(), bytes_per_sample, interleaved.get());
+    const int size = bytes_per_sample * num_samples;
+
     base::AutoLock lock(lock_);
     if (diff > 1000) {
       started_ = true;
       previous_time_ = now_time;
 
       // Log out the extra delay added by the FIFO. This is a best effort
       // estimate. We might be +- 10ms off here.
       int extra_fifo_delay =
           static_cast<int>(BytesToMilliseconds(fifo_->forward_bytes() + size));
       DVLOG(1) << extra_fifo_delay;
     }
 
     // We add an initial delay of ~1 second before loopback starts to ensure
     // a stable callback sequence and to avoid initial bursts which might add
     // to the extra FIFO delay.
     if (!started_)
       return;
 
     // Append new data to the FIFO and extend the size if the max capacity
     // was exceeded. Flush the FIFO when extended just in case.
-    if (!fifo_->Append(src, size)) {
+    if (!fifo_->Append((const uint8*)interleaved.get(), size)) {
       fifo_->set_forward_capacity(2 * fifo_->forward_capacity());
       fifo_->Clear();
     }
   }
 
   virtual void OnError(AudioInputStream* stream) OVERRIDE {}
 
   // AudioOutputStream::AudioSourceCallback implementation
   virtual int OnMoreData(AudioBus* dest,
                          AudioBuffersState buffers_state) OVERRIDE {
@@ skipping 285 matching lines @@
     double expected_time_between_callbacks_ms =
         ExpectedTimeBetweenCallbacks(params);
     const int num_callbacks =
         (kCallbackTestTimeMs / expected_time_between_callbacks_ms);
 
     MakeAudioInputStreamOnAudioThread(params);
 
     int count = 0;
     MockAudioInputCallback sink;
 
-    EXPECT_CALL(sink,
-                OnData(audio_input_stream_,
-                       NotNull(),
-                       params.
-                       GetBytesPerBuffer(), _, _))
+    EXPECT_CALL(sink, OnData(audio_input_stream_, NotNull(), _, _))
         .Times(AtLeast(num_callbacks))
         .WillRepeatedly(
-             CheckCountAndPostQuitTask(&count, num_callbacks, loop()));
+            CheckCountAndPostQuitTask(&count, num_callbacks, loop()));
     EXPECT_CALL(sink, OnError(audio_input_stream_)).Times(0);
 
     OpenAndStartAudioInputStreamOnAudioThread(&sink);
 
     start_time_ = base::TimeTicks::Now();
     loop()->Run();
     end_time_ = base::TimeTicks::Now();
 
     StopAndCloseAudioInputStreamOnAudioThread();
 
@@ skipping 302 matching lines @@
   base::PlatformThread::Sleep(base::TimeDelta::FromSeconds(20));
   printf("\n");
   StopAndCloseAudioOutputStreamOnAudioThread();
   StopAndCloseAudioInputStreamOnAudioThread();
 }
 
 INSTANTIATE_TEST_CASE_P(AudioAndroidInputTest, AudioAndroidInputTest,
     testing::ValuesIn(RunAudioRecordInputPathTests()));
 
 }  // namespace media