media/audio/audio_manager_base.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/audio_manager_base.h"
   6
   7 #include "base/bind.h"
   8 #include "base/bind_helpers.h"
   9 #include "base/command_line.h"
  10 #include "base/message_loop/message_loop_proxy.h"
  11 #include "base/threading/thread.h"
  12 #include "build/build_config.h"
  13 #include "media/audio/audio_output_dispatcher_impl.h"
  14 #include "media/audio/audio_output_proxy.h"
  15 #include "media/audio/audio_output_resampler.h"
  16 #include "media/audio/audio_util.h"
  17 #include "media/audio/fake_audio_input_stream.h"
  18 #include "media/audio/fake_audio_output_stream.h"
  19 #include "media/base/media_switches.h"
  20
  21 namespace media {
  22
  23 static const int kStreamCloseDelaySeconds = 5;
  24
  25 // Default maximum number of output streams that can be open simultaneously
  26 // for all platforms.
  27 static const int kDefaultMaxOutputStreams = 16;
  28
  29 // Default maximum number of input streams that can be open simultaneously
  30 // for all platforms.
  31 static const int kDefaultMaxInputStreams = 16;
  32
  33 static const int kMaxInputChannels = 2;
  34
  35 const char AudioManagerBase::kDefaultDeviceName[] = "Default";
  36 const char AudioManagerBase::kDefaultDeviceId[] = "default";
  37
  38 struct AudioManagerBase::DispatcherParams {
  39   DispatcherParams(const AudioParameters& input,
  40                    const AudioParameters& output,
  41                    const std::string& device_id)
  42       : input_params(input),
  43         output_params(output),
  44         input_device_id(device_id) {}
  45   ~DispatcherParams() {}
  46
  47   const AudioParameters input_params;
  48   const AudioParameters output_params;
  49   const std::string input_device_id;
  50   scoped_refptr<AudioOutputDispatcher> dispatcher;
  51
  52  private:
  53   DISALLOW_COPY_AND_ASSIGN(DispatcherParams);
  54 };
  55
  56 class AudioManagerBase::CompareByParams {
  57  public:
  58   explicit CompareByParams(const DispatcherParams* dispatcher)
  59       : dispatcher_(dispatcher) {}
  60   bool operator()(DispatcherParams* dispatcher_in) const {
  61     // We will reuse the existing dispatcher when:
  62     // 1) Unified IO is not used, input_params and output_params of the
  63     //    existing dispatcher are the same as the requested dispatcher.
  64     // 2) Unified IO is used, input_params, output_params and input_device_id
  65     //    of the existing dispatcher are the same as the request dispatcher.
  66     return (dispatcher_->input_params == dispatcher_in->input_params &&
  67             dispatcher_->output_params == dispatcher_in->output_params &&
  68             (!dispatcher_->input_params.input_channels() ||
  69              dispatcher_->input_device_id == dispatcher_in->input_device_id));
  70   }
  71
  72  private:
  73   const DispatcherParams* dispatcher_;
  74 };
  75
  76 AudioManagerBase::AudioManagerBase()
  77     : max_num_output_streams_(kDefaultMaxOutputStreams),
  78       max_num_input_streams_(kDefaultMaxInputStreams),
  79       num_output_streams_(0),
  80       num_input_streams_(0),
  81       // TODO(dalecurtis): Switch this to an ObserverListThreadSafe, so we don't
  82       // block the UI thread when swapping devices.
  83       output_listeners_(
  84           ObserverList<AudioDeviceListener>::NOTIFY_EXISTING_ONLY),
  85       audio_thread_(new base::Thread("AudioThread")) {
  86 #if defined(OS_WIN)
  87   audio_thread_->init_com_with_mta(true);
  88 #elif defined(OS_MACOSX)
  89   // CoreAudio calls must occur on the main thread of the process, which in our
  90   // case is sadly the browser UI thread.  Failure to execute calls on the right
  91   // thread leads to crashes and odd behavior.  See http://crbug.com/158170.
  92   // TODO(dalecurtis): We should require the message loop to be passed in.
  93   const CommandLine* cmd_line = CommandLine::ForCurrentProcess();
  94   if (!cmd_line->HasSwitch(switches::kDisableMainThreadAudio) &&
  95       base::MessageLoopProxy::current().get() &&
  96       base::MessageLoop::current()->IsType(base::MessageLoop::TYPE_UI)) {
  97     message_loop_ = base::MessageLoopProxy::current();
  98     return;
  99   }
 100 #endif
 101
 102   CHECK(audio_thread_->Start());
 103   message_loop_ = audio_thread_->message_loop_proxy();
 104 }
 105
 106 AudioManagerBase::~AudioManagerBase() {
 107   // The platform specific AudioManager implementation must have already
 108   // stopped the audio thread. Otherwise, we may destroy audio streams before
 109   // stopping the thread, resulting an unexpected behavior.
 110   // This way we make sure activities of the audio streams are all stopped
 111   // before we destroy them.
 112   CHECK(!audio_thread_.get());
 113   // All the output streams should have been deleted.
 114   DCHECK_EQ(0, num_output_streams_);
 115   // All the input streams should have been deleted.
 116   DCHECK_EQ(0, num_input_streams_);
 117 }
 118
 119 string16 AudioManagerBase::GetAudioInputDeviceModel() {
 120   return string16();
 121 }
 122
 123 scoped_refptr<base::MessageLoopProxy> AudioManagerBase::GetMessageLoop() {
 124   return message_loop_;
 125 }
 126
 127 scoped_refptr<base::MessageLoopProxy> AudioManagerBase::GetWorkerLoop() {
 128   // Lazily start the worker thread.
 129   if (!audio_thread_->IsRunning())
 130     CHECK(audio_thread_->Start());
 131
 132   return audio_thread_->message_loop_proxy();
 133 }
 134
 135 AudioOutputStream* AudioManagerBase::MakeAudioOutputStream(
 136     const AudioParameters& params,
 137     const std::string& input_device_id) {
 138   // TODO(miu): Fix ~50 call points across several unit test modules to call
 139   // this method on the audio thread, then uncomment the following:
 140   // DCHECK(message_loop_->BelongsToCurrentThread());
 141
 142   if (!params.IsValid()) {
 143     DLOG(ERROR) << "Audio parameters are invalid";
 144     return NULL;
 145   }
 146
 147   // Limit the number of audio streams opened. This is to prevent using
 148   // excessive resources for a large number of audio streams. More
 149   // importantly it prevents instability on certain systems.
 150   // See bug: http://crbug.com/30242.
 151   if (num_output_streams_ >= max_num_output_streams_) {
 152     DLOG(ERROR) << "Number of opened output audio streams "
 153                 << num_output_streams_
 154                 << " exceed the max allowed number "
 155                 << max_num_output_streams_;
 156     return NULL;
 157   }
 158
 159   AudioOutputStream* stream;
 160   switch (params.format()) {
 161     case AudioParameters::AUDIO_PCM_LINEAR:
 162       stream = MakeLinearOutputStream(params);
 163       break;
 164     case AudioParameters::AUDIO_PCM_LOW_LATENCY:
 165       stream = MakeLowLatencyOutputStream(params, input_device_id);
 166       break;
 167     case AudioParameters::AUDIO_FAKE:
 168       stream = FakeAudioOutputStream::MakeFakeStream(this, params);
 169       break;
 170     default:
 171       stream = NULL;
 172       break;
 173   }
 174
 175   if (stream) {
 176     ++num_output_streams_;
 177   }
 178
 179   return stream;
 180 }
 181
 182 AudioInputStream* AudioManagerBase::MakeAudioInputStream(
 183     const AudioParameters& params, const std::string& device_id) {
 184   // TODO(miu): Fix ~20 call points across several unit test modules to call
 185   // this method on the audio thread, then uncomment the following:
 186   // DCHECK(message_loop_->BelongsToCurrentThread());
 187
 188   if (!params.IsValid() || (params.channels() > kMaxInputChannels) ||
 189       device_id.empty()) {
 190     DLOG(ERROR) << "Audio parameters are invalid for device " << device_id;
 191     return NULL;
 192   }
 193
 194   if (num_input_streams_ >= max_num_input_streams_) {
 195     DLOG(ERROR) << "Number of opened input audio streams "
 196                 << num_input_streams_
 197                 << " exceed the max allowed number " << max_num_input_streams_;
 198     return NULL;
 199   }
 200
 201   AudioInputStream* stream;
 202   switch (params.format()) {
 203     case AudioParameters::AUDIO_PCM_LINEAR:
 204       stream = MakeLinearInputStream(params, device_id);
 205       break;
 206     case AudioParameters::AUDIO_PCM_LOW_LATENCY:
 207       stream = MakeLowLatencyInputStream(params, device_id);
 208       break;
 209     case AudioParameters::AUDIO_FAKE:
 210       stream = FakeAudioInputStream::MakeFakeStream(this, params);
 211       break;
 212     default:
 213       stream = NULL;
 214       break;
 215   }
 216
 217   if (stream) {
 218     ++num_input_streams_;
 219   }
 220
 221   return stream;
 222 }
 223
 224 AudioOutputStream* AudioManagerBase::MakeAudioOutputStreamProxy(
 225     const AudioParameters& params, const std::string& input_device_id) {
 226 #if defined(OS_IOS)
 227   // IOS implements audio input only.
 228   NOTIMPLEMENTED();
 229   return NULL;
 230 #else
 231   DCHECK(message_loop_->BelongsToCurrentThread());
 232
 233   // If we're not using AudioOutputResampler our output parameters are the same
 234   // as our input parameters.
 235   AudioParameters output_params = params;
 236   if (params.format() == AudioParameters::AUDIO_PCM_LOW_LATENCY) {
 237     output_params = GetPreferredOutputStreamParameters(params);
 238
 239     // Ensure we only pass on valid output parameters.
 240     if (!output_params.IsValid()) {
 241       // We've received invalid audio output parameters, so switch to a mock
 242       // output device based on the input parameters.  This may happen if the OS
 243       // provided us junk values for the hardware configuration.
 244       LOG(ERROR) << "Invalid audio output parameters received; using fake "
 245                  << "audio path. Channels: " << output_params.channels() << ", "
 246                  << "Sample Rate: " << output_params.sample_rate() << ", "
 247                  << "Bits Per Sample: " << output_params.bits_per_sample()
 248                  << ", Frames Per Buffer: "
 249                  << output_params.frames_per_buffer();
 250
 251       // Tell the AudioManager to create a fake output device.
 252       output_params = AudioParameters(
 253           AudioParameters::AUDIO_FAKE, params.channel_layout(),
 254           params.sample_rate(), params.bits_per_sample(),
 255           params.frames_per_buffer());
 256     }
 257   }
 258
 259   DispatcherParams* dispatcher_params =
 260       new DispatcherParams(params, output_params, input_device_id);
 261
 262   AudioOutputDispatchers::iterator it =
 263       std::find_if(output_dispatchers_.begin(), output_dispatchers_.end(),
 264                    CompareByParams(dispatcher_params));
 265   if (it != output_dispatchers_.end()) {
 266     delete dispatcher_params;
 267     return new AudioOutputProxy((*it)->dispatcher.get());
 268   }
 269
 270   const base::TimeDelta kCloseDelay =
 271       base::TimeDelta::FromSeconds(kStreamCloseDelaySeconds);
 272   scoped_refptr<AudioOutputDispatcher> dispatcher;
 273   if (output_params.format() != AudioParameters::AUDIO_FAKE) {
 274     dispatcher = new AudioOutputResampler(this, params, output_params,
 275                                           input_device_id, kCloseDelay);
 276   } else {
 277     dispatcher = new AudioOutputDispatcherImpl(this, output_params,
 278                                                input_device_id, kCloseDelay);
 279   }
 280
 281   dispatcher_params->dispatcher = dispatcher;
 282   output_dispatchers_.push_back(dispatcher_params);
 283   return new AudioOutputProxy(dispatcher.get());
 284 #endif  // defined(OS_IOS)
 285 }
 286
 287 void AudioManagerBase::ShowAudioInputSettings() {
 288 }
 289
 290 void AudioManagerBase::GetAudioInputDeviceNames(
 291     media::AudioDeviceNames* device_names) {
 292 }
 293
 294 void AudioManagerBase::ReleaseOutputStream(AudioOutputStream* stream) {
 295   DCHECK(stream);
 296   // TODO(xians) : Have a clearer destruction path for the AudioOutputStream.
 297   // For example, pass the ownership to AudioManager so it can delete the
 298   // streams.
 299   --num_output_streams_;
 300   delete stream;
 301 }
 302
 303 void AudioManagerBase::ReleaseInputStream(AudioInputStream* stream) {
 304   DCHECK(stream);
 305   // TODO(xians) : Have a clearer destruction path for the AudioInputStream.
 306   --num_input_streams_;
 307   delete stream;
 308 }
 309
 310 void AudioManagerBase::Shutdown() {
 311   // To avoid running into deadlocks while we stop the thread, shut it down
 312   // via a local variable while not holding the audio thread lock.
 313   scoped_ptr<base::Thread> audio_thread;
 314   {
 315     base::AutoLock lock(audio_thread_lock_);
 316     audio_thread_.swap(audio_thread);
 317   }
 318
 319   if (!audio_thread)
 320     return;
 321
 322   // Only true when we're sharing the UI message loop with the browser.  The UI
 323   // loop is no longer running at this time and browser destruction is imminent.
 324   if (message_loop_->BelongsToCurrentThread()) {
 325     ShutdownOnAudioThread();
 326   } else {
 327     message_loop_->PostTask(FROM_HERE, base::Bind(
 328         &AudioManagerBase::ShutdownOnAudioThread, base::Unretained(this)));
 329   }
 330
 331   // Stop() will wait for any posted messages to be processed first.
 332   audio_thread->Stop();
 333 }
 334
 335 void AudioManagerBase::ShutdownOnAudioThread() {
 336 // IOS implements audio input only.
 337 #if defined(OS_IOS)
 338   return;
 339 #else
 340   // This should always be running on the audio thread, but since we've cleared
 341   // the audio_thread_ member pointer when we get here, we can't verify exactly
 342   // what thread we're running on.  The method is not public though and only
 343   // called from one place, so we'll leave it at that.
 344   AudioOutputDispatchers::iterator it = output_dispatchers_.begin();
 345   for (; it != output_dispatchers_.end(); ++it) {
 346     scoped_refptr<AudioOutputDispatcher>& dispatcher = (*it)->dispatcher;
 347     if (dispatcher.get()) {
 348       dispatcher->Shutdown();
 349       // All AudioOutputProxies must have been freed before Shutdown is called.
 350       // If they still exist, things will go bad.  They have direct pointers to
 351       // both physical audio stream objects that belong to the dispatcher as
 352       // well as the message loop of the audio thread that will soon go away.
 353       // So, better crash now than later.
 354       DCHECK(dispatcher->HasOneRef()) << "AudioOutputProxies are still alive";
 355       dispatcher = NULL;
 356     }
 357   }
 358
 359   output_dispatchers_.clear();
 360 #endif  // defined(OS_IOS)
 361 }
 362
 363 void AudioManagerBase::AddOutputDeviceChangeListener(
 364     AudioDeviceListener* listener) {
 365   DCHECK(message_loop_->BelongsToCurrentThread());
 366   output_listeners_.AddObserver(listener);
 367 }
 368
 369 void AudioManagerBase::RemoveOutputDeviceChangeListener(
 370     AudioDeviceListener* listener) {
 371   DCHECK(message_loop_->BelongsToCurrentThread());
 372   output_listeners_.RemoveObserver(listener);
 373 }
 374
 375 void AudioManagerBase::NotifyAllOutputDeviceChangeListeners() {
 376   DCHECK(message_loop_->BelongsToCurrentThread());
 377   DVLOG(1) << "Firing OnDeviceChange() notifications.";
 378   FOR_EACH_OBSERVER(AudioDeviceListener, output_listeners_, OnDeviceChange());
 379 }
 380
 381 AudioParameters AudioManagerBase::GetDefaultOutputStreamParameters() {
 382   return GetPreferredOutputStreamParameters(AudioParameters());
 383 }
 384
 385 AudioParameters AudioManagerBase::GetInputStreamParameters(
 386     const std::string& device_id) {
 387   NOTREACHED();
 388   return AudioParameters();
 389 }
 390
 391 }  // namespace media