Replace AudioConferenceMixer with AudioMixer.

webrtc/audio/audio_transport_proxy.cc

 /*
  *  Copyright (c) 2016 The WebRTC project authors. All Rights Reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
 #include "webrtc/audio/audio_transport_proxy.h"
 
 namespace webrtc {
 
+namespace {
+// Resample audio in |frame| to given sample rate preserving the
+// channel count and place the result in |destination|.
+int Resample(const AudioFrame& frame,

[the sun, 2016/11/14 20:03:47]

I'd find this order more intuitive:

source_frame,
resampler
destination_sample_rate
destination

Try sticking to either of "target", destination, "dest" or "dst".

[aleloi, 2016/11/15 16:56:54]

I was trying to follow the style guide for parameter ordering. First come the
input-only vars, then both input and output and lastly output. The resampler is
both input/output because it changes state.

On the other hand the destination sample rate and destination are two parameters
that both describe the 'output'. But making a whole new struct for that seems
unnecessary...

[the sun, 2016/11/16 20:22:57]

Uhm, ok. Thanks for educating me.

+             const int target_sample_rate,
+             PushResampler<int16_t>* resampler,
+             int16_t* destination) {
+  const int frame_sample_rate = frame.sample_rate_hz_;

[the sun, 2016/11/14 20:03:46]

Remove this local

[aleloi, 2016/11/15 16:56:54]

Done.

+  const int number_of_channels = frame.num_channels_;
+  const int target_number_of_samples_per_channel = target_sample_rate / 100;
+  resampler->InitializeIfNeeded(frame_sample_rate, target_sample_rate,
+                                number_of_channels);
+
+  return resampler->Resample(
+      frame.data_, frame.samples_per_channel_ * number_of_channels,
+      static_cast<int16_t*>(destination),

[the sun, 2016/11/14 20:03:47]

cast not needed

[aleloi, 2016/11/15 16:56:54]

Acknowledged.

+      number_of_channels * target_number_of_samples_per_channel);
+}
+}  // namespace
+
 AudioTransportProxy::AudioTransportProxy(AudioTransport* voe_audio_transport,
                                          AudioProcessing* apm,
                                          AudioMixer* mixer)
-    : voe_audio_transport_(voe_audio_transport) {
+    : voe_audio_transport_(voe_audio_transport), apm_(apm), mixer_(mixer) {
+  RTC_DCHECK(apm);

[the sun, 2016/11/14 20:03:46]

nit: use same order as ctor init list

[aleloi, 2016/11/15 16:56:54]

Done.

+  RTC_DCHECK(mixer);
   RTC_DCHECK(voe_audio_transport);
-  RTC_DCHECK(apm);
 }
 
 AudioTransportProxy::~AudioTransportProxy() {}
 
 int32_t AudioTransportProxy::RecordedDataIsAvailable(
     const void* audioSamples,
     const size_t nSamples,
     const size_t nBytesPerSample,
     const size_t nChannels,
     const uint32_t samplesPerSec,
@@ skipping 19 matching lines @@
   RTC_DCHECK_EQ(sizeof(int16_t) * nChannels, nBytesPerSample);
   RTC_DCHECK_GE(nChannels, 1u);
   RTC_DCHECK_LE(nChannels, 2u);
   RTC_DCHECK_GE(
       samplesPerSec,
       static_cast<uint32_t>(AudioProcessing::NativeRate::kSampleRate8kHz));
   RTC_DCHECK_EQ(nSamples * 100, samplesPerSec);
   RTC_DCHECK_LE(nBytesPerSample * nSamples * nChannels,
                 sizeof(AudioFrame::data_));
 
-  // Pass call through to original audio transport instance.
-  return voe_audio_transport_->NeedMorePlayData(
-      nSamples, nBytesPerSample, nChannels, samplesPerSec, audioSamples,
-      nSamplesOut, elapsed_time_ms, ntp_time_ms);
+  mixer_->Mix(static_cast<int>(nChannels), &frame_for_mixing_);

[the sun, 2016/11/14 20:03:46]

Cast should be unnecessary here.

+  *elapsed_time_ms = frame_for_mixing_.elapsed_time_ms_;
+  *ntp_time_ms = frame_for_mixing_.ntp_time_ms_;
+
+  const auto error = apm_->ProcessReverseStream(&frame_for_mixing_);
+  RTC_DCHECK_EQ(error, AudioProcessing::kNoError);
+
+  nSamplesOut = Resample(frame_for_mixing_, samplesPerSec, &resampler_,
+                         static_cast<int16_t*>(audioSamples));

[the sun, 2016/11/14 20:03:46]

DCHECK that nSamplesOut is nSamples?

[aleloi, 2016/11/15 16:56:54]

Done.

+  return 0;
 }
 
 void AudioTransportProxy::PushCaptureData(int voe_channel,
                                           const void* audio_data,
                                           int bits_per_sample,
                                           int sample_rate,
                                           size_t number_of_channels,
                                           size_t number_of_frames) {
   // This is part of deprecated VoE interface operating on specific
   // VoE channels. It should not be used.
   RTC_NOTREACHED();
 }
 
 void AudioTransportProxy::PullRenderData(int bits_per_sample,
                                          int sample_rate,
                                          size_t number_of_channels,
                                          size_t number_of_frames,
                                          void* audio_data,
                                          int64_t* elapsed_time_ms,
                                          int64_t* ntp_time_ms) {
   RTC_DCHECK_EQ(static_cast<size_t>(bits_per_sample), 8 * sizeof(int16_t));

[the sun, 2016/11/14 20:03:46]

Heh, it's called int16 for a reason.
http://en.cppreference.com/w/cpp/types/integer

[aleloi, 2016/11/15 16:56:54]

I hoped it helped with reading the code. I added comments instead. Hope it looks
better!

   RTC_DCHECK_GE(number_of_channels, 1u);
   RTC_DCHECK_LE(number_of_channels, 2u);
   RTC_DCHECK_GE(static_cast<int>(sample_rate),
                 AudioProcessing::NativeRate::kSampleRate8kHz);
   RTC_DCHECK_EQ(static_cast<int>(number_of_frames * 100), sample_rate);
   RTC_DCHECK_LE(bits_per_sample / 8 * number_of_frames * number_of_channels,
                 sizeof(AudioFrame::data_));
-  voe_audio_transport_->PullRenderData(
-      bits_per_sample, sample_rate, number_of_channels, number_of_frames,
-      audio_data, elapsed_time_ms, ntp_time_ms);
+  mixer_->Mix(number_of_channels, &frame_for_mixing_);
+  *elapsed_time_ms = frame_for_mixing_.elapsed_time_ms_;
+  *ntp_time_ms = frame_for_mixing_.ntp_time_ms_;
+
+  Resample(frame_for_mixing_, sample_rate, &resampler_,

[the sun, 2016/11/14 20:03:47]

Check return value?

[aleloi, 2016/11/15 16:56:54]

Done.

+           static_cast<int16_t*>(audio_data));
 }
 
 }  // namespace webrtc