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): for muted input frames, don't resample. Either 1) allow

[hlundin-webrtc, 2017/03/16 14:47:48]

I would suggest that this function simply writes the correct number of zeros to
destination if frame is muted.

EDIT: This might not work, since you would then not be priming the resampler
filters with the correct data (i.e., it will be missing out on the zero
samples). I will have to think about his.

[yujo, 2017/03/16 23:37:21]

I think the correct answer is to push AudioFrame deeper, what do you think?
(Also sorry, the TODO made no sense. I didn't see that destination_sample_rate
was available as a local.)

[hlundin-webrtc, 2017/03/17 14:29:38]

I think the TODO now is good enough for this CL. I agree that we should push
AudioFrame deeper later on.

+  // resampler to return output length without doing the resample, so we know
+  // how much to zero here; or 2) make resampler accept a hint that the input is
+  // zeroed.
   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