Refactor FakeAudioDevice to have separate methods for starting recording and playout.

webrtc/test/fake_audio_device.cc

 /*
  *  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.
  */
 
 #include "webrtc/test/fake_audio_device.h"
 
 #include <algorithm>
 
-#include "webrtc/base/platform_thread.h"
-#include "webrtc/modules/media_file/media_file_utility.h"
+#include "webrtc/base/random.h"
 #include "webrtc/system_wrappers/include/clock.h"
 #include "webrtc/system_wrappers/include/event_wrapper.h"
-#include "webrtc/system_wrappers/include/file_wrapper.h"
-#include "webrtc/test/gtest.h"
 
 namespace webrtc {
 namespace test {
 
+class FakeAudioDevice::PulsedNoiseCapturer {
+ public:
+  PulsedNoiseCapturer(size_t num_samples, int16_t max_amplitude)
+      : fill_with_zero_(false) {
+    RTC_DCHECK_GT(max_amplitude, 0);
+    random_audio_.SetSize(num_samples);

[peah-webrtc, 2017/01/26 09:23:59]

Instead add random_audio_(num_samples, 0) to the initializer list

[perkj_webrtc, 2017/01/26 12:16:25]

Done.

+    null_audio_.SetSize(num_samples);

[peah-webrtc, 2017/01/26 09:23:59]

Instead add null_audio_(num_samples, 0) to the initializer list

[perkj_webrtc, 2017/01/26 12:16:25]

Done.

+    memset(null_audio_.data(), 0, null_audio_.size() * sizeof(int16_t));

[peah-webrtc, 2017/01/26 09:23:59]

This can be removed if you use a vector instead.

[perkj_webrtc, 2017/01/26 12:16:25]

I did not know I could use a std::vector. c++11 news apparently. Thanks
http://en.cppreference.com/w/cpp/container/vector/data 

+
+    webrtc::Random random_generator(1);
+    for (size_t i = 0; i < num_samples; ++i) {

[peah-webrtc, 2017/01/26 09:23:59]

You can instead use
for (auto& r : random_audio_) {
  r = random_generator.Rand(-max_amplitude, max_amplitude);
}

But I think you should move this to the Capture() method.

[perkj_webrtc, 2017/01/26 12:16:25]

ok, I did that first but decided against it since I guessed  one cared and I
could save the cycles. 

+      random_audio_[i] = random_generator.Rand(-max_amplitude, max_amplitude);
+    }
+  }
+
+  rtc::ArrayView<int16_t> Capture() {

[peah-webrtc, 2017/01/26 09:23:59]

rtc::ArrayView<int16_t> returns an object that can be used to modify the
returned buffer. I guess that is not what you want, right?

Instead I guess you should use rtc::ArrayView<const int16_t>? Or is it the way
that RecordedDataIsAvailable operates that requires this to be non-const

[perkj_webrtc, 2017/01/26 12:16:25]

Done.

+    fill_with_zero_ = !fill_with_zero_;

[peah-webrtc, 2017/01/26 09:23:59]

I think you should do this with proper (nonrepeating) random data instead.
e.g,:
rtc::ArrayView<int16_t> Capture() {
  fill_with_zero_ = !fill_with_zero_;
  if (!fill_with_zero_) {
    for (auto& r : random_audio_) {
      r = random_generator_.Rand(-max_amplitude, max_amplitude);
    }
  }
  return fill_with_zero_ ? null_audio_ : random_audio_;
}

Or even cooler
rtc::ArrayView<int16_t> Capture() {
  fill_with_zero_ = !fill_with_zero_;
  if (!fill_with_zero_) {
std::generate(random_audio_.begin(), random_audio_.end(), [&]() { return
random_generator_.Rand(-max_amplitude, max_amplitude); })
  return fill_with_zero_ ? null_audio_ : random_audio_;
}


Note, however, that for these variants random_generator_ must be a member
variable.

[perkj_webrtc, 2017/01/26 12:16:25]

nice. I like std::generate.

+    return fill_with_zero_ ? null_audio_ : random_audio_;
+  }
+
+ private:
+  bool fill_with_zero_;
+  rtc::BufferT<int16_t> random_audio_;

[peah-webrtc, 2017/01/26 09:23:59]

Since the sizes of these are constant, I'd rather use std::vector<int16_t>
instead of rtc::BufferT.

[perkj_webrtc, 2017/01/26 12:16:25]

sure,  I did not know about std::vector::data()

+  rtc::BufferT<int16_t> null_audio_;
+};
+
 FakeAudioDevice::FakeAudioDevice(Clock* clock,
-                                 const std::string& filename,
-                                 float speed)
-    : audio_callback_(NULL),
-      capturing_(false),
-      captured_audio_(),
-      playout_buffer_(),
+                                 float speed,
+                                 int sampling_frequency_in_hz)
+    : sampling_frequency_in_hz_(sampling_frequency_in_hz),
+      audio_callback_(NULL),
+      rendering_(false),
       speed_(speed),
       last_playout_ms_(-1),
       clock_(clock, speed),
       tick_(EventTimerWrapper::Create()),
-      thread_(FakeAudioDevice::Run, this, "FakeAudioDevice"),
-      file_utility_(new ModuleFileUtility(0)),
-      input_stream_(FileWrapper::Create()) {
-  memset(captured_audio_, 0, sizeof(captured_audio_));
-  memset(playout_buffer_, 0, sizeof(playout_buffer_));
-  // Open audio input file as read-only and looping.
-  EXPECT_TRUE(input_stream_->OpenFile(filename.c_str(), true)) << filename;
+      thread_(FakeAudioDevice::Run, this, "FakeAudioDevice") {
+  // Assuming 10ms audio packets.
+  playout_buffer_.SetSize(sampling_frequency_in_hz_ / 100);

[peah-webrtc, 2017/01/26 09:23:59]

Change this to vector, and set the size in the initializer list.

[perkj_webrtc, 2017/01/26 12:16:25]

Done.

 }
 
 FakeAudioDevice::~FakeAudioDevice() {
-  Stop();
-
+  StopPlayout();
+  StopRecording();
   thread_.Stop();
 }
 
+int32_t FakeAudioDevice::StartPlayout() {
+  rtc::CritScope cs(&lock_);
+  rendering_ = true;
+  return 0;
+}
+
+int32_t FakeAudioDevice::StopPlayout() {
+  rtc::CritScope cs(&lock_);
+  rendering_ = false;
+  return 0;
+}
+
+void FakeAudioDevice::StartRecordingPulsedNoise(int16_t max_amplitude) {
+  rtc::CritScope cs(&lock_);
+  capturer_.reset(new FakeAudioDevice::PulsedNoiseCapturer(
+      sampling_frequency_in_hz_ / 100, max_amplitude));
+}
+
+int32_t FakeAudioDevice::StopRecording() {
+  rtc::CritScope cs(&lock_);
+  capturer_.reset();
+  return 0;
+}
+
 int32_t FakeAudioDevice::Init() {
-  rtc::CritScope cs(&lock_);
-  if (file_utility_->InitPCMReading(*input_stream_.get()) != 0)
-    return -1;
-
-  if (!tick_->StartTimer(true, 10 / speed_))
-    return -1;
+  RTC_CHECK(tick_->StartTimer(true, 10 / speed_));
   thread_.Start();
   thread_.SetPriority(rtc::kHighPriority);
   return 0;
 }
 
 int32_t FakeAudioDevice::RegisterAudioCallback(AudioTransport* callback) {
   rtc::CritScope cs(&lock_);
   audio_callback_ = callback;
   return 0;
 }
 
 bool FakeAudioDevice::Playing() const {
   rtc::CritScope cs(&lock_);
-  return capturing_;
+  return rendering_;
 }
 
 int32_t FakeAudioDevice::PlayoutDelay(uint16_t* delay_ms) const {
   *delay_ms = 0;
   return 0;
 }
 
 bool FakeAudioDevice::Recording() const {
   rtc::CritScope cs(&lock_);
-  return capturing_;
+  return !!capturer_;
 }
 
 bool FakeAudioDevice::Run(void* obj) {
-  static_cast<FakeAudioDevice*>(obj)->CaptureAudio();
+  static_cast<FakeAudioDevice*>(obj)->ProcessAudio();
   return true;
 }
 
-void FakeAudioDevice::CaptureAudio() {
+void FakeAudioDevice::ProcessAudio() {
   {
     rtc::CritScope cs(&lock_);
-    if (capturing_) {
-      int bytes_read = file_utility_->ReadPCMData(
-          *input_stream_.get(), captured_audio_, kBufferSizeBytes);
-      if (bytes_read <= 0)
-        return;
-      // 2 bytes per sample.
-      size_t num_samples = static_cast<size_t>(bytes_read / 2);
+    if (capturer_) {
+      // Capture 10ms of audio. 2 bytes per sample.
+      rtc::ArrayView<int16_t> audio_data = capturer_->Capture();
       uint32_t new_mic_level;
-      EXPECT_EQ(0,
-                audio_callback_->RecordedDataIsAvailable(captured_audio_,
-                                                         num_samples,
-                                                         2,
-                                                         1,
-                                                         kFrequencyHz,
-                                                         0,
-                                                         0,
-                                                         0,
-                                                         false,
-                                                         new_mic_level));
-      size_t samples_needed = kFrequencyHz / 100;
+      RTC_CHECK_EQ(
+          0, audio_callback_->RecordedDataIsAvailable(
+                 audio_data.data(), audio_data.size(), 2, 1,
+                 sampling_frequency_in_hz_, 0, 0, 0, false, new_mic_level));
+    }
+    if (rendering_) {
+      // Assuming 10ms audio packet size.
+      size_t samples_needed = sampling_frequency_in_hz_ / 100;
       int64_t now_ms = clock_.TimeInMilliseconds();
       uint32_t time_since_last_playout_ms = now_ms - last_playout_ms_;
       if (last_playout_ms_ > 0 && time_since_last_playout_ms > 0) {
-        samples_needed = std::min(
-            static_cast<size_t>(kFrequencyHz / time_since_last_playout_ms),
-            kBufferSizeBytes / 2);
+        samples_needed =
+            std::min(static_cast<size_t>(sampling_frequency_in_hz_ /
+                                         time_since_last_playout_ms),
+                     playout_buffer_.size());
       }
       size_t samples_out = 0;
       int64_t elapsed_time_ms = -1;
       int64_t ntp_time_ms = -1;
-      EXPECT_EQ(0,
-                audio_callback_->NeedMorePlayData(samples_needed,
-                                                  2,
-                                                  1,
-                                                  kFrequencyHz,
-                                                  playout_buffer_,
-                                                  samples_out,
-                                                  &elapsed_time_ms,
-                                                  &ntp_time_ms));
+      RTC_CHECK_EQ(0, audio_callback_->NeedMorePlayData(
+                          samples_needed, 2, 1, sampling_frequency_in_hz_,
+                          playout_buffer_.data(), samples_out, &elapsed_time_ms,
+                          &ntp_time_ms));
     }
   }
   tick_->Wait(WEBRTC_EVENT_INFINITE);
 }
 
-void FakeAudioDevice::Start() {
-  rtc::CritScope cs(&lock_);
-  capturing_ = true;
-}
 
-void FakeAudioDevice::Stop() {
-  rtc::CritScope cs(&lock_);
-  capturing_ = false;
-}
 }  // namespace test
 }  // namespace webrtc