Added a level indicator to new mixer.

webrtc/modules/audio_mixer/new_audio_conference_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.
  */
 
@@ skipping 55 matching lines @@
   } else if (frame->num_channels_ == 2 && number_of_channels == 1) {
     AudioFrameOperations::StereoToMono(frame);
   }
 }
 
 // Mix |frame| into |mixed_frame|, with saturation protection and upmixing.
 // These effects are applied to |frame| itself prior to mixing. Assumes that
 // |mixed_frame| always has at least as many channels as |frame|. Supports
 // stereo at most.
 //
-// TODO(andrew): consider not modifying |frame| here.
 void MixFrames(AudioFrame* mixed_frame, AudioFrame* frame, bool use_limiter) {
   RTC_DCHECK_GE(mixed_frame->num_channels_, frame->num_channels_);
   if (use_limiter) {
     // Divide by two to avoid saturation in the mixing.
     // This is only meaningful if the limiter will be used.
     *frame >>= 1;
   }
   RTC_DCHECK_EQ(frame->num_channels_, mixed_frame->num_channels_);
   *mixed_frame += *frame;
 }
@@ skipping 143 matching lines @@
   for (FrameAndMuteInfo& frame_and_mute : additionalFramesList) {
     RemixFrame(frame_and_mute.frame, number_of_channels);
   }
 
   audio_frame_for_mixing->UpdateFrame(
       -1, time_stamp_, NULL, 0, output_frequency_, AudioFrame::kNormalSpeech,
       AudioFrame::kVadPassive, number_of_channels);
 
   time_stamp_ += static_cast<uint32_t>(sample_size_);
 
-  use_limiter_ = num_mixed_audio_sources_ > 1 &&
-                 output_frequency_ <= AudioProcessing::kMaxNativeSampleRateHz;
+  use_limiter_ = num_mixed_audio_sources_ > 1;
 
   // We only use the limiter if it supports the output sample rate and
   // we're actually mixing multiple streams.
   MixFromList(audio_frame_for_mixing, mixList, id_, use_limiter_);
 
   {
     CriticalSectionScoped cs(crit_.get());
     MixAnonomouslyFromList(audio_frame_for_mixing, additionalFramesList);
 
     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();
     } else {
       // Only call the limiter if we have something to mix.
       LimitMixedAudio(audio_frame_for_mixing);
     }
   }
+
+  // Pass the final result to the level indicator.
+  audio_level_.ComputeLevel(*audio_frame_for_mixing);
+
   return;
 }
 
 int32_t NewAudioConferenceMixerImpl::SetOutputFrequency(
     const Frequency& frequency) {
   CriticalSectionScoped cs(crit_.get());
 
   output_frequency_ = frequency;
   sample_size_ =
       static_cast<size_t>((output_frequency_ * kProcessPeriodicityInMs) / 1000);
@@ skipping 314 matching lines @@
   *mixedAudio += *mixedAudio;
 
   if (error != limiter_->kNoError) {
     WEBRTC_TRACE(kTraceError, kTraceAudioMixerServer, id_,
                  "Error from AudioProcessing: %d", error);
     RTC_NOTREACHED();
     return false;
   }
   return true;
 }
+
+uint32_t NewAudioConferenceMixerImpl::GetAudioOutputLevel() {
+  int8_t current_level = audio_level_.Level();
+  uint32_t level = static_cast<uint32_t>(current_level);
+  WEBRTC_TRACE(kTraceStateInfo, kTraceAudioMixerServer, id_,
+               "GetAudioOutputLevel() => level=%u", level);
+  return level;
+}
+
+uint32_t NewAudioConferenceMixerImpl::GetAudioOutputLevelFullRange() {
+  int16_t current_level = audio_level_.LevelFullRange();
+  uint32_t level = static_cast<uint32_t>(current_level);
+  WEBRTC_TRACE(kTraceStateInfo, kTraceAudioMixerServer, id_,
+               "GetAudioOutputLevelFullRange() => level=%u", level);
+  return level;
+}
 }  // namespace webrtc