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/audio_output_resampler.h" 6 7 #include "base/bind.h" 8 #include "base/bind_helpers.h" 9 #include "base/compiler_specific.h" 10 #include "base/message_loop/message_loop.h" 11 #include "base/metrics/histogram.h" 12 #include "base/time/time.h" 13 #include "build/build_config.h" 14 #include "media/audio/audio_io.h" 15 #include "media/audio/audio_output_dispatcher_impl.h" 16 #include "media/audio/audio_output_proxy.h" 17 #include "media/audio/audio_util.h" 18 #include "media/audio/sample_rates.h" 19 #include "media/base/audio_converter.h" 20 #include "media/base/limits.h" 21 22 namespace media { 23 24 class OnMoreDataConverter 25 : public AudioOutputStream::AudioSourceCallback, 26 public AudioConverter::InputCallback { 27 public: 28 OnMoreDataConverter(const AudioParameters& input_params, 29 const AudioParameters& output_params); 30 virtual ~OnMoreDataConverter(); 31 32 // AudioSourceCallback interface. 33 virtual int OnMoreData(AudioBus* dest, 34 AudioBuffersState buffers_state) OVERRIDE; 35 virtual int OnMoreIOData(AudioBus* source, 36 AudioBus* dest, 37 AudioBuffersState buffers_state) OVERRIDE; 38 virtual void OnError(AudioOutputStream* stream) OVERRIDE; 39 40 // Sets |source_callback_|. If this is not a new object, then Stop() must be 41 // called before Start(). 42 void Start(AudioOutputStream::AudioSourceCallback* callback); 43 44 // Clears |source_callback_| and flushes the resampler. 45 void Stop(); 46 47 private: 48 // AudioConverter::InputCallback implementation. 49 virtual double ProvideInput(AudioBus* audio_bus, 50 base::TimeDelta buffer_delay) OVERRIDE; 51 52 // Ratio of input bytes to output bytes used to correct playback delay with 53 // regard to buffering and resampling. 54 double io_ratio_; 55 56 // Source callback and associated lock. 57 base::Lock source_lock_; 58 AudioOutputStream::AudioSourceCallback* source_callback_; 59 60 // |source| passed to OnMoreIOData() which should be passed downstream. 61 AudioBus* source_bus_; 62 63 // Last AudioBuffersState object received via OnMoreData(), used to correct 64 // playback delay by ProvideInput() and passed on to |source_callback_|. 65 AudioBuffersState current_buffers_state_; 66 67 const int input_bytes_per_second_; 68 69 // Handles resampling, buffering, and channel mixing between input and output 70 // parameters. 71 AudioConverter audio_converter_; 72 73 DISALLOW_COPY_AND_ASSIGN(OnMoreDataConverter); 74 }; 75 76 // Record UMA statistics for hardware output configuration. 77 static void RecordStats(const AudioParameters& output_params) { 78 UMA_HISTOGRAM_ENUMERATION( 79 "Media.HardwareAudioBitsPerChannel", output_params.bits_per_sample(), 80 limits::kMaxBitsPerSample); 81 UMA_HISTOGRAM_ENUMERATION( 82 "Media.HardwareAudioChannelLayout", output_params.channel_layout(), 83 CHANNEL_LAYOUT_MAX); 84 UMA_HISTOGRAM_ENUMERATION( 85 "Media.HardwareAudioChannelCount", output_params.channels(), 86 limits::kMaxChannels); 87 88 AudioSampleRate asr = media::AsAudioSampleRate(output_params.sample_rate()); 89 if (asr != kUnexpectedAudioSampleRate) { 90 UMA_HISTOGRAM_ENUMERATION( 91 "Media.HardwareAudioSamplesPerSecond", asr, kUnexpectedAudioSampleRate); 92 } else { 93 UMA_HISTOGRAM_COUNTS( 94 "Media.HardwareAudioSamplesPerSecondUnexpected", 95 output_params.sample_rate()); 96 } 97 } 98 99 // Record UMA statistics for hardware output configuration after fallback. 100 static void RecordFallbackStats(const AudioParameters& output_params) { 101 UMA_HISTOGRAM_BOOLEAN("Media.FallbackToHighLatencyAudioPath", true); 102 UMA_HISTOGRAM_ENUMERATION( 103 "Media.FallbackHardwareAudioBitsPerChannel", 104 output_params.bits_per_sample(), limits::kMaxBitsPerSample); 105 UMA_HISTOGRAM_ENUMERATION( 106 "Media.FallbackHardwareAudioChannelLayout", 107 output_params.channel_layout(), CHANNEL_LAYOUT_MAX); 108 UMA_HISTOGRAM_ENUMERATION( 109 "Media.FallbackHardwareAudioChannelCount", 110 output_params.channels(), limits::kMaxChannels); 111 112 AudioSampleRate asr = media::AsAudioSampleRate(output_params.sample_rate()); 113 if (asr != kUnexpectedAudioSampleRate) { 114 UMA_HISTOGRAM_ENUMERATION( 115 "Media.FallbackHardwareAudioSamplesPerSecond", 116 asr, kUnexpectedAudioSampleRate); 117 } else { 118 UMA_HISTOGRAM_COUNTS( 119 "Media.FallbackHardwareAudioSamplesPerSecondUnexpected", 120 output_params.sample_rate()); 121 } 122 } 123 124 // Only Windows has a high latency output driver that is not the same as the low 125 // latency path. 126 #if defined(OS_WIN) 127 // Converts low latency based |output_params| into high latency appropriate 128 // output parameters in error situations. 129 static AudioParameters SetupFallbackParams( 130 const AudioParameters& input_params, const AudioParameters& output_params) { 131 // Choose AudioParameters appropriate for opening the device in high latency 132 // mode. |kMinLowLatencyFrameSize| is arbitrarily based on Pepper Flash's 133 // MAXIMUM frame size for low latency. 134 static const int kMinLowLatencyFrameSize = 2048; 135 int frames_per_buffer = std::min( 136 std::max(input_params.frames_per_buffer(), kMinLowLatencyFrameSize), 137 static_cast<int>( 138 GetHighLatencyOutputBufferSize(input_params.sample_rate()))); 139 140 return AudioParameters( 141 AudioParameters::AUDIO_PCM_LINEAR, input_params.channel_layout(), 142 input_params.sample_rate(), input_params.bits_per_sample(), 143 frames_per_buffer); 144 } 145 #endif 146 147 AudioOutputResampler::AudioOutputResampler(AudioManager* audio_manager, 148 const AudioParameters& input_params, 149 const AudioParameters& output_params, 150 const std::string& input_device_id, 151 const base::TimeDelta& close_delay) 152 : AudioOutputDispatcher(audio_manager, input_params, input_device_id), 153 close_delay_(close_delay), 154 output_params_(output_params), 155 input_device_id_(input_device_id), 156 streams_opened_(false) { 157 DCHECK(input_params.IsValid()); 158 DCHECK(output_params.IsValid()); 159 DCHECK_EQ(output_params_.format(), AudioParameters::AUDIO_PCM_LOW_LATENCY); 160 161 // Record UMA statistics for the hardware configuration. 162 RecordStats(output_params); 163 164 Initialize(); 165 } 166 167 AudioOutputResampler::~AudioOutputResampler() { 168 DCHECK(callbacks_.empty()); 169 } 170 171 void AudioOutputResampler::Initialize() { 172 DCHECK(!streams_opened_); 173 DCHECK(callbacks_.empty()); 174 dispatcher_ = new AudioOutputDispatcherImpl( 175 audio_manager_, output_params_, input_device_id_, close_delay_); 176 } 177 178 bool AudioOutputResampler::OpenStream() { 179 DCHECK_EQ(base::MessageLoop::current(), message_loop_); 180 181 if (dispatcher_->OpenStream()) { 182 // Only record the UMA statistic if we didn't fallback during construction 183 // and only for the first stream we open. 184 if (!streams_opened_ && 185 output_params_.format() == AudioParameters::AUDIO_PCM_LOW_LATENCY) { 186 UMA_HISTOGRAM_BOOLEAN("Media.FallbackToHighLatencyAudioPath", false); 187 } 188 streams_opened_ = true; 189 return true; 190 } 191 192 // If we've already tried to open the stream in high latency mode or we've 193 // successfully opened a stream previously, there's nothing more to be done. 194 if (output_params_.format() != AudioParameters::AUDIO_PCM_LOW_LATENCY || 195 streams_opened_ || !callbacks_.empty()) { 196 return false; 197 } 198 199 DCHECK_EQ(output_params_.format(), AudioParameters::AUDIO_PCM_LOW_LATENCY); 200 201 // Record UMA statistics about the hardware which triggered the failure so 202 // we can debug and triage later. 203 RecordFallbackStats(output_params_); 204 205 // Only Windows has a high latency output driver that is not the same as the 206 // low latency path. 207 #if defined(OS_WIN) 208 DLOG(ERROR) << "Unable to open audio device in low latency mode. Falling " 209 << "back to high latency audio output."; 210 211 output_params_ = SetupFallbackParams(params_, output_params_); 212 Initialize(); 213 if (dispatcher_->OpenStream()) { 214 streams_opened_ = true; 215 return true; 216 } 217 #endif 218 219 DLOG(ERROR) << "Unable to open audio device in high latency mode. Falling " 220 << "back to fake audio output."; 221 222 // Finally fall back to a fake audio output device. 223 output_params_.Reset( 224 AudioParameters::AUDIO_FAKE, params_.channel_layout(), 225 params_.channels(), params_.input_channels(), params_.sample_rate(), 226 params_.bits_per_sample(), params_.frames_per_buffer()); 227 Initialize(); 228 if (dispatcher_->OpenStream()) { 229 streams_opened_ = true; 230 return true; 231 } 232 233 return false; 234 } 235 236 bool AudioOutputResampler::StartStream( 237 AudioOutputStream::AudioSourceCallback* callback, 238 AudioOutputProxy* stream_proxy) { 239 DCHECK_EQ(base::MessageLoop::current(), message_loop_); 240 241 OnMoreDataConverter* resampler_callback = NULL; 242 CallbackMap::iterator it = callbacks_.find(stream_proxy); 243 if (it == callbacks_.end()) { 244 resampler_callback = new OnMoreDataConverter(params_, output_params_); 245 callbacks_[stream_proxy] = resampler_callback; 246 } else { 247 resampler_callback = it->second; 248 } 249 250 resampler_callback->Start(callback); 251 bool result = dispatcher_->StartStream(resampler_callback, stream_proxy); 252 if (!result) 253 resampler_callback->Stop(); 254 return result; 255 } 256 257 void AudioOutputResampler::StreamVolumeSet(AudioOutputProxy* stream_proxy, 258 double volume) { 259 DCHECK_EQ(base::MessageLoop::current(), message_loop_); 260 dispatcher_->StreamVolumeSet(stream_proxy, volume); 261 } 262 263 void AudioOutputResampler::StopStream(AudioOutputProxy* stream_proxy) { 264 DCHECK_EQ(base::MessageLoop::current(), message_loop_); 265 dispatcher_->StopStream(stream_proxy); 266 267 // Now that StopStream() has completed the underlying physical stream should 268 // be stopped and no longer calling OnMoreData(), making it safe to Stop() the 269 // OnMoreDataConverter. 270 CallbackMap::iterator it = callbacks_.find(stream_proxy); 271 if (it != callbacks_.end()) 272 it->second->Stop(); 273 } 274 275 void AudioOutputResampler::CloseStream(AudioOutputProxy* stream_proxy) { 276 DCHECK_EQ(base::MessageLoop::current(), message_loop_); 277 dispatcher_->CloseStream(stream_proxy); 278 279 // We assume that StopStream() is always called prior to CloseStream(), so 280 // that it is safe to delete the OnMoreDataConverter here. 281 CallbackMap::iterator it = callbacks_.find(stream_proxy); 282 if (it != callbacks_.end()) { 283 delete it->second; 284 callbacks_.erase(it); 285 } 286 } 287 288 void AudioOutputResampler::Shutdown() { 289 DCHECK_EQ(base::MessageLoop::current(), message_loop_); 290 291 // No AudioOutputProxy objects should hold a reference to us when we get 292 // to this stage. 293 DCHECK(HasOneRef()) << "Only the AudioManager should hold a reference"; 294 295 dispatcher_->Shutdown(); 296 DCHECK(callbacks_.empty()); 297 } 298 299 OnMoreDataConverter::OnMoreDataConverter(const AudioParameters& input_params, 300 const AudioParameters& output_params) 301 : source_callback_(NULL), 302 source_bus_(NULL), 303 input_bytes_per_second_(input_params.GetBytesPerSecond()), 304 audio_converter_(input_params, output_params, false) { 305 io_ratio_ = 306 static_cast<double>(input_params.GetBytesPerSecond()) / 307 output_params.GetBytesPerSecond(); 308 } 309 310 OnMoreDataConverter::~OnMoreDataConverter() { 311 // Ensure Stop() has been called so we don't end up with an AudioOutputStream 312 // calling back into OnMoreData() after destruction. 313 CHECK(!source_callback_); 314 } 315 316 void OnMoreDataConverter::Start( 317 AudioOutputStream::AudioSourceCallback* callback) { 318 base::AutoLock auto_lock(source_lock_); 319 CHECK(!source_callback_); 320 source_callback_ = callback; 321 322 // While AudioConverter can handle multiple inputs, we're using it only with 323 // a single input currently. Eventually this may be the basis for a browser 324 // side mixer. 325 audio_converter_.AddInput(this); 326 } 327 328 void OnMoreDataConverter::Stop() { 329 base::AutoLock auto_lock(source_lock_); 330 CHECK(source_callback_); 331 source_callback_ = NULL; 332 audio_converter_.RemoveInput(this); 333 } 334 335 int OnMoreDataConverter::OnMoreData(AudioBus* dest, 336 AudioBuffersState buffers_state) { 337 return OnMoreIOData(NULL, dest, buffers_state); 338 } 339 340 int OnMoreDataConverter::OnMoreIOData(AudioBus* source, 341 AudioBus* dest, 342 AudioBuffersState buffers_state) { 343 base::AutoLock auto_lock(source_lock_); 344 // While we waited for |source_lock_| the callback might have been cleared. 345 if (!source_callback_) { 346 dest->Zero(); 347 return dest->frames(); 348 } 349 350 source_bus_ = source; 351 current_buffers_state_ = buffers_state; 352 audio_converter_.Convert(dest); 353 354 // Always return the full number of frames requested, ProvideInput_Locked() 355 // will pad with silence if it wasn't able to acquire enough data. 356 return dest->frames(); 357 } 358 359 double OnMoreDataConverter::ProvideInput(AudioBus* dest, 360 base::TimeDelta buffer_delay) { 361 source_lock_.AssertAcquired(); 362 363 // Adjust playback delay to include |buffer_delay|. 364 // TODO(dalecurtis): Stop passing bytes around, it doesn't make sense since 365 // AudioBus is just float data. Use TimeDelta instead. 366 AudioBuffersState new_buffers_state; 367 new_buffers_state.pending_bytes = 368 io_ratio_ * (current_buffers_state_.total_bytes() + 369 buffer_delay.InSecondsF() * input_bytes_per_second_); 370 371 // Retrieve data from the original callback. 372 int frames = source_callback_->OnMoreIOData( 373 source_bus_, dest, new_buffers_state); 374 375 // |source_bus_| should only be provided once. 376 // TODO(dalecurtis, crogers): This is not a complete fix. If ProvideInput() 377 // is called multiple times, we need to do something more clever here. 378 source_bus_ = NULL; 379 380 // Zero any unfilled frames if anything was filled, otherwise we'll just 381 // return a volume of zero and let AudioConverter drop the output. 382 if (frames > 0 && frames < dest->frames()) 383 dest->ZeroFramesPartial(frames, dest->frames() - frames); 384 385 // TODO(dalecurtis): Return the correct volume here. 386 return frames > 0 ? 1 : 0; 387 } 388 389 void OnMoreDataConverter::OnError(AudioOutputStream* stream) { 390 base::AutoLock auto_lock(source_lock_); 391 if (source_callback_) 392 source_callback_->OnError(stream); 393 } 394 395 } // namespace media 396
