Added automatic mode to FakeInputAudioStream to generate automatic beeps

media/audio/fake_audio_input_stream.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "media/audio/fake_audio_input_stream.h"
 
 #include "base/bind.h"
 #include "base/lazy_instance.h"
 #include "media/audio/audio_manager_base.h"
 
 using base::TimeTicks;
 using base::TimeDelta;
 
 namespace media {
 
 namespace {
 
 // These values are based on experiments for local-to-local
 // PeerConnection to demonstrate audio/video synchronization.
 const int kBeepDurationMilliseconds = 20;
 const int kBeepFrequency = 400;
 
+// Intervals between two automatic beeps.
+const int kAutomaticBeepIntervalInMs = 500;
+
+// Automatic beep will be triggered every |kAutomaticBeepIntervalInMs| unless
+// users explicitly call BeepOnce(), which will disable the automatic beep.
 struct BeepContext {
-  BeepContext() : beep_once(false) {}
+  BeepContext() : beep_once(false), automatic(true) {}

[DaleCurtis, 2014/04/29 17:30:56]

Shouldn't this default to false? Isn't this used in production for cases w/o a
mic?

[no longer working on chromium, 2014/05/02 14:30:47]

That is good point, I honestly have no idea how the fake input stream is used
for production.

My understanding is that, In production, when there is no mic, all the clients
won't pass the UI if they are requesting mic.

But I searched the code base and found out that in AudioManagerLinux, if no
cras, no pulse and no alsa, it will use FakeAudioManager:
#if defined(USE_ALSA)
  UMA_HISTOGRAM_ENUMERATION("Media.LinuxAudioIO", kAlsa, kAudioIOMax + 1);
  return new AudioManagerAlsa(audio_log_factory);
#else
  return new FakeAudioManager(audio_log_factory);
#endif
But I believe there is no way to make FakeAudioManager working in such case,
since it does not have any device:
bool FakeAudioManager::HasAudioOutputDevices() { return false; }
bool FakeAudioManager::HasAudioInputDevices() { return false; }

It is used in order to get things compiled.

I don't really want to add one more static method to enable the automatic beep,
so I added Alpha to double check if it OK to have the automatic as true by
default.

   base::Lock beep_lock;
   bool beep_once;
+  bool automatic;
 };
 
 static base::LazyInstance<BeepContext> g_beep_context =
     LAZY_INSTANCE_INITIALIZER;
 
 }  // namespace
 
 AudioInputStream* FakeAudioInputStream::MakeFakeStream(
     AudioManagerBase* manager,
     const AudioParameters& params) {
@@ skipping 24 matching lines @@
   buffer_.reset(new uint8[buffer_size_]);
   memset(buffer_.get(), 0, buffer_size_);
   return true;
 }
 
 void FakeAudioInputStream::Start(AudioInputCallback* callback)  {
   DCHECK(!thread_.IsRunning());
   DCHECK(!callback_);
   callback_ = callback;
   last_callback_time_ = TimeTicks::Now();
   thread_.Start();

[DaleCurtis, 2014/04/29 17:30:56]

Just an FYI, but this whole thing could be switched to use FakeAudioConsumer
which could be renamed FakeAudioScheduler or something.

[no longer working on chromium, 2014/05/02 14:30:47]

Sounds great.

   thread_.message_loop()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&FakeAudioInputStream::DoCallback, base::Unretained(this)),
       callback_interval_);
 }
 
 void FakeAudioInputStream::DoCallback() {
   DCHECK(callback_);
 
+  const TimeTicks now = TimeTicks::Now();
+  base::TimeDelta next_callback_time =
+      last_callback_time_ + callback_interval_ * 2 - now;
+
+  // If we are falling behind, try to catch up as much as we can in the next
+  // callback.
+  if (next_callback_time < base::TimeDelta())
+    next_callback_time = base::TimeDelta();
+
+  // Accumulate the time from the last beep.
+  interval_from_last_beep_ += now - last_callback_time_;
+
+  last_callback_time_ = now;
+
   memset(buffer_.get(), 0, buffer_size_);
 
   bool should_beep = false;
   {
     BeepContext* beep_context = g_beep_context.Pointer();
     base::AutoLock auto_lock(beep_context->beep_lock);
-    should_beep = beep_context->beep_once;
-    beep_context->beep_once = false;
+    if (beep_context->automatic) {
+      int delta_ms = interval_from_last_beep_.InMilliseconds() -
+          kAutomaticBeepIntervalInMs;
+      if (delta_ms > 0) {

[DaleCurtis, 2014/04/29 17:30:56]

just use > base::TimeDelta to avoid converting back and forth.

[no longer working on chromium, 2014/05/02 14:30:47]

Done.

+        should_beep = true;
+        interval_from_last_beep_ =  TimeDelta::FromMilliseconds(delta_ms);
+      }
+    } else {
+      should_beep = beep_context->beep_once;
+      beep_context->beep_once = false;
+    }
   }
 
   // If this object was instructed to generate a beep or has started to
   // generate a beep sound.
   if (should_beep || beep_generated_in_buffers_) {
     // Compute the number of frames to output high value. Then compute the
     // number of bytes based on channels and bits per channel.
     int high_frames = beep_period_in_frames_ / 2;
     int high_bytes = high_frames * params_.bits_per_sample() *
         params_.channels() / 8;
 
     // Separate high and low with the same number of bytes to generate a
     // square wave.
     int position = 0;
     while (position + high_bytes <= buffer_size_) {
       // Write high values first.
       memset(buffer_.get() + position, 128, high_bytes);
-
       // Then leave low values in the buffer with |high_bytes|.
       position += high_bytes * 2;
     }
 
     ++beep_generated_in_buffers_;
     if (beep_generated_in_buffers_ >= beep_duration_in_buffers_)
       beep_generated_in_buffers_ = 0;
   }
 
   callback_->OnData(this, buffer_.get(), buffer_size_, buffer_size_, 1.0);
   frames_elapsed_ += params_.frames_per_buffer();
 
-  const TimeTicks now = TimeTicks::Now();
-  base::TimeDelta next_callback_time =
-      last_callback_time_ + callback_interval_ * 2 - now;
-
-  // If we are falling behind, try to catch up as much as we can in the next
-  // callback.
-  if (next_callback_time < base::TimeDelta())
-    next_callback_time = base::TimeDelta();
-
-  last_callback_time_ = now;
   thread_.message_loop()->PostDelayedTask(
       FROM_HERE,
       base::Bind(&FakeAudioInputStream::DoCallback, base::Unretained(this)),
       next_callback_time);
 }
 
 void FakeAudioInputStream::Stop() {
   thread_.Stop();
   callback_ = NULL;
 }
@@ skipping 17 matching lines @@
 
 bool FakeAudioInputStream::GetAutomaticGainControl() {
   return true;
 }
 
 // static
 void FakeAudioInputStream::BeepOnce() {
   BeepContext* beep_context = g_beep_context.Pointer();
   base::AutoLock auto_lock(beep_context->beep_lock);
   beep_context->beep_once = true;
+  beep_context->automatic = false;
 }
 
 }  // namespace media