src/media/audio/win/audio_low_latency_input_win.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/win/audio_low_latency_input_win.h"
   6
   7 #include "base/logging.h"
   8 #include "base/memory/scoped_ptr.h"
   9 #include "base/strings/utf_string_conversions.h"
  10 #include "media/audio/win/audio_manager_win.h"
  11 #include "media/audio/win/avrt_wrapper_win.h"
  12 #include "media/audio/win/core_audio_util_win.h"
  13 #include "media/base/audio_bus.h"
  14
  15 using base::win::ScopedComPtr;
  16 using base::win::ScopedCOMInitializer;
  17
  18 namespace media {
  19 namespace {
  20
  21 // Returns true if |device| represents the default communication capture device.
  22 bool IsDefaultCommunicationDevice(IMMDeviceEnumerator* enumerator,
  23                                   IMMDevice* device) {
  24   ScopedComPtr<IMMDevice> communications;
  25   if (FAILED(enumerator->GetDefaultAudioEndpoint(eCapture, eCommunications,
  26                                                  communications.Receive()))) {
  27     return false;
  28   }
  29
  30   base::win::ScopedCoMem<WCHAR> communications_id, device_id;
  31   device->GetId(&device_id);
  32   communications->GetId(&communications_id);
  33   return lstrcmpW(communications_id, device_id) == 0;
  34 }
  35
  36 }  // namespace
  37
  38 WASAPIAudioInputStream::WASAPIAudioInputStream(AudioManagerWin* manager,
  39                                                const AudioParameters& params,
  40                                                const std::string& device_id)
  41     : manager_(manager),
  42       capture_thread_(NULL),
  43       opened_(false),
  44       started_(false),
  45       frame_size_(0),
  46       packet_size_frames_(0),
  47       packet_size_bytes_(0),
  48       endpoint_buffer_size_frames_(0),
  49       effects_(params.effects()),
  50       device_id_(device_id),
  51       perf_count_to_100ns_units_(0.0),
  52       ms_to_frame_count_(0.0),
  53       sink_(NULL),
  54       audio_bus_(media::AudioBus::Create(params)) {
  55   DCHECK(manager_);
  56
  57   // Load the Avrt DLL if not already loaded. Required to support MMCSS.
  58   bool avrt_init = avrt::Initialize();
  59   DCHECK(avrt_init) << "Failed to load the Avrt.dll";
  60
  61   // Set up the desired capture format specified by the client.
  62   format_.nSamplesPerSec = params.sample_rate();
  63   format_.wFormatTag = WAVE_FORMAT_PCM;
  64   format_.wBitsPerSample = params.bits_per_sample();
  65   format_.nChannels = params.channels();
  66   format_.nBlockAlign = (format_.wBitsPerSample / 8) * format_.nChannels;
  67   format_.nAvgBytesPerSec = format_.nSamplesPerSec * format_.nBlockAlign;
  68   format_.cbSize = 0;
  69
  70   // Size in bytes of each audio frame.
  71   frame_size_ = format_.nBlockAlign;
  72   // Store size of audio packets which we expect to get from the audio
  73   // endpoint device in each capture event.
  74   packet_size_frames_ = params.GetBytesPerBuffer() / format_.nBlockAlign;
  75   packet_size_bytes_ = params.GetBytesPerBuffer();
  76   DVLOG(1) << "Number of bytes per audio frame  : " << frame_size_;
  77   DVLOG(1) << "Number of audio frames per packet: " << packet_size_frames_;
  78
  79   // All events are auto-reset events and non-signaled initially.
  80
  81   // Create the event which the audio engine will signal each time
  82   // a buffer becomes ready to be processed by the client.
  83   audio_samples_ready_event_.Set(CreateEvent(NULL, FALSE, FALSE, NULL));
  84   DCHECK(audio_samples_ready_event_.IsValid());
  85
  86   // Create the event which will be set in Stop() when capturing shall stop.
  87   stop_capture_event_.Set(CreateEvent(NULL, FALSE, FALSE, NULL));
  88   DCHECK(stop_capture_event_.IsValid());
  89
  90   ms_to_frame_count_ = static_cast<double>(params.sample_rate()) / 1000.0;
  91
  92   LARGE_INTEGER performance_frequency;
  93   if (QueryPerformanceFrequency(&performance_frequency)) {
  94     perf_count_to_100ns_units_ =
  95         (10000000.0 / static_cast<double>(performance_frequency.QuadPart));
  96   } else {
  97     DLOG(ERROR) << "High-resolution performance counters are not supported.";
  98   }
  99 }
 100
 101 WASAPIAudioInputStream::~WASAPIAudioInputStream() {
 102   DCHECK(CalledOnValidThread());
 103 }
 104
 105 bool WASAPIAudioInputStream::Open() {
 106   DCHECK(CalledOnValidThread());
 107   // Verify that we are not already opened.
 108   if (opened_)
 109     return false;
 110
 111   // Obtain a reference to the IMMDevice interface of the capturing
 112   // device with the specified unique identifier or role which was
 113   // set at construction.
 114   HRESULT hr = SetCaptureDevice();
 115   if (FAILED(hr))
 116     return false;
 117
 118   // Obtain an IAudioClient interface which enables us to create and initialize
 119   // an audio stream between an audio application and the audio engine.
 120   hr = ActivateCaptureDevice();
 121   if (FAILED(hr))
 122     return false;
 123
 124   // Retrieve the stream format which the audio engine uses for its internal
 125   // processing/mixing of shared-mode streams. This function call is for
 126   // diagnostic purposes only and only in debug mode.
 127 #ifndef NDEBUG
 128   hr = GetAudioEngineStreamFormat();
 129 #endif
 130
 131   // Verify that the selected audio endpoint supports the specified format
 132   // set during construction.
 133   if (!DesiredFormatIsSupported())
 134     return false;
 135
 136   // Initialize the audio stream between the client and the device using
 137   // shared mode and a lowest possible glitch-free latency.
 138   hr = InitializeAudioEngine();
 139
 140   opened_ = SUCCEEDED(hr);
 141   return opened_;
 142 }
 143
 144 void WASAPIAudioInputStream::Start(AudioInputCallback* callback) {
 145   DCHECK(CalledOnValidThread());
 146   DCHECK(callback);
 147   DLOG_IF(ERROR, !opened_) << "Open() has not been called successfully";
 148   if (!opened_)
 149     return;
 150
 151   if (started_)
 152     return;
 153
 154   DCHECK(!sink_);
 155   sink_ = callback;
 156
 157   // Starts periodic AGC microphone measurements if the AGC has been enabled
 158   // using SetAutomaticGainControl().
 159   StartAgc();
 160
 161   // Create and start the thread that will drive the capturing by waiting for
 162   // capture events.
 163   capture_thread_ =
 164       new base::DelegateSimpleThread(this, "wasapi_capture_thread");
 165   capture_thread_->Start();
 166
 167   // Start streaming data between the endpoint buffer and the audio engine.
 168   HRESULT hr = audio_client_->Start();
 169   DLOG_IF(ERROR, FAILED(hr)) << "Failed to start input streaming.";
 170
 171   if (SUCCEEDED(hr) && audio_render_client_for_loopback_)
 172     hr = audio_render_client_for_loopback_->Start();
 173
 174   started_ = SUCCEEDED(hr);
 175 }
 176
 177 void WASAPIAudioInputStream::Stop() {
 178   DCHECK(CalledOnValidThread());
 179   DVLOG(1) << "WASAPIAudioInputStream::Stop()";
 180   if (!started_)
 181     return;
 182
 183   // Stops periodic AGC microphone measurements.
 184   StopAgc();
 185
 186   // Shut down the capture thread.
 187   if (stop_capture_event_.IsValid()) {
 188     SetEvent(stop_capture_event_.Get());
 189   }
 190
 191   // Stop the input audio streaming.
 192   HRESULT hr = audio_client_->Stop();
 193   if (FAILED(hr)) {
 194     LOG(ERROR) << "Failed to stop input streaming.";
 195   }
 196
 197   // Wait until the thread completes and perform cleanup.
 198   if (capture_thread_) {
 199     SetEvent(stop_capture_event_.Get());
 200     capture_thread_->Join();
 201     capture_thread_ = NULL;
 202   }
 203
 204   started_ = false;
 205   sink_ = NULL;
 206 }
 207
 208 void WASAPIAudioInputStream::Close() {
 209   DVLOG(1) << "WASAPIAudioInputStream::Close()";
 210   // It is valid to call Close() before calling open or Start().
 211   // It is also valid to call Close() after Start() has been called.
 212   Stop();
 213
 214   // Inform the audio manager that we have been closed. This will cause our
 215   // destruction.
 216   manager_->ReleaseInputStream(this);
 217 }
 218
 219 double WASAPIAudioInputStream::GetMaxVolume() {
 220   // Verify that Open() has been called succesfully, to ensure that an audio
 221   // session exists and that an ISimpleAudioVolume interface has been created.
 222   DLOG_IF(ERROR, !opened_) << "Open() has not been called successfully";
 223   if (!opened_)
 224     return 0.0;
 225
 226   // The effective volume value is always in the range 0.0 to 1.0, hence
 227   // we can return a fixed value (=1.0) here.
 228   return 1.0;
 229 }
 230
 231 void WASAPIAudioInputStream::SetVolume(double volume) {
 232   DVLOG(1) << "SetVolume(volume=" << volume << ")";
 233   DCHECK(CalledOnValidThread());
 234   DCHECK_GE(volume, 0.0);
 235   DCHECK_LE(volume, 1.0);
 236
 237   DLOG_IF(ERROR, !opened_) << "Open() has not been called successfully";
 238   if (!opened_)
 239     return;
 240
 241   // Set a new master volume level. Valid volume levels are in the range
 242   // 0.0 to 1.0. Ignore volume-change events.
 243   HRESULT hr = simple_audio_volume_->SetMasterVolume(static_cast<float>(volume),
 244       NULL);
 245   DLOG_IF(WARNING, FAILED(hr)) << "Failed to set new input master volume.";
 246
 247   // Update the AGC volume level based on the last setting above. Note that,
 248   // the volume-level resolution is not infinite and it is therefore not
 249   // possible to assume that the volume provided as input parameter can be
 250   // used directly. Instead, a new query to the audio hardware is required.
 251   // This method does nothing if AGC is disabled.
 252   UpdateAgcVolume();
 253 }
 254
 255 double WASAPIAudioInputStream::GetVolume() {
 256   DCHECK(opened_) << "Open() has not been called successfully";
 257   if (!opened_)
 258     return 0.0;
 259
 260   // Retrieve the current volume level. The value is in the range 0.0 to 1.0.
 261   float level = 0.0f;
 262   HRESULT hr = simple_audio_volume_->GetMasterVolume(&level);
 263   DLOG_IF(WARNING, FAILED(hr)) << "Failed to get input master volume.";
 264
 265   return static_cast<double>(level);
 266 }
 267
 268 bool WASAPIAudioInputStream::IsMuted() {
 269   DCHECK(opened_) << "Open() has not been called successfully";
 270   DCHECK(CalledOnValidThread());
 271   if (!opened_)
 272     return false;
 273
 274   // Retrieves the current muting state for the audio session.
 275   BOOL is_muted = FALSE;
 276   HRESULT hr = simple_audio_volume_->GetMute(&is_muted);
 277   DLOG_IF(WARNING, FAILED(hr)) << "Failed to get input master volume.";
 278
 279   return is_muted != FALSE;
 280 }
 281
 282 // static
 283 AudioParameters WASAPIAudioInputStream::GetInputStreamParameters(
 284     const std::string& device_id) {
 285   int sample_rate = 48000;
 286   ChannelLayout channel_layout = CHANNEL_LAYOUT_STEREO;
 287
 288   base::win::ScopedCoMem<WAVEFORMATEX> audio_engine_mix_format;
 289   int effects = AudioParameters::NO_EFFECTS;
 290   if (SUCCEEDED(GetMixFormat(device_id, &audio_engine_mix_format, &effects))) {
 291     sample_rate = static_cast<int>(audio_engine_mix_format->nSamplesPerSec);
 292     channel_layout = audio_engine_mix_format->nChannels == 1 ?
 293         CHANNEL_LAYOUT_MONO : CHANNEL_LAYOUT_STEREO;
 294   }
 295
 296   // Use 10ms frame size as default.
 297   int frames_per_buffer = sample_rate / 100;
 298   return AudioParameters(
 299       AudioParameters::AUDIO_PCM_LOW_LATENCY, channel_layout, sample_rate,
 300       16, frames_per_buffer, effects);
 301 }
 302
 303 // static
 304 HRESULT WASAPIAudioInputStream::GetMixFormat(const std::string& device_id,
 305                                              WAVEFORMATEX** device_format,
 306                                              int* effects) {
 307   DCHECK(effects);
 308
 309   // It is assumed that this static method is called from a COM thread, i.e.,
 310   // CoInitializeEx() is not called here to avoid STA/MTA conflicts.
 311   ScopedComPtr<IMMDeviceEnumerator> enumerator;
 312   HRESULT hr = enumerator.CreateInstance(__uuidof(MMDeviceEnumerator), NULL,
 313                                          CLSCTX_INPROC_SERVER);
 314   if (FAILED(hr))
 315     return hr;
 316
 317   ScopedComPtr<IMMDevice> endpoint_device;
 318   if (device_id == AudioManagerBase::kDefaultDeviceId) {
 319     // Retrieve the default capture audio endpoint.
 320     hr = enumerator->GetDefaultAudioEndpoint(eCapture, eConsole,
 321                                              endpoint_device.Receive());
 322   } else if (device_id == AudioManagerBase::kLoopbackInputDeviceId) {
 323     // Get the mix format of the default playback stream.
 324     hr = enumerator->GetDefaultAudioEndpoint(eRender, eConsole,
 325                                              endpoint_device.Receive());
 326   } else {
 327     // Retrieve a capture endpoint device that is specified by an endpoint
 328     // device-identification string.
 329     hr = enumerator->GetDevice(base::UTF8ToUTF16(device_id).c_str(),
 330                                endpoint_device.Receive());
 331   }
 332
 333   if (FAILED(hr))
 334     return hr;
 335
 336   *effects = IsDefaultCommunicationDevice(enumerator, endpoint_device) ?
 337       AudioParameters::DUCKING : AudioParameters::NO_EFFECTS;
 338
 339   ScopedComPtr<IAudioClient> audio_client;
 340   hr = endpoint_device->Activate(__uuidof(IAudioClient),
 341                                  CLSCTX_INPROC_SERVER,
 342                                  NULL,
 343                                  audio_client.ReceiveVoid());
 344   return SUCCEEDED(hr) ? audio_client->GetMixFormat(device_format) : hr;
 345 }
 346
 347 void WASAPIAudioInputStream::Run() {
 348   ScopedCOMInitializer com_init(ScopedCOMInitializer::kMTA);
 349
 350   // Increase the thread priority.
 351   capture_thread_->SetThreadPriority(base::kThreadPriority_RealtimeAudio);
 352
 353   // Enable MMCSS to ensure that this thread receives prioritized access to
 354   // CPU resources.
 355   DWORD task_index = 0;
 356   HANDLE mm_task = avrt::AvSetMmThreadCharacteristics(L"Pro Audio",
 357                                                       &task_index);
 358   bool mmcss_is_ok =
 359       (mm_task && avrt::AvSetMmThreadPriority(mm_task, AVRT_PRIORITY_CRITICAL));
 360   if (!mmcss_is_ok) {
 361     // Failed to enable MMCSS on this thread. It is not fatal but can lead
 362     // to reduced QoS at high load.
 363     DWORD err = GetLastError();
 364     LOG(WARNING) << "Failed to enable MMCSS (error code=" << err << ").";
 365   }
 366
 367   // Allocate a buffer with a size that enables us to take care of cases like:
 368   // 1) The recorded buffer size is smaller, or does not match exactly with,
 369   //    the selected packet size used in each callback.
 370   // 2) The selected buffer size is larger than the recorded buffer size in
 371   //    each event.
 372   size_t buffer_frame_index = 0;
 373   size_t capture_buffer_size = std::max(
 374       2 * endpoint_buffer_size_frames_ * frame_size_,
 375       2 * packet_size_frames_ * frame_size_);
 376   scoped_ptr<uint8[]> capture_buffer(new uint8[capture_buffer_size]);
 377
 378   LARGE_INTEGER now_count;
 379   bool recording = true;
 380   bool error = false;
 381   double volume = GetVolume();
 382   HANDLE wait_array[2] =
 383       { stop_capture_event_.Get(), audio_samples_ready_event_.Get() };
 384
 385   while (recording && !error) {
 386     HRESULT hr = S_FALSE;
 387
 388     // Wait for a close-down event or a new capture event.
 389     DWORD wait_result = WaitForMultipleObjects(2, wait_array, FALSE, INFINITE);
 390     switch (wait_result) {
 391       case WAIT_FAILED:
 392         error = true;
 393         break;
 394       case WAIT_OBJECT_0 + 0:
 395         // |stop_capture_event_| has been set.
 396         recording = false;
 397         break;
 398       case WAIT_OBJECT_0 + 1:
 399         {
 400           // |audio_samples_ready_event_| has been set.
 401           BYTE* data_ptr = NULL;
 402           UINT32 num_frames_to_read = 0;
 403           DWORD flags = 0;
 404           UINT64 device_position = 0;
 405           UINT64 first_audio_frame_timestamp = 0;
 406
 407           // Retrieve the amount of data in the capture endpoint buffer,
 408           // replace it with silence if required, create callbacks for each
 409           // packet and store non-delivered data for the next event.
 410           hr = audio_capture_client_->GetBuffer(&data_ptr,
 411                                                 &num_frames_to_read,
 412                                                 &flags,
 413                                                 &device_position,
 414                                                 &first_audio_frame_timestamp);
 415           if (FAILED(hr)) {
 416             DLOG(ERROR) << "Failed to get data from the capture buffer";
 417             continue;
 418           }
 419
 420           if (num_frames_to_read != 0) {
 421             size_t pos = buffer_frame_index * frame_size_;
 422             size_t num_bytes = num_frames_to_read * frame_size_;
 423             DCHECK_GE(capture_buffer_size, pos + num_bytes);
 424
 425             if (flags & AUDCLNT_BUFFERFLAGS_SILENT) {
 426               // Clear out the local buffer since silence is reported.
 427               memset(&capture_buffer[pos], 0, num_bytes);
 428             } else {
 429               // Copy captured data from audio engine buffer to local buffer.
 430               memcpy(&capture_buffer[pos], data_ptr, num_bytes);
 431             }
 432
 433             buffer_frame_index += num_frames_to_read;
 434           }
 435
 436           hr = audio_capture_client_->ReleaseBuffer(num_frames_to_read);
 437           DLOG_IF(ERROR, FAILED(hr)) << "Failed to release capture buffer";
 438
 439           // Derive a delay estimate for the captured audio packet.
 440           // The value contains two parts (A+B), where A is the delay of the
 441           // first audio frame in the packet and B is the extra delay
 442           // contained in any stored data. Unit is in audio frames.
 443           QueryPerformanceCounter(&now_count);
 444           double audio_delay_frames =
 445               ((perf_count_to_100ns_units_ * now_count.QuadPart -
 446                 first_audio_frame_timestamp) / 10000.0) * ms_to_frame_count_ +
 447                 buffer_frame_index - num_frames_to_read;
 448
 449           // Get a cached AGC volume level which is updated once every second
 450           // on the audio manager thread. Note that, |volume| is also updated
 451           // each time SetVolume() is called through IPC by the render-side AGC.
 452           GetAgcVolume(&volume);
 453
 454           // Deliver captured data to the registered consumer using a packet
 455           // size which was specified at construction.
 456           uint32 delay_frames = static_cast<uint32>(audio_delay_frames + 0.5);
 457           while (buffer_frame_index >= packet_size_frames_) {
 458             // Copy data to audio bus to match the OnData interface.
 459             uint8* audio_data = reinterpret_cast<uint8*>(capture_buffer.get());
 460             audio_bus_->FromInterleaved(
 461                 audio_data, audio_bus_->frames(), format_.wBitsPerSample / 8);
 462
 463             // Deliver data packet, delay estimation and volume level to
 464             // the user.
 465             sink_->OnData(
 466                 this, audio_bus_.get(), delay_frames * frame_size_, volume);
 467
 468             // Store parts of the recorded data which can't be delivered
 469             // using the current packet size. The stored section will be used
 470             // either in the next while-loop iteration or in the next
 471             // capture event.
 472             memmove(&capture_buffer[0],
 473                     &capture_buffer[packet_size_bytes_],
 474                     (buffer_frame_index - packet_size_frames_) * frame_size_);
 475
 476             buffer_frame_index -= packet_size_frames_;
 477             delay_frames -= packet_size_frames_;
 478           }
 479         }
 480         break;
 481       default:
 482         error = true;
 483         break;
 484     }
 485   }
 486
 487   if (recording && error) {
 488     // TODO(henrika): perhaps it worth improving the cleanup here by e.g.
 489     // stopping the audio client, joining the thread etc.?
 490     NOTREACHED() << "WASAPI capturing failed with error code "
 491                  << GetLastError();
 492   }
 493
 494   // Disable MMCSS.
 495   if (mm_task && !avrt::AvRevertMmThreadCharacteristics(mm_task)) {
 496     PLOG(WARNING) << "Failed to disable MMCSS";
 497   }
 498 }
 499
 500 void WASAPIAudioInputStream::HandleError(HRESULT err) {
 501   NOTREACHED() << "Error code: " << err;
 502   if (sink_)
 503     sink_->OnError(this);
 504 }
 505
 506 HRESULT WASAPIAudioInputStream::SetCaptureDevice() {
 507   DCHECK(!endpoint_device_);
 508
 509   ScopedComPtr<IMMDeviceEnumerator> enumerator;
 510   HRESULT hr = enumerator.CreateInstance(__uuidof(MMDeviceEnumerator),
 511                                          NULL, CLSCTX_INPROC_SERVER);
 512   if (FAILED(hr))
 513     return hr;
 514
 515   // Retrieve the IMMDevice by using the specified role or the specified
 516   // unique endpoint device-identification string.
 517
 518   if (effects_ & AudioParameters::DUCKING) {
 519     // Ducking has been requested and it is only supported for the default
 520     // communication device.  So, let's open up the communication device and
 521     // see if the ID of that device matches the requested ID.
 522     // We consider a kDefaultDeviceId as well as an explicit device id match,
 523     // to be valid matches.
 524     hr = enumerator->GetDefaultAudioEndpoint(eCapture, eCommunications,
 525                                              endpoint_device_.Receive());
 526     if (endpoint_device_ && device_id_ != AudioManagerBase::kDefaultDeviceId) {
 527       base::win::ScopedCoMem<WCHAR> communications_id;
 528       endpoint_device_->GetId(&communications_id);
 529       if (device_id_ !=
 530           base::WideToUTF8(static_cast<WCHAR*>(communications_id))) {
 531         DLOG(WARNING) << "Ducking has been requested for a non-default device."
 532                          "Not supported.";
 533         // We can't honor the requested effect flag, so turn it off and
 534         // continue.  We'll check this flag later to see if we've actually
 535         // opened up the communications device, so it's important that it
 536         // reflects the active state.
 537         effects_ &= ~AudioParameters::DUCKING;
 538         endpoint_device_.Release();  // Fall back on code below.
 539       }
 540     }
 541   }
 542
 543   if (!endpoint_device_) {
 544     if (device_id_ == AudioManagerBase::kDefaultDeviceId) {
 545       // Retrieve the default capture audio endpoint for the specified role.
 546       // Note that, in Windows Vista, the MMDevice API supports device roles
 547       // but the system-supplied user interface programs do not.
 548       hr = enumerator->GetDefaultAudioEndpoint(eCapture, eConsole,
 549                                                endpoint_device_.Receive());
 550     } else if (device_id_ == AudioManagerBase::kLoopbackInputDeviceId) {
 551       // Capture the default playback stream.
 552       hr = enumerator->GetDefaultAudioEndpoint(eRender, eConsole,
 553                                                endpoint_device_.Receive());
 554     } else {
 555       hr = enumerator->GetDevice(base::UTF8ToUTF16(device_id_).c_str(),
 556                                  endpoint_device_.Receive());
 557     }
 558   }
 559
 560   if (FAILED(hr))
 561     return hr;
 562
 563   // Verify that the audio endpoint device is active, i.e., the audio
 564   // adapter that connects to the endpoint device is present and enabled.
 565   DWORD state = DEVICE_STATE_DISABLED;
 566   hr = endpoint_device_->GetState(&state);
 567   if (FAILED(hr))
 568     return hr;
 569
 570   if (!(state & DEVICE_STATE_ACTIVE)) {
 571     DLOG(ERROR) << "Selected capture device is not active.";
 572     hr = E_ACCESSDENIED;
 573   }
 574
 575   return hr;
 576 }
 577
 578 HRESULT WASAPIAudioInputStream::ActivateCaptureDevice() {
 579   // Creates and activates an IAudioClient COM object given the selected
 580   // capture endpoint device.
 581   HRESULT hr = endpoint_device_->Activate(__uuidof(IAudioClient),
 582                                           CLSCTX_INPROC_SERVER,
 583                                           NULL,
 584                                           audio_client_.ReceiveVoid());
 585   return hr;
 586 }
 587
 588 HRESULT WASAPIAudioInputStream::GetAudioEngineStreamFormat() {
 589   HRESULT hr = S_OK;
 590 #ifndef NDEBUG
 591   // The GetMixFormat() method retrieves the stream format that the
 592   // audio engine uses for its internal processing of shared-mode streams.
 593   // The method always uses a WAVEFORMATEXTENSIBLE structure, instead
 594   // of a stand-alone WAVEFORMATEX structure, to specify the format.
 595   // An WAVEFORMATEXTENSIBLE structure can specify both the mapping of
 596   // channels to speakers and the number of bits of precision in each sample.
 597   base::win::ScopedCoMem<WAVEFORMATEXTENSIBLE> format_ex;
 598   hr = audio_client_->GetMixFormat(
 599       reinterpret_cast<WAVEFORMATEX**>(&format_ex));
 600
 601   // See http://msdn.microsoft.com/en-us/windows/hardware/gg463006#EFH
 602   // for details on the WAVE file format.
 603   WAVEFORMATEX format = format_ex->Format;
 604   DVLOG(2) << "WAVEFORMATEX:";
 605   DVLOG(2) << "  wFormatTags    : 0x" << std::hex << format.wFormatTag;
 606   DVLOG(2) << "  nChannels      : " << format.nChannels;
 607   DVLOG(2) << "  nSamplesPerSec : " << format.nSamplesPerSec;
 608   DVLOG(2) << "  nAvgBytesPerSec: " << format.nAvgBytesPerSec;
 609   DVLOG(2) << "  nBlockAlign    : " << format.nBlockAlign;
 610   DVLOG(2) << "  wBitsPerSample : " << format.wBitsPerSample;
 611   DVLOG(2) << "  cbSize         : " << format.cbSize;
 612
 613   DVLOG(2) << "WAVEFORMATEXTENSIBLE:";
 614   DVLOG(2) << " wValidBitsPerSample: " <<
 615       format_ex->Samples.wValidBitsPerSample;
 616   DVLOG(2) << " dwChannelMask      : 0x" << std::hex <<
 617       format_ex->dwChannelMask;
 618   if (format_ex->SubFormat == KSDATAFORMAT_SUBTYPE_PCM)
 619     DVLOG(2) << " SubFormat          : KSDATAFORMAT_SUBTYPE_PCM";
 620   else if (format_ex->SubFormat == KSDATAFORMAT_SUBTYPE_IEEE_FLOAT)
 621     DVLOG(2) << " SubFormat          : KSDATAFORMAT_SUBTYPE_IEEE_FLOAT";
 622   else if (format_ex->SubFormat == KSDATAFORMAT_SUBTYPE_WAVEFORMATEX)
 623     DVLOG(2) << " SubFormat          : KSDATAFORMAT_SUBTYPE_WAVEFORMATEX";
 624 #endif
 625   return hr;
 626 }
 627
 628 bool WASAPIAudioInputStream::DesiredFormatIsSupported() {
 629   // An application that uses WASAPI to manage shared-mode streams can rely
 630   // on the audio engine to perform only limited format conversions. The audio
 631   // engine can convert between a standard PCM sample size used by the
 632   // application and the floating-point samples that the engine uses for its
 633   // internal processing. However, the format for an application stream
 634   // typically must have the same number of channels and the same sample
 635   // rate as the stream format used by the device.
 636   // Many audio devices support both PCM and non-PCM stream formats. However,
 637   // the audio engine can mix only PCM streams.
 638   base::win::ScopedCoMem<WAVEFORMATEX> closest_match;
 639   HRESULT hr = audio_client_->IsFormatSupported(AUDCLNT_SHAREMODE_SHARED,
 640                                                 &format_,
 641                                                 &closest_match);
 642   DLOG_IF(ERROR, hr == S_FALSE) << "Format is not supported "
 643                                 << "but a closest match exists.";
 644   return (hr == S_OK);
 645 }
 646
 647 HRESULT WASAPIAudioInputStream::InitializeAudioEngine() {
 648   DWORD flags;
 649   // Use event-driven mode only fo regular input devices. For loopback the
 650   // EVENTCALLBACK flag is specified when intializing
 651   // |audio_render_client_for_loopback_|.
 652   if (device_id_ == AudioManagerBase::kLoopbackInputDeviceId) {
 653     flags = AUDCLNT_STREAMFLAGS_LOOPBACK | AUDCLNT_STREAMFLAGS_NOPERSIST;
 654   } else {
 655     flags =
 656       AUDCLNT_STREAMFLAGS_EVENTCALLBACK | AUDCLNT_STREAMFLAGS_NOPERSIST;
 657   }
 658
 659   // Initialize the audio stream between the client and the device.
 660   // We connect indirectly through the audio engine by using shared mode.
 661   // Note that, |hnsBufferDuration| is set of 0, which ensures that the
 662   // buffer is never smaller than the minimum buffer size needed to ensure
 663   // that glitches do not occur between the periodic processing passes.
 664   // This setting should lead to lowest possible latency.
 665   HRESULT hr = audio_client_->Initialize(
 666       AUDCLNT_SHAREMODE_SHARED,
 667       flags,
 668       0,  // hnsBufferDuration
 669       0,
 670       &format_,
 671       (effects_ & AudioParameters::DUCKING) ? &kCommunicationsSessionId : NULL);
 672
 673   if (FAILED(hr))
 674     return hr;
 675
 676   // Retrieve the length of the endpoint buffer shared between the client
 677   // and the audio engine. The buffer length determines the maximum amount
 678   // of capture data that the audio engine can read from the endpoint buffer
 679   // during a single processing pass.
 680   // A typical value is 960 audio frames <=> 20ms @ 48kHz sample rate.
 681   hr = audio_client_->GetBufferSize(&endpoint_buffer_size_frames_);
 682   if (FAILED(hr))
 683     return hr;
 684
 685   DVLOG(1) << "endpoint buffer size: " << endpoint_buffer_size_frames_
 686            << " [frames]";
 687
 688 #ifndef NDEBUG
 689   // The period between processing passes by the audio engine is fixed for a
 690   // particular audio endpoint device and represents the smallest processing
 691   // quantum for the audio engine. This period plus the stream latency between
 692   // the buffer and endpoint device represents the minimum possible latency
 693   // that an audio application can achieve.
 694   // TODO(henrika): possibly remove this section when all parts are ready.
 695   REFERENCE_TIME device_period_shared_mode = 0;
 696   REFERENCE_TIME device_period_exclusive_mode = 0;
 697   HRESULT hr_dbg = audio_client_->GetDevicePeriod(
 698       &device_period_shared_mode, &device_period_exclusive_mode);
 699   if (SUCCEEDED(hr_dbg)) {
 700     DVLOG(1) << "device period: "
 701              << static_cast<double>(device_period_shared_mode / 10000.0)
 702              << " [ms]";
 703   }
 704
 705   REFERENCE_TIME latency = 0;
 706   hr_dbg = audio_client_->GetStreamLatency(&latency);
 707   if (SUCCEEDED(hr_dbg)) {
 708     DVLOG(1) << "stream latency: " << static_cast<double>(latency / 10000.0)
 709              << " [ms]";
 710   }
 711 #endif
 712
 713   // Set the event handle that the audio engine will signal each time a buffer
 714   // becomes ready to be processed by the client.
 715   //
 716   // In loopback case the capture device doesn't receive any events, so we
 717   // need to create a separate playback client to get notifications. According
 718   // to MSDN:
 719   //
 720   //   A pull-mode capture client does not receive any events when a stream is
 721   //   initialized with event-driven buffering and is loopback-enabled. To
 722   //   work around this, initialize a render stream in event-driven mode. Each
 723   //   time the client receives an event for the render stream, it must signal
 724   //   the capture client to run the capture thread that reads the next set of
 725   //   samples from the capture endpoint buffer.
 726   //
 727   // http://msdn.microsoft.com/en-us/library/windows/desktop/dd316551(v=vs.85).aspx
 728   if (device_id_ == AudioManagerBase::kLoopbackInputDeviceId) {
 729     hr = endpoint_device_->Activate(
 730         __uuidof(IAudioClient), CLSCTX_INPROC_SERVER, NULL,
 731         audio_render_client_for_loopback_.ReceiveVoid());
 732     if (FAILED(hr))
 733       return hr;
 734
 735     hr = audio_render_client_for_loopback_->Initialize(
 736         AUDCLNT_SHAREMODE_SHARED,
 737         AUDCLNT_STREAMFLAGS_EVENTCALLBACK | AUDCLNT_STREAMFLAGS_NOPERSIST,
 738         0, 0, &format_, NULL);
 739     if (FAILED(hr))
 740       return hr;
 741
 742     hr = audio_render_client_for_loopback_->SetEventHandle(
 743         audio_samples_ready_event_.Get());
 744   } else {
 745     hr = audio_client_->SetEventHandle(audio_samples_ready_event_.Get());
 746   }
 747
 748   if (FAILED(hr))
 749     return hr;
 750
 751   // Get access to the IAudioCaptureClient interface. This interface
 752   // enables us to read input data from the capture endpoint buffer.
 753   hr = audio_client_->GetService(__uuidof(IAudioCaptureClient),
 754                                  audio_capture_client_.ReceiveVoid());
 755   if (FAILED(hr))
 756     return hr;
 757
 758   // Obtain a reference to the ISimpleAudioVolume interface which enables
 759   // us to control the master volume level of an audio session.
 760   hr = audio_client_->GetService(__uuidof(ISimpleAudioVolume),
 761                                  simple_audio_volume_.ReceiveVoid());
 762   return hr;
 763 }
 764
 765 }  // namespace media