media/audio/fake_audio_input_stream.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "media/audio/fake_audio_input_stream.h"
   6
   7 #include "base/bind.h"
   8 #include "base/lazy_instance.h"
   9 #include "media/audio/audio_manager_base.h"
  10
  11 using base::TimeTicks;
  12 using base::TimeDelta;
  13
  14 namespace media {
  15
  16 namespace {
  17
  18 // These values are based on experiments for local-to-local
  19 // PeerConnection to demonstrate audio/video synchronization.
  20 const int kBeepDurationMilliseconds = 20;
  21 const int kBeepFrequency = 400;
  22
  23 struct BeepContext {
  24   BeepContext() : beep_once(false) {}
  25   base::Lock beep_lock;
  26   bool beep_once;
  27 };
  28
  29 static base::LazyInstance<BeepContext> g_beep_context =
  30     LAZY_INSTANCE_INITIALIZER;
  31
  32 }  // namespace
  33
  34 AudioInputStream* FakeAudioInputStream::MakeFakeStream(
  35     AudioManagerBase* manager,
  36     const AudioParameters& params) {
  37   return new FakeAudioInputStream(manager, params);
  38 }
  39
  40 FakeAudioInputStream::FakeAudioInputStream(AudioManagerBase* manager,
  41                                            const AudioParameters& params)
  42     : audio_manager_(manager),
  43       callback_(NULL),
  44       buffer_size_((params.channels() * params.bits_per_sample() *
  45                     params.frames_per_buffer()) / 8),
  46       params_(params),
  47       thread_("FakeAudioRecordingThread"),
  48       callback_interval_(base::TimeDelta::FromMilliseconds(
  49           (params.frames_per_buffer() * 1000) / params.sample_rate())),
  50       beep_duration_in_buffers_(
  51           kBeepDurationMilliseconds * params.sample_rate() /
  52           params.frames_per_buffer() / 1000),
  53       beep_generated_in_buffers_(0),
  54       beep_period_in_frames_(params.sample_rate() / kBeepFrequency),
  55       frames_elapsed_(0) {
  56 }
  57
  58 FakeAudioInputStream::~FakeAudioInputStream() {}
  59
  60 bool FakeAudioInputStream::Open() {
  61   buffer_.reset(new uint8[buffer_size_]);
  62   memset(buffer_.get(), 0, buffer_size_);
  63   return true;
  64 }
  65
  66 void FakeAudioInputStream::Start(AudioInputCallback* callback)  {
  67   DCHECK(!thread_.IsRunning());
  68   callback_ = callback;
  69   last_callback_time_ = TimeTicks::Now();
  70   thread_.Start();
  71   thread_.message_loop()->PostDelayedTask(
  72       FROM_HERE,
  73       base::Bind(&FakeAudioInputStream::DoCallback, base::Unretained(this)),
  74       callback_interval_);
  75 }
  76
  77 void FakeAudioInputStream::DoCallback() {
  78   DCHECK(callback_);
  79
  80   memset(buffer_.get(), 0, buffer_size_);
  81
  82   bool should_beep = false;
  83   {
  84     BeepContext* beep_context = g_beep_context.Pointer();
  85     base::AutoLock auto_lock(beep_context->beep_lock);
  86     should_beep = beep_context->beep_once;
  87     beep_context->beep_once = false;
  88   }
  89
  90   // If this object was instructed to generate a beep or has started to
  91   // generate a beep sound.
  92   if (should_beep || beep_generated_in_buffers_) {
  93     // Compute the number of frames to output high value. Then compute the
  94     // number of bytes based on channels and bits per channel.
  95     int high_frames = beep_period_in_frames_ / 2;
  96     int high_bytes = high_frames * params_.bits_per_sample() *
  97         params_.channels() / 8;
  98
  99     // Separate high and low with the same number of bytes to generate a
 100     // square wave.
 101     int position = 0;
 102     while (position + high_bytes <= buffer_size_) {
 103       // Write high values first.
 104       memset(buffer_.get() + position, 128, high_bytes);
 105
 106       // Then leave low values in the buffer with |high_bytes|.
 107       position += high_bytes * 2;
 108     }
 109
 110     ++beep_generated_in_buffers_;
 111     if (beep_generated_in_buffers_ >= beep_duration_in_buffers_)
 112       beep_generated_in_buffers_ = 0;
 113   }
 114
 115   callback_->OnData(this, buffer_.get(), buffer_size_, buffer_size_, 1.0);
 116   frames_elapsed_ += params_.frames_per_buffer();
 117
 118   const TimeTicks now = TimeTicks::Now();
 119   base::TimeDelta next_callback_time =
 120       last_callback_time_ + callback_interval_ * 2 - now;
 121
 122   // If we are falling behind, try to catch up as much as we can in the next
 123   // callback.
 124   if (next_callback_time < base::TimeDelta())
 125     next_callback_time = base::TimeDelta();
 126
 127   last_callback_time_ = now;
 128   thread_.message_loop()->PostDelayedTask(
 129       FROM_HERE,
 130       base::Bind(&FakeAudioInputStream::DoCallback, base::Unretained(this)),
 131       next_callback_time);
 132 }
 133
 134 void FakeAudioInputStream::Stop() {
 135   thread_.Stop();
 136 }
 137
 138 void FakeAudioInputStream::Close() {
 139   if (callback_) {
 140     callback_->OnClose(this);
 141     callback_ = NULL;
 142   }
 143   audio_manager_->ReleaseInputStream(this);
 144 }
 145
 146 double FakeAudioInputStream::GetMaxVolume() {
 147   return 1.0;
 148 }
 149
 150 void FakeAudioInputStream::SetVolume(double volume) {
 151 }
 152
 153 double FakeAudioInputStream::GetVolume() {
 154   return 1.0;
 155 }
 156
 157 void FakeAudioInputStream::SetAutomaticGainControl(bool enabled) {}
 158
 159 bool FakeAudioInputStream::GetAutomaticGainControl() {
 160   return true;
 161 }
 162
 163 // static
 164 void FakeAudioInputStream::BeepOnce() {
 165   BeepContext* beep_context = g_beep_context.Pointer();
 166   base::AutoLock auto_lock(beep_context->beep_lock);
 167   beep_context->beep_once = true;
 168 }
 169
 170 }  // namespace media