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.
5 #include "media/audio/win/wavein_input_win.h"
7 #pragma comment(lib, "winmm.lib")
9 #include "base/logging.h"
10 #include "media/audio/audio_io.h"
11 #include "media/audio/win/audio_manager_win.h"
12 #include "media/audio/win/device_enumeration_win.h"
16 // Our sound buffers are allocated once and kept in a linked list using the
17 // the WAVEHDR::dwUser variable. The last buffer points to the first buffer.
18 static WAVEHDR* GetNextBuffer(WAVEHDR* current) {
19 return reinterpret_cast<WAVEHDR*>(current->dwUser);
22 PCMWaveInAudioInputStream::PCMWaveInAudioInputStream(
23 AudioManagerWin* manager, const AudioParameters& params, int num_buffers,
24 const std::string& device_id)
25 : state_(kStateEmpty),
27 device_id_(device_id),
30 num_buffers_(num_buffers),
32 channels_(params.channels()) {
33 DCHECK_GT(num_buffers_, 0);
34 format_.wFormatTag = WAVE_FORMAT_PCM;
35 format_.nChannels = params.channels() > 2 ? 2 : params.channels();
36 format_.nSamplesPerSec = params.sample_rate();
37 format_.wBitsPerSample = params.bits_per_sample();
39 format_.nBlockAlign = (format_.nChannels * format_.wBitsPerSample) / 8;
40 format_.nAvgBytesPerSec = format_.nBlockAlign * format_.nSamplesPerSec;
41 buffer_size_ = params.frames_per_buffer() * format_.nBlockAlign;
42 // If we don't have a packet size we use 100ms.
44 buffer_size_ = format_.nAvgBytesPerSec / 10;
45 // The event is auto-reset.
46 stopped_event_.Set(::CreateEventW(NULL, FALSE, FALSE, NULL));
49 PCMWaveInAudioInputStream::~PCMWaveInAudioInputStream() {
50 DCHECK(NULL == wavein_);
53 bool PCMWaveInAudioInputStream::Open() {
54 DCHECK(thread_checker_.CalledOnValidThread());
55 if (state_ != kStateEmpty)
57 if (num_buffers_ < 2 || num_buffers_ > 10)
60 // Convert the stored device id string into an unsigned integer
61 // corresponding to the selected device.
62 UINT device_id = WAVE_MAPPER;
63 if (!GetDeviceId(&device_id)) {
67 // Open the specified input device for recording.
68 MMRESULT result = MMSYSERR_NOERROR;
69 result = ::waveInOpen(&wavein_, device_id, &format_,
70 reinterpret_cast<DWORD_PTR>(WaveCallback),
71 reinterpret_cast<DWORD_PTR>(this),
73 if (result != MMSYSERR_NOERROR)
81 void PCMWaveInAudioInputStream::SetupBuffers() {
83 WAVEHDR* first = NULL;
84 for (int ix = 0; ix != num_buffers_; ++ix) {
85 uint32 sz = sizeof(WAVEHDR) + buffer_size_;
86 buffer_ = reinterpret_cast<WAVEHDR*>(new char[sz]);
87 buffer_->lpData = reinterpret_cast<char*>(buffer_) + sizeof(WAVEHDR);
88 buffer_->dwBufferLength = buffer_size_;
89 buffer_->dwBytesRecorded = 0;
90 buffer_->dwUser = reinterpret_cast<DWORD_PTR>(last);
91 buffer_->dwFlags = WHDR_DONE;
96 ::waveInPrepareHeader(wavein_, buffer_, sizeof(WAVEHDR));
98 // Fix the first buffer to point to the last one.
99 first->dwUser = reinterpret_cast<DWORD_PTR>(last);
102 void PCMWaveInAudioInputStream::FreeBuffers() {
103 WAVEHDR* current = buffer_;
104 for (int ix = 0; ix != num_buffers_; ++ix) {
105 WAVEHDR* next = GetNextBuffer(current);
106 if (current->dwFlags & WHDR_PREPARED)
107 ::waveInUnprepareHeader(wavein_, current, sizeof(WAVEHDR));
108 delete[] reinterpret_cast<char*>(current);
114 void PCMWaveInAudioInputStream::Start(AudioInputCallback* callback) {
115 DCHECK(thread_checker_.CalledOnValidThread());
116 if (state_ != kStateReady)
120 callback_ = callback;
121 state_ = kStateRecording;
123 WAVEHDR* buffer = buffer_;
124 for (int ix = 0; ix != num_buffers_; ++ix) {
125 QueueNextPacket(buffer);
126 buffer = GetNextBuffer(buffer);
130 MMRESULT result = ::waveInStart(wavein_);
131 if (result != MMSYSERR_NOERROR) {
133 state_ = kStateReady;
138 // Stopping is tricky. First, no buffer should be locked by the audio driver
139 // or else the waveInReset() will deadlock and secondly, the callback should
140 // not be inside the AudioInputCallback's OnData because waveInReset()
141 // forcefully kills the callback thread.
142 void PCMWaveInAudioInputStream::Stop() {
143 DVLOG(1) << "PCMWaveInAudioInputStream::Stop()";
144 DCHECK(thread_checker_.CalledOnValidThread());
145 if (state_ != kStateRecording)
148 bool already_stopped = false;
150 // Tell the callback that we're stopping.
151 // As a result, |stopped_event_| will be signaled in callback method.
152 base::AutoLock auto_lock(lock_);
153 already_stopped = (callback_ == NULL);
160 // Wait for the callback to finish, it will signal us when ready to be reset.
161 DWORD wait = ::WaitForSingleObject(stopped_event_, INFINITE);
162 DCHECK_EQ(wait, WAIT_OBJECT_0);
164 // Stop input and reset the current position to zero for |wavein_|.
165 // All pending buffers are marked as done and returned to the application.
166 MMRESULT res = ::waveInReset(wavein_);
167 DCHECK_EQ(res, static_cast<MMRESULT>(MMSYSERR_NOERROR));
169 state_ = kStateReady;
172 void PCMWaveInAudioInputStream::Close() {
173 DVLOG(1) << "PCMWaveInAudioInputStream::Close()";
174 DCHECK(thread_checker_.CalledOnValidThread());
176 // We should not call Close() while recording. Catch it with DCHECK and
177 // implement auto-stop just in case.
178 DCHECK_NE(state_, kStateRecording);
184 // waveInClose() generates a WIM_CLOSE callback. In case Start() was never
185 // called, force a reset to ensure close succeeds.
186 MMRESULT res = ::waveInReset(wavein_);
187 DCHECK_EQ(res, static_cast<MMRESULT>(MMSYSERR_NOERROR));
188 res = ::waveInClose(wavein_);
189 DCHECK_EQ(res, static_cast<MMRESULT>(MMSYSERR_NOERROR));
190 state_ = kStateClosed;
194 // Tell the audio manager that we have been released. This can result in
195 // the manager destroying us in-place so this needs to be the last thing
196 // we do on this function.
197 manager_->ReleaseInputStream(this);
200 double PCMWaveInAudioInputStream::GetMaxVolume() {
201 // TODO(henrika): Add volume support using the Audio Mixer API.
205 void PCMWaveInAudioInputStream::SetVolume(double volume) {
206 // TODO(henrika): Add volume support using the Audio Mixer API.
209 double PCMWaveInAudioInputStream::GetVolume() {
210 // TODO(henrika): Add volume support using the Audio Mixer API.
214 void PCMWaveInAudioInputStream::SetAutomaticGainControl(bool enabled) {
215 // TODO(henrika): Add AGC support when volume control has been added.
219 bool PCMWaveInAudioInputStream::GetAutomaticGainControl() {
220 // TODO(henrika): Add AGC support when volume control has been added.
225 void PCMWaveInAudioInputStream::HandleError(MMRESULT error) {
226 DLOG(WARNING) << "PCMWaveInAudio error " << error;
227 callback_->OnError(this);
230 void PCMWaveInAudioInputStream::QueueNextPacket(WAVEHDR *buffer) {
231 MMRESULT res = ::waveInAddBuffer(wavein_, buffer, sizeof(WAVEHDR));
232 if (res != MMSYSERR_NOERROR)
236 bool PCMWaveInAudioInputStream::GetDeviceId(UINT* device_index) {
237 // Deliver the default input device id (WAVE_MAPPER) if the default
238 // device has been selected.
239 if (device_id_ == AudioManagerBase::kDefaultDeviceId) {
240 *device_index = WAVE_MAPPER;
244 // Get list of all available and active devices.
245 AudioDeviceNames device_names;
246 if (!media::GetInputDeviceNamesWinXP(&device_names))
249 if (device_names.empty())
252 // Search the full list of devices and compare with the specified
253 // device id which was specified in the constructor. Stop comparing
254 // when a match is found and return the corresponding index.
256 bool found_device = false;
257 AudioDeviceNames::const_iterator it = device_names.begin();
258 while (it != device_names.end()) {
259 if (it->unique_id.compare(device_id_) == 0) {
260 *device_index = index;
271 // Windows calls us back in this function when some events happen. Most notably
272 // when it has an audio buffer with recorded data.
273 void PCMWaveInAudioInputStream::WaveCallback(HWAVEIN hwi, UINT msg,
275 DWORD_PTR param1, DWORD_PTR) {
276 PCMWaveInAudioInputStream* obj =
277 reinterpret_cast<PCMWaveInAudioInputStream*>(instance);
279 // The lock ensures that Stop() can't be called during a callback.
280 base::AutoLock auto_lock(obj->lock_);
282 if (msg == WIM_DATA) {
283 // The WIM_DATA message is sent when waveform-audio data is present in
284 // the input buffer and the buffer is being returned to the application.
285 // The message can be sent when the buffer is full or after the
286 // waveInReset function is called.
287 if (obj->callback_) {
288 // TODO(henrika): the |volume| parameter is always set to zero since
289 // there is currently no support for controlling the microphone volume
291 WAVEHDR* buffer = reinterpret_cast<WAVEHDR*>(param1);
292 obj->callback_->OnData(obj,
293 reinterpret_cast<const uint8*>(buffer->lpData),
294 buffer->dwBytesRecorded,
295 buffer->dwBytesRecorded,
298 // Queue the finished buffer back with the audio driver. Since we are
299 // reusing the same buffers we can get away without calling
300 // waveInPrepareHeader.
301 obj->QueueNextPacket(buffer);
303 // Main thread has called Stop() and set |callback_| to NULL and is
304 // now waiting to issue waveInReset which will kill this thread.
305 // We should not call AudioSourceCallback code anymore.
306 ::SetEvent(obj->stopped_event_);
308 } else if (msg == WIM_CLOSE) {
309 // Intentionaly no-op for now.
310 } else if (msg == WIM_OPEN) {
311 // Intentionaly no-op for now.