content/browser/renderer_host/media/audio_input_device_manager.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 "content/browser/renderer_host/media/audio_input_device_manager.h"
   6
   7 #include "base/bind.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "content/public/browser/browser_thread.h"
  10 #include "content/public/common/media_stream_request.h"
  11 #include "media/audio/audio_device_name.h"
  12 #include "media/audio/audio_input_ipc.h"
  13 #include "media/audio/audio_manager_base.h"
  14 #include "media/audio/audio_parameters.h"
  15 #include "media/base/channel_layout.h"
  16 #include "media/base/scoped_histogram_timer.h"
  17
  18 namespace content {
  19
  20 const int AudioInputDeviceManager::kFakeOpenSessionId = 1;
  21
  22 namespace {
  23 // Starting id for the first capture session.
  24 const int kFirstSessionId = AudioInputDeviceManager::kFakeOpenSessionId + 1;
  25 }
  26
  27 AudioInputDeviceManager::AudioInputDeviceManager(
  28     media::AudioManager* audio_manager)
  29     : listener_(NULL),
  30       next_capture_session_id_(kFirstSessionId),
  31       use_fake_device_(false),
  32       audio_manager_(audio_manager) {
  33   // TODO(xians): Remove this fake_device after the unittests do not need it.
  34   StreamDeviceInfo fake_device(MEDIA_DEVICE_AUDIO_CAPTURE,
  35                                media::AudioManagerBase::kDefaultDeviceName,
  36                                media::AudioManagerBase::kDefaultDeviceId,
  37                                44100, media::CHANNEL_LAYOUT_STEREO, false);
  38   fake_device.session_id = kFakeOpenSessionId;
  39   devices_.push_back(fake_device);
  40 }
  41
  42 AudioInputDeviceManager::~AudioInputDeviceManager() {
  43 }
  44
  45 const StreamDeviceInfo* AudioInputDeviceManager::GetOpenedDeviceInfoById(
  46     int session_id) {
  47   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
  48   StreamDeviceList::iterator device = GetDevice(session_id);
  49   if (device == devices_.end())
  50     return NULL;
  51
  52   return &(*device);
  53 }
  54
  55 void AudioInputDeviceManager::Register(
  56     MediaStreamProviderListener* listener,
  57     base::MessageLoopProxy* device_thread_loop) {
  58   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
  59   DCHECK(!listener_);
  60   DCHECK(!device_loop_.get());
  61   listener_ = listener;
  62   device_loop_ = device_thread_loop;
  63 }
  64
  65 void AudioInputDeviceManager::Unregister() {
  66   DCHECK(listener_);
  67   listener_ = NULL;
  68 }
  69
  70 void AudioInputDeviceManager::EnumerateDevices(MediaStreamType stream_type) {
  71   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
  72   DCHECK(listener_);
  73
  74   device_loop_->PostTask(
  75       FROM_HERE,
  76       base::Bind(&AudioInputDeviceManager::EnumerateOnDeviceThread,
  77                  this, stream_type));
  78 }
  79
  80 int AudioInputDeviceManager::Open(const StreamDeviceInfo& device) {
  81   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
  82   // Generate a new id for this device.
  83   int session_id = next_capture_session_id_++;
  84   device_loop_->PostTask(
  85       FROM_HERE,
  86       base::Bind(&AudioInputDeviceManager::OpenOnDeviceThread,
  87                  this, session_id, device));
  88
  89   return session_id;
  90 }
  91
  92 void AudioInputDeviceManager::Close(int session_id) {
  93   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
  94   DCHECK(listener_);
  95   StreamDeviceList::iterator device = GetDevice(session_id);
  96   if (device == devices_.end())
  97     return;
  98   const MediaStreamType stream_type = device->device.type;
  99   if (session_id != kFakeOpenSessionId)
 100     devices_.erase(device);
 101
 102   // Post a callback through the listener on IO thread since
 103   // MediaStreamManager is expecting the callback asynchronously.
 104   BrowserThread::PostTask(BrowserThread::IO,
 105                           FROM_HERE,
 106                           base::Bind(&AudioInputDeviceManager::ClosedOnIOThread,
 107                                      this, stream_type, session_id));
 108 }
 109
 110 void AudioInputDeviceManager::UseFakeDevice() {
 111   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 112   use_fake_device_ = true;
 113 }
 114
 115 bool AudioInputDeviceManager::ShouldUseFakeDevice() const {
 116   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 117   return use_fake_device_;
 118 }
 119
 120 void AudioInputDeviceManager::EnumerateOnDeviceThread(
 121     MediaStreamType stream_type) {
 122   SCOPED_UMA_HISTOGRAM_TIMER(
 123       "Media.AudioInputDeviceManager.EnumerateOnDeviceThreadTime");
 124   DCHECK(IsOnDeviceThread());
 125
 126   media::AudioDeviceNames device_names;
 127
 128   switch (stream_type) {
 129     case MEDIA_DEVICE_AUDIO_CAPTURE:
 130       // AudioManager is guaranteed to outlive MediaStreamManager in
 131       // BrowserMainloop.
 132       audio_manager_->GetAudioInputDeviceNames(&device_names);
 133       break;
 134
 135     default:
 136       NOTREACHED();
 137       break;
 138   }
 139
 140   scoped_ptr<StreamDeviceInfoArray> devices(new StreamDeviceInfoArray());
 141   for (media::AudioDeviceNames::iterator it = device_names.begin();
 142        it != device_names.end(); ++it) {
 143     // Add device information to device vector.
 144     devices->push_back(StreamDeviceInfo(
 145         stream_type, it->device_name, it->unique_id, false));
 146   }
 147
 148   // If the |use_fake_device_| flag is on, inject the fake device if there is
 149   // no available device on the OS.
 150   if (use_fake_device_ && devices->empty()) {
 151     devices->push_back(StreamDeviceInfo(
 152         stream_type, media::AudioManagerBase::kDefaultDeviceName,
 153         media::AudioManagerBase::kDefaultDeviceId, false));
 154   }
 155
 156   // Return the device list through the listener by posting a task on
 157   // IO thread since MediaStreamManager handles the callback asynchronously.
 158   BrowserThread::PostTask(
 159       BrowserThread::IO,
 160       FROM_HERE,
 161       base::Bind(&AudioInputDeviceManager::DevicesEnumeratedOnIOThread,
 162                  this, stream_type, base::Passed(&devices)));
 163 }
 164
 165 void AudioInputDeviceManager::OpenOnDeviceThread(
 166     int session_id, const StreamDeviceInfo& info) {
 167   SCOPED_UMA_HISTOGRAM_TIMER(
 168       "Media.AudioInputDeviceManager.OpenOnDeviceThreadTime");
 169   DCHECK(IsOnDeviceThread());
 170
 171   StreamDeviceInfo out(info.device.type, info.device.name, info.device.id,
 172                        0, 0, false);
 173   out.session_id = session_id;
 174   if (use_fake_device_) {
 175     // Don't need to query the hardware information if using fake device.
 176     out.device.sample_rate = 44100;
 177     out.device.channel_layout = media::CHANNEL_LAYOUT_STEREO;
 178   } else {
 179     // Get the preferred sample rate and channel configuration for the
 180     // audio device.
 181     media::AudioParameters params =
 182         audio_manager_->GetInputStreamParameters(info.device.id);
 183     out.device.sample_rate = params.sample_rate();
 184     out.device.channel_layout = params.channel_layout();
 185   }
 186
 187   // Return the |session_id| through the listener by posting a task on
 188   // IO thread since MediaStreamManager handles the callback asynchronously.
 189   BrowserThread::PostTask(BrowserThread::IO,
 190                           FROM_HERE,
 191                           base::Bind(&AudioInputDeviceManager::OpenedOnIOThread,
 192                                      this, session_id, out));
 193 }
 194
 195 void AudioInputDeviceManager::DevicesEnumeratedOnIOThread(
 196     MediaStreamType stream_type,
 197     scoped_ptr<StreamDeviceInfoArray> devices) {
 198   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 199   // Ensure that |devices| gets deleted on exit.
 200   if (listener_)
 201     listener_->DevicesEnumerated(stream_type, *devices);
 202 }
 203
 204 void AudioInputDeviceManager::OpenedOnIOThread(int session_id,
 205                                                const StreamDeviceInfo& info) {
 206   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 207   DCHECK_EQ(session_id, info.session_id);
 208   DCHECK(GetDevice(session_id) == devices_.end());
 209   devices_.push_back(info);
 210
 211   if (listener_)
 212     listener_->Opened(info.device.type, session_id);
 213 }
 214
 215 void AudioInputDeviceManager::ClosedOnIOThread(MediaStreamType stream_type,
 216                                                int session_id) {
 217   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 218   if (listener_)
 219     listener_->Closed(stream_type, session_id);
 220 }
 221
 222 bool AudioInputDeviceManager::IsOnDeviceThread() const {
 223   return device_loop_->BelongsToCurrentThread();
 224 }
 225
 226 AudioInputDeviceManager::StreamDeviceList::iterator
 227 AudioInputDeviceManager::GetDevice(int session_id) {
 228   for (StreamDeviceList::iterator i(devices_.begin()); i != devices_.end();
 229        ++i) {
 230     if (i->session_id == session_id)
 231       return i;
 232   }
 233
 234   return devices_.end();
 235 }
 236
 237 }  // namespace content