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

content/renderer/media/webrtc_audio_renderer.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 "content/renderer/media/webrtc_audio_renderer.h"
 
 #include "base/logging.h"
 #include "base/metrics/histogram.h"
 #include "base/strings/string_util.h"
 #include "base/strings/stringprintf.h"
@@ skipping 183 matching lines @@
       source_render_view_id_(source_render_view_id),
       source_render_frame_id_(source_render_frame_id),
       session_id_(session_id),
       media_stream_(media_stream),
       source_(NULL),
       play_ref_count_(0),
       start_ref_count_(0),
       audio_delay_milliseconds_(0),
       fifo_delay_milliseconds_(0),
       sample_rate_(sample_rate),
+      number_of_channels_(0),
       frames_per_buffer_(frames_per_buffer) {
   WebRtcLogMessage(base::StringPrintf(
       "WAR::WAR. source_render_view_id=%d"
       ", session_id=%d, sample_rate=%d, frames_per_buffer=%d",
       source_render_view_id,
       session_id,
       sample_rate,
       frames_per_buffer));
 }
 
 WebRtcAudioRenderer::~WebRtcAudioRenderer() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK_EQ(state_, UNINITIALIZED);
-  buffer_.reset();
 }
 
 bool WebRtcAudioRenderer::Initialize(WebRtcAudioRendererSource* source) {
   DVLOG(1) << "WebRtcAudioRenderer::Initialize()";
   DCHECK(thread_checker_.CalledOnValidThread());
   base::AutoLock auto_lock(lock_);
   DCHECK_EQ(state_, UNINITIALIZED);
   DCHECK(source);
   DCHECK(!sink_.get());
   DCHECK(!source_);
 
   // Use stereo output on all platforms.
   media::ChannelLayout channel_layout = media::CHANNEL_LAYOUT_STEREO;
 
-  // TODO(tommi,henrika): Maybe we should just change |sample_rate_| to be
-  // immutable and change its value instead of using a temporary?
-  int sample_rate = sample_rate_;
-  DVLOG(1) << "Audio output hardware sample rate: " << sample_rate;
+  DVLOG(1) << "Audio output hardware sample rate: " << sample_rate_;
 
   // WebRTC does not yet support higher rates than 96000 on the client side
   // and 48000 is the preferred sample rate. Therefore, if 192000 is detected,
   // we change the rate to 48000 instead. The consequence is that the native
   // layer will be opened up at 192kHz but WebRTC will provide data at 48kHz
   // which will then be resampled by the audio converted on the browser side
   // to match the native audio layer.
-  if (sample_rate == 192000) {
+  if (sample_rate_ == 192000) {
     DVLOG(1) << "Resampling from 48000 to 192000 is required";
-    sample_rate = 48000;
+    sample_rate_ = 48000;
   }
-  media::AudioSampleRate asr = media::AsAudioSampleRate(sample_rate);
+  media::AudioSampleRate asr = media::AsAudioSampleRate(sample_rate_);
   if (asr != media::kUnexpectedAudioSampleRate) {
     UMA_HISTOGRAM_ENUMERATION(
         "WebRTC.AudioOutputSampleRate", asr, media::kUnexpectedAudioSampleRate);
   } else {
-    UMA_HISTOGRAM_COUNTS("WebRTC.AudioOutputSampleRateUnexpected", sample_rate);
+    UMA_HISTOGRAM_COUNTS("WebRTC.AudioOutputSampleRateUnexpected",
+                         sample_rate_);
   }
 
   // Verify that the reported output hardware sample rate is supported
   // on the current platform.
   if (std::find(&kValidOutputRates[0],
                 &kValidOutputRates[0] + arraysize(kValidOutputRates),
-                sample_rate) ==
+                sample_rate_) ==
                     &kValidOutputRates[arraysize(kValidOutputRates)]) {
-    DLOG(ERROR) << sample_rate << " is not a supported output rate.";
+    DLOG(ERROR) << sample_rate_ << " is not a supported output rate.";
     return false;
   }
 
   // Set up audio parameters for the source, i.e., the WebRTC client.
 
   // The WebRTC client only supports multiples of 10ms as buffer size where
   // 10ms is preferred for lowest possible delay.
   media::AudioParameters source_params;
-  int buffer_size = (sample_rate / 100);
-  DVLOG(1) << "Using WebRTC output buffer size: " << buffer_size;
+  const int frames_per_10ms = (sample_rate_ / 100);
+  DVLOG(1) << "Using WebRTC output buffer size: " << frames_per_10ms;
 
-  int channels = ChannelLayoutToChannelCount(channel_layout);
+  number_of_channels_ = ChannelLayoutToChannelCount(channel_layout);
   source_params.Reset(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
-                      channel_layout, channels, 0,
-                      sample_rate, 16, buffer_size);
+                      channel_layout, number_of_channels_, 0,
+                      sample_rate_, 16, frames_per_10ms);
 
   // Set up audio parameters for the sink, i.e., the native audio output stream.
   // We strive to open up using native parameters to achieve best possible
   // performance and to ensure that no FIFO is needed on the browser side to
   // match the client request. Any mismatch between the source and the sink is
   // taken care of in this class instead using a pull FIFO.
 
   media::AudioParameters sink_params;
 
-  // Use native output siz as default.
-  buffer_size = frames_per_buffer_;
+  // Use native output size as default.
 #if defined(OS_ANDROID)
   // TODO(henrika): Keep tuning this scheme and espcicially for low-latency
   // cases. Might not be possible to come up with the perfect solution using
   // the render side only.
-  const int frames_per_10ms = (sample_rate / 100);
-  if (buffer_size < 2 * frames_per_10ms) {
+  if (frames_per_buffer_ < 2 * frames_per_10ms) {
     // Examples of low-latency frame sizes and the resulting |buffer_size|:
     //  Nexus 7     : 240 audio frames => 2*480 = 960
     //  Nexus 10    : 256              => 2*441 = 882
     //  Galaxy Nexus: 144              => 2*441 = 882
-    buffer_size = 2 * frames_per_10ms;
+    frames_per_buffer_ = 2 * frames_per_10ms;
     DVLOG(1) << "Low-latency output detected on Android";
   }
 #endif
-  DVLOG(1) << "Using sink output buffer size: " << buffer_size;
+  DVLOG(1) << "Using sink output buffer size: " << frames_per_buffer_;
 
   sink_params.Reset(media::AudioParameters::AUDIO_PCM_LOW_LATENCY,
-                    channel_layout, channels, 0, sample_rate, 16, buffer_size);
+                    channel_layout, number_of_channels_, 0, sample_rate_, 16,
+                    frames_per_buffer_);
 
   // Create a FIFO if re-buffering is required to match the source input with
   // the sink request. The source acts as provider here and the sink as
   // consumer.
   fifo_delay_milliseconds_ = 0;
   if (source_params.frames_per_buffer() != sink_params.frames_per_buffer()) {
     DVLOG(1) << "Rebuffering from " << source_params.frames_per_buffer()
              << " to " << sink_params.frames_per_buffer();
     audio_fifo_.reset(new media::AudioPullFifo(
         source_params.channels(),
         source_params.frames_per_buffer(),
         base::Bind(
             &WebRtcAudioRenderer::SourceCallback,
             base::Unretained(this))));
 
     if (sink_params.frames_per_buffer() > source_params.frames_per_buffer()) {
       int frame_duration_milliseconds = base::Time::kMillisecondsPerSecond /
           static_cast<double>(source_params.sample_rate());
       fifo_delay_milliseconds_ = (sink_params.frames_per_buffer() -
         source_params.frames_per_buffer()) * frame_duration_milliseconds;
     }
   }
 
-  // Allocate local audio buffers based on the parameters above.
-  // It is assumed that each audio sample contains 16 bits and each
-  // audio frame contains one or two audio samples depending on the
-  // number of channels.
-  buffer_.reset(
-      new int16[source_params.frames_per_buffer() * source_params.channels()]);
-
   source_ = source;
-  source->SetRenderFormat(source_params);
 
   // Configure the audio rendering client and start rendering.
   sink_ = AudioDeviceFactory::NewOutputDevice(
       source_render_view_id_, source_render_frame_id_);
 
   // TODO(tommi): Rename InitializeUnifiedStream to rather reflect association
   // with a session.
   DCHECK_GE(session_id_, 0);
   sink_->InitializeUnifiedStream(sink_params, this, session_id_);
 
@@ skipping 160 matching lines @@
   DVLOG(2) << "WebRtcAudioRenderer::SourceCallback("
            << fifo_frame_delay << ", "
            << audio_bus->frames() << ")";
 
   int output_delay_milliseconds = audio_delay_milliseconds_;
   output_delay_milliseconds += fifo_delay_milliseconds_;
   DVLOG(2) << "output_delay_milliseconds: " << output_delay_milliseconds;
 
   // We need to keep render data for the |source_| regardless of |state_|,
   // otherwise the data will be buffered up inside |source_|.
-  source_->RenderData(reinterpret_cast<uint8*>(buffer_.get()),
-                      audio_bus->channels(), audio_bus->frames(),
-                      output_delay_milliseconds);
+  source_->RenderData(audio_bus, sample_rate_, output_delay_milliseconds);
 
   // Avoid filling up the audio bus if we are not playing; instead
   // return here and ensure that the returned value in Render() is 0.
-  if (state_ != PLAYING) {
+  if (state_ != PLAYING)
     audio_bus->Zero();
-    return;
-  }
-
-  // De-interleave each channel and convert to 32-bit floating-point
-  // with nominal range -1.0 -> +1.0 to match the callback format.
-  audio_bus->FromInterleaved(buffer_.get(),
-                             audio_bus->frames(),
-                             sizeof(buffer_[0]));
 }
 
 void WebRtcAudioRenderer::UpdateSourceVolume(
     webrtc::AudioSourceInterface* source) {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   // Note: If there are no playing audio renderers, then the volume will be
   // set to 0.0.
   float volume = 0.0f;
 
@@ skipping 67 matching lines @@
       if (RemovePlayingState(source, state))
         EnterPauseState();
     } else if (AddPlayingState(source, state)) {
       EnterPlayState();
     }
     UpdateSourceVolume(source);
   }
 }
 
 }  // namespace content