1 /* DirectSoundCapture
2 *
3 * Copyright 1998 Marcus Meissner
4 * Copyright 1998 Rob Riggs
5 * Copyright 2000-2001 TransGaming Technologies, Inc.
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21 /*
22 * TODO:
23 * Implement FX support.
24 * Implement both IDirectSoundCaptureBuffer and IDirectSoundCaptureBuffer8
25 * Make DirectSoundCaptureCreate and DirectSoundCaptureCreate8 behave differently
26 */
27
28 #include <stdarg.h>
29
30 #define NONAMELESSSTRUCT
31 #define NONAMELESSUNION
32 #include "windef.h"
33 #include "winbase.h"
34 #include "winuser.h"
35 #include "mmsystem.h"
36 #include "mmddk.h"
37 #include "winternl.h"
38 #include "winnls.h"
39 #include "wine/debug.h"
40 #include "dsound.h"
41 #include "dsdriver.h"
42 #include "dsound_private.h"
43
44 WINE_DEFAULT_DEBUG_CHANNEL(dsound);
45
46 /*****************************************************************************
47 * IDirectSoundCapture implementation structure
48 */
49 struct IDirectSoundCaptureImpl
50 {
51 /* IUnknown fields */
52 const IDirectSoundCaptureVtbl *lpVtbl;
53 LONG ref;
54
55 DirectSoundCaptureDevice *device;
56 };
57
58 static HRESULT IDirectSoundCaptureImpl_Create(LPDIRECTSOUNDCAPTURE8 * ppds);
59
60
61 /*****************************************************************************
62 * IDirectSoundCaptureNotify implementation structure
63 */
64 struct IDirectSoundCaptureNotifyImpl
65 {
66 /* IUnknown fields */
67 const IDirectSoundNotifyVtbl *lpVtbl;
68 LONG ref;
69 IDirectSoundCaptureBufferImpl* dscb;
70 };
71
72 static HRESULT IDirectSoundCaptureNotifyImpl_Create(IDirectSoundCaptureBufferImpl *dscb,
73 IDirectSoundCaptureNotifyImpl ** pdscn);
74
75
76 DirectSoundCaptureDevice * DSOUND_capture[MAXWAVEDRIVERS];
77
78 static HRESULT DirectSoundCaptureDevice_Create(DirectSoundCaptureDevice ** ppDevice);
79
80 static const char * const captureStateString[] = {
81 "STATE_STOPPED",
82 "STATE_STARTING",
83 "STATE_CAPTURING",
84 "STATE_STOPPING"
85 };
86
87 HRESULT DSOUND_CaptureCreate(
88 REFIID riid,
89 LPDIRECTSOUNDCAPTURE *ppDSC)
90 {
91 LPDIRECTSOUNDCAPTURE pDSC;
92 HRESULT hr;
93 TRACE("(%s, %p)\n", debugstr_guid(riid), ppDSC);
94
95 if (!IsEqualIID(riid, &IID_IUnknown) &&
96 !IsEqualIID(riid, &IID_IDirectSoundCapture)) {
97 *ppDSC = 0;
98 return E_NOINTERFACE;
99 }
100
101 /* Get dsound configuration */
102 setup_dsound_options();
103
104 hr = IDirectSoundCaptureImpl_Create(&pDSC);
105 if (hr == DS_OK) {
106 IDirectSoundCapture_AddRef(pDSC);
107 *ppDSC = pDSC;
108 } else {
109 WARN("IDirectSoundCaptureImpl_Create failed\n");
110 *ppDSC = 0;
111 }
112
113 return hr;
114 }
115
116 HRESULT DSOUND_CaptureCreate8(
117 REFIID riid,
118 LPDIRECTSOUNDCAPTURE8 *ppDSC8)
119 {
120 LPDIRECTSOUNDCAPTURE8 pDSC8;
121 HRESULT hr;
122 TRACE("(%s, %p)\n", debugstr_guid(riid), ppDSC8);
123
124 if (!IsEqualIID(riid, &IID_IUnknown) &&
125 !IsEqualIID(riid, &IID_IDirectSoundCapture8)) {
126 *ppDSC8 = 0;
127 return E_NOINTERFACE;
128 }
129
130 /* Get dsound configuration */
131 setup_dsound_options();
132
133 hr = IDirectSoundCaptureImpl_Create(&pDSC8);
134 if (hr == DS_OK) {
135 IDirectSoundCapture_AddRef(pDSC8);
136 *ppDSC8 = pDSC8;
137 } else {
138 WARN("IDirectSoundCaptureImpl_Create failed\n");
139 *ppDSC8 = 0;
140 }
141
142 return hr;
143 }
144
145 /***************************************************************************
146 * DirectSoundCaptureCreate [DSOUND.6]
147 *
148 * Create and initialize a DirectSoundCapture interface.
149 *
150 * PARAMS
151 * lpcGUID [I] Address of the GUID that identifies the sound capture device.
152 * lplpDSC [O] Address of a variable to receive the interface pointer.
153 * pUnkOuter [I] Must be NULL.
154 *
155 * RETURNS
156 * Success: DS_OK
157 * Failure: DSERR_NOAGGREGATION, DSERR_ALLOCATED, DSERR_INVALIDPARAM,
158 * DSERR_OUTOFMEMORY
159 *
160 * NOTES
161 * lpcGUID must be one of the values returned from DirectSoundCaptureEnumerate
162 * or NULL for the default device or DSDEVID_DefaultCapture or
163 * DSDEVID_DefaultVoiceCapture.
164 *
165 * DSERR_ALLOCATED is returned for sound devices that do not support full duplex.
166 */
167 HRESULT WINAPI DirectSoundCaptureCreate(
168 LPCGUID lpcGUID,
169 LPDIRECTSOUNDCAPTURE *ppDSC,
170 LPUNKNOWN pUnkOuter)
171 {
172 HRESULT hr;
173 LPDIRECTSOUNDCAPTURE pDSC;
174 TRACE("(%s,%p,%p)\n", debugstr_guid(lpcGUID), ppDSC, pUnkOuter);
175
176 if (ppDSC == NULL) {
177 WARN("invalid parameter: ppDSC == NULL\n");
178 return DSERR_INVALIDPARAM;
179 }
180
181 if (pUnkOuter) {
182 WARN("invalid parameter: pUnkOuter != NULL\n");
183 *ppDSC = NULL;
184 return DSERR_NOAGGREGATION;
185 }
186
187 hr = DSOUND_CaptureCreate(&IID_IDirectSoundCapture, &pDSC);
188 if (hr == DS_OK) {
189 hr = IDirectSoundCapture_Initialize(pDSC, lpcGUID);
190 if (hr != DS_OK) {
191 IDirectSoundCapture_Release(pDSC);
192 pDSC = 0;
193 }
194 }
195
196 *ppDSC = pDSC;
197
198 return hr;
199 }
200
201 /***************************************************************************
202 * DirectSoundCaptureCreate8 [DSOUND.12]
203 *
204 * Create and initialize a DirectSoundCapture interface.
205 *
206 * PARAMS
207 * lpcGUID [I] Address of the GUID that identifies the sound capture device.
208 * lplpDSC [O] Address of a variable to receive the interface pointer.
209 * pUnkOuter [I] Must be NULL.
210 *
211 * RETURNS
212 * Success: DS_OK
213 * Failure: DSERR_NOAGGREGATION, DSERR_ALLOCATED, DSERR_INVALIDPARAM,
214 * DSERR_OUTOFMEMORY
215 *
216 * NOTES
217 * lpcGUID must be one of the values returned from DirectSoundCaptureEnumerate
218 * or NULL for the default device or DSDEVID_DefaultCapture or
219 * DSDEVID_DefaultVoiceCapture.
220 *
221 * DSERR_ALLOCATED is returned for sound devices that do not support full duplex.
222 */
223 HRESULT WINAPI DirectSoundCaptureCreate8(
224 LPCGUID lpcGUID,
225 LPDIRECTSOUNDCAPTURE8 *ppDSC8,
226 LPUNKNOWN pUnkOuter)
227 {
228 HRESULT hr;
229 LPDIRECTSOUNDCAPTURE8 pDSC8;
230 TRACE("(%s,%p,%p)\n", debugstr_guid(lpcGUID), ppDSC8, pUnkOuter);
231
232 if (ppDSC8 == NULL) {
233 WARN("invalid parameter: ppDSC8 == NULL\n");
234 return DSERR_INVALIDPARAM;
235 }
236
237 if (pUnkOuter) {
238 WARN("invalid parameter: pUnkOuter != NULL\n");
239 *ppDSC8 = NULL;
240 return DSERR_NOAGGREGATION;
241 }
242
243 hr = DSOUND_CaptureCreate8(&IID_IDirectSoundCapture8, &pDSC8);
244 if (hr == DS_OK) {
245 hr = IDirectSoundCapture_Initialize(pDSC8, lpcGUID);
246 if (hr != DS_OK) {
247 IDirectSoundCapture_Release(pDSC8);
248 pDSC8 = 0;
249 }
250 }
251
252 *ppDSC8 = pDSC8;
253
254 return hr;
255 }
256
257 /***************************************************************************
258 * DirectSoundCaptureEnumerateA [DSOUND.7]
259 *
260 * Enumerate all DirectSound drivers installed in the system.
261 *
262 * PARAMS
263 * lpDSEnumCallback [I] Address of callback function.
264 * lpContext [I] Address of user defined context passed to callback function.
265 *
266 * RETURNS
267 * Success: DS_OK
268 * Failure: DSERR_INVALIDPARAM
269 */
270 HRESULT WINAPI
271 DirectSoundCaptureEnumerateA(
272 LPDSENUMCALLBACKA lpDSEnumCallback,
273 LPVOID lpContext)
274 {
275 unsigned devs, wid;
276 DSDRIVERDESC desc;
277 GUID guid;
278 int err;
279
280 TRACE("(%p,%p)\n", lpDSEnumCallback, lpContext );
281
282 if (lpDSEnumCallback == NULL) {
283 WARN("invalid parameter: lpDSEnumCallback == NULL\n");
284 return DSERR_INVALIDPARAM;
285 }
286
287 devs = waveInGetNumDevs();
288 if (devs > 0) {
289 if (GetDeviceID(&DSDEVID_DefaultCapture, &guid) == DS_OK) {
290 for (wid = 0; wid < devs; ++wid) {
291 if (IsEqualGUID( &guid, &DSOUND_capture_guids[wid] ) ) {
292 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0));
293 if (err == DS_OK) {
294 TRACE("calling lpDSEnumCallback(NULL,\"%s\",\"%s\",%p)\n",
295 "Primary Sound Capture Driver",desc.szDrvname,lpContext);
296 if (lpDSEnumCallback(NULL, "Primary Sound Capture Driver", desc.szDrvname, lpContext) == FALSE)
297 return DS_OK;
298 }
299 }
300 }
301 }
302 }
303
304 for (wid = 0; wid < devs; ++wid) {
305 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0));
306 if (err == DS_OK) {
307 TRACE("calling lpDSEnumCallback(%s,\"%s\",\"%s\",%p)\n",
308 debugstr_guid(&DSOUND_capture_guids[wid]),desc.szDesc,desc.szDrvname,lpContext);
309 if (lpDSEnumCallback(&DSOUND_capture_guids[wid], desc.szDesc, desc.szDrvname, lpContext) == FALSE)
310 return DS_OK;
311 }
312 }
313
314 return DS_OK;
315 }
316
317 /***************************************************************************
318 * DirectSoundCaptureEnumerateW [DSOUND.8]
319 *
320 * Enumerate all DirectSound drivers installed in the system.
321 *
322 * PARAMS
323 * lpDSEnumCallback [I] Address of callback function.
324 * lpContext [I] Address of user defined context passed to callback function.
325 *
326 * RETURNS
327 * Success: DS_OK
328 * Failure: DSERR_INVALIDPARAM
329 */
330 HRESULT WINAPI
331 DirectSoundCaptureEnumerateW(
332 LPDSENUMCALLBACKW lpDSEnumCallback,
333 LPVOID lpContext)
334 {
335 unsigned devs, wid;
336 DSDRIVERDESC desc;
337 GUID guid;
338 int err;
339 WCHAR wDesc[MAXPNAMELEN];
340 WCHAR wName[MAXPNAMELEN];
341
342 TRACE("(%p,%p)\n", lpDSEnumCallback, lpContext );
343
344 if (lpDSEnumCallback == NULL) {
345 WARN("invalid parameter: lpDSEnumCallback == NULL\n");
346 return DSERR_INVALIDPARAM;
347 }
348
349 devs = waveInGetNumDevs();
350 if (devs > 0) {
351 if (GetDeviceID(&DSDEVID_DefaultCapture, &guid) == DS_OK) {
352 for (wid = 0; wid < devs; ++wid) {
353 if (IsEqualGUID( &guid, &DSOUND_capture_guids[wid] ) ) {
354 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0));
355 if (err == DS_OK) {
356 TRACE("calling lpDSEnumCallback(NULL,\"%s\",\"%s\",%p)\n",
357 "Primary Sound Capture Driver",desc.szDrvname,lpContext);
358 MultiByteToWideChar( CP_ACP, 0, "Primary Sound Capture Driver", -1,
359 wDesc, sizeof(wDesc)/sizeof(WCHAR) );
360 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1,
361 wName, sizeof(wName)/sizeof(WCHAR) );
362 if (lpDSEnumCallback(NULL, wDesc, wName, lpContext) == FALSE)
363 return DS_OK;
364 }
365 }
366 }
367 }
368 }
369
370 for (wid = 0; wid < devs; ++wid) {
371 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDDESC,(DWORD_PTR)&desc,0));
372 if (err == DS_OK) {
373 TRACE("calling lpDSEnumCallback(%s,\"%s\",\"%s\",%p)\n",
374 debugstr_guid(&DSOUND_capture_guids[wid]),desc.szDesc,desc.szDrvname,lpContext);
375 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1,
376 wDesc, sizeof(wDesc)/sizeof(WCHAR) );
377 MultiByteToWideChar( CP_ACP, 0, desc.szDrvname, -1,
378 wName, sizeof(wName)/sizeof(WCHAR) );
379 if (lpDSEnumCallback(&DSOUND_capture_guids[wid], wDesc, wName, lpContext) == FALSE)
380 return DS_OK;
381 }
382 }
383
384 return DS_OK;
385 }
386
387 static void capture_CheckNotify(IDirectSoundCaptureBufferImpl *This, DWORD from, DWORD len)
388 {
389 int i;
390 for (i = 0; i < This->nrofnotifies; ++i) {
391 LPDSBPOSITIONNOTIFY event = This->notifies + i;
392 DWORD offset = event->dwOffset;
393 TRACE("checking %d, position %d, event = %p\n", i, offset, event->hEventNotify);
394
395 if (offset == DSBPN_OFFSETSTOP) {
396 if (!from && !len) {
397 SetEvent(event->hEventNotify);
398 TRACE("signalled event %p (%d)\n", event->hEventNotify, i);
399 return;
400 }
401 else return;
402 }
403
404 if (offset >= from && offset < (from + len))
405 {
406 TRACE("signalled event %p (%d)\n", event->hEventNotify, i);
407 SetEvent(event->hEventNotify);
408 }
409 }
410 }
411
412 static void CALLBACK
413 DSOUND_capture_callback(HWAVEIN hwi, UINT msg, DWORD_PTR dwUser, DWORD_PTR dw1,
414 DWORD_PTR dw2)
415 {
416 DirectSoundCaptureDevice * This = (DirectSoundCaptureDevice*)dwUser;
417 IDirectSoundCaptureBufferImpl * Moi = This->capture_buffer;
418 TRACE("(%p,%08x(%s),%08lx,%08lx,%08lx) entering at %d\n",hwi,msg,
419 msg == MM_WIM_OPEN ? "MM_WIM_OPEN" : msg == MM_WIM_CLOSE ? "MM_WIM_CLOSE" :
420 msg == MM_WIM_DATA ? "MM_WIM_DATA" : "UNKNOWN",dwUser,dw1,dw2,GetTickCount());
421
422 if (msg == MM_WIM_DATA) {
423 EnterCriticalSection( &(This->lock) );
424 TRACE("DirectSoundCapture msg=MM_WIM_DATA, old This->state=%s, old This->index=%d\n",
425 captureStateString[This->state],This->index);
426 if (This->state != STATE_STOPPED) {
427 int index = This->index;
428 if (This->state == STATE_STARTING)
429 This->state = STATE_CAPTURING;
430 capture_CheckNotify(Moi, (DWORD_PTR)This->pwave[index].lpData - (DWORD_PTR)This->buffer, This->pwave[index].dwBufferLength);
431 This->index = (This->index + 1) % This->nrofpwaves;
432 if ( (This->index == 0) && !(This->capture_buffer->flags & DSCBSTART_LOOPING) ) {
433 TRACE("end of buffer\n");
434 This->state = STATE_STOPPED;
435 capture_CheckNotify(Moi, 0, 0);
436 } else {
437 if (This->state == STATE_CAPTURING) {
438 waveInUnprepareHeader(hwi, &(This->pwave[index]), sizeof(WAVEHDR));
439 waveInPrepareHeader(hwi, &(This->pwave[index]), sizeof(WAVEHDR));
440 waveInAddBuffer(hwi, &(This->pwave[index]), sizeof(WAVEHDR));
441 } else if (This->state == STATE_STOPPING) {
442 TRACE("stopping\n");
443 This->state = STATE_STOPPED;
444 }
445 }
446 }
447 TRACE("DirectSoundCapture new This->state=%s, new This->index=%d\n",
448 captureStateString[This->state],This->index);
449 LeaveCriticalSection( &(This->lock) );
450 }
451
452 TRACE("completed\n");
453 }
454
455 /***************************************************************************
456 * IDirectSoundCaptureImpl
457 */
458 static HRESULT WINAPI
459 IDirectSoundCaptureImpl_QueryInterface(
460 LPDIRECTSOUNDCAPTURE iface,
461 REFIID riid,
462 LPVOID* ppobj )
463 {
464 IDirectSoundCaptureImpl *This = (IDirectSoundCaptureImpl *)iface;
465 TRACE( "(%p,%s,%p)\n", This, debugstr_guid(riid), ppobj );
466
467 if (ppobj == NULL) {
468 WARN("invalid parameter\n");
469 return E_INVALIDARG;
470 }
471
472 *ppobj = NULL;
473
474 if (IsEqualIID(riid, &IID_IUnknown)) {
475 IDirectSoundCapture_AddRef((LPDIRECTSOUNDCAPTURE)This);
476 *ppobj = This;
477 return DS_OK;
478 } else if (IsEqualIID(riid, &IID_IDirectSoundCapture)) {
479 IDirectSoundCapture_AddRef((LPDIRECTSOUNDCAPTURE)This);
480 *ppobj = This;
481 return DS_OK;
482 }
483
484 WARN("unsupported riid: %s\n", debugstr_guid(riid));
485 return E_NOINTERFACE;
486 }
487
488 static ULONG WINAPI
489 IDirectSoundCaptureImpl_AddRef( LPDIRECTSOUNDCAPTURE iface )
490 {
491 IDirectSoundCaptureImpl *This = (IDirectSoundCaptureImpl *)iface;
492 ULONG ref = InterlockedIncrement(&(This->ref));
493 TRACE("(%p) ref was %d\n", This, ref - 1);
494 return ref;
495 }
496
497 static ULONG WINAPI
498 IDirectSoundCaptureImpl_Release( LPDIRECTSOUNDCAPTURE iface )
499 {
500 IDirectSoundCaptureImpl *This = (IDirectSoundCaptureImpl *)iface;
501 ULONG ref = InterlockedDecrement(&(This->ref));
502 TRACE("(%p) ref was %d\n", This, ref + 1);
503
504 if (!ref) {
505 if (This->device)
506 DirectSoundCaptureDevice_Release(This->device);
507
508 HeapFree( GetProcessHeap(), 0, This );
509 TRACE("(%p) released\n", This);
510 }
511 return ref;
512 }
513
514 HRESULT WINAPI IDirectSoundCaptureImpl_CreateCaptureBuffer(
515 LPDIRECTSOUNDCAPTURE iface,
516 LPCDSCBUFFERDESC lpcDSCBufferDesc,
517 LPDIRECTSOUNDCAPTUREBUFFER* lplpDSCaptureBuffer,
518 LPUNKNOWN pUnk )
519 {
520 HRESULT hr;
521 IDirectSoundCaptureImpl *This = (IDirectSoundCaptureImpl *)iface;
522
523 TRACE( "(%p,%p,%p,%p)\n",iface,lpcDSCBufferDesc,lplpDSCaptureBuffer,pUnk);
524
525 if (lpcDSCBufferDesc == NULL) {
526 WARN("invalid parameter: lpcDSCBufferDesc == NULL)\n");
527 return DSERR_INVALIDPARAM;
528 }
529
530 if (lplpDSCaptureBuffer == NULL) {
531 WARN("invalid parameter: lplpDSCaptureBuffer == NULL\n");
532 return DSERR_INVALIDPARAM;
533 }
534
535 if (pUnk != NULL) {
536 WARN("invalid parameter: pUnk != NULL\n");
537 return DSERR_INVALIDPARAM;
538 }
539
540 /* FIXME: We can only have one buffer so what do we do here? */
541 if (This->device->capture_buffer) {
542 WARN("lnvalid parameter: already has buffer\n");
543 return DSERR_INVALIDPARAM; /* DSERR_GENERIC ? */
544 }
545
546 hr = IDirectSoundCaptureBufferImpl_Create(This->device,
547 (IDirectSoundCaptureBufferImpl **)lplpDSCaptureBuffer, lpcDSCBufferDesc);
548
549 if (hr != DS_OK)
550 WARN("IDirectSoundCaptureBufferImpl_Create failed\n");
551
552 return hr;
553 }
554
555 HRESULT WINAPI IDirectSoundCaptureImpl_GetCaps(
556 LPDIRECTSOUNDCAPTURE iface,
557 LPDSCCAPS lpDSCCaps )
558 {
559 IDirectSoundCaptureImpl *This = (IDirectSoundCaptureImpl *)iface;
560 TRACE("(%p,%p)\n",This,lpDSCCaps);
561
562 if (This->device == NULL) {
563 WARN("not initialized\n");
564 return DSERR_UNINITIALIZED;
565 }
566
567 if (lpDSCCaps== NULL) {
568 WARN("invalid parameter: lpDSCCaps== NULL\n");
569 return DSERR_INVALIDPARAM;
570 }
571
572 if (lpDSCCaps->dwSize < sizeof(*lpDSCCaps)) {
573 WARN("invalid parameter: lpDSCCaps->dwSize = %d\n", lpDSCCaps->dwSize);
574 return DSERR_INVALIDPARAM;
575 }
576
577 lpDSCCaps->dwFlags = This->device->drvcaps.dwFlags;
578 lpDSCCaps->dwFormats = This->device->drvcaps.dwFormats;
579 lpDSCCaps->dwChannels = This->device->drvcaps.dwChannels;
580
581 TRACE("(flags=0x%08x,format=0x%08x,channels=%d)\n",lpDSCCaps->dwFlags,
582 lpDSCCaps->dwFormats, lpDSCCaps->dwChannels);
583
584 return DS_OK;
585 }
586
587 HRESULT WINAPI IDirectSoundCaptureImpl_Initialize(
588 LPDIRECTSOUNDCAPTURE iface,
589 LPCGUID lpcGUID )
590 {
591 IDirectSoundCaptureImpl *This = (IDirectSoundCaptureImpl *)iface;
592 TRACE("(%p,%s)\n", This, debugstr_guid(lpcGUID));
593
594 if (This->device != NULL) {
595 WARN("already initialized\n");
596 return DSERR_ALREADYINITIALIZED;
597 }
598 return DirectSoundCaptureDevice_Initialize(&This->device, lpcGUID);
599 }
600
601 static const IDirectSoundCaptureVtbl dscvt =
602 {
603 /* IUnknown methods */
604 IDirectSoundCaptureImpl_QueryInterface,
605 IDirectSoundCaptureImpl_AddRef,
606 IDirectSoundCaptureImpl_Release,
607
608 /* IDirectSoundCapture methods */
609 IDirectSoundCaptureImpl_CreateCaptureBuffer,
610 IDirectSoundCaptureImpl_GetCaps,
611 IDirectSoundCaptureImpl_Initialize
612 };
613
614 static HRESULT IDirectSoundCaptureImpl_Create(
615 LPDIRECTSOUNDCAPTURE8 * ppDSC)
616 {
617 IDirectSoundCaptureImpl *pDSC;
618 TRACE("(%p)\n", ppDSC);
619
620 /* Allocate memory */
621 pDSC = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectSoundCaptureImpl));
622 if (pDSC == NULL) {
623 WARN("out of memory\n");
624 *ppDSC = NULL;
625 return DSERR_OUTOFMEMORY;
626 }
627
628 pDSC->lpVtbl = &dscvt;
629 pDSC->ref = 0;
630 pDSC->device = NULL;
631
632 *ppDSC = (LPDIRECTSOUNDCAPTURE8)pDSC;
633
634 return DS_OK;
635 }
636
637 /*******************************************************************************
638 * IDirectSoundCaptureNotify
639 */
640 static HRESULT WINAPI IDirectSoundCaptureNotifyImpl_QueryInterface(
641 LPDIRECTSOUNDNOTIFY iface,
642 REFIID riid,
643 LPVOID *ppobj)
644 {
645 IDirectSoundCaptureNotifyImpl *This = (IDirectSoundCaptureNotifyImpl *)iface;
646 TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
647
648 if (This->dscb == NULL) {
649 WARN("invalid parameter\n");
650 return E_INVALIDARG;
651 }
652
653 return IDirectSoundCaptureBuffer_QueryInterface((LPDIRECTSOUNDCAPTUREBUFFER)This->dscb, riid, ppobj);
654 }
655
656 static ULONG WINAPI IDirectSoundCaptureNotifyImpl_AddRef(LPDIRECTSOUNDNOTIFY iface)
657 {
658 IDirectSoundCaptureNotifyImpl *This = (IDirectSoundCaptureNotifyImpl *)iface;
659 ULONG ref = InterlockedIncrement(&(This->ref));
660 TRACE("(%p) ref was %d\n", This, ref - 1);
661 return ref;
662 }
663
664 static ULONG WINAPI IDirectSoundCaptureNotifyImpl_Release(LPDIRECTSOUNDNOTIFY iface)
665 {
666 IDirectSoundCaptureNotifyImpl *This = (IDirectSoundCaptureNotifyImpl *)iface;
667 ULONG ref = InterlockedDecrement(&(This->ref));
668 TRACE("(%p) ref was %d\n", This, ref + 1);
669
670 if (!ref) {
671 if (This->dscb->hwnotify)
672 IDsDriverNotify_Release(This->dscb->hwnotify);
673 This->dscb->notify=NULL;
674 IDirectSoundCaptureBuffer_Release((LPDIRECTSOUNDCAPTUREBUFFER)This->dscb);
675 HeapFree(GetProcessHeap(),0,This);
676 TRACE("(%p) released\n", This);
677 }
678 return ref;
679 }
680
681 static HRESULT WINAPI IDirectSoundCaptureNotifyImpl_SetNotificationPositions(
682 LPDIRECTSOUNDNOTIFY iface,
683 DWORD howmuch,
684 LPCDSBPOSITIONNOTIFY notify)
685 {
686 IDirectSoundCaptureNotifyImpl *This = (IDirectSoundCaptureNotifyImpl *)iface;
687 TRACE("(%p,0x%08x,%p)\n",This,howmuch,notify);
688
689 if (howmuch > 0 && notify == NULL) {
690 WARN("invalid parameter: notify == NULL\n");
691 return DSERR_INVALIDPARAM;
692 }
693
694 if (TRACE_ON(dsound)) {
695 unsigned int i;
696 for (i=0;i<howmuch;i++)
697 TRACE("notify at %d to %p\n",
698 notify[i].dwOffset,notify[i].hEventNotify);
699 }
700
701 if (This->dscb->hwnotify) {
702 HRESULT hres;
703 hres = IDsDriverNotify_SetNotificationPositions(This->dscb->hwnotify, howmuch, notify);
704 if (hres != DS_OK)
705 WARN("IDsDriverNotify_SetNotificationPositions failed\n");
706 return hres;
707 } else if (howmuch > 0) {
708 /* Make an internal copy of the caller-supplied array.
709 * Replace the existing copy if one is already present. */
710 if (This->dscb->notifies)
711 This->dscb->notifies = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
712 This->dscb->notifies, howmuch * sizeof(DSBPOSITIONNOTIFY));
713 else
714 This->dscb->notifies = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
715 howmuch * sizeof(DSBPOSITIONNOTIFY));
716
717 if (This->dscb->notifies == NULL) {
718 WARN("out of memory\n");
719 return DSERR_OUTOFMEMORY;
720 }
721 CopyMemory(This->dscb->notifies, notify, howmuch * sizeof(DSBPOSITIONNOTIFY));
722 This->dscb->nrofnotifies = howmuch;
723 } else {
724 HeapFree(GetProcessHeap(), 0, This->dscb->notifies);
725 This->dscb->notifies = NULL;
726 This->dscb->nrofnotifies = 0;
727 }
728
729 return S_OK;
730 }
731
732 static const IDirectSoundNotifyVtbl dscnvt =
733 {
734 IDirectSoundCaptureNotifyImpl_QueryInterface,
735 IDirectSoundCaptureNotifyImpl_AddRef,
736 IDirectSoundCaptureNotifyImpl_Release,
737 IDirectSoundCaptureNotifyImpl_SetNotificationPositions,
738 };
739
740 static HRESULT IDirectSoundCaptureNotifyImpl_Create(
741 IDirectSoundCaptureBufferImpl *dscb,
742 IDirectSoundCaptureNotifyImpl **pdscn)
743 {
744 IDirectSoundCaptureNotifyImpl * dscn;
745 TRACE("(%p,%p)\n",dscb,pdscn);
746
747 dscn = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*dscn));
748
749 if (dscn == NULL) {
750 WARN("out of memory\n");
751 return DSERR_OUTOFMEMORY;
752 }
753
754 dscn->ref = 0;
755 dscn->lpVtbl = &dscnvt;
756 dscn->dscb = dscb;
757 dscb->notify = dscn;
758 IDirectSoundCaptureBuffer_AddRef((LPDIRECTSOUNDCAPTUREBUFFER)dscb);
759
760 *pdscn = dscn;
761 return DS_OK;
762 }
763
764 /*******************************************************************************
765 * IDirectSoundCaptureBuffer
766 */
767 static HRESULT WINAPI
768 IDirectSoundCaptureBufferImpl_QueryInterface(
769 LPDIRECTSOUNDCAPTUREBUFFER8 iface,
770 REFIID riid,
771 LPVOID* ppobj )
772 {
773 IDirectSoundCaptureBufferImpl *This = (IDirectSoundCaptureBufferImpl *)iface;
774 HRESULT hres;
775 TRACE( "(%p,%s,%p)\n", This, debugstr_guid(riid), ppobj );
776
777 if (ppobj == NULL) {
778 WARN("invalid parameter\n");
779 return E_INVALIDARG;
780 }
781
782 *ppobj = NULL;
783
784 if ( IsEqualGUID( &IID_IDirectSoundNotify, riid ) ) {
785 if (!This->notify)
786 hres = IDirectSoundCaptureNotifyImpl_Create(This, &This->notify);
787 if (This->notify) {
788 IDirectSoundNotify_AddRef((LPDIRECTSOUNDNOTIFY)This->notify);
789 if (This->device->hwbuf && !This->hwnotify) {
790 hres = IDsCaptureDriverBuffer_QueryInterface(This->device->hwbuf,
791 &IID_IDsDriverNotify, (LPVOID*)&(This->hwnotify));
792 if (hres != DS_OK) {
793 WARN("IDsCaptureDriverBuffer_QueryInterface failed\n");
794 IDirectSoundNotify_Release((LPDIRECTSOUNDNOTIFY)This->notify);
795 *ppobj = 0;
796 return hres;
797 }
798 }
799
800 *ppobj = This->notify;
801 return DS_OK;
802 }
803
804 WARN("IID_IDirectSoundNotify\n");
805 return E_FAIL;
806 }
807
808 if ( IsEqualGUID( &IID_IDirectSoundCaptureBuffer, riid ) ||
809 IsEqualGUID( &IID_IDirectSoundCaptureBuffer8, riid ) ) {
810 IDirectSoundCaptureBuffer8_AddRef(iface);
811 *ppobj = This;
812 return NO_ERROR;
813 }
814
815 FIXME("(%p,%s,%p) unsupported GUID\n", This, debugstr_guid(riid), ppobj);
816 return E_NOINTERFACE;
817 }
818
819 static ULONG WINAPI
820 IDirectSoundCaptureBufferImpl_AddRef( LPDIRECTSOUNDCAPTUREBUFFER8 iface )
821 {
822 IDirectSoundCaptureBufferImpl *This = (IDirectSoundCaptureBufferImpl *)iface;
823 ULONG ref = InterlockedIncrement(&(This->ref));
824 TRACE("(%p) ref was %d\n", This, ref - 1);
825 return ref;
826 }
827
828 static ULONG WINAPI
829 IDirectSoundCaptureBufferImpl_Release( LPDIRECTSOUNDCAPTUREBUFFER8 iface )
830 {
831 IDirectSoundCaptureBufferImpl *This = (IDirectSoundCaptureBufferImpl *)iface;
832 ULONG ref = InterlockedDecrement(&(This->ref));
833 TRACE("(%p) ref was %d\n", This, ref + 1);
834
835 if (!ref) {
836 TRACE("deleting object\n");
837 if (This->device->state == STATE_CAPTURING)
838 This->device->state = STATE_STOPPING;
839
840 HeapFree(GetProcessHeap(),0, This->pdscbd);
841
842 if (This->device->hwi) {
843 waveInReset(This->device->hwi);
844 waveInClose(This->device->hwi);
845 HeapFree(GetProcessHeap(),0, This->device->pwave);
846 This->device->pwave = 0;
847 This->device->hwi = 0;
848 }
849
850 if (This->device->hwbuf)
851 IDsCaptureDriverBuffer_Release(This->device->hwbuf);
852
853 /* remove from DirectSoundCaptureDevice */
854 This->device->capture_buffer = NULL;
855
856 if (This->notify)
857 IDirectSoundNotify_Release((LPDIRECTSOUNDNOTIFY)This->notify);
858
859 /* If driver manages its own buffer, IDsCaptureDriverBuffer_Release
860 should have freed the buffer. Prevent freeing it again in
861 IDirectSoundCaptureBufferImpl_Create */
862 if (!(This->device->drvdesc.dwFlags & DSDDESC_USESYSTEMMEMORY))
863 This->device->buffer = NULL;
864
865 HeapFree(GetProcessHeap(), 0, This->notifies);
866 HeapFree( GetProcessHeap(), 0, This );
867 TRACE("(%p) released\n", This);
868 }
869 return ref;
870 }
871
872 static HRESULT WINAPI
873 IDirectSoundCaptureBufferImpl_GetCaps(
874 LPDIRECTSOUNDCAPTUREBUFFER8 iface,
875 LPDSCBCAPS lpDSCBCaps )
876 {
877 IDirectSoundCaptureBufferImpl *This = (IDirectSoundCaptureBufferImpl *)iface;
878 TRACE( "(%p,%p)\n", This, lpDSCBCaps );
879
880 if (lpDSCBCaps == NULL) {
881 WARN("invalid parameter: lpDSCBCaps == NULL\n");
882 return DSERR_INVALIDPARAM;
883 }
884
885 if (lpDSCBCaps->dwSize < sizeof(DSCBCAPS)) {
886 WARN("invalid parameter: lpDSCBCaps->dwSize = %d\n", lpDSCBCaps->dwSize);
887 return DSERR_INVALIDPARAM;
888 }
889
890 if (This->device == NULL) {
891 WARN("invalid parameter: This->device == NULL\n");
892 return DSERR_INVALIDPARAM;
893 }
894
895 lpDSCBCaps->dwSize = sizeof(DSCBCAPS);
896 lpDSCBCaps->dwFlags = This->flags;
897 lpDSCBCaps->dwBufferBytes = This->pdscbd->dwBufferBytes;
898 lpDSCBCaps->dwReserved = 0;
899
900 TRACE("returning DS_OK\n");
901 return DS_OK;
902 }
903
904 static HRESULT WINAPI
905 IDirectSoundCaptureBufferImpl_GetCurrentPosition(
906 LPDIRECTSOUNDCAPTUREBUFFER8 iface,
907 LPDWORD lpdwCapturePosition,
908 LPDWORD lpdwReadPosition )
909 {
910 IDirectSoundCaptureBufferImpl *This = (IDirectSoundCaptureBufferImpl *)iface;
911 HRESULT hres = DS_OK;
912 TRACE( "(%p,%p,%p)\n", This, lpdwCapturePosition, lpdwReadPosition );
913
914 if (This->device == NULL) {
915 WARN("invalid parameter: This->device == NULL\n");
916 return DSERR_INVALIDPARAM;
917 }
918
919 if (This->device->driver) {
920 hres = IDsCaptureDriverBuffer_GetPosition(This->device->hwbuf, lpdwCapturePosition, lpdwReadPosition );
921 if (hres != DS_OK)
922 WARN("IDsCaptureDriverBuffer_GetPosition failed\n");
923 } else if (This->device->hwi) {
924 DWORD pos;
925
926 EnterCriticalSection(&This->device->lock);
927 pos = (DWORD_PTR)This->device->pwave[This->device->index].lpData - (DWORD_PTR)This->device->buffer;
928 if (lpdwCapturePosition)
929 *lpdwCapturePosition = (This->device->pwave[This->device->index].dwBufferLength + pos) % This->device->buflen;
930 if (lpdwReadPosition)
931 *lpdwReadPosition = pos;
932 LeaveCriticalSection(&This->device->lock);
933
934 } else {
935 WARN("no driver\n");
936 hres = DSERR_NODRIVER;
937 }
938
939 TRACE("cappos=%d readpos=%d\n", (lpdwCapturePosition?*lpdwCapturePosition:-1), (lpdwReadPosition?*lpdwReadPosition:-1));
940 TRACE("returning %08x\n", hres);
941 return hres;
942 }
943
944 static HRESULT WINAPI
945 IDirectSoundCaptureBufferImpl_GetFormat(
946 LPDIRECTSOUNDCAPTUREBUFFER8 iface,
947 LPWAVEFORMATEX lpwfxFormat,
948 DWORD dwSizeAllocated,
949 LPDWORD lpdwSizeWritten )
950 {
951 IDirectSoundCaptureBufferImpl *This = (IDirectSoundCaptureBufferImpl *)iface;
952 HRESULT hres = DS_OK;
953 TRACE( "(%p,%p,0x%08x,%p)\n", This, lpwfxFormat, dwSizeAllocated,
954 lpdwSizeWritten );
955
956 if (This->device == NULL) {
957 WARN("invalid parameter: This->device == NULL\n");
958 return DSERR_INVALIDPARAM;
959 }
960
961 if (dwSizeAllocated > (sizeof(WAVEFORMATEX) + This->device->pwfx->cbSize))
962 dwSizeAllocated = sizeof(WAVEFORMATEX) + This->device->pwfx->cbSize;
963
964 if (lpwfxFormat) { /* NULL is valid (just want size) */
965 CopyMemory(lpwfxFormat, This->device->pwfx, dwSizeAllocated);
966 if (lpdwSizeWritten)
967 *lpdwSizeWritten = dwSizeAllocated;
968 } else {
969 if (lpdwSizeWritten)
970 *lpdwSizeWritten = sizeof(WAVEFORMATEX) + This->device->pwfx->cbSize;
971 else {
972 TRACE("invalid parameter: lpdwSizeWritten = NULL\n");
973 hres = DSERR_INVALIDPARAM;
974 }
975 }
976
977 TRACE("returning %08x\n", hres);
978 return hres;
979 }
980
981 static HRESULT WINAPI
982 IDirectSoundCaptureBufferImpl_GetStatus(
983 LPDIRECTSOUNDCAPTUREBUFFER8 iface,
984 LPDWORD lpdwStatus )
985 {
986 IDirectSoundCaptureBufferImpl *This = (IDirectSoundCaptureBufferImpl *)iface;
987 TRACE( "(%p, %p), thread is %04x\n", This, lpdwStatus, GetCurrentThreadId() );
988
989 if (This->device == NULL) {
990 WARN("invalid parameter: This->device == NULL\n");
991 return DSERR_INVALIDPARAM;
992 }
993
994 if (lpdwStatus == NULL) {
995 WARN("invalid parameter: lpdwStatus == NULL\n");
996 return DSERR_INVALIDPARAM;
997 }
998
999 *lpdwStatus = 0;
1000 EnterCriticalSection(&(This->device->lock));
1001
1002 TRACE("old This->device->state=%s, old lpdwStatus=%08x\n",
1003 captureStateString[This->device->state],*lpdwStatus);
1004 if ((This->device->state == STATE_STARTING) ||
1005 (This->device->state == STATE_CAPTURING)) {
1006 *lpdwStatus |= DSCBSTATUS_CAPTURING;
1007 if (This->flags & DSCBSTART_LOOPING)
1008 *lpdwStatus |= DSCBSTATUS_LOOPING;
1009 }
1010 TRACE("new This->device->state=%s, new lpdwStatus=%08x\n",
1011 captureStateString[This->device->state],*lpdwStatus);
1012 LeaveCriticalSection(&(This->device->lock));
1013
1014 TRACE("status=%x\n", *lpdwStatus);
1015 TRACE("returning DS_OK\n");
1016 return DS_OK;
1017 }
1018
1019 static HRESULT WINAPI
1020 IDirectSoundCaptureBufferImpl_Initialize(
1021 LPDIRECTSOUNDCAPTUREBUFFER8 iface,
1022 LPDIRECTSOUNDCAPTURE lpDSC,
1023 LPCDSCBUFFERDESC lpcDSCBDesc )
1024 {
1025 IDirectSoundCaptureBufferImpl *This = (IDirectSoundCaptureBufferImpl *)iface;
1026
1027 FIXME( "(%p,%p,%p): stub\n", This, lpDSC, lpcDSCBDesc );
1028
1029 return DS_OK;
1030 }
1031
1032 static HRESULT WINAPI
1033 IDirectSoundCaptureBufferImpl_Lock(
1034 LPDIRECTSOUNDCAPTUREBUFFER8 iface,
1035 DWORD dwReadCusor,
1036 DWORD dwReadBytes,
1037 LPVOID* lplpvAudioPtr1,
1038 LPDWORD lpdwAudioBytes1,
1039 LPVOID* lplpvAudioPtr2,
1040 LPDWORD lpdwAudioBytes2,
1041 DWORD dwFlags )
1042 {
1043 HRESULT hres = DS_OK;
1044 IDirectSoundCaptureBufferImpl *This = (IDirectSoundCaptureBufferImpl *)iface;
1045 TRACE( "(%p,%08u,%08u,%p,%p,%p,%p,0x%08x) at %d\n", This, dwReadCusor,
1046 dwReadBytes, lplpvAudioPtr1, lpdwAudioBytes1, lplpvAudioPtr2,
1047 lpdwAudioBytes2, dwFlags, GetTickCount() );
1048
1049 if (This->device == NULL) {
1050 WARN("invalid parameter: This->device == NULL\n");
1051 return DSERR_INVALIDPARAM;
1052 }
1053
1054 if (lplpvAudioPtr1 == NULL) {
1055 WARN("invalid parameter: lplpvAudioPtr1 == NULL\n");
1056 return DSERR_INVALIDPARAM;
1057 }
1058
1059 if (lpdwAudioBytes1 == NULL) {
1060 WARN("invalid parameter: lpdwAudioBytes1 == NULL\n");
1061 return DSERR_INVALIDPARAM;
1062 }
1063
1064 EnterCriticalSection(&(This->device->lock));
1065
1066 if (This->device->driver) {
1067 hres = IDsCaptureDriverBuffer_Lock(This->device->hwbuf, lplpvAudioPtr1,
1068 lpdwAudioBytes1, lplpvAudioPtr2,
1069 lpdwAudioBytes2, dwReadCusor,
1070 dwReadBytes, dwFlags);
1071 if (hres != DS_OK)
1072 WARN("IDsCaptureDriverBuffer_Lock failed\n");
1073 } else if (This->device->hwi) {
1074 *lplpvAudioPtr1 = This->device->buffer + dwReadCusor;
1075 if ( (dwReadCusor + dwReadBytes) > This->device->buflen) {
1076 *lpdwAudioBytes1 = This->device->buflen - dwReadCusor;
1077 if (lplpvAudioPtr2)
1078 *lplpvAudioPtr2 = This->device->buffer;
1079 if (lpdwAudioBytes2)
1080 *lpdwAudioBytes2 = dwReadBytes - *lpdwAudioBytes1;
1081 } else {
1082 *lpdwAudioBytes1 = dwReadBytes;
1083 if (lplpvAudioPtr2)
1084 *lplpvAudioPtr2 = 0;
1085 if (lpdwAudioBytes2)
1086 *lpdwAudioBytes2 = 0;
1087 }
1088 } else {
1089 TRACE("invalid call\n");
1090 hres = DSERR_INVALIDCALL; /* DSERR_NODRIVER ? */
1091 }
1092
1093 LeaveCriticalSection(&(This->device->lock));
1094
1095 TRACE("returning %08x\n", hres);
1096 return hres;
1097 }
1098
1099 static HRESULT WINAPI
1100 IDirectSoundCaptureBufferImpl_Start(
1101 LPDIRECTSOUNDCAPTUREBUFFER8 iface,
1102 DWORD dwFlags )
1103 {
1104 HRESULT hres = DS_OK;
1105 IDirectSoundCaptureBufferImpl *This = (IDirectSoundCaptureBufferImpl *)iface;
1106 TRACE( "(%p,0x%08x)\n", This, dwFlags );
1107
1108 if (This->device == NULL) {
1109 WARN("invalid parameter: This->device == NULL\n");
1110 return DSERR_INVALIDPARAM;
1111 }
1112
1113 if ( (This->device->driver == 0) && (This->device->hwi == 0) ) {
1114 WARN("no driver\n");
1115 return DSERR_NODRIVER;
1116 }
1117
1118 EnterCriticalSection(&(This->device->lock));
1119
1120 This->flags = dwFlags;
1121 TRACE("old This->state=%s\n",captureStateString[This->device->state]);
1122 if (This->device->state == STATE_STOPPED)
1123 This->device->state = STATE_STARTING;
1124 else if (This->device->state == STATE_STOPPING)
1125 This->device->state = STATE_CAPTURING;
1126 TRACE("new This->device->state=%s\n",captureStateString[This->device->state]);
1127
1128 LeaveCriticalSection(&(This->device->lock));
1129
1130 if (This->device->driver) {
1131 hres = IDsCaptureDriverBuffer_Start(This->device->hwbuf, dwFlags);
1132 if (hres != DS_OK)
1133 WARN("IDsCaptureDriverBuffer_Start failed\n");
1134 } else if (This->device->hwi) {
1135 DirectSoundCaptureDevice *device = This->device;
1136
1137 if (device->buffer) {
1138 int c;
1139 DWORD blocksize = DSOUND_fraglen(device->pwfx->nSamplesPerSec, device->pwfx->nBlockAlign);
1140 device->nrofpwaves = device->buflen / blocksize + !!(device->buflen % blocksize);
1141 TRACE("nrofpwaves=%d\n", device->nrofpwaves);
1142
1143 /* prepare headers */
1144 if (device->pwave)
1145 device->pwave = HeapReAlloc(GetProcessHeap(), 0,device->pwave, device->nrofpwaves*sizeof(WAVEHDR));
1146 else
1147 device->pwave = HeapAlloc(GetProcessHeap(), 0, device->nrofpwaves*sizeof(WAVEHDR));
1148
1149 for (c = 0; c < device->nrofpwaves; ++c) {
1150 device->pwave[c].lpData = (char *)device->buffer + c * blocksize;
1151 if (c + 1 == device->nrofpwaves)
1152 device->pwave[c].dwBufferLength = device->buflen - c * blocksize;
1153 else
1154 device->pwave[c].dwBufferLength = blocksize;
1155 device->pwave[c].dwBytesRecorded = 0;
1156 device->pwave[c].dwUser = (DWORD_PTR)device;
1157 device->pwave[c].dwFlags = 0;
1158 device->pwave[c].dwLoops = 0;
1159 hres = mmErr(waveInPrepareHeader(device->hwi, &(device->pwave[c]),sizeof(WAVEHDR)));
1160 if (hres != DS_OK) {
1161 WARN("waveInPrepareHeader failed\n");
1162 while (c--)
1163 waveInUnprepareHeader(device->hwi, &(device->pwave[c]),sizeof(WAVEHDR));
1164 break;
1165 }
1166
1167 hres = mmErr(waveInAddBuffer(device->hwi, &(device->pwave[c]), sizeof(WAVEHDR)));
1168 if (hres != DS_OK) {
1169 WARN("waveInAddBuffer failed\n");
1170 while (c--)
1171 waveInUnprepareHeader(device->hwi, &(device->pwave[c]),sizeof(WAVEHDR));
1172 break;
1173 }
1174 }
1175
1176 FillMemory(device->buffer, device->buflen, (device->pwfx->wBitsPerSample == 8) ? 128 : 0);
1177 }
1178
1179 device->index = 0;
1180
1181 if (hres == DS_OK) {
1182 /* start filling the first buffer */
1183 hres = mmErr(waveInStart(device->hwi));
1184 if (hres != DS_OK)
1185 WARN("waveInStart failed\n");
1186 }
1187
1188 if (hres != DS_OK) {
1189 WARN("calling waveInClose because of error\n");
1190 waveInClose(device->hwi);
1191 device->hwi = 0;
1192 }
1193 } else {
1194 WARN("no driver\n");
1195 hres = DSERR_NODRIVER;
1196 }
1197
1198 TRACE("returning %08x\n", hres);
1199 return hres;
1200 }
1201
1202 static HRESULT WINAPI
1203 IDirectSoundCaptureBufferImpl_Stop( LPDIRECTSOUNDCAPTUREBUFFER8 iface )
1204 {
1205 HRESULT hres = DS_OK;
1206 IDirectSoundCaptureBufferImpl *This = (IDirectSoundCaptureBufferImpl *)iface;
1207 TRACE( "(%p)\n", This );
1208
1209 if (This->device == NULL) {
1210 WARN("invalid parameter: This->device == NULL\n");
1211 return DSERR_INVALIDPARAM;
1212 }
1213
1214 EnterCriticalSection(&(This->device->lock));
1215
1216 TRACE("old This->device->state=%s\n",captureStateString[This->device->state]);
1217 if (This->device->state == STATE_CAPTURING)
1218 This->device->state = STATE_STOPPING;
1219 else if (This->device->state == STATE_STARTING)
1220 This->device->state = STATE_STOPPED;
1221 TRACE("new This->device->state=%s\n",captureStateString[This->device->state]);
1222
1223 LeaveCriticalSection(&(This->device->lock));
1224
1225 if (This->device->driver) {
1226 hres = IDsCaptureDriverBuffer_Stop(This->device->hwbuf);
1227 if (hres != DS_OK)
1228 WARN("IDsCaptureDriverBuffer_Stop() failed\n");
1229 } else if (This->device->hwi) {
1230 hres = mmErr(waveInReset(This->device->hwi));
1231 if (hres != DS_OK)
1232 WARN("waveInReset() failed\n");
1233 } else {
1234 WARN("no driver\n");
1235 hres = DSERR_NODRIVER;
1236 }
1237
1238 TRACE("returning %08x\n", hres);
1239 return hres;
1240 }
1241
1242 static HRESULT WINAPI
1243 IDirectSoundCaptureBufferImpl_Unlock(
1244 LPDIRECTSOUNDCAPTUREBUFFER8 iface,
1245 LPVOID lpvAudioPtr1,
1246 DWORD dwAudioBytes1,
1247 LPVOID lpvAudioPtr2,
1248 DWORD dwAudioBytes2 )
1249 {
1250 HRESULT hres = DS_OK;
1251 IDirectSoundCaptureBufferImpl *This = (IDirectSoundCaptureBufferImpl *)iface;
1252 TRACE( "(%p,%p,%08u,%p,%08u)\n", This, lpvAudioPtr1, dwAudioBytes1,
1253 lpvAudioPtr2, dwAudioBytes2 );
1254
1255 if (lpvAudioPtr1 == NULL) {
1256 WARN("invalid parameter: lpvAudioPtr1 == NULL\n");
1257 return DSERR_INVALIDPARAM;
1258 }
1259
1260 if (This->device->driver) {
1261 hres = IDsCaptureDriverBuffer_Unlock(This->device->hwbuf, lpvAudioPtr1,
1262 dwAudioBytes1, lpvAudioPtr2, dwAudioBytes2);
1263 if (hres != DS_OK)
1264 WARN("IDsCaptureDriverBuffer_Unlock failed\n");
1265 } else if (!This->device->hwi) {
1266 WARN("invalid call\n");
1267 hres = DSERR_INVALIDCALL;
1268 }
1269
1270 TRACE("returning %08x\n", hres);
1271 return hres;
1272 }
1273
1274 static HRESULT WINAPI
1275 IDirectSoundCaptureBufferImpl_GetObjectInPath(
1276 LPDIRECTSOUNDCAPTUREBUFFER8 iface,
1277 REFGUID rguidObject,
1278 DWORD dwIndex,
1279 REFGUID rguidInterface,
1280 LPVOID* ppObject )
1281 {
1282 IDirectSoundCaptureBufferImpl *This = (IDirectSoundCaptureBufferImpl *)iface;
1283
1284 FIXME( "(%p,%s,%u,%s,%p): stub\n", This, debugstr_guid(rguidObject),
1285 dwIndex, debugstr_guid(rguidInterface), ppObject );
1286
1287 return DS_OK;
1288 }
1289
1290 static HRESULT WINAPI
1291 IDirectSoundCaptureBufferImpl_GetFXStatus(
1292 LPDIRECTSOUNDCAPTUREBUFFER8 iface,
1293 DWORD dwFXCount,
1294 LPDWORD pdwFXStatus )
1295 {
1296 IDirectSoundCaptureBufferImpl *This = (IDirectSoundCaptureBufferImpl *)iface;
1297
1298 FIXME( "(%p,%u,%p): stub\n", This, dwFXCount, pdwFXStatus );
1299
1300 return DS_OK;
1301 }
1302
1303 static const IDirectSoundCaptureBuffer8Vtbl dscbvt =
1304 {
1305 /* IUnknown methods */
1306 IDirectSoundCaptureBufferImpl_QueryInterface,
1307 IDirectSoundCaptureBufferImpl_AddRef,
1308 IDirectSoundCaptureBufferImpl_Release,
1309
1310 /* IDirectSoundCaptureBuffer methods */
1311 IDirectSoundCaptureBufferImpl_GetCaps,
1312 IDirectSoundCaptureBufferImpl_GetCurrentPosition,
1313 IDirectSoundCaptureBufferImpl_GetFormat,
1314 IDirectSoundCaptureBufferImpl_GetStatus,
1315 IDirectSoundCaptureBufferImpl_Initialize,
1316 IDirectSoundCaptureBufferImpl_Lock,
1317 IDirectSoundCaptureBufferImpl_Start,
1318 IDirectSoundCaptureBufferImpl_Stop,
1319 IDirectSoundCaptureBufferImpl_Unlock,
1320
1321 /* IDirectSoundCaptureBuffer methods */
1322 IDirectSoundCaptureBufferImpl_GetObjectInPath,
1323 IDirectSoundCaptureBufferImpl_GetFXStatus
1324 };
1325
1326 HRESULT IDirectSoundCaptureBufferImpl_Create(
1327 DirectSoundCaptureDevice *device,
1328 IDirectSoundCaptureBufferImpl ** ppobj,
1329 LPCDSCBUFFERDESC lpcDSCBufferDesc)
1330 {
1331 LPWAVEFORMATEX wfex;
1332 TRACE( "(%p,%p,%p)\n", device, ppobj, lpcDSCBufferDesc);
1333
1334 if (ppobj == NULL) {
1335 WARN("invalid parameter: ppobj == NULL\n");
1336 return DSERR_INVALIDPARAM;
1337 }
1338
1339 if (!device) {
1340 WARN("not initialized\n");
1341 *ppobj = NULL;
1342 return DSERR_UNINITIALIZED;
1343 }
1344
1345 if (lpcDSCBufferDesc == NULL) {
1346 WARN("invalid parameter: lpcDSCBufferDesc == NULL\n");
1347 *ppobj = NULL;
1348 return DSERR_INVALIDPARAM;
1349 }
1350
1351 if ( ((lpcDSCBufferDesc->dwSize != sizeof(DSCBUFFERDESC)) &&
1352 (lpcDSCBufferDesc->dwSize != sizeof(DSCBUFFERDESC1))) ||
1353 (lpcDSCBufferDesc->dwBufferBytes == 0) ||
1354 (lpcDSCBufferDesc->lpwfxFormat == NULL) ) { /* FIXME: DSERR_BADFORMAT ? */
1355 WARN("invalid lpcDSCBufferDesc\n");
1356 *ppobj = NULL;
1357 return DSERR_INVALIDPARAM;
1358 }
1359
1360 wfex = lpcDSCBufferDesc->lpwfxFormat;
1361
1362 TRACE("(formattag=0x%04x,chans=%d,samplerate=%d,"
1363 "bytespersec=%d,blockalign=%d,bitspersamp=%d,cbSize=%d)\n",
1364 wfex->wFormatTag, wfex->nChannels, wfex->nSamplesPerSec,
1365 wfex->nAvgBytesPerSec, wfex->nBlockAlign,
1366 wfex->wBitsPerSample, wfex->cbSize);
1367
1368 device->pwfx = DSOUND_CopyFormat(wfex);
1369 if ( device->pwfx == NULL ) {
1370 *ppobj = NULL;
1371 return DSERR_OUTOFMEMORY;
1372 }
1373
1374 *ppobj = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,
1375 sizeof(IDirectSoundCaptureBufferImpl));
1376
1377 if ( *ppobj == NULL ) {
1378 WARN("out of memory\n");
1379 *ppobj = NULL;
1380 return DSERR_OUTOFMEMORY;
1381 } else {
1382 HRESULT err = DS_OK;
1383 LPBYTE newbuf;
1384 DWORD buflen;
1385 IDirectSoundCaptureBufferImpl *This = *ppobj;
1386
1387 This->ref = 1;
1388 This->device = device;
1389 This->device->capture_buffer = This;
1390 This->notify = NULL;
1391 This->nrofnotifies = 0;
1392 This->hwnotify = NULL;
1393
1394 This->pdscbd = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,
1395 lpcDSCBufferDesc->dwSize);
1396 if (This->pdscbd)
1397 CopyMemory(This->pdscbd, lpcDSCBufferDesc, lpcDSCBufferDesc->dwSize);
1398 else {
1399 WARN("no memory\n");
1400 This->device->capture_buffer = 0;
1401 HeapFree( GetProcessHeap(), 0, This );
1402 *ppobj = NULL;
1403 return DSERR_OUTOFMEMORY;
1404 }
1405
1406 This->lpVtbl = &dscbvt;
1407
1408 if (device->driver) {
1409 if (This->device->drvdesc.dwFlags & DSDDESC_DOMMSYSTEMOPEN)
1410 FIXME("DSDDESC_DOMMSYSTEMOPEN not supported\n");
1411
1412 if (This->device->drvdesc.dwFlags & DSDDESC_USESYSTEMMEMORY) {
1413 /* allocate buffer from system memory */
1414 buflen = lpcDSCBufferDesc->dwBufferBytes;
1415 TRACE("desired buflen=%d, old buffer=%p\n", buflen, device->buffer);
1416 if (device->buffer)
1417 newbuf = HeapReAlloc(GetProcessHeap(),0,device->buffer,buflen);
1418 else
1419 newbuf = HeapAlloc(GetProcessHeap(),0,buflen);
1420
1421 if (newbuf == NULL) {
1422 WARN("failed to allocate capture buffer\n");
1423 err = DSERR_OUTOFMEMORY;
1424 /* but the old buffer might still exist and must be re-prepared */
1425 } else {
1426 device->buffer = newbuf;
1427 device->buflen = buflen;
1428 }
1429 } else {
1430 /* let driver allocate memory */
1431 device->buflen = lpcDSCBufferDesc->dwBufferBytes;
1432 /* FIXME: */
1433 HeapFree( GetProcessHeap(), 0, device->buffer);
1434 device->buffer = NULL;
1435 }
1436
1437 err = IDsCaptureDriver_CreateCaptureBuffer(device->driver,
1438 device->pwfx,0,0,&(device->buflen),&(device->buffer),(LPVOID*)&(device->hwbuf));
1439 if (err != DS_OK) {
1440 WARN("IDsCaptureDriver_CreateCaptureBuffer failed\n");
1441 This->device->capture_buffer = 0;
1442 HeapFree( GetProcessHeap(), 0, This );
1443 *ppobj = NULL;
1444 return err;
1445 }
1446 } else {
1447 DWORD flags = CALLBACK_FUNCTION;
1448 err = mmErr(waveInOpen(&(device->hwi),
1449 device->drvdesc.dnDevNode, device->pwfx,
1450 (DWORD_PTR)DSOUND_capture_callback, (DWORD_PTR)device, flags));
1451 if (err != DS_OK) {
1452 WARN("waveInOpen failed\n");
1453 This->device->capture_buffer = 0;
1454 HeapFree( GetProcessHeap(), 0, This );
1455 *ppobj = NULL;
1456 return err;
1457 }
1458
1459 buflen = lpcDSCBufferDesc->dwBufferBytes;
1460 TRACE("desired buflen=%d, old buffer=%p\n", buflen, device->buffer);
1461 if (device->buffer)
1462 newbuf = HeapReAlloc(GetProcessHeap(),0,device->buffer,buflen);
1463 else
1464 newbuf = HeapAlloc(GetProcessHeap(),0,buflen);
1465 if (newbuf == NULL) {
1466 WARN("failed to allocate capture buffer\n");
1467 err = DSERR_OUTOFMEMORY;
1468 /* but the old buffer might still exist and must be re-prepared */
1469 } else {
1470 device->buffer = newbuf;
1471 device->buflen = buflen;
1472 }
1473 }
1474 }
1475
1476 TRACE("returning DS_OK\n");
1477 return DS_OK;
1478 }
1479
1480 /*******************************************************************************
1481 * DirectSoundCaptureDevice
1482 */
1483 HRESULT DirectSoundCaptureDevice_Initialize(
1484 DirectSoundCaptureDevice ** ppDevice,
1485 LPCGUID lpcGUID)
1486 {
1487 HRESULT err = DSERR_INVALIDPARAM;
1488 unsigned wid, widn;
1489 BOOLEAN found = FALSE;
1490 GUID devGUID;
1491 DirectSoundCaptureDevice *device = *ppDevice;
1492 TRACE("(%p, %s)\n", ppDevice, debugstr_guid(lpcGUID));
1493
1494 /* Default device? */
1495 if ( !lpcGUID || IsEqualGUID(lpcGUID, &GUID_NULL) )
1496 lpcGUID = &DSDEVID_DefaultCapture;
1497
1498 if (GetDeviceID(lpcGUID, &devGUID) != DS_OK) {
1499 WARN("invalid parameter: lpcGUID\n");
1500 return DSERR_INVALIDPARAM;
1501 }
1502
1503 widn = waveInGetNumDevs();
1504 if (!widn) {
1505 WARN("no audio devices found\n");
1506 return DSERR_NODRIVER;
1507 }
1508
1509 /* enumerate WINMM audio devices and find the one we want */
1510 for (wid=0; wid<widn; wid++) {
1511 if (IsEqualGUID( &devGUID, &DSOUND_capture_guids[wid]) ) {
1512 found = TRUE;
1513 break;
1514 }
1515 }
1516
1517 if (found == FALSE) {
1518 WARN("No device found matching given ID!\n");
1519 return DSERR_NODRIVER;
1520 }
1521
1522 if (DSOUND_capture[wid]) {
1523 WARN("already in use\n");
1524 return DSERR_ALLOCATED;
1525 }
1526
1527 err = DirectSoundCaptureDevice_Create(&(device));
1528 if (err != DS_OK) {
1529 WARN("DirectSoundCaptureDevice_Create failed\n");
1530 return err;
1531 }
1532
1533 *ppDevice = device;
1534 device->guid = devGUID;
1535
1536 /* Disable the direct sound driver to force emulation if requested. */
1537 device->driver = NULL;
1538 if (ds_hw_accel != DS_HW_ACCEL_EMULATION)
1539 {
1540 err = mmErr(waveInMessage(UlongToHandle(wid),DRV_QUERYDSOUNDIFACE,(DWORD_PTR)&device->driver,0));
1541 if ( (err != DS_OK) && (err != DSERR_UNSUPPORTED) ) {
1542 WARN("waveInMessage failed; err=%x\n",err);
1543 return err;
1544 }
1545 }
1546 err = DS_OK;
1547
1548 /* Get driver description */
1549 if (device->driver) {
1550 TRACE("using DirectSound driver\n");
1551 err = IDsCaptureDriver_GetDriverDesc(device->driver, &(device->drvdesc));
1552 if (err != DS_OK) {
1553 WARN("IDsCaptureDriver_GetDriverDesc failed\n");
1554 return err;
1555 }
1556 } else {
1557 TRACE("using WINMM\n");
1558 /* if no DirectSound interface available, use WINMM API instead */
1559 device->drvdesc.dwFlags = DSDDESC_DOMMSYSTEMOPEN |
1560 DSDDESC_DOMMSYSTEMSETFORMAT;
1561 }
1562
1563 device->drvdesc.dnDevNode = wid;
1564
1565 /* open the DirectSound driver if available */
1566 if (device->driver && (err == DS_OK))
1567 err = IDsCaptureDriver_Open(device->driver);
1568
1569 if (err == DS_OK) {
1570 *ppDevice = device;
1571
1572 /* the driver is now open, so it's now allowed to call GetCaps */
1573 if (device->driver) {
1574 device->drvcaps.dwSize = sizeof(device->drvcaps);
1575 err = IDsCaptureDriver_GetCaps(device->driver,&(device->drvcaps));
1576 if (err != DS_OK) {
1577 WARN("IDsCaptureDriver_GetCaps failed\n");
1578 return err;
1579 }
1580 } else /*if (device->hwi)*/ {
1581 WAVEINCAPSA wic;
1582 err = mmErr(waveInGetDevCapsA((UINT)device->drvdesc.dnDevNode, &wic, sizeof(wic)));
1583
1584 if (err == DS_OK) {
1585 device->drvcaps.dwFlags = 0;
1586 lstrcpynA(device->drvdesc.szDrvname, wic.szPname,
1587 sizeof(device->drvdesc.szDrvname));
1588
1589 device->drvcaps.dwFlags |= DSCCAPS_EMULDRIVER;
1590 device->drvcaps.dwFormats = wic.dwFormats;
1591 device->drvcaps.dwChannels = wic.wChannels;
1592 }
1593 }
1594 }
1595
1596 return err;
1597 }
1598
1599 static HRESULT DirectSoundCaptureDevice_Create(
1600 DirectSoundCaptureDevice ** ppDevice)
1601 {
1602 DirectSoundCaptureDevice * device;
1603 TRACE("(%p)\n", ppDevice);
1604
1605 /* Allocate memory */
1606 device = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DirectSoundCaptureDevice));
1607
1608 if (device == NULL) {
1609 WARN("out of memory\n");
1610 return DSERR_OUTOFMEMORY;
1611 }
1612
1613 device->ref = 1;
1614 device->state = STATE_STOPPED;
1615
1616 InitializeCriticalSection( &(device->lock) );
1617 device->lock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": DirectSoundCaptureDevice.lock");
1618
1619 *ppDevice = device;
1620
1621 return DS_OK;
1622 }
1623
1624 ULONG DirectSoundCaptureDevice_Release(
1625 DirectSoundCaptureDevice * device)
1626 {
1627 ULONG ref = InterlockedDecrement(&(device->ref));
1628 TRACE("(%p) ref was %d\n", device, ref + 1);
1629
1630 if (!ref) {
1631 TRACE("deleting object\n");
1632 if (device->capture_buffer)
1633 IDirectSoundCaptureBufferImpl_Release(
1634 (LPDIRECTSOUNDCAPTUREBUFFER8) device->capture_buffer);
1635
1636 if (device->driver) {
1637 IDsCaptureDriver_Close(device->driver);
1638 IDsCaptureDriver_Release(device->driver);
1639 }
1640
1641 HeapFree(GetProcessHeap(), 0, device->pwfx);
1642 device->lock.DebugInfo->Spare[0] = 0;
1643 DeleteCriticalSection( &(device->lock) );
1644 DSOUND_capture[device->drvdesc.dnDevNode] = NULL;
1645 HeapFree(GetProcessHeap(), 0, device);
1646 TRACE("(%p) released\n", device);
1647 }
1648 return ref;
1649 }
1650
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.