Feed the render data to MediaStreamAudioProcessor and used AudioBus in render callback

content/renderer/media/webrtc_audio_device_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 <vector>
 
 #include "base/environment.h"
 #include "base/file_util.h"
 #include "base/files/file_path.h"
 #include "base/path_service.h"
@@ skipping 228 matching lines @@
 
 class MockWebRtcAudioRendererSource : public WebRtcAudioRendererSource {
  public:
   explicit MockWebRtcAudioRendererSource(base::WaitableEvent* event)
       : event_(event) {
     DCHECK(event_);
   }
   virtual ~MockWebRtcAudioRendererSource() {}
 
   // WebRtcAudioRendererSource implementation.
-  virtual void RenderData(uint8* audio_data,
-                          int number_of_channels,
-                          int number_of_frames,
+  virtual void RenderData(media::AudioBus* audio_bus,
+                          int sample_rate,
                           int audio_delay_milliseconds) OVERRIDE {
     // Signal that a callback has been received.
     // Initialize the memory to zero to avoid uninitialized warning from
     // Valgrind.
-    memset(audio_data, 0,
-           sizeof(int16) * number_of_channels * number_of_frames);
+    audio_bus->Zero();
     event_->Signal();
   }
 
-  virtual void SetRenderFormat(const media::AudioParameters& params) OVERRIDE {
-  }
-
   virtual void RemoveAudioRenderer(WebRtcAudioRenderer* renderer) OVERRIDE {};
 
  private:
    base::WaitableEvent* event_;
 
    DISALLOW_COPY_AND_ASSIGN(MockWebRtcAudioRendererSource);
 };
 
 // Prints numerical information to stdout in a controlled format so we can plot
 // the result.
@@ skipping 47 matching lines @@
                               bool enable_apm) {
   scoped_refptr<WebRtcAudioDeviceImpl> webrtc_audio_device(
       new WebRtcAudioDeviceImpl());
   WebRTCAutoDelete<webrtc::VoiceEngine> engine(webrtc::VoiceEngine::Create());
   EXPECT_TRUE(engine.valid());
   ScopedWebRTCPtr<webrtc::VoEBase> base(engine.get());
   EXPECT_TRUE(base.valid());
   int err = base->Init(webrtc_audio_device.get());
   EXPECT_EQ(0, err);
 
-  // We use OnSetFormat() and SetRenderFormat() to configure the audio
-  // parameters so that this test can run on machine without hardware device.
+  // We use OnSetFormat() to configure the audio parameters so that this
+  // test can run on machine without hardware device.
   const media::AudioParameters params = media::AudioParameters(
       media::AudioParameters::AUDIO_PCM_LOW_LATENCY, CHANNEL_LAYOUT_STEREO,
       48000, 2, 480);
   PeerConnectionAudioSink* capturer_sink =
       static_cast<PeerConnectionAudioSink*>(webrtc_audio_device.get());
   WebRtcAudioRendererSource* renderer_source =
       static_cast<WebRtcAudioRendererSource*>(webrtc_audio_device.get());
-  renderer_source->SetRenderFormat(params);
 
   // Turn on/off all the signal processing components like AGC, AEC and NS.
   ScopedWebRTCPtr<webrtc::VoEAudioProcessing> audio_processing(engine.get());
   EXPECT_TRUE(audio_processing.valid());
   audio_processing->SetAgcStatus(enable_apm);
   audio_processing->SetNsStatus(enable_apm);
   audio_processing->SetEcStatus(enable_apm);
 
   // Create a voice channel for the WebRtc.
   int channel = base->CreateChannel();
   EXPECT_NE(-1, channel);
   SetChannelCodec(engine.get(), channel);
 
   // Use our fake network transmission and start playout and recording.
   ScopedWebRTCPtr<webrtc::VoENetwork> network(engine.get());
   EXPECT_TRUE(network.valid());
   scoped_ptr<WebRTCTransportImpl> transport(
       new WebRTCTransportImpl(network.get()));
   EXPECT_EQ(0, network->RegisterExternalTransport(channel, *transport.get()));
   EXPECT_EQ(0, base->StartPlayout(channel));
   EXPECT_EQ(0, base->StartSend(channel));
 
   // Read speech data from a speech test file.
   const int input_packet_size =
       params.frames_per_buffer() * 2 * params.channels();
-  const int num_output_channels = webrtc_audio_device->output_channels();
-  const int output_packet_size = webrtc_audio_device->output_buffer_size() * 2 *
-      num_output_channels;
   const size_t length = input_packet_size * kNumberOfPacketsForLoopbackTest;
   scoped_ptr<char[]> capture_data(new char[length]);
   ReadDataFromSpeechFile(capture_data.get(), length);
 
   // Start the timer.
-  scoped_ptr<uint8[]> buffer(new uint8[output_packet_size]);
+  scoped_ptr<media::AudioBus> render_audio_bus(media::AudioBus::Create(params));
   base::Time start_time = base::Time::Now();
   int delay = 0;
   std::vector<int> voe_channels;
   voe_channels.push_back(channel);
   for (int j = 0; j < kNumberOfPacketsForLoopbackTest; ++j) {
     // Sending fake capture data to WebRtc.
     capturer_sink->OnData(
         reinterpret_cast<int16*>(capture_data.get() + input_packet_size * j),
         params.sample_rate(),
         params.channels(),
         params.frames_per_buffer(),
         voe_channels,
         kHardwareLatencyInMs,
         1.0,
         enable_apm,
         false);
 
     // Receiving data from WebRtc.
     renderer_source->RenderData(
-        reinterpret_cast<uint8*>(buffer.get()),
-        num_output_channels, webrtc_audio_device->output_buffer_size(),
+        render_audio_bus.get(), params.sample_rate(),
         kHardwareLatencyInMs + delay);
     delay = (base::Time::Now() - start_time).InMilliseconds();
   }
 
   int latency = (base::Time::Now() - start_time).InMilliseconds();
 
   EXPECT_EQ(0, base->StopSend(channel));
   EXPECT_EQ(0, base->StopPlayout(channel));
   EXPECT_EQ(0, base->DeleteChannel(channel));
   EXPECT_EQ(0, base->Terminate());
@@ skipping 563 matching lines @@
     LOG(WARNING) << "Test disabled due to the test hangs on WinXP.";
     return;
   }
 #endif
   int latency = RunWebRtcLoopbackTimeTest(audio_manager_.get(), true);
   PrintPerfResultMs("webrtc_loopback_with_signal_processing (100 packets)",
                     "t", latency);
 }
 
 }  // namespace content