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 #include "media/base/audio_bus.h" 11 12 using base::TimeTicks; 13 using base::TimeDelta; 14 15 namespace media { 16 17 namespace { 18 19 // These values are based on experiments for local-to-local 20 // PeerConnection to demonstrate audio/video synchronization. 21 const int kBeepDurationMilliseconds = 20; 22 const int kBeepFrequency = 400; 23 24 // Intervals between two automatic beeps. 25 const int kAutomaticBeepIntervalInMs = 500; 26 27 // Automatic beep will be triggered every |kAutomaticBeepIntervalInMs| unless 28 // users explicitly call BeepOnce(), which will disable the automatic beep. 29 class BeepContext { 30 public: 31 BeepContext() : beep_once_(false), automatic_beep_(true) {} 32 33 void SetBeepOnce(bool enable) { 34 base::AutoLock auto_lock(lock_); 35 beep_once_ = enable; 36 37 // Disable the automatic beep if users explicit set |beep_once_| to true. 38 if (enable) 39 automatic_beep_ = false; 40 } 41 bool beep_once() const { 42 base::AutoLock auto_lock(lock_); 43 return beep_once_; 44 } 45 bool automatic_beep() const { 46 base::AutoLock auto_lock(lock_); 47 return automatic_beep_; 48 } 49 50 private: 51 mutable base::Lock lock_; 52 bool beep_once_; 53 bool automatic_beep_; 54 }; 55 56 static base::LazyInstance<BeepContext> g_beep_context = 57 LAZY_INSTANCE_INITIALIZER; 58 59 } // namespace 60 61 AudioInputStream* FakeAudioInputStream::MakeFakeStream( 62 AudioManagerBase* manager, 63 const AudioParameters& params) { 64 return new FakeAudioInputStream(manager, params); 65 } 66 67 FakeAudioInputStream::FakeAudioInputStream(AudioManagerBase* manager, 68 const AudioParameters& params) 69 : audio_manager_(manager), 70 callback_(NULL), 71 buffer_size_((params.channels() * params.bits_per_sample() * 72 params.frames_per_buffer()) / 73 8), 74 params_(params), 75 task_runner_(manager->GetTaskRunner()), 76 callback_interval_(base::TimeDelta::FromMilliseconds( 77 (params.frames_per_buffer() * 1000) / params.sample_rate())), 78 beep_duration_in_buffers_(kBeepDurationMilliseconds * 79 params.sample_rate() / 80 params.frames_per_buffer() / 81 1000), 82 beep_generated_in_buffers_(0), 83 beep_period_in_frames_(params.sample_rate() / kBeepFrequency), 84 frames_elapsed_(0), 85 audio_bus_(AudioBus::Create(params)), 86 weak_factory_(this) { 87 DCHECK(audio_manager_->GetTaskRunner()->BelongsToCurrentThread()); 88 } 89 90 FakeAudioInputStream::~FakeAudioInputStream() {} 91 92 bool FakeAudioInputStream::Open() { 93 DCHECK(audio_manager_->GetTaskRunner()->BelongsToCurrentThread()); 94 buffer_.reset(new uint8[buffer_size_]); 95 memset(buffer_.get(), 0, buffer_size_); 96 audio_bus_->Zero(); 97 return true; 98 } 99 100 void FakeAudioInputStream::Start(AudioInputCallback* callback) { 101 DCHECK(audio_manager_->GetTaskRunner()->BelongsToCurrentThread()); 102 DCHECK(!callback_); 103 callback_ = callback; 104 last_callback_time_ = TimeTicks::Now(); 105 task_runner_->PostDelayedTask( 106 FROM_HERE, 107 base::Bind(&FakeAudioInputStream::DoCallback, weak_factory_.GetWeakPtr()), 108 callback_interval_); 109 } 110 111 void FakeAudioInputStream::DoCallback() { 112 DCHECK(callback_); 113 114 const TimeTicks now = TimeTicks::Now(); 115 base::TimeDelta next_callback_time = 116 last_callback_time_ + callback_interval_ * 2 - now; 117 118 // If we are falling behind, try to catch up as much as we can in the next 119 // callback. 120 if (next_callback_time < base::TimeDelta()) 121 next_callback_time = base::TimeDelta(); 122 123 // Accumulate the time from the last beep. 124 interval_from_last_beep_ += now - last_callback_time_; 125 126 last_callback_time_ = now; 127 128 memset(buffer_.get(), 0, buffer_size_); 129 130 bool should_beep = false; 131 { 132 BeepContext* beep_context = g_beep_context.Pointer(); 133 if (beep_context->automatic_beep()) { 134 base::TimeDelta delta = interval_from_last_beep_ - 135 TimeDelta::FromMilliseconds(kAutomaticBeepIntervalInMs); 136 if (delta > base::TimeDelta()) { 137 should_beep = true; 138 interval_from_last_beep_ = delta; 139 } 140 } else { 141 should_beep = beep_context->beep_once(); 142 beep_context->SetBeepOnce(false); 143 } 144 } 145 146 // If this object was instructed to generate a beep or has started to 147 // generate a beep sound. 148 if (should_beep || beep_generated_in_buffers_) { 149 // Compute the number of frames to output high value. Then compute the 150 // number of bytes based on channels and bits per channel. 151 int high_frames = beep_period_in_frames_ / 2; 152 int high_bytes = high_frames * params_.bits_per_sample() * 153 params_.channels() / 8; 154 155 // Separate high and low with the same number of bytes to generate a 156 // square wave. 157 int position = 0; 158 while (position + high_bytes <= buffer_size_) { 159 // Write high values first. 160 memset(buffer_.get() + position, 128, high_bytes); 161 // Then leave low values in the buffer with |high_bytes|. 162 position += high_bytes * 2; 163 } 164 165 ++beep_generated_in_buffers_; 166 if (beep_generated_in_buffers_ >= beep_duration_in_buffers_) 167 beep_generated_in_buffers_ = 0; 168 } 169 170 audio_bus_->FromInterleaved( 171 buffer_.get(), audio_bus_->frames(), params_.bits_per_sample() / 8); 172 callback_->OnData(this, audio_bus_.get(), buffer_size_, 1.0); 173 frames_elapsed_ += params_.frames_per_buffer(); 174 175 task_runner_->PostDelayedTask( 176 FROM_HERE, 177 base::Bind(&FakeAudioInputStream::DoCallback, weak_factory_.GetWeakPtr()), 178 next_callback_time); 179 } 180 181 void FakeAudioInputStream::Stop() { 182 DCHECK(audio_manager_->GetTaskRunner()->BelongsToCurrentThread()); 183 weak_factory_.InvalidateWeakPtrs(); 184 callback_ = NULL; 185 } 186 187 void FakeAudioInputStream::Close() { 188 DCHECK(audio_manager_->GetTaskRunner()->BelongsToCurrentThread()); 189 audio_manager_->ReleaseInputStream(this); 190 } 191 192 double FakeAudioInputStream::GetMaxVolume() { 193 DCHECK(audio_manager_->GetTaskRunner()->BelongsToCurrentThread()); 194 return 1.0; 195 } 196 197 void FakeAudioInputStream::SetVolume(double volume) { 198 DCHECK(audio_manager_->GetTaskRunner()->BelongsToCurrentThread()); 199 } 200 201 double FakeAudioInputStream::GetVolume() { 202 DCHECK(audio_manager_->GetTaskRunner()->BelongsToCurrentThread()); 203 return 1.0; 204 } 205 206 bool FakeAudioInputStream::IsMuted() { 207 DCHECK(audio_manager_->GetTaskRunner()->BelongsToCurrentThread()); 208 return false; 209 } 210 211 void FakeAudioInputStream::SetAutomaticGainControl(bool enabled) {} 212 213 bool FakeAudioInputStream::GetAutomaticGainControl() { 214 return true; 215 } 216 217 // static 218 void FakeAudioInputStream::BeepOnce() { 219 BeepContext* beep_context = g_beep_context.Pointer(); 220 beep_context->SetBeepOnce(true); 221 } 222 223 } // namespace media 224
