Remove AgcManager.

webrtc/modules/audio_processing/agc/agc_manager_direct.h

 /*
  *  Copyright (c) 2013 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.
  */
 
 #ifndef WEBRTC_MODULES_AUDIO_PROCESSING_AGC_AGC_MANAGER_DIRECT_H_
 #define WEBRTC_MODULES_AUDIO_PROCESSING_AGC_AGC_MANAGER_DIRECT_H_
 
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/modules/audio_processing/agc/agc.h"
 
 namespace webrtc {
 
 class AudioFrame;
 class DebugFile;
 class GainControl;
 
 // Callbacks that need to be injected into AgcManagerDirect to read and control
-// the volume values. They have different behavior if they are called from
-// AgcManager or AudioProcessing. This is done to remove the VoiceEngine
-// dependency in AgcManagerDirect.
+// the volume values. This is done to remove the VoiceEngine dependency in
+// AgcManagerDirect.
 class VolumeCallbacks {

[Andrew MacDonald, 2015/08/19 17:58:39]

Not for this CL, but do we need to use this callback approach any longer?
Perhaps add a TODO to remove if not.

[aluebs-webrtc, 2015/09/28 22:51:08]

Added TODO. But how would you imagine it to work?

[Andrew MacDonald, 2015/09/29 05:33:34]

Instead of triggering a callback on volume change, we'd have Process() indicate
it was ready to deliver a new volume. Similar to how the localizers work.

[aluebs-webrtc, 2015/09/29 18:10:39]

And let the APM update the volume in the GainControlForNewAgc? Or are you
thinking of getting rid of this all? Then how would the VoE get notified about
the volume control? And how do we do this without disrupting how it works in
mobile, where the new AGC is not possible to use? We can take this offline when
the time comes :)

[Andrew MacDonald, 2015/09/29 18:17:11]

These callbacks don't get delivered to voice engine. It requests the updated
value from APM:
https://code.google.com/p/chromium/codesearch#chromium/src/third_party/webrtc...

Same with Chrome:
https://code.google.com/p/chromium/codesearch#chromium/src/content/renderer/m...

Hence the "direct" part of AgcManagerDirect.

[aluebs-webrtc, 2015/09/29 19:10:34]

Ok, I think I get your point but we can discuss when we move forward with this.

  public:
   virtual ~VolumeCallbacks() {}
   virtual void SetMicVolume(int volume) = 0;
   virtual int GetMicVolume() = 0;
 };
 
 // Direct interface to use AGC to set volume and compression values.
 // AudioProcessing uses this interface directly to integrate the callback-less
-// AGC. AgcManager delegates most of its calls here. See agc_manager.h for
-// undocumented methods.
+// AGC.
 //
 // This class is not thread-safe.
 class AgcManagerDirect {

[Andrew MacDonald, 2015/08/19 17:58:39]

final, and DISALLOW_COPY_AND_ASSIGN

[aluebs-webrtc, 2015/09/28 22:51:08]

Done.

  public:
   // AgcManagerDirect will configure GainControl internally. The user is
   // responsible for processing the audio using it after the call to Process.
   // The operating range of startup_min_level is [12, 255] and any input value
   // outside that range will be clamped.
   AgcManagerDirect(GainControl* gctrl,
                    VolumeCallbacks* volume_callbacks,
                    int startup_min_level);
   // Dependency injection for testing. Don't delete |agc| as the memory is owned
   // by the manager.
   AgcManagerDirect(Agc* agc,
                    GainControl* gctrl,
                    VolumeCallbacks* volume_callbacks,
                    int startup_min_level);
   ~AgcManagerDirect();
 
   int Initialize();
   void AnalyzePreProcess(int16_t* audio,
                          int num_channels,
                          int samples_per_channel);
   void Process(const int16_t* audio, int length, int sample_rate_hz);
 
+  // Call when the capture stream has been muted/unmuted. This causes the
+  // manager to disregard all incoming audio; chances are good it's background
+  // noise to which we'd like to avoid adapting.
+  void SetCaptureMuted(bool muted);
+  bool capture_muted() { return capture_muted_; }
+
+  float voice_probability();
+
+ private:
   // Sets a new microphone level, after first checking that it hasn't been
   // updated by the user, in which case no action is taken.
   void SetLevel(int new_level);
 
   // Set the maximum level the AGC is allowed to apply. Also updates the
   // maximum compression gain to compensate. The level must be at least
   // |kClippedLevelMin|.
   void SetMaxLevel(int level);
 
-  void SetCaptureMuted(bool muted);
-  bool capture_muted() { return capture_muted_; }
-
-  float voice_probability();
-
- private:
   int CheckVolumeAndReset();
   void UpdateGain();
   void UpdateCompressor();
 
   rtc::scoped_ptr<Agc> agc_;
   GainControl* gctrl_;
   VolumeCallbacks* volume_callbacks_;
 
   int frames_since_clipped_;
   int level_;
   int max_level_;
   int max_compression_gain_;
   int target_compression_;
   int compression_;
   float compression_accumulator_;
   bool capture_muted_;
   bool check_volume_on_next_process_;
   bool startup_;
   int startup_min_level_;
 
   rtc::scoped_ptr<DebugFile> file_preproc_;
   rtc::scoped_ptr<DebugFile> file_postproc_;
 };
 
 }  // namespace webrtc
 
 #endif  // WEBRTC_MODULES_AUDIO_PROCESSING_AGC_AGC_MANAGER_DIRECT_H_