src/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,
  38                                0);
  39   fake_device.session_id = kFakeOpenSessionId;
  40   devices_.push_back(fake_device);
  41 }
  42
  43 AudioInputDeviceManager::~AudioInputDeviceManager() {
  44 }
  45
  46 const StreamDeviceInfo* AudioInputDeviceManager::GetOpenedDeviceInfoById(
  47     int session_id) {
  48   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
  49   StreamDeviceList::iterator device = GetDevice(session_id);
  50   if (device == devices_.end())
  51     return NULL;
  52
  53   return &(*device);
  54 }
  55
  56 void AudioInputDeviceManager::Register(
  57     MediaStreamProviderListener* listener,
  58     base::MessageLoopProxy* device_thread_loop) {
  59   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
  60   DCHECK(!listener_);
  61   DCHECK(!device_loop_.get());
  62   listener_ = listener;
  63   device_loop_ = device_thread_loop;
  64 }
  65
  66 void AudioInputDeviceManager::Unregister() {
  67   DCHECK(listener_);
  68   listener_ = NULL;
  69 }
  70
  71 void AudioInputDeviceManager::EnumerateDevices(MediaStreamType stream_type) {
  72   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
  73   DCHECK(listener_);
  74
  75   device_loop_->PostTask(
  76       FROM_HERE,
  77       base::Bind(&AudioInputDeviceManager::EnumerateOnDeviceThread,
  78                  this, stream_type));
  79 }
  80
  81 int AudioInputDeviceManager::Open(const StreamDeviceInfo& device) {
  82   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
  83   // Generate a new id for this device.
  84   int session_id = next_capture_session_id_++;
  85   device_loop_->PostTask(
  86       FROM_HERE,
  87       base::Bind(&AudioInputDeviceManager::OpenOnDeviceThread,
  88                  this, session_id, device));
  89
  90   return session_id;
  91 }
  92
  93 void AudioInputDeviceManager::Close(int session_id) {
  94   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
  95   DCHECK(listener_);
  96   StreamDeviceList::iterator device = GetDevice(session_id);
  97   if (device == devices_.end())
  98     return;
  99   const MediaStreamType stream_type = device->device.type;
 100   if (session_id != kFakeOpenSessionId)
 101     devices_.erase(device);
 102
 103   // Post a callback through the listener on IO thread since
 104   // MediaStreamManager is expecting the callback asynchronously.
 105   BrowserThread::PostTask(BrowserThread::IO,
 106                           FROM_HERE,
 107                           base::Bind(&AudioInputDeviceManager::ClosedOnIOThread,
 108                                      this, stream_type, session_id));
 109 }
 110
 111 void AudioInputDeviceManager::UseFakeDevice() {
 112   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 113   use_fake_device_ = true;
 114 }
 115
 116 bool AudioInputDeviceManager::ShouldUseFakeDevice() const {
 117   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 118   return use_fake_device_;
 119 }
 120
 121 void AudioInputDeviceManager::EnumerateOnDeviceThread(
 122     MediaStreamType stream_type) {
 123   SCOPED_UMA_HISTOGRAM_TIMER(
 124       "Media.AudioInputDeviceManager.EnumerateOnDeviceThreadTime");
 125   DCHECK(IsOnDeviceThread());
 126
 127   media::AudioDeviceNames device_names;
 128
 129   switch (stream_type) {
 130     case MEDIA_DEVICE_AUDIO_CAPTURE:
 131       // AudioManager is guaranteed to outlive MediaStreamManager in
 132       // BrowserMainloop.
 133       audio_manager_->GetAudioInputDeviceNames(&device_names);
 134       break;
 135
 136     default:
 137       NOTREACHED();
 138       break;
 139   }
 140
 141   scoped_ptr<StreamDeviceInfoArray> devices(new StreamDeviceInfoArray());
 142   for (media::AudioDeviceNames::iterator it = device_names.begin();
 143        it != device_names.end(); ++it) {
 144     // Add device information to device vector.
 145     devices->push_back(StreamDeviceInfo(
 146         stream_type, it->device_name, it->unique_id));
 147   }
 148
 149   // If the |use_fake_device_| flag is on, inject the fake device if there is
 150   // no available device on the OS.
 151   if (use_fake_device_ && devices->empty()) {
 152     devices->push_back(StreamDeviceInfo(
 153         stream_type, media::AudioManagerBase::kDefaultDeviceName,
 154         media::AudioManagerBase::kDefaultDeviceId));
 155   }
 156
 157   // Return the device list through the listener by posting a task on
 158   // IO thread since MediaStreamManager handles the callback asynchronously.
 159   BrowserThread::PostTask(
 160       BrowserThread::IO,
 161       FROM_HERE,
 162       base::Bind(&AudioInputDeviceManager::DevicesEnumeratedOnIOThread,
 163                  this, stream_type, base::Passed(&devices)));
 164 }
 165
 166 void AudioInputDeviceManager::OpenOnDeviceThread(
 167     int session_id, const StreamDeviceInfo& info) {
 168   SCOPED_UMA_HISTOGRAM_TIMER(
 169       "Media.AudioInputDeviceManager.OpenOnDeviceThreadTime");
 170   DCHECK(IsOnDeviceThread());
 171
 172   StreamDeviceInfo out(info.device.type, info.device.name, info.device.id,
 173                        0, 0, 0);
 174   out.session_id = session_id;
 175
 176   MediaStreamDevice::AudioDeviceParameters& input_params = out.device.input;
 177
 178   if (use_fake_device_) {
 179     // Don't need to query the hardware information if using fake device.
 180     input_params.sample_rate = 44100;
 181     input_params.channel_layout = media::CHANNEL_LAYOUT_STEREO;
 182   } else {
 183     // Get the preferred sample rate and channel configuration for the
 184     // audio device.
 185     media::AudioParameters params =
 186         audio_manager_->GetInputStreamParameters(info.device.id);
 187     input_params.sample_rate = params.sample_rate();
 188     input_params.channel_layout = params.channel_layout();
 189     input_params.frames_per_buffer = params.frames_per_buffer();
 190
 191     // Add preferred output device information if a matching output device
 192     // exists.
 193     out.device.matched_output_device_id =
 194         audio_manager_->GetAssociatedOutputDeviceID(info.device.id);
 195     if (!out.device.matched_output_device_id.empty()) {
 196       params = audio_manager_->GetOutputStreamParameters(
 197           out.device.matched_output_device_id);
 198       MediaStreamDevice::AudioDeviceParameters& matched_output_params =
 199           out.device.matched_output;
 200       matched_output_params.sample_rate = params.sample_rate();
 201       matched_output_params.channel_layout = params.channel_layout();
 202       matched_output_params.frames_per_buffer = params.frames_per_buffer();
 203     }
 204   }
 205
 206   // Return the |session_id| through the listener by posting a task on
 207   // IO thread since MediaStreamManager handles the callback asynchronously.
 208   BrowserThread::PostTask(BrowserThread::IO,
 209                           FROM_HERE,
 210                           base::Bind(&AudioInputDeviceManager::OpenedOnIOThread,
 211                                      this, session_id, out));
 212 }
 213
 214 void AudioInputDeviceManager::DevicesEnumeratedOnIOThread(
 215     MediaStreamType stream_type,
 216     scoped_ptr<StreamDeviceInfoArray> devices) {
 217   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 218   // Ensure that |devices| gets deleted on exit.
 219   if (listener_)
 220     listener_->DevicesEnumerated(stream_type, *devices);
 221 }
 222
 223 void AudioInputDeviceManager::OpenedOnIOThread(int session_id,
 224                                                const StreamDeviceInfo& info) {
 225   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 226   DCHECK_EQ(session_id, info.session_id);
 227   DCHECK(GetDevice(session_id) == devices_.end());
 228
 229   devices_.push_back(info);
 230
 231   if (listener_)
 232     listener_->Opened(info.device.type, session_id);
 233 }
 234
 235 void AudioInputDeviceManager::ClosedOnIOThread(MediaStreamType stream_type,
 236                                                int session_id) {
 237   DCHECK(BrowserThread::CurrentlyOn(BrowserThread::IO));
 238   if (listener_)
 239     listener_->Closed(stream_type, session_id);
 240 }
 241
 242 bool AudioInputDeviceManager::IsOnDeviceThread() const {
 243   return device_loop_->BelongsToCurrentThread();
 244 }
 245
 246 AudioInputDeviceManager::StreamDeviceList::iterator
 247 AudioInputDeviceManager::GetDevice(int session_id) {
 248   for (StreamDeviceList::iterator i(devices_.begin()); i != devices_.end();
 249        ++i) {
 250     if (i->session_id == session_id)
 251       return i;
 252   }
 253
 254   return devices_.end();
 255 }
 256
 257 }  // namespace content