audioproc_f with simulated mic analog gain

webrtc/modules/audio_processing/test/fake_recording_device.cc

Index: webrtc/modules/audio_processing/test/fake_recording_device.cc
diff --git a/webrtc/modules/audio_processing/test/fake_recording_device.cc b/webrtc/modules/audio_processing/test/fake_recording_device.cc
new file mode 100644
index 0000000000000000000000000000000000000000..240d07d03e6d9c0f456e02cf0aaa4242dde1045d
--- /dev/null
+++ b/webrtc/modules/audio_processing/test/fake_recording_device.cc
@@ -0,0 +1,142 @@
+/*
+ *  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.
+ */
+
+#include "webrtc/modules/audio_processing/test/fake_recording_device.h"
+
+#include <algorithm>
+
+#include "webrtc/base/logging.h"
+#include "webrtc/base/ptr_util.h"
+
+namespace webrtc {
+namespace test {
+
+namespace {
+
+constexpr int16_t kInt16SampleMin = -32768;
+constexpr int16_t kInt16SampleMax = 32767;
+constexpr float kFloatSampleMin = -1.0f;
+constexpr float kFloatSampleMax = 1.0f;
+
+int16_t ClipSampleFloatToInt16(float sample) {
+  return std::max(std::min(sample, static_cast<float>(kInt16SampleMax)),
+                  static_cast<float>(kInt16SampleMin));
+}
+
+float ClipSampleFloatToFloat(float sample) {
+  return std::max(std::min(sample, kFloatSampleMax), kFloatSampleMin);
+}

[AleBzk, 2017/07/26 13:42:30]

Removed since these functions may confuse the reader at this stage.

+
+}  // namespace
+
+// Abstract class for the different fake recording devices.
+class FakeRecordingDeviceWorker {
+ public:
+  FakeRecordingDeviceWorker(const int& mic_level,
+                            const rtc::Optional<int>& undo_mic_level)
+      : mic_level_(mic_level), undo_mic_level_(undo_mic_level) {}
+  virtual ~FakeRecordingDeviceWorker() = default;
+  virtual void ModifyBufferInt16(AudioFrame* buffer) = 0;
+  virtual void ModifyBufferFloat(ChannelBuffer<float>* buffer) = 0;
+
+ protected:
+  const int& mic_level_;
+  const rtc::Optional<int>& undo_mic_level_;
+};
+
+namespace {
+
+// Identity fake recording device. The samples are not modified, which is
+// equivalent to a constant gain curve at 1.0 - only used for testing.
+class FakeRecordingDeviceIdentity final : public FakeRecordingDeviceWorker {
+ public:
+  FakeRecordingDeviceIdentity(const int& mic_level,
+                              const rtc::Optional<int>& undo_mic_level)
+      : FakeRecordingDeviceWorker(mic_level, undo_mic_level) {}
+  ~FakeRecordingDeviceIdentity() override = default;
+  void ModifyBufferInt16(AudioFrame* buffer) override {}
+  void ModifyBufferFloat(ChannelBuffer<float>* buffer) override {}
+};
+
+// Linear fake recording device. The gain curve is a linear function mapping the
+// mic levels range [0, 255] to [0.0, 1.0].
+class FakeRecordingDeviceLinear final : public FakeRecordingDeviceWorker {
+ public:
+  FakeRecordingDeviceLinear(const int& mic_level,
+                            const rtc::Optional<int>& undo_mic_level)
+      : FakeRecordingDeviceWorker(mic_level, undo_mic_level) {}
+  ~FakeRecordingDeviceLinear() override = default;
+  void ModifyBufferInt16(AudioFrame* buffer) override {
+    const size_t number_of_samples =
+        buffer->samples_per_channel_ * buffer->num_channels_;
+    RTC_DCHECK_LE(number_of_samples, AudioFrame::kMaxDataSizeSamples);
+    int16_t* data = buffer->mutable_data();
+    for (size_t i = 0; i < number_of_samples; ++i) {
+      const float sample_f = data[i];
+      if (undo_mic_level_ && *undo_mic_level_ > 0) {
+        // Virtually restore the unmodified microphone level.
+        data[i] =
+            ClipSampleFloatToInt16(sample_f * mic_level_ / *undo_mic_level_);
+      } else {
+        // Simulate the mic gain only.
+        data[i] = ClipSampleFloatToInt16(sample_f * mic_level_ / 255.0f);
+      }
+    }
+  }
+  void ModifyBufferFloat(ChannelBuffer<float>* buffer) override {
+    for (size_t c = 0; c < buffer->num_channels(); ++c) {
+      for (size_t i = 0; i < buffer->num_frames(); ++i) {
+        if (undo_mic_level_ && *undo_mic_level_ > 0) {
+          // Virtually restore the unmodified microphone level.
+          buffer->channels()[c][i] = ClipSampleFloatToFloat(
+              buffer->channels()[c][i] * mic_level_ / *undo_mic_level_);
+        } else {
+          // Simulate the mic gain only.
+          buffer->channels()[c][i] = ClipSampleFloatToFloat(
+              buffer->channels()[c][i] * mic_level_ / 255.0f);
+        }
+      }
+    }
+  }
+};
+
+}  // namespace
+
+FakeRecordingDevice::FakeRecordingDevice(int initial_mic_level, DeviceKind kind)

[peah-webrtc, 2017/06/29 22:04:00]

Having seen the usage of the constructor, I definitely think the comment about
the cast in the construction does not make sense.

As it is now, the constructor first converts the simulated_mic_kind into a
DeviceKind using a static_cast. 
     fake_recording_device_(settings.initial_mic_level,
                              settings_.simulate_mic_gain
                                   ?
static_cast<FakeRecordingDevice::DeviceKind>(
                                          *settings.simulated_mic_kind)
                                    : kDefaultFakeRecDeviceKind),

Then the resulting DeviceKind variable is only used in the constructor switch
statement.

I think you should simply pass settings.simulated_mic_kind into the constructor
and make the switch statement on that. That would be more direct, and would
require less code.

+    : mic_level_(initial_mic_level) {
+  switch (kind) {
+    case FakeRecordingDevice::DeviceKind::IDENTITY:
+      worker_ = rtc::MakeUnique<FakeRecordingDeviceIdentity>(mic_level_,
+                                                             undo_mic_level_);
+      break;
+    case FakeRecordingDevice::DeviceKind::LINEAR:
+      worker_ = rtc::MakeUnique<FakeRecordingDeviceLinear>(mic_level_,
+                                                           undo_mic_level_);
+      break;
+    default:
+      RTC_NOTREACHED();
+      break;
+  }
+}
+
+FakeRecordingDevice::~FakeRecordingDevice() = default;
+
+void FakeRecordingDevice::SimulateAnalogGain(AudioFrame* buffer) {
+  RTC_DCHECK(worker_);
+  worker_->ModifyBufferInt16(buffer);
+}
+
+void FakeRecordingDevice::SimulateAnalogGain(ChannelBuffer<float>* buffer) {
+  RTC_DCHECK(worker_);
+  worker_->ModifyBufferFloat(buffer);
+}
+
+}  // namespace test
+}  // namespace webrtc