Add mute state field to AudioFrame.

webrtc/modules/audio_mixer/frame_combiner.cc

 /*
  *  Copyright (c) 2017 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.
  */
 
@@ skipping 17 matching lines @@
 
 void CombineZeroFrames(AudioFrame* audio_frame_for_mixing) {
   audio_frame_for_mixing->elapsed_time_ms_ = -1;
   AudioFrameOperations::Mute(audio_frame_for_mixing);
 }
 
 void CombineOneFrame(const AudioFrame* input_frame,
                      AudioFrame* audio_frame_for_mixing) {
   audio_frame_for_mixing->timestamp_ = input_frame->timestamp_;
   audio_frame_for_mixing->elapsed_time_ms_ = input_frame->elapsed_time_ms_;
-  std::copy(input_frame->data_,
-            input_frame->data_ +
-                input_frame->num_channels_ * input_frame->samples_per_channel_,
-            audio_frame_for_mixing->data_);
+  if (!input_frame->muted()) {
+    size_t length =
+        input_frame->num_channels_ * input_frame->samples_per_channel_;
+    const int16_t* input_data = input_frame->data();
+    std::copy(input_data, input_data + length,
+              audio_frame_for_mixing->mutable_data());
+  } else {
+    AudioFrameOperations::Mute(audio_frame_for_mixing);
+  }
 }
 
 std::unique_ptr<AudioProcessing> CreateLimiter() {
   Config config;
   config.Set<ExperimentalAgc>(new ExperimentalAgc(false));
   std::unique_ptr<AudioProcessing> limiter(AudioProcessing::Create(config));
   RTC_DCHECK(limiter);
 
   const auto check_no_error = [](int x) {
     RTC_DCHECK_EQ(x, AudioProcessing::kNoError);
@@ skipping 46 matching lines @@
       AudioFrame::kVadUnknown, number_of_channels);
 
   if (mix_list.empty()) {
     CombineZeroFrames(audio_frame_for_mixing);
   } else if (mix_list.size() == 1) {
     CombineOneFrame(mix_list.front(), audio_frame_for_mixing);
   } else {
     std::vector<rtc::ArrayView<const int16_t>> input_frames;
     for (size_t i = 0; i < mix_list.size(); ++i) {
       input_frames.push_back(rtc::ArrayView<const int16_t>(
-          mix_list[i]->data_, samples_per_channel * number_of_channels));
+          mix_list[i]->data(), samples_per_channel * number_of_channels));
     }
     CombineMultipleFrames(input_frames, audio_frame_for_mixing);
   }
 }
 
 void FrameCombiner::CombineMultipleFrames(
     const std::vector<rtc::ArrayView<const int16_t>>& input_frames,
     AudioFrame* audio_frame_for_mixing) const {
   RTC_DCHECK(!input_frames.empty());
   RTC_DCHECK(audio_frame_for_mixing);
 
   const size_t frame_length = input_frames.front().size();
   for (const auto& frame : input_frames) {
     RTC_DCHECK_EQ(frame_length, frame.size());
   }
 
   // Algorithm: int16 frames are added to a sufficiently large
   // statically allocated int32 buffer. For > 2 participants this is
   // more efficient than addition in place in the int16 audio
   // frame. The audio quality loss due to halving the samples is
   // smaller than 16-bit addition in place.
   RTC_DCHECK_GE(kMaximalFrameSize, frame_length);
   std::array<int32_t, kMaximalFrameSize> add_buffer;
 
   add_buffer.fill(0);
 
   for (const auto& frame : input_frames) {
+    // TODO(yujo): skip this for muted input frames.
     std::transform(frame.begin(), frame.end(), add_buffer.begin(),
                    add_buffer.begin(), std::plus<int32_t>());
   }
 
   if (use_apm_limiter_) {
     // Halve all samples to avoid saturation before limiting.
     std::transform(add_buffer.begin(), add_buffer.begin() + frame_length,
-                   audio_frame_for_mixing->data_, [](int32_t a) {
+                   audio_frame_for_mixing->mutable_data(), [](int32_t a) {
                      return rtc::saturated_cast<int16_t>(a / 2);
                    });
 
     // Smoothly limit the audio.
     RTC_DCHECK(limiter_);
     const int error = limiter_->ProcessStream(audio_frame_for_mixing);
     if (error != limiter_->kNoError) {
       LOG_F(LS_ERROR) << "Error from AudioProcessing: " << error;
       RTC_NOTREACHED();
     }
 
     // And now we can safely restore the level. This procedure results in
     // some loss of resolution, deemed acceptable.
     //
     // It's possible to apply the gain in the AGC (with a target level of 0 dbFS
     // and compression gain of 6 dB). However, in the transition frame when this
     // is enabled (moving from one to two audio sources) it has the potential to
     // create discontinuities in the mixed frame.
     //
     // Instead we double the frame (with addition since left-shifting a
     // negative value is undefined).
     AudioFrameOperations::Add(*audio_frame_for_mixing, audio_frame_for_mixing);
   } else {
     std::transform(add_buffer.begin(), add_buffer.begin() + frame_length,
-                   audio_frame_for_mixing->data_,
+                   audio_frame_for_mixing->mutable_data(),
                    [](int32_t a) { return rtc::saturated_cast<int16_t>(a); });
   }
 }
 }  // namespace webrtc