Add mute state field to AudioFrame.

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,
              const int destination_sample_rate,
              PushResampler<int16_t>* resampler,
              int16_t* destination) {
   const int number_of_channels = static_cast<int>(frame.num_channels_);
   const int target_number_of_samples_per_channel =
       destination_sample_rate / 100;
   resampler->InitializeIfNeeded(frame.sample_rate_hz_, destination_sample_rate,
                                 number_of_channels);
 
+  // TODO(yujo): make resampler take an AudioFrame, and add special case
+  // handling of muted frames.

[the sun, 2017/03/23 19:34:38]

Note: That would mean the resampler needs to maintain the muted state also, and
possibly run for a while on zeroed input, to allow IR and filter state to
converge...

[yujo, 2017/03/24 07:30:14]

I'm not clear on how the resampler works, but maybe it's best to let it work
through the muted frames normally, then.

I think the important thing is actually to have it take an audio frame and write
an audio frame, and to make sure that muted input always gives muted output.
Does that sound right?

   return resampler->Resample(
-      frame.data_, frame.samples_per_channel_ * number_of_channels, destination,
-      number_of_channels * target_number_of_samples_per_channel);
+      frame.data(), frame.samples_per_channel_ * number_of_channels,
+      destination, 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), apm_(apm), mixer_(mixer) {
   RTC_DCHECK(voe_audio_transport);
   RTC_DCHECK(apm);
   RTC_DCHECK(mixer);
@@ skipping 29 matching lines @@
   RTC_DCHECK_EQ(sizeof(int16_t) * nChannels, nBytesPerSample);
   RTC_DCHECK_GE(nChannels, 1);
   RTC_DCHECK_LE(nChannels, 2);
   RTC_DCHECK_GE(
       samplesPerSec,
       static_cast<uint32_t>(AudioProcessing::NativeRate::kSampleRate8kHz));
 
   // 100 = 1 second / data duration (10 ms).
   RTC_DCHECK_EQ(nSamples * 100, samplesPerSec);
   RTC_DCHECK_LE(nBytesPerSample * nSamples * nChannels,
-                sizeof(AudioFrame::data_));
+                AudioFrame::kMaxDataSizeBytes);
 
   mixer_->Mix(nChannels, &mixed_frame_);
   *elapsed_time_ms = mixed_frame_.elapsed_time_ms_;
   *ntp_time_ms = mixed_frame_.ntp_time_ms_;
 
   const auto error = apm_->ProcessReverseStream(&mixed_frame_);
   RTC_DCHECK_EQ(error, AudioProcessing::kNoError);
 
   nSamplesOut = Resample(mixed_frame_, samplesPerSec, &resampler_,
                          static_cast<int16_t*>(audioSamples));
@@ skipping 22 matching lines @@
   RTC_DCHECK_EQ(bits_per_sample, 16);
   RTC_DCHECK_GE(number_of_channels, 1);
   RTC_DCHECK_LE(number_of_channels, 2);
   RTC_DCHECK_GE(sample_rate, AudioProcessing::NativeRate::kSampleRate8kHz);
 
   // 100 = 1 second / data duration (10 ms).
   RTC_DCHECK_EQ(number_of_frames * 100, sample_rate);
 
   // 8 = bits per byte.
   RTC_DCHECK_LE(bits_per_sample / 8 * number_of_frames * number_of_channels,
-                sizeof(AudioFrame::data_));
+                AudioFrame::kMaxDataSizeBytes);
   mixer_->Mix(number_of_channels, &mixed_frame_);
   *elapsed_time_ms = mixed_frame_.elapsed_time_ms_;
   *ntp_time_ms = mixed_frame_.ntp_time_ms_;
 
   const auto output_samples = Resample(mixed_frame_, sample_rate, &resampler_,
                                        static_cast<int16_t*>(audio_data));
   RTC_DCHECK_EQ(output_samples, number_of_channels * number_of_frames);
 }
 
 }  // namespace webrtc