Move functionality out from AudioFrame and into AudioFrameOperations.

webrtc/modules/audio_mixer/audio_mixer_impl.cc

 /*
  *  Copyright (c) 2012 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/modules/audio_mixer/audio_mixer_impl.h"
 
 #include <algorithm>
 #include <functional>
 #include <utility>
 
+#include "webrtc/audio/utility/audio_frame_operations.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/modules/audio_mixer/audio_frame_manipulator.h"
-#include "webrtc/modules/utility/include/audio_frame_operations.h"
 
 namespace webrtc {
 namespace {
 
 struct SourceFrame {
   SourceFrame(AudioMixerImpl::SourceStatus* source_status,
               AudioFrame* audio_frame,
               bool muted)
       : source_status(source_status), audio_frame(audio_frame), muted(muted) {
     RTC_DCHECK(source_status);
@@ skipping 69 matching lines @@
     RTC_DCHECK_EQ(mixed_audio->sample_rate_hz_, frame->sample_rate_hz_);
     RTC_DCHECK_EQ(
         frame->samples_per_channel_,
         static_cast<size_t>((mixed_audio->sample_rate_hz_ *
                              webrtc::AudioMixerImpl::kFrameDurationInMs) /
                             1000));
 
     // Mix |f.frame| into |mixed_audio|, with saturation protection.
     // These effect is applied to |f.frame| itself prior to mixing.
     if (use_limiter) {
-      // Divide by two to avoid saturation in the mixing.
-      // This is only meaningful if the limiter will be used.
-      *frame >>= 1;
+      // This is to avoid saturation in the mixing. It is only
+      // meaningful if the limiter will be used.
+      AudioFrameOperations::ApplyHalfGain(frame);
     }
     RTC_DCHECK_EQ(frame->num_channels_, mixed_audio->num_channels_);
-    *mixed_audio += *frame;
+    AudioFrameOperations::Add(*frame, mixed_audio);
   }
   return 0;
 }
 
 AudioMixerImpl::SourceStatusList::const_iterator FindSourceInList(
     AudioMixerImpl::Source const* audio_source,
     AudioMixerImpl::SourceStatusList const* audio_source_list) {
   return std::find_if(
       audio_source_list->begin(), audio_source_list->end(),
       [audio_source](const std::unique_ptr<AudioMixerImpl::SourceStatus>& p) {
@@ skipping 118 matching lines @@
 
     use_limiter_ = mix_list.size() > 1;
 
     // We only use the limiter if we're actually mixing multiple streams.
     MixFromList(audio_frame_for_mixing, mix_list, use_limiter_);
   }
 
   if (audio_frame_for_mixing->samples_per_channel_ == 0) {
     // Nothing was mixed, set the audio samples to silence.
     audio_frame_for_mixing->samples_per_channel_ = sample_size_;
-    audio_frame_for_mixing->Mute();
+    AudioFrameOperations::Mute(audio_frame_for_mixing);
   } else {
     // Only call the limiter if we have something to mix.
     LimitMixedAudio(audio_frame_for_mixing);
   }
 
   return;
 }
 
 void AudioMixerImpl::SetOutputFrequency(int frequency) {
   RTC_DCHECK_RUNS_SERIALIZED(&race_checker_);
@@ skipping 86 matching lines @@
   // 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).
-  *mixed_audio += *mixed_audio;
+  AudioFrameOperations::Add(*mixed_audio, mixed_audio);
 
   if (error != limiter_->kNoError) {
     LOG_F(LS_ERROR) << "Error from AudioProcessing: " << error;
     RTC_NOTREACHED();
     return false;
   }
   return true;
 }
 
 bool AudioMixerImpl::GetAudioSourceMixabilityStatusForTest(
     AudioMixerImpl::Source* audio_source) const {
   RTC_DCHECK_RUNS_SERIALIZED(&race_checker_);
   rtc::CritScope lock(&crit_);
 
   const auto iter = FindSourceInList(audio_source, &audio_source_list_);
   if (iter != audio_source_list_.end()) {
     return (*iter)->is_mixed;
   }
 
   LOG(LS_ERROR) << "Audio source unknown";
   return false;
 }
 }  // namespace webrtc