First try on a fake analog volume control interface for use in audioproc_f.

webrtc/modules/audio_processing/test/analog_volume_mapper.h

+/*
+ *  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.
+ */
+
+#ifndef WEBRTC_MODULES_AUDIO_PROCESSING_TEST_ANALOG_VOLUME_MAPPER_H_
+#define WEBRTC_MODULES_AUDIO_PROCESSING_TEST_ANALOG_VOLUME_MAPPER_H_
+
+#include "webrtc/base/checks.h"
+
+namespace webrtc {
+
+// Class for simulating an analog gain controller controlled by
+// webrtc::GainControl. The class wraps a mapping from the current
+// level to a floating point scaling factor abstracting
+// non-linearities in the gain curve of real analog microphones. The
+// intended mode of operation is to use get_scaling_factor() to apply
+// a gain factor to a signal.
+class AnalogLevelMapper {
+ public:
+  enum class LevelToScalingMappingKind {

[peah-webrtc, 2017/04/26 07:20:03]

I really think it would be easier to see how to best implement it if is
integrated in the simulator.

This class describes a mapping between a gain value, and a scaling. I think I
see how you want to apply that but it seems to me that it is not as
straightforward as it could be. But since I don't see the usage of the class, it
is hard to tell.

I'd have imagined a class that modules the analog microphone gain in such a
manner that it receives the microphone signal, and the analog gain provided by
APM, and returns a scaled microphone signal, together with the gain that was
actually applied. That is exactly how the analog gain effect appears to APM and
to me it would make sense to model it like this.

This class may be used as part of such a class though. but it does not look like
that with the setting and getting methods.
There are some things that get quite tricky to model in this class. For
instance, how do you handle a gain curve that applies soft saturation? That is
both gain and signal dependent, and to apply that you need both the gain, the
gain mapping and the signal as this is signal dependent.

Seeing the integrations of class, this implementation may fit really well into
that though. 
If not in a CL, maybe you could present or describe how exactly this is to be
used? 

+    kIdentity,  // Any level produces a constant scaling factor of 1.0f.
+    kLinear     // A level within [0, 255] is linearly scaled. 0 produces
+                // 0.f, and 255 is 1.0f.
+  };
+
+  explicit AnalogLevelMapper(LevelToScalingMappingKind mapping_kind)
+      : mapping_kind_(mapping_kind) {}
+
+  // |level| must be within [0, 255].
+  void set_analog_level(int level) {
+    RTC_DCHECK_LE(0, level);
+    RTC_DCHECK_LE(level, 255);
+    level_ = level;
+  }
+
+  int analog_level() const { return level_; }
+
+  float GetScalingFactor() const {
+    switch (mapping_kind_) {
+      case LevelToScalingMappingKind::kIdentity: {
+        return 1.0f;
+      }
+      case LevelToScalingMappingKind::kLinear: {
+        return static_cast<float>(level_) / 255.0f;
+      }
+    }
+  }
+
+ private:
+  int level_ = 0;
+  const LevelToScalingMappingKind mapping_kind_;
+};
+}  // namespace webrtc
+
+#endif  // WEBRTC_MODULES_AUDIO_PROCESSING_TEST_ANALOG_VOLUME_MAPPER_H_