?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
- TBN_DRAGOUT and NM_RDBLCLK notifications.
[wine.git] / dlls / dsound / capture.c
blob3245717dfe93c24356da4175fa549afd9ad2e88c
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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21 /*
22 * TODO:
23 * Implement DirectSoundFullDuplex support.
24 * Implement FX support.
25 */
26
27 #include "config.h"
28 #include <assert.h>
29 #include <stdarg.h>
30 #include <stdio.h>
31 #include <sys/types.h>
32 #include <sys/fcntl.h>
33 #ifdef HAVE_UNISTD_H
34 # include <unistd.h>
35 #endif
36 #include <stdlib.h>
37 #include <string.h>
38
39 #include "windef.h"
40 #include "winbase.h"
41 #include "wingdi.h"
42 #include "winuser.h"
43 #include "winerror.h"
44 #include "mmsystem.h"
45 #include "mmddk.h"
46 #include "winreg.h"
47 #include "winternl.h"
48 #include "winnls.h"
49 #include "wine/debug.h"
50 #include "dsound.h"
51 #include "dsdriver.h"
52 #include "dsound_private.h"
53
54 WINE_DEFAULT_DEBUG_CHANNEL(dsound);
55
56 static HRESULT WINAPI IDirectSoundCaptureImpl_Initialize(
57 LPDIRECTSOUNDCAPTURE iface,
58 LPCGUID lpcGUID );
59 static ULONG WINAPI IDirectSoundCaptureImpl_Release(
60 LPDIRECTSOUNDCAPTURE iface );
61 static ULONG WINAPI IDirectSoundCaptureBufferImpl_Release(
62 LPDIRECTSOUNDCAPTUREBUFFER8 iface );
63 static HRESULT DSOUND_CreateDirectSoundCaptureBuffer(
64 IDirectSoundCaptureImpl *ipDSC,
65 LPCDSCBUFFERDESC lpcDSCBufferDesc,
66 LPVOID* ppobj );
67 static HRESULT WINAPI IDirectSoundFullDuplexImpl_Initialize(
68 LPDIRECTSOUNDFULLDUPLEX iface,
69 LPCGUID pCaptureGuid,
70 LPCGUID pRendererGuid,
71 LPCDSCBUFFERDESC lpDscBufferDesc,
72 LPCDSBUFFERDESC lpDsBufferDesc,
73 HWND hWnd,
74 DWORD dwLevel,
75 LPLPDIRECTSOUNDCAPTUREBUFFER8 lplpDirectSoundCaptureBuffer8,
76 LPLPDIRECTSOUNDBUFFER8 lplpDirectSoundBuffer8 );
77
78 static ICOM_VTABLE(IDirectSoundCapture) dscvt;
79 static ICOM_VTABLE(IDirectSoundCaptureBuffer8) dscbvt;
80 static ICOM_VTABLE(IDirectSoundFullDuplex) dsfdvt;
81
82 static IDirectSoundCaptureImpl* dsound_capture = NULL;
83
84 static const char * captureStateString[] = {
85 "STATE_STOPPED",
86 "STATE_STARTING",
87 "STATE_CAPTURING",
88 "STATE_STOPPING"
89 };
90
91 /***************************************************************************
92 * DirectSoundCaptureCreate [DSOUND.6]
93 *
94 * Create and initialize a DirectSoundCapture interface.
95 *
96 * PARAMS
97 * lpcGUID [I] Address of the GUID that identifies the sound capture device.
98 * lplpDSC [O] Address of a variable to receive the interface pointer.
99 * pUnkOuter [I] Must be NULL.
100 *
101 * RETURNS
102 * Success: DS_OK
103 * Failure: DSERR_NOAGGREGATION, DSERR_ALLOCATED, DSERR_INVALIDPARAM,
104 * DSERR_OUTOFMEMORY
105 *
106 * NOTES
107 * lpcGUID must be one of the values returned from DirectSoundCaptureEnumerate
108 * or NULL for the default device or DSDEVID_DefaultCapture or
109 * DSDEVID_DefaultVoiceCapture.
110 *
111 * DSERR_ALLOCATED is returned for sound devices that do not support full duplex.
112 */
113 HRESULT WINAPI
114 DirectSoundCaptureCreate8(
115 LPCGUID lpcGUID,
116 LPDIRECTSOUNDCAPTURE* lplpDSC,
117 LPUNKNOWN pUnkOuter )
118 {
119 IDirectSoundCaptureImpl** ippDSC=(IDirectSoundCaptureImpl**)lplpDSC;
120 TRACE("(%s,%p,%p)\n", debugstr_guid(lpcGUID), lplpDSC, pUnkOuter);
121
122 if ( pUnkOuter ) {
123 WARN("invalid parameter: pUnkOuter != NULL\n");
124 return DSERR_NOAGGREGATION;
125 }
126
127 if ( !lplpDSC ) {
128 WARN("invalid parameter: lplpDSC == NULL\n");
129 return DSERR_INVALIDPARAM;
130 }
131
132 /* Default device? */
133 if ( !lpcGUID || IsEqualGUID(lpcGUID, &GUID_NULL) )
134 lpcGUID = &DSDEVID_DefaultCapture;
135
136 *ippDSC = (IDirectSoundCaptureImpl*)HeapAlloc(GetProcessHeap(),
137 HEAP_ZERO_MEMORY, sizeof(IDirectSoundCaptureImpl));
138
139 if (*ippDSC == NULL) {
140 WARN("out of memory\n");
141 return DSERR_OUTOFMEMORY;
142 } else {
143 ICOM_THIS(IDirectSoundCaptureImpl, *ippDSC);
144
145 This->ref = 1;
146 This->state = STATE_STOPPED;
147
148 InitializeCriticalSection( &(This->lock) );
149
150 This->lpVtbl = &dscvt;
151 dsound_capture = This;
152
153 if (GetDeviceID(lpcGUID, &This->guid) == DS_OK) {
154 HRESULT hres;
155 hres = IDirectSoundCaptureImpl_Initialize( (LPDIRECTSOUNDCAPTURE)This, &This->guid);
156 if (hres != DS_OK)
157 WARN("IDirectSoundCaptureImpl_Initialize failed\n");
158 return hres;
159 }
160 }
161 WARN("invalid GUID: %s\n", debugstr_guid(lpcGUID));
162 return DSERR_INVALIDPARAM;
163 }
164
165 /***************************************************************************
166 * DirectSoundCaptureEnumerateA [DSOUND.7]
167 *
168 * Enumerate all DirectSound drivers installed in the system.
169 *
170 * PARAMS
171 * lpDSEnumCallback [I] Address of callback function.
172 * lpContext [I] Address of user defined context passed to callback function.
173 *
174 * RETURNS
175 * Success: DS_OK
176 * Failure: DSERR_INVALIDPARAM
177 */
178 HRESULT WINAPI
179 DirectSoundCaptureEnumerateA(
180 LPDSENUMCALLBACKA lpDSEnumCallback,
181 LPVOID lpContext)
182 {
183 unsigned devs, wid;
184 DSDRIVERDESC desc;
185 GUID guid;
186 int err;
187
188 TRACE("(%p,%p)\n", lpDSEnumCallback, lpContext );
189
190 if (lpDSEnumCallback == NULL) {
191 WARN("invalid parameter: lpDSEnumCallback == NULL\n");
192 return DSERR_INVALIDPARAM;
193 }
194
195 devs = waveInGetNumDevs();
196 if (devs > 0) {
197 if (GetDeviceID(&DSDEVID_DefaultCapture, &guid) == DS_OK) {
198 GUID temp;
199 for (wid = 0; wid < devs; ++wid) {
200 err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDGUID,(DWORD)&temp,0));
201 if (err == DS_OK) {
202 if (IsEqualGUID( &guid, &temp ) ) {
203 err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDDESC,(DWORD)&desc,0));
204 if (err == DS_OK) {
205 TRACE("calling lpDSEnumCallback(NULL,\"%s\",\"%s\",%p)\n",
206 "Primary Sound Capture Driver",desc.szDrvName,lpContext);
207 if (lpDSEnumCallback(NULL, "Primary Sound Capture Driver", desc.szDrvName, lpContext) == FALSE)
208 return DS_OK;
209 }
210 }
211 }
212 }
213 }
214 }
215
216 for (wid = 0; wid < devs; ++wid) {
217 err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDDESC,(DWORD)&desc,0));
218 if (err == DS_OK) {
219 err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDGUID,(DWORD)&guid,0));
220 if (err == DS_OK) {
221 TRACE("calling lpDSEnumCallback(%s,\"%s\",\"%s\",%p)\n",
222 debugstr_guid(&guid),desc.szDesc,desc.szDrvName,lpContext);
223 if (lpDSEnumCallback(&guid, desc.szDesc, desc.szDrvName, lpContext) == FALSE)
224 return DS_OK;
225 }
226 }
227 }
228
229 return DS_OK;
230 }
231
232 /***************************************************************************
233 * DirectSoundCaptureEnumerateW [DSOUND.8]
234 *
235 * Enumerate all DirectSound drivers installed in the system.
236 *
237 * PARAMS
238 * lpDSEnumCallback [I] Address of callback function.
239 * lpContext [I] Address of user defined context passed to callback function.
240 *
241 * RETURNS
242 * Success: DS_OK
243 * Failure: DSERR_INVALIDPARAM
244 */
245 HRESULT WINAPI
246 DirectSoundCaptureEnumerateW(
247 LPDSENUMCALLBACKW lpDSEnumCallback,
248 LPVOID lpContext)
249 {
250 unsigned devs, wid;
251 DSDRIVERDESC desc;
252 GUID guid;
253 int err;
254 WCHAR wDesc[MAXPNAMELEN];
255 WCHAR wName[MAXPNAMELEN];
256
257 TRACE("(%p,%p)\n", lpDSEnumCallback, lpContext );
258
259 if (lpDSEnumCallback == NULL) {
260 WARN("invalid parameter: lpDSEnumCallback == NULL\n");
261 return DSERR_INVALIDPARAM;
262 }
263
264 devs = waveInGetNumDevs();
265 if (devs > 0) {
266 if (GetDeviceID(&DSDEVID_DefaultCapture, &guid) == DS_OK) {
267 GUID temp;
268 for (wid = 0; wid < devs; ++wid) {
269 err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDGUID,(DWORD)&temp,0));
270 if (err == DS_OK) {
271 if (IsEqualGUID( &guid, &temp ) ) {
272 err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDDESC,(DWORD)&desc,0));
273 if (err == DS_OK) {
274 TRACE("calling lpDSEnumCallback(NULL,\"%s\",\"%s\",%p)\n",
275 "Primary Sound Capture Driver",desc.szDrvName,lpContext);
276 MultiByteToWideChar( CP_ACP, 0, "Primary Sound Capture Driver", -1,
277 wDesc, sizeof(wDesc)/sizeof(WCHAR) );
278 MultiByteToWideChar( CP_ACP, 0, desc.szDrvName, -1,
279 wName, sizeof(wName)/sizeof(WCHAR) );
280 if (lpDSEnumCallback(NULL, wDesc, wName, lpContext) == FALSE)
281 return DS_OK;
282 }
283 }
284 }
285 }
286 }
287 }
288
289 for (wid = 0; wid < devs; ++wid) {
290 err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDDESC,(DWORD)&desc,0));
291 if (err == DS_OK) {
292 err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDGUID,(DWORD)&guid,0));
293 if (err == DS_OK) {
294 TRACE("calling lpDSEnumCallback(%s,\"%s\",\"%s\",%p)\n",
295 debugstr_guid(&DSDEVID_DefaultCapture),desc.szDesc,desc.szDrvName,lpContext);
296 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1,
297 wDesc, sizeof(wDesc)/sizeof(WCHAR) );
298 MultiByteToWideChar( CP_ACP, 0, desc.szDrvName, -1,
299 wName, sizeof(wName)/sizeof(WCHAR) );
300 if (lpDSEnumCallback((LPGUID)&DSDEVID_DefaultCapture, wDesc, wName, lpContext) == FALSE)
301 return DS_OK;
302 }
303 }
304 }
305
306 return DS_OK;
307 }
308
309 static void CALLBACK
310 DSOUND_capture_callback(
311 HWAVEIN hwi,
312 UINT msg,
313 DWORD dwUser,
314 DWORD dw1,
315 DWORD dw2 )
316 {
317 IDirectSoundCaptureImpl* This = (IDirectSoundCaptureImpl*)dwUser;
318 TRACE("(%p,%08x(%s),%08lx,%08lx,%08lx) entering at %ld\n",hwi,msg,
319 msg == MM_WIM_OPEN ? "MM_WIM_OPEN" : msg == MM_WIM_CLOSE ? "MM_WIM_CLOSE" :
320 msg == MM_WIM_DATA ? "MM_WIM_DATA" : "UNKNOWN",dwUser,dw1,dw2,GetTickCount());
321
322 if (msg == MM_WIM_DATA) {
323 LPWAVEHDR pHdr = (LPWAVEHDR)dw1;
324 EnterCriticalSection( &(This->lock) );
325 TRACE("DirectSoundCapture msg=MM_WIM_DATA, old This->state=%s, old This->index=%d\n",
326 captureStateString[This->state],This->index);
327 if (This->state != STATE_STOPPED) {
328 int index = This->index;
329 if (This->state == STATE_STARTING) {
330 This->read_position = pHdr->dwBytesRecorded;
331 This->state = STATE_CAPTURING;
332 }
333 waveInUnprepareHeader(hwi,&(This->pwave[This->index]),sizeof(WAVEHDR));
334 if (This->capture_buffer->nrofnotifies)
335 SetEvent(This->capture_buffer->notifies[This->index].hEventNotify);
336 This->index = (This->index + 1) % This->nrofpwaves;
337 if ( (This->index == 0) && !(This->capture_buffer->flags & DSCBSTART_LOOPING) ) {
338 TRACE("end of buffer\n");
339 This->state = STATE_STOPPED;
340 } else {
341 if (This->state == STATE_CAPTURING) {
342 waveInPrepareHeader(hwi,&(This->pwave[index]),sizeof(WAVEHDR));
343 waveInAddBuffer(hwi, &(This->pwave[index]), sizeof(WAVEHDR));
344 } else if (This->state == STATE_STOPPING) {
345 TRACE("stopping\n");
346 This->state = STATE_STOPPED;
347 }
348 }
349 }
350 TRACE("DirectSoundCapture new This->state=%s, new This->index=%d\n",
351 captureStateString[This->state],This->index);
352 LeaveCriticalSection( &(This->lock) );
353 }
354
355 TRACE("completed\n");
356 }
357
358 static HRESULT WINAPI
359 IDirectSoundCaptureImpl_QueryInterface(
360 LPDIRECTSOUNDCAPTURE iface,
361 REFIID riid,
362 LPVOID* ppobj )
363 {
364 ICOM_THIS(IDirectSoundCaptureImpl,iface);
365 TRACE( "(%p,%s,%p)\n", This, debugstr_guid(riid), ppobj );
366
367 if (ppobj == NULL) {
368 WARN("invalid parameter\n");
369 return E_INVALIDARG;
370 }
371
372 *ppobj = NULL;
373
374 if (This->driver) {
375 HRESULT hres;
376 hres = IDsCaptureDriver_QueryInterface(This->driver, riid, ppobj);
377 if (hres != DS_OK)
378 WARN("IDsCaptureDriver_QueryInterface failed\n");
379 return hres;
380 }
381
382 WARN("unsupported riid: %s\n", debugstr_guid(riid));
383 return E_FAIL;
384 }
385
386 static ULONG WINAPI
387 IDirectSoundCaptureImpl_AddRef( LPDIRECTSOUNDCAPTURE iface )
388 {
389 ULONG uRef;
390 ICOM_THIS(IDirectSoundCaptureImpl,iface);
391 TRACE("(%p) ref was %ld, thread is %04lx\n",This, This->ref, GetCurrentThreadId());
392
393 EnterCriticalSection( &(This->lock) );
394 uRef = ++(This->ref);
395
396 if (This->driver)
397 IDsCaptureDriver_AddRef(This->driver);
398
399 LeaveCriticalSection( &(This->lock) );
400
401 return uRef;
402 }
403
404 static ULONG WINAPI
405 IDirectSoundCaptureImpl_Release( LPDIRECTSOUNDCAPTURE iface )
406 {
407 ULONG uRef;
408 ICOM_THIS(IDirectSoundCaptureImpl,iface);
409 TRACE("(%p) ref was %ld, thread is %04lx\n",This, This->ref, GetCurrentThreadId());
410
411 EnterCriticalSection( &(This->lock) );
412
413 uRef = --(This->ref);
414
415 LeaveCriticalSection( &(This->lock) );
416
417 if ( uRef == 0 ) {
418 TRACE("deleting object\n");
419 if (This->driver) {
420 IDsCaptureDriver_Close(This->driver);
421 IDsCaptureDriver_Release(This->driver);
422 }
423
424 if (This->capture_buffer)
425 IDirectSoundCaptureBufferImpl_Release(
426 (LPDIRECTSOUNDCAPTUREBUFFER8) This->capture_buffer);
427
428 if (This->pwfx)
429 HeapFree(GetProcessHeap(), 0, This->pwfx);
430
431 DeleteCriticalSection( &(This->lock) );
432 HeapFree( GetProcessHeap(), 0, This );
433 dsound_capture = NULL;
434 TRACE("(%p) released\n",This);
435 }
436
437 return uRef;
438 }
439
440 static HRESULT WINAPI
441 IDirectSoundCaptureImpl_CreateCaptureBuffer(
442 LPDIRECTSOUNDCAPTURE iface,
443 LPCDSCBUFFERDESC lpcDSCBufferDesc,
444 LPDIRECTSOUNDCAPTUREBUFFER* lplpDSCaptureBuffer,
445 LPUNKNOWN pUnk )
446 {
447 HRESULT hr;
448 ICOM_THIS(IDirectSoundCaptureImpl,iface);
449
450 TRACE( "(%p,%p,%p,%p)\n",This,lpcDSCBufferDesc,lplpDSCaptureBuffer,pUnk );
451
452 if (This == NULL) {
453 WARN("invalid parameter: This == NULL\n");
454 return DSERR_INVALIDPARAM;
455 }
456
457 if (lpcDSCBufferDesc == NULL) {
458 WARN("invalid parameter: lpcDSCBufferDesc == NULL)\n");
459 return DSERR_INVALIDPARAM;
460 }
461
462 if (lplpDSCaptureBuffer == NULL) {
463 WARN("invalid parameter: lplpDSCaptureBuffer == NULL\n");
464 return DSERR_INVALIDPARAM;
465 }
466
467 if (pUnk != NULL) {
468 WARN("invalid parameter: pUnk != NULL\n");
469 return DSERR_INVALIDPARAM;
470 }
471
472 /* FIXME: We can only have one buffer so what do we do here? */
473 if (This->capture_buffer) {
474 WARN("lnvalid parameter: already has buffer\n");
475 return DSERR_INVALIDPARAM; /* DSERR_GENERIC ? */
476 }
477
478 hr = DSOUND_CreateDirectSoundCaptureBuffer( This, lpcDSCBufferDesc,
479 (LPVOID*)lplpDSCaptureBuffer );
480
481 if (hr != DS_OK)
482 WARN("DSOUND_CreateDirectSoundCaptureBuffer failed\n");
483
484 return hr;
485 }
486
487 static HRESULT WINAPI
488 IDirectSoundCaptureImpl_GetCaps(
489 LPDIRECTSOUNDCAPTURE iface,
490 LPDSCCAPS lpDSCCaps )
491 {
492 ICOM_THIS(IDirectSoundCaptureImpl,iface);
493 TRACE("(%p,%p)\n",This,lpDSCCaps);
494
495 if (lpDSCCaps== NULL) {
496 WARN("invalid parameter: lpDSCCaps== NULL\n");
497 return DSERR_INVALIDPARAM;
498 }
499
500 if (lpDSCCaps->dwSize < sizeof(*lpDSCCaps)) {
501 WARN("invalid parameter: lpDSCCaps->dwSize = %ld < %d\n",
502 lpDSCCaps->dwSize, sizeof(*lpDSCCaps));
503 return DSERR_INVALIDPARAM;
504 }
505
506 if ( !(This->initialized) ) {
507 WARN("not initialized\n");
508 return DSERR_UNINITIALIZED;
509 }
510
511 lpDSCCaps->dwFlags = This->drvcaps.dwFlags;
512 lpDSCCaps->dwFormats = This->drvcaps.dwFormats;
513 lpDSCCaps->dwChannels = This->drvcaps.dwChannels;
514
515 TRACE("(flags=0x%08lx,format=0x%08lx,channels=%ld)\n",lpDSCCaps->dwFlags,
516 lpDSCCaps->dwFormats, lpDSCCaps->dwChannels);
517
518 return DS_OK;
519 }
520
521 static HRESULT WINAPI
522 IDirectSoundCaptureImpl_Initialize(
523 LPDIRECTSOUNDCAPTURE iface,
524 LPCGUID lpcGUID )
525 {
526 HRESULT err = DSERR_INVALIDPARAM;
527 unsigned wid, widn;
528 ICOM_THIS(IDirectSoundCaptureImpl,iface);
529 TRACE("(%p)\n", This);
530
531 if (!This) {
532 WARN("invalid parameter: This == NULL\n");
533 return DSERR_INVALIDPARAM;
534 }
535
536 if (This->initialized) {
537 WARN("already initialized\n");
538 return DSERR_ALREADYINITIALIZED;
539 }
540
541 widn = waveInGetNumDevs();
542
543 if (!widn) {
544 WARN("no audio devices found\n");
545 return DSERR_NODRIVER;
546 }
547
548 /* Get dsound configuration */
549 setup_dsound_options();
550
551 /* enumerate WINMM audio devices and find the one we want */
552 for (wid=0; wid<widn; wid++) {
553 GUID guid;
554 err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDGUID,(DWORD)(&guid),0));
555 if (err != DS_OK) {
556 WARN("waveInMessage failed; err=%lx\n",err);
557 return err;
558 }
559 if (IsEqualGUID( lpcGUID, &guid) ) {
560 err = DS_OK;
561 break;
562 }
563 }
564
565 if (err != DS_OK) {
566 WARN("invalid parameter\n");
567 return DSERR_INVALIDPARAM;
568 }
569
570 err = mmErr(waveInMessage((HWAVEIN)wid,DRV_QUERYDSOUNDIFACE,(DWORD)&(This->driver),0));
571 if ( (err != DS_OK) && (err != DSERR_UNSUPPORTED) ) {
572 WARN("waveInMessage failed; err=%lx\n",err);
573 return err;
574 }
575 err = DS_OK;
576
577 /* Disable the direct sound driver to force emulation if requested. */
578 if (ds_hw_accel == DS_HW_ACCEL_EMULATION)
579 This->driver = NULL;
580
581 /* Get driver description */
582 if (This->driver) {
583 TRACE("using DirectSound driver\n");
584 err = IDsCaptureDriver_GetDriverDesc(This->driver, &(This->drvdesc));
585 if (err != DS_OK) {
586 WARN("IDsCaptureDriver_GetDriverDesc failed\n");
587 return err;
588 }
589 } else {
590 TRACE("using WINMM\n");
591 /* if no DirectSound interface available, use WINMM API instead */
592 This->drvdesc.dwFlags = DSDDESC_DOMMSYSTEMOPEN |
593 DSDDESC_DOMMSYSTEMSETFORMAT;
594 }
595
596 This->drvdesc.dnDevNode = wid;
597
598 /* open the DirectSound driver if available */
599 if (This->driver && (err == DS_OK))
600 err = IDsCaptureDriver_Open(This->driver);
601
602 if (err == DS_OK) {
603 This->initialized = TRUE;
604
605 /* the driver is now open, so it's now allowed to call GetCaps */
606 if (This->driver) {
607 This->drvcaps.dwSize = sizeof(This->drvcaps);
608 err = IDsCaptureDriver_GetCaps(This->driver,&(This->drvcaps));
609 if (err != DS_OK) {
610 WARN("IDsCaptureDriver_GetCaps failed\n");
611 return err;
612 }
613 } else /*if (This->hwi)*/ {
614 WAVEINCAPSA wic;
615 err = mmErr(waveInGetDevCapsA((UINT)This->drvdesc.dnDevNode, &wic, sizeof(wic)));
616
617 if (err == DS_OK) {
618 This->drvcaps.dwFlags = 0;
619 strncpy(This->drvdesc.szDrvName, wic.szPname,
620 sizeof(This->drvdesc.szDrvName));
621
622 This->drvcaps.dwFlags |= DSCCAPS_EMULDRIVER;
623 This->drvcaps.dwFormats = wic.dwFormats;
624 This->drvcaps.dwChannels = wic.wChannels;
625 }
626 }
627 }
628
629 return err;
630 }
631
632 static ICOM_VTABLE(IDirectSoundCapture) dscvt =
633 {
634 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
635 /* IUnknown methods */
636 IDirectSoundCaptureImpl_QueryInterface,
637 IDirectSoundCaptureImpl_AddRef,
638 IDirectSoundCaptureImpl_Release,
639
640 /* IDirectSoundCapture methods */
641 IDirectSoundCaptureImpl_CreateCaptureBuffer,
642 IDirectSoundCaptureImpl_GetCaps,
643 IDirectSoundCaptureImpl_Initialize
644 };
645
646 static HRESULT
647 DSOUND_CreateDirectSoundCaptureBuffer(
648 IDirectSoundCaptureImpl *ipDSC,
649 LPCDSCBUFFERDESC lpcDSCBufferDesc,
650 LPVOID* ppobj )
651 {
652 LPWAVEFORMATEX wfex;
653 TRACE( "(%p,%p)\n", lpcDSCBufferDesc, ppobj );
654
655 if (ipDSC == NULL) {
656 WARN("invalid parameter: ipDSC == NULL\n");
657 return DSERR_INVALIDPARAM;
658 }
659
660 if (lpcDSCBufferDesc == NULL) {
661 WARN("invalid parameter: lpcDSCBufferDesc == NULL\n");
662 return DSERR_INVALIDPARAM;
663 }
664
665 if (ppobj == NULL) {
666 WARN("invalid parameter: ppobj == NULL\n");
667 return DSERR_INVALIDPARAM;
668 }
669
670 if ( ((lpcDSCBufferDesc->dwSize != sizeof(DSCBUFFERDESC)) &&
671 (lpcDSCBufferDesc->dwSize != sizeof(DSCBUFFERDESC1))) ||
672 (lpcDSCBufferDesc->dwBufferBytes == 0) ||
673 (lpcDSCBufferDesc->lpwfxFormat == NULL) ) {
674 WARN("invalid lpcDSCBufferDesc\n");
675 *ppobj = NULL;
676 return DSERR_INVALIDPARAM;
677 }
678
679 if ( !ipDSC->initialized ) {
680 WARN("not initialized\n");
681 *ppobj = NULL;
682 return DSERR_UNINITIALIZED;
683 }
684
685 wfex = lpcDSCBufferDesc->lpwfxFormat;
686
687 if (wfex) {
688 TRACE("(formattag=0x%04x,chans=%d,samplerate=%ld,"
689 "bytespersec=%ld,blockalign=%d,bitspersamp=%d,cbSize=%d)\n",
690 wfex->wFormatTag, wfex->nChannels, wfex->nSamplesPerSec,
691 wfex->nAvgBytesPerSec, wfex->nBlockAlign,
692 wfex->wBitsPerSample, wfex->cbSize);
693
694 if (wfex->wFormatTag == WAVE_FORMAT_PCM) {
695 ipDSC->pwfx = HeapAlloc(GetProcessHeap(),0,sizeof(WAVEFORMATEX));
696 memcpy(ipDSC->pwfx, wfex, sizeof(WAVEFORMATEX));
697 ipDSC->pwfx->cbSize = 0;
698 } else {
699 ipDSC->pwfx = HeapAlloc(GetProcessHeap(),0,sizeof(WAVEFORMATEX)+wfex->cbSize);
700 memcpy(ipDSC->pwfx, wfex, sizeof(WAVEFORMATEX)+wfex->cbSize);
701 }
702 } else {
703 WARN("lpcDSCBufferDesc->lpwfxFormat == 0\n");
704 *ppobj = NULL;
705 return DSERR_INVALIDPARAM; /* FIXME: DSERR_BADFORMAT ? */
706 }
707
708 *ppobj = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,
709 sizeof(IDirectSoundCaptureBufferImpl));
710
711 if ( *ppobj == NULL ) {
712 WARN("out of memory\n");
713 *ppobj = NULL;
714 return DSERR_OUTOFMEMORY;
715 } else {
716 HRESULT err = DS_OK;
717 ICOM_THIS(IDirectSoundCaptureBufferImpl,*ppobj);
718
719 This->ref = 1;
720 This->dsound = ipDSC;
721 This->dsound->capture_buffer = This;
722 This->notify = NULL;
723 This->nrofnotifies = 0;
724 This->hwnotify = NULL;
725
726 This->pdscbd = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,
727 lpcDSCBufferDesc->dwSize);
728 if (This->pdscbd)
729 memcpy(This->pdscbd, lpcDSCBufferDesc, lpcDSCBufferDesc->dwSize);
730 else {
731 WARN("no memory\n");
732 This->dsound->capture_buffer = 0;
733 HeapFree( GetProcessHeap(), 0, This );
734 *ppobj = NULL;
735 return DSERR_OUTOFMEMORY;
736 }
737
738 This->lpVtbl = &dscbvt;
739
740 if (ipDSC->driver) {
741 err = IDsCaptureDriver_CreateCaptureBuffer(ipDSC->driver,
742 ipDSC->pwfx,0,0,&(ipDSC->buflen),&(ipDSC->buffer),(LPVOID*)&(ipDSC->hwbuf));
743 if (err != DS_OK) {
744 WARN("IDsCaptureDriver_CreateCaptureBuffer failed\n");
745 This->dsound->capture_buffer = 0;
746 HeapFree( GetProcessHeap(), 0, This );
747 *ppobj = NULL;
748 return err;
749 }
750 } else {
751 LPBYTE newbuf;
752 DWORD buflen;
753 DWORD flags = CALLBACK_FUNCTION;
754 if (ds_hw_accel != DS_HW_ACCEL_EMULATION)
755 flags |= WAVE_DIRECTSOUND;
756 err = mmErr(waveInOpen(&(ipDSC->hwi),
757 ipDSC->drvdesc.dnDevNode, ipDSC->pwfx,
758 (DWORD)DSOUND_capture_callback, (DWORD)ipDSC, flags));
759 if (err != DS_OK) {
760 WARN("waveInOpen failed\n");
761 This->dsound->capture_buffer = 0;
762 HeapFree( GetProcessHeap(), 0, This );
763 *ppobj = NULL;
764 return err;
765 }
766
767 buflen = lpcDSCBufferDesc->dwBufferBytes;
768 TRACE("desired buflen=%ld, old buffer=%p\n", buflen, ipDSC->buffer);
769 if (ipDSC->buffer)
770 newbuf = (LPBYTE)HeapReAlloc(GetProcessHeap(),0,ipDSC->buffer,buflen);
771 else
772 newbuf = (LPBYTE)HeapAlloc(GetProcessHeap(),0,buflen);
773 if (newbuf == NULL) {
774 WARN("failed to allocate capture buffer\n");
775 err = DSERR_OUTOFMEMORY;
776 /* but the old buffer might still exist and must be re-prepared */
777 } else {
778 ipDSC->buffer = newbuf;
779 ipDSC->buflen = buflen;
780 }
781 }
782 }
783
784 TRACE("returning DS_OK\n");
785 return DS_OK;
786 }
787
788 /*******************************************************************************
789 * IDirectSoundCaptureNotify
790 */
791 static HRESULT WINAPI IDirectSoundCaptureNotifyImpl_QueryInterface(
792 LPDIRECTSOUNDNOTIFY iface,
793 REFIID riid,
794 LPVOID *ppobj)
795 {
796 ICOM_THIS(IDirectSoundCaptureNotifyImpl,iface);
797 TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
798
799 if (This->dscb == NULL) {
800 WARN("invalid parameter\n");
801 return E_INVALIDARG;
802 }
803
804 return IDirectSoundCaptureBuffer_QueryInterface((LPDIRECTSOUNDCAPTUREBUFFER)This->dscb, riid, ppobj);
805 }
806
807 static ULONG WINAPI IDirectSoundCaptureNotifyImpl_AddRef(LPDIRECTSOUNDNOTIFY iface)
808 {
809 ICOM_THIS(IDirectSoundCaptureNotifyImpl,iface);
810 DWORD ref;
811
812 TRACE("(%p) ref was %ld, thread is %04lx\n",This, This->ref, GetCurrentThreadId());
813
814 ref = InterlockedIncrement(&(This->ref));
815 return ref;
816 }
817
818 static ULONG WINAPI IDirectSoundCaptureNotifyImpl_Release(LPDIRECTSOUNDNOTIFY iface)
819 {
820 ICOM_THIS(IDirectSoundCaptureNotifyImpl,iface);
821 DWORD ref;
822
823 TRACE("(%p) ref was %ld, thread is %04lx\n",This, This->ref, GetCurrentThreadId());
824
825 ref = InterlockedDecrement(&(This->ref));
826 if (ref == 0) {
827 if (This->dscb->hwnotify)
828 IDsDriverNotify_Release(This->dscb->hwnotify);
829 This->dscb->notify=NULL;
830 IDirectSoundCaptureBuffer_Release((LPDIRECTSOUNDCAPTUREBUFFER)This->dscb);
831 HeapFree(GetProcessHeap(),0,This);
832 TRACE("(%p) released\n",This);
833 }
834 return ref;
835 }
836
837 static HRESULT WINAPI IDirectSoundCaptureNotifyImpl_SetNotificationPositions(
838 LPDIRECTSOUNDNOTIFY iface,
839 DWORD howmuch,
840 LPCDSBPOSITIONNOTIFY notify)
841 {
842 ICOM_THIS(IDirectSoundCaptureNotifyImpl,iface);
843 TRACE("(%p,0x%08lx,%p)\n",This,howmuch,notify);
844
845 if (howmuch > 0 && notify == NULL) {
846 WARN("invalid parameter: notify == NULL\n");
847 return DSERR_INVALIDPARAM;
848 }
849
850 if (TRACE_ON(dsound)) {
851 int i;
852 for (i=0;i<howmuch;i++)
853 TRACE("notify at %ld to 0x%08lx\n",
854 notify[i].dwOffset,(DWORD)notify[i].hEventNotify);
855 }
856
857 if (This->dscb->hwnotify) {
858 HRESULT hres;
859 hres = IDsDriverNotify_SetNotificationPositions(This->dscb->hwnotify, howmuch, notify);
860 if (hres != DS_OK)
861 WARN("IDsDriverNotify_SetNotificationPositions failed\n");
862 return hres;
863 } else if (howmuch > 0) {
864 /* Make an internal copy of the caller-supplied array.
865 * Replace the existing copy if one is already present. */
866 if (This->dscb->notifies)
867 This->dscb->notifies = HeapReAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
868 This->dscb->notifies, howmuch * sizeof(DSBPOSITIONNOTIFY));
869 else
870 This->dscb->notifies = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
871 howmuch * sizeof(DSBPOSITIONNOTIFY));
872
873 if (This->dscb->notifies == NULL) {
874 WARN("out of memory\n");
875 return DSERR_OUTOFMEMORY;
876 }
877 memcpy(This->dscb->notifies, notify, howmuch * sizeof(DSBPOSITIONNOTIFY));
878 This->dscb->nrofnotifies = howmuch;
879 } else {
880 if (This->dscb->notifies) {
881 HeapFree(GetProcessHeap(), 0, This->dscb->notifies);
882 This->dscb->notifies = NULL;
883 }
884 This->dscb->nrofnotifies = 0;
885 }
886
887 return S_OK;
888 }
889
890 ICOM_VTABLE(IDirectSoundNotify) dscnvt =
891 {
892 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
893 IDirectSoundCaptureNotifyImpl_QueryInterface,
894 IDirectSoundCaptureNotifyImpl_AddRef,
895 IDirectSoundCaptureNotifyImpl_Release,
896 IDirectSoundCaptureNotifyImpl_SetNotificationPositions,
897 };
898
899 HRESULT WINAPI IDirectSoundCaptureNotifyImpl_Create(
900 IDirectSoundCaptureBufferImpl *dscb,
901 IDirectSoundCaptureNotifyImpl **pdscn)
902 {
903 IDirectSoundCaptureNotifyImpl * dscn;
904 TRACE("(%p,%p)\n",dscb,pdscn);
905
906 dscn = (IDirectSoundCaptureNotifyImpl*)HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(dscn));
907
908 if (dscn == NULL) {
909 WARN("out of memory\n");
910 return DSERR_OUTOFMEMORY;
911 }
912
913 dscn->ref = 0;
914 dscn->lpVtbl = &dscnvt;
915 dscn->dscb = dscb;
916 dscb->notify = dscn;
917 IDirectSoundCaptureBuffer_AddRef((LPDIRECTSOUNDCAPTUREBUFFER)dscb);
918
919 *pdscn = dscn;
920 return DS_OK;
921 }
922
923 /*******************************************************************************
924 * IDirectSoundCaptureBuffer
925 */
926 static HRESULT WINAPI
927 IDirectSoundCaptureBufferImpl_QueryInterface(
928 LPDIRECTSOUNDCAPTUREBUFFER8 iface,
929 REFIID riid,
930 LPVOID* ppobj )
931 {
932 ICOM_THIS(IDirectSoundCaptureBufferImpl,iface);
933 HRESULT hres;
934 TRACE( "(%p,%s,%p)\n", This, debugstr_guid(riid), ppobj );
935
936 if (ppobj == NULL) {
937 WARN("invalid parameter\n");
938 return E_INVALIDARG;
939 }
940
941 *ppobj = NULL;
942
943 if ( IsEqualGUID( &IID_IDirectSoundNotify, riid ) ||
944 IsEqualGUID( &IID_IDirectSoundNotify8, riid ) ) {
945 if (!This->notify)
946 hres = IDirectSoundCaptureNotifyImpl_Create(This, &This->notify);
947 if (This->notify) {
948 if (This->dsound->hwbuf) {
949 hres = IDsCaptureDriverBuffer_QueryInterface(This->dsound->hwbuf,
950 &IID_IDsDriverNotify, (LPVOID*)&(This->hwnotify));
951 if (hres != DS_OK) {
952 WARN("IDsCaptureDriverBuffer_QueryInterface failed\n");
953 *ppobj = 0;
954 return hres;
955 }
956 }
957
958 IDirectSoundNotify_AddRef((LPDIRECTSOUNDNOTIFY)This->notify);
959 *ppobj = (LPVOID)This->notify;
960 return DS_OK;
961 }
962
963 WARN("IID_IDirectSoundNotify\n");
964 return E_FAIL;
965 }
966
967 if ( IsEqualGUID( &IID_IDirectSoundCaptureBuffer, riid ) ||
968 IsEqualGUID( &IID_IDirectSoundCaptureBuffer8, riid ) ) {
969 IDirectSoundCaptureBuffer8_AddRef(iface);
970 *ppobj = This;
971 return NO_ERROR;
972 }
973
974 FIXME("(%p,%s,%p) unsupported GUID\n", This, debugstr_guid(riid), ppobj);
975 return E_NOINTERFACE;
976 }
977
978 static ULONG WINAPI
979 IDirectSoundCaptureBufferImpl_AddRef( LPDIRECTSOUNDCAPTUREBUFFER8 iface )
980 {
981 ULONG uRef;
982 ICOM_THIS(IDirectSoundCaptureBufferImpl,iface);
983 TRACE("(%p) ref was %ld, thread is %04lx\n",This, This->ref, GetCurrentThreadId());
984
985 assert(This->dsound);
986
987 EnterCriticalSection( &(This->dsound->lock) );
988
989 uRef = ++(This->ref);
990
991 LeaveCriticalSection( &(This->dsound->lock) );
992
993 return uRef;
994 }
995
996 static ULONG WINAPI
997 IDirectSoundCaptureBufferImpl_Release( LPDIRECTSOUNDCAPTUREBUFFER8 iface )
998 {
999 ULONG uRef;
1000 ICOM_THIS(IDirectSoundCaptureBufferImpl,iface);
1001 TRACE("(%p) ref was %ld, thread is %04lx\n",This, This->ref, GetCurrentThreadId());
1002
1003 assert(This->dsound);
1004
1005 EnterCriticalSection( &(This->dsound->lock) );
1006
1007 uRef = --(This->ref);
1008
1009 LeaveCriticalSection( &(This->dsound->lock) );
1010
1011 if ( uRef == 0 ) {
1012 TRACE("deleting object\n");
1013 if (This->pdscbd)
1014 HeapFree(GetProcessHeap(),0, This->pdscbd);
1015
1016 if (This->dsound->hwi) {
1017 waveInReset(This->dsound->hwi);
1018 waveInClose(This->dsound->hwi);
1019 if (This->dsound->pwave) {
1020 HeapFree(GetProcessHeap(),0, This->dsound->pwave);
1021 This->dsound->pwave = 0;
1022 }
1023 This->dsound->hwi = 0;
1024 }
1025
1026 if (This->dsound->hwbuf)
1027 IDsCaptureDriverBuffer_Release(This->dsound->hwbuf);
1028
1029 /* remove from IDirectSoundCaptureImpl */
1030 if (This->dsound)
1031 This->dsound->capture_buffer = NULL;
1032 else
1033 ERR("does not reference dsound\n");
1034
1035 if (This->notify)
1036 IDirectSoundNotify_Release((LPDIRECTSOUNDNOTIFY)This->notify);
1037
1038 if (This->notifies != NULL)
1039 HeapFree(GetProcessHeap(), 0, This->notifies);
1040
1041 HeapFree( GetProcessHeap(), 0, This );
1042 TRACE("(%p) released\n",This);
1043 }
1044
1045 return uRef;
1046 }
1047
1048 static HRESULT WINAPI
1049 IDirectSoundCaptureBufferImpl_GetCaps(
1050 LPDIRECTSOUNDCAPTUREBUFFER8 iface,
1051 LPDSCBCAPS lpDSCBCaps )
1052 {
1053 ICOM_THIS(IDirectSoundCaptureBufferImpl,iface);
1054 TRACE( "(%p,%p)\n", This, lpDSCBCaps );
1055
1056 if (This == NULL) {
1057 WARN("invalid parameter: This == NULL\n");
1058 return DSERR_INVALIDPARAM;
1059 }
1060
1061 if (lpDSCBCaps == NULL) {
1062 WARN("invalid parameter: lpDSCBCaps == NULL\n");
1063 return DSERR_INVALIDPARAM;
1064 }
1065
1066 if (lpDSCBCaps->dwSize < sizeof(DSCBCAPS)) {
1067 WARN("invalid parameter: lpDSCBCaps->dwSize = %ld < %d\n",
1068 lpDSCBCaps->dwSize, sizeof(DSCBCAPS));
1069 return DSERR_INVALIDPARAM;
1070 }
1071
1072 if (This->dsound == NULL) {
1073 WARN("invalid parameter: This->dsound == NULL\n");
1074 return DSERR_INVALIDPARAM;
1075 }
1076
1077 lpDSCBCaps->dwSize = sizeof(DSCBCAPS);
1078 lpDSCBCaps->dwFlags = This->flags;
1079 lpDSCBCaps->dwBufferBytes = This->pdscbd->dwBufferBytes;
1080 lpDSCBCaps->dwReserved = 0;
1081
1082 TRACE("returning DS_OK\n");
1083 return DS_OK;
1084 }
1085
1086 static HRESULT WINAPI
1087 IDirectSoundCaptureBufferImpl_GetCurrentPosition(
1088 LPDIRECTSOUNDCAPTUREBUFFER8 iface,
1089 LPDWORD lpdwCapturePosition,
1090 LPDWORD lpdwReadPosition )
1091 {
1092 ICOM_THIS(IDirectSoundCaptureBufferImpl,iface);
1093 TRACE( "(%p,%p,%p)\n", This, lpdwCapturePosition, lpdwReadPosition );
1094
1095 if (This == NULL) {
1096 WARN("invalid parameter: This == NULL\n");
1097 return DSERR_INVALIDPARAM;
1098 }
1099
1100 if (This->dsound == NULL) {
1101 WARN("invalid parameter: This->dsound == NULL\n");
1102 return DSERR_INVALIDPARAM;
1103 }
1104
1105 if (This->dsound->driver) {
1106 HRESULT hres;
1107 hres = IDsCaptureDriverBuffer_GetPosition(This->dsound->hwbuf, lpdwCapturePosition, lpdwReadPosition );
1108 if (hres != DS_OK) {
1109 WARN("IDsCaptureDriverBuffer_GetPosition failed\n");
1110 return hres;
1111 }
1112 } else if (This->dsound->hwi) {
1113 EnterCriticalSection(&(This->dsound->lock));
1114 TRACE("old This->dsound->state=%s\n",captureStateString[This->dsound->state]);
1115 if (lpdwCapturePosition) {
1116 MMTIME mtime;
1117 mtime.wType = TIME_BYTES;
1118 waveInGetPosition(This->dsound->hwi, &mtime, sizeof(mtime));
1119 TRACE("mtime.u.cb=%ld,This->dsound->buflen=%ld\n", mtime.u.cb,
1120 This->dsound->buflen);
1121 mtime.u.cb = mtime.u.cb % This->dsound->buflen;
1122 *lpdwCapturePosition = mtime.u.cb;
1123 }
1124
1125 if (lpdwReadPosition) {
1126 if (This->dsound->state == STATE_STARTING) {
1127 if (lpdwCapturePosition)
1128 This->dsound->read_position = *lpdwCapturePosition;
1129 This->dsound->state = STATE_CAPTURING;
1130 }
1131 *lpdwReadPosition = This->dsound->read_position;
1132 }
1133 TRACE("new This->dsound->state=%s\n",captureStateString[This->dsound->state]);
1134 LeaveCriticalSection(&(This->dsound->lock));
1135 if (lpdwCapturePosition) TRACE("*lpdwCapturePosition=%ld\n",*lpdwCapturePosition);
1136 if (lpdwReadPosition) TRACE("*lpdwReadPosition=%ld\n",*lpdwReadPosition);
1137 } else {
1138 WARN("no driver\n");
1139 return DSERR_NODRIVER;
1140 }
1141
1142 TRACE("returning DS_OK\n");
1143 return DS_OK;
1144 }
1145
1146 static HRESULT WINAPI
1147 IDirectSoundCaptureBufferImpl_GetFormat(
1148 LPDIRECTSOUNDCAPTUREBUFFER8 iface,
1149 LPWAVEFORMATEX lpwfxFormat,
1150 DWORD dwSizeAllocated,
1151 LPDWORD lpdwSizeWritten )
1152 {
1153 ICOM_THIS(IDirectSoundCaptureBufferImpl,iface);
1154 TRACE( "(%p,%p,0x%08lx,%p)\n", This, lpwfxFormat, dwSizeAllocated,
1155 lpdwSizeWritten );
1156
1157 if (This == NULL) {
1158 WARN("invalid parameter: This == NULL\n");
1159 return DSERR_INVALIDPARAM;
1160 }
1161
1162 if (This->dsound == NULL) {
1163 WARN("invalid parameter: This->dsound == NULL\n");
1164 return DSERR_INVALIDPARAM;
1165 }
1166
1167 if (dwSizeAllocated > (sizeof(WAVEFORMATEX) + This->dsound->pwfx->cbSize))
1168 dwSizeAllocated = sizeof(WAVEFORMATEX) + This->dsound->pwfx->cbSize;
1169
1170 if (lpwfxFormat) { /* NULL is valid (just want size) */
1171 memcpy(lpwfxFormat, This->dsound->pwfx, dwSizeAllocated);
1172 if (lpdwSizeWritten)
1173 *lpdwSizeWritten = dwSizeAllocated;
1174 } else {
1175 if (lpdwSizeWritten)
1176 *lpdwSizeWritten = sizeof(WAVEFORMATEX) + This->dsound->pwfx->cbSize;
1177 else {
1178 TRACE("invalid parameter: lpdwSizeWritten = NULL\n");
1179 return DSERR_INVALIDPARAM;
1180 }
1181 }
1182
1183 TRACE("returning DS_OK\n");
1184 return DS_OK;
1185 }
1186
1187 static HRESULT WINAPI
1188 IDirectSoundCaptureBufferImpl_GetStatus(
1189 LPDIRECTSOUNDCAPTUREBUFFER8 iface,
1190 LPDWORD lpdwStatus )
1191 {
1192 ICOM_THIS(IDirectSoundCaptureBufferImpl,iface);
1193 TRACE( "(%p, %p), thread is %04lx\n", This, lpdwStatus, GetCurrentThreadId() );
1194
1195 if (This == NULL) {
1196 WARN("invalid parameter: This == NULL\n");
1197 return DSERR_INVALIDPARAM;
1198 }
1199
1200 if (This->dsound == NULL) {
1201 WARN("invalid parameter: This->dsound == NULL\n");
1202 return DSERR_INVALIDPARAM;
1203 }
1204
1205 if (lpdwStatus == NULL) {
1206 WARN("invalid parameter: lpdwStatus == NULL\n");
1207 return DSERR_INVALIDPARAM;
1208 }
1209
1210 *lpdwStatus = 0;
1211 EnterCriticalSection(&(This->dsound->lock));
1212
1213 TRACE("old This->dsound->state=%s, old lpdwStatus=%08lx\n",
1214 captureStateString[This->dsound->state],*lpdwStatus);
1215 if ((This->dsound->state == STATE_STARTING) ||
1216 (This->dsound->state == STATE_CAPTURING)) {
1217 *lpdwStatus |= DSCBSTATUS_CAPTURING;
1218 if (This->flags & DSCBSTART_LOOPING)
1219 *lpdwStatus |= DSCBSTATUS_LOOPING;
1220 }
1221 TRACE("new This->dsound->state=%s, new lpdwStatus=%08lx\n",
1222 captureStateString[This->dsound->state],*lpdwStatus);
1223 LeaveCriticalSection(&(This->dsound->lock));
1224
1225 TRACE("status=%lx\n", *lpdwStatus);
1226 TRACE("returning DS_OK\n");
1227 return DS_OK;
1228 }
1229
1230 static HRESULT WINAPI
1231 IDirectSoundCaptureBufferImpl_Initialize(
1232 LPDIRECTSOUNDCAPTUREBUFFER8 iface,
1233 LPDIRECTSOUNDCAPTURE lpDSC,
1234 LPCDSCBUFFERDESC lpcDSCBDesc )
1235 {
1236 ICOM_THIS(IDirectSoundCaptureBufferImpl,iface);
1237
1238 FIXME( "(%p,%p,%p): stub\n", This, lpDSC, lpcDSCBDesc );
1239
1240 return DS_OK;
1241 }
1242
1243 static HRESULT WINAPI
1244 IDirectSoundCaptureBufferImpl_Lock(
1245 LPDIRECTSOUNDCAPTUREBUFFER8 iface,
1246 DWORD dwReadCusor,
1247 DWORD dwReadBytes,
1248 LPVOID* lplpvAudioPtr1,
1249 LPDWORD lpdwAudioBytes1,
1250 LPVOID* lplpvAudioPtr2,
1251 LPDWORD lpdwAudioBytes2,
1252 DWORD dwFlags )
1253 {
1254 HRESULT err = DS_OK;
1255 ICOM_THIS(IDirectSoundCaptureBufferImpl,iface);
1256 TRACE( "(%p,%08lu,%08lu,%p,%p,%p,%p,0x%08lx) at %ld\n", This, dwReadCusor,
1257 dwReadBytes, lplpvAudioPtr1, lpdwAudioBytes1, lplpvAudioPtr2,
1258 lpdwAudioBytes2, dwFlags, GetTickCount() );
1259
1260 if (This == NULL) {
1261 WARN("invalid parameter: This == NULL\n");
1262 return DSERR_INVALIDPARAM;
1263 }
1264
1265 if (This->dsound == NULL) {
1266 WARN("invalid parameter: This->dsound == NULL\n");
1267 return DSERR_INVALIDPARAM;
1268 }
1269
1270 if (lplpvAudioPtr1 == NULL) {
1271 WARN("invalid parameter: lplpvAudioPtr1 == NULL\n");
1272 return DSERR_INVALIDPARAM;
1273 }
1274
1275 if (lpdwAudioBytes1 == NULL) {
1276 WARN("invalid parameter: lpdwAudioBytes1 == NULL\n");
1277 return DSERR_INVALIDPARAM;
1278 }
1279
1280 EnterCriticalSection(&(This->dsound->lock));
1281
1282 if (This->dsound->driver) {
1283 err = IDsCaptureDriverBuffer_Lock(This->dsound->hwbuf, lplpvAudioPtr1,
1284 lpdwAudioBytes1, lplpvAudioPtr2, lpdwAudioBytes2,
1285 dwReadCusor, dwReadBytes, dwFlags);
1286 if (err != DS_OK)
1287 WARN("IDsCaptureDriverBuffer_Lock failed\n");
1288 } else if (This->dsound->hwi) {
1289 *lplpvAudioPtr1 = This->dsound->buffer + dwReadCusor;
1290 if ( (dwReadCusor + dwReadBytes) > This->dsound->buflen) {
1291 *lpdwAudioBytes1 = This->dsound->buflen - dwReadCusor;
1292 if (lplpvAudioPtr2)
1293 *lplpvAudioPtr2 = This->dsound->buffer;
1294 if (lpdwAudioBytes2)
1295 *lpdwAudioBytes2 = dwReadBytes - *lpdwAudioBytes1;
1296 } else {
1297 *lpdwAudioBytes1 = dwReadBytes;
1298 if (lplpvAudioPtr2)
1299 *lplpvAudioPtr2 = 0;
1300 if (lpdwAudioBytes2)
1301 *lpdwAudioBytes2 = 0;
1302 }
1303 } else {
1304 TRACE("invalid call\n");
1305 err = DSERR_INVALIDCALL; /* DSERR_NODRIVER ? */
1306 }
1307
1308 LeaveCriticalSection(&(This->dsound->lock));
1309
1310 return err;
1311 }
1312
1313 static HRESULT WINAPI
1314 IDirectSoundCaptureBufferImpl_Start(
1315 LPDIRECTSOUNDCAPTUREBUFFER8 iface,
1316 DWORD dwFlags )
1317 {
1318 HRESULT err = DS_OK;
1319 ICOM_THIS(IDirectSoundCaptureBufferImpl,iface);
1320 TRACE( "(%p,0x%08lx)\n", This, dwFlags );
1321
1322 if (This == NULL) {
1323 WARN("invalid parameter: This == NULL\n");
1324 return DSERR_INVALIDPARAM;
1325 }
1326
1327 if (This->dsound == NULL) {
1328 WARN("invalid parameter: This->dsound == NULL\n");
1329 return DSERR_INVALIDPARAM;
1330 }
1331
1332 if ( (This->dsound->driver == 0) && (This->dsound->hwi == 0) ) {
1333 WARN("no driver\n");
1334 return DSERR_NODRIVER;
1335 }
1336
1337 EnterCriticalSection(&(This->dsound->lock));
1338
1339 This->flags = dwFlags;
1340 TRACE("old This->dsound->state=%s\n",captureStateString[This->dsound->state]);
1341 if (This->dsound->state == STATE_STOPPED)
1342 This->dsound->state = STATE_STARTING;
1343 else if (This->dsound->state == STATE_STOPPING)
1344 This->dsound->state = STATE_CAPTURING;
1345 TRACE("new This->dsound->state=%s\n",captureStateString[This->dsound->state]);
1346
1347 LeaveCriticalSection(&(This->dsound->lock));
1348
1349 if (This->dsound->driver) {
1350 err = IDsCaptureDriverBuffer_Start(This->dsound->hwbuf, dwFlags);
1351 if (err != DS_OK)
1352 WARN("IDsCaptureDriverBuffer_Start failed\n");
1353 return err;
1354 } else {
1355 IDirectSoundCaptureImpl* ipDSC = This->dsound;
1356
1357 if (ipDSC->buffer) {
1358 if (This->nrofnotifies) {
1359 unsigned c;
1360
1361 ipDSC->nrofpwaves = This->nrofnotifies;
1362 TRACE("nrofnotifies=%d\n", This->nrofnotifies);
1363
1364 /* prepare headers */
1365 if (ipDSC->pwave)
1366 ipDSC->pwave = HeapReAlloc(GetProcessHeap(),0,ipDSC->pwave,
1367 ipDSC->nrofpwaves*sizeof(WAVEHDR));
1368 else
1369 ipDSC->pwave = HeapAlloc(GetProcessHeap(),0,
1370 ipDSC->nrofpwaves*sizeof(WAVEHDR));
1371
1372 for (c = 0; c < ipDSC->nrofpwaves; c++) {
1373 if (This->notifies[c].dwOffset == DSBPN_OFFSETSTOP) {
1374 TRACE("got DSBPN_OFFSETSTOP\n");
1375 ipDSC->nrofpwaves = c;
1376 break;
1377 }
1378 if (c == 0) {
1379 ipDSC->pwave[0].lpData = ipDSC->buffer;
1380 ipDSC->pwave[0].dwBufferLength =
1381 This->notifies[0].dwOffset + 1;
1382 } else {
1383 ipDSC->pwave[c].lpData = ipDSC->buffer +
1384 This->notifies[c-1].dwOffset + 1;
1385 ipDSC->pwave[c].dwBufferLength =
1386 This->notifies[c].dwOffset -
1387 This->notifies[c-1].dwOffset;
1388 }
1389 ipDSC->pwave[c].dwBytesRecorded = 0;
1390 ipDSC->pwave[c].dwUser = (DWORD)ipDSC;
1391 ipDSC->pwave[c].dwFlags = 0;
1392 ipDSC->pwave[c].dwLoops = 0;
1393 err = mmErr(waveInPrepareHeader(ipDSC->hwi,
1394 &(ipDSC->pwave[c]),sizeof(WAVEHDR)));
1395 if (err != DS_OK) {
1396 WARN("waveInPrepareHeader failed\n");
1397 while (c--)
1398 waveInUnprepareHeader(ipDSC->hwi,
1399 &(ipDSC->pwave[c]),sizeof(WAVEHDR));
1400 break;
1401 }
1402
1403 err = mmErr(waveInAddBuffer(ipDSC->hwi,
1404 &(ipDSC->pwave[c]), sizeof(WAVEHDR)));
1405 if (err != DS_OK) {
1406 WARN("waveInAddBuffer failed\n");
1407 while (c--)
1408 waveInUnprepareHeader(ipDSC->hwi,
1409 &(ipDSC->pwave[c]),sizeof(WAVEHDR));
1410 break;
1411 }
1412 }
1413
1414 memset(ipDSC->buffer,
1415 (ipDSC->pwfx->wBitsPerSample == 8) ? 128 : 0, ipDSC->buflen);
1416 } else {
1417 TRACE("no notifiers specified\n");
1418 /* no notifiers specified so just create a single default header */
1419 ipDSC->nrofpwaves = 1;
1420 if (ipDSC->pwave)
1421 ipDSC->pwave = HeapReAlloc(GetProcessHeap(),0,ipDSC->pwave,sizeof(WAVEHDR));
1422 else
1423 ipDSC->pwave = HeapAlloc(GetProcessHeap(),0,sizeof(WAVEHDR));
1424
1425 ipDSC->pwave[0].lpData = ipDSC->buffer;
1426 ipDSC->pwave[0].dwBufferLength = ipDSC->buflen;
1427 ipDSC->pwave[0].dwBytesRecorded = 0;
1428 ipDSC->pwave[0].dwUser = (DWORD)ipDSC;
1429 ipDSC->pwave[0].dwFlags = 0;
1430 ipDSC->pwave[0].dwLoops = 0;
1431
1432 err = mmErr(waveInPrepareHeader(ipDSC->hwi,
1433 &(ipDSC->pwave[0]),sizeof(WAVEHDR)));
1434 if (err != DS_OK) {
1435 WARN("waveInPrepareHeader failed\n");
1436 waveInUnprepareHeader(ipDSC->hwi,
1437 &(ipDSC->pwave[0]),sizeof(WAVEHDR));
1438 }
1439 err = mmErr(waveInAddBuffer(ipDSC->hwi,
1440 &(ipDSC->pwave[0]), sizeof(WAVEHDR)));
1441 if (err != DS_OK) {
1442 WARN("waveInAddBuffer failed\n");
1443 waveInUnprepareHeader(ipDSC->hwi,
1444 &(ipDSC->pwave[0]),sizeof(WAVEHDR));
1445 }
1446 }
1447 }
1448
1449 ipDSC->index = 0;
1450 ipDSC->read_position = 0;
1451
1452 if (err == DS_OK) {
1453 /* start filling the first buffer */
1454 err = mmErr(waveInStart(ipDSC->hwi));
1455 if (err != DS_OK)
1456 WARN("waveInStart failed\n");
1457 }
1458 }
1459
1460 if (err != DS_OK) {
1461 WARN("calling waveInClose because of error\n");
1462 waveInClose(This->dsound->hwi);
1463 This->dsound->hwi = 0;
1464 }
1465
1466 TRACE("returning %ld\n", err);
1467 return err;
1468 }
1469
1470 static HRESULT WINAPI
1471 IDirectSoundCaptureBufferImpl_Stop( LPDIRECTSOUNDCAPTUREBUFFER8 iface )
1472 {
1473 HRESULT err = DS_OK;
1474 ICOM_THIS(IDirectSoundCaptureBufferImpl,iface);
1475 TRACE( "(%p)\n", This );
1476
1477 if (This == NULL) {
1478 WARN("invalid parameter: This == NULL\n");
1479 return DSERR_INVALIDPARAM;
1480 }
1481
1482 if (This->dsound == NULL) {
1483 WARN("invalid parameter: This->dsound == NULL\n");
1484 return DSERR_INVALIDPARAM;
1485 }
1486
1487 EnterCriticalSection(&(This->dsound->lock));
1488
1489 TRACE("old This->dsound->state=%s\n",captureStateString[This->dsound->state]);
1490 if (This->dsound->state == STATE_CAPTURING)
1491 This->dsound->state = STATE_STOPPING;
1492 else if (This->dsound->state == STATE_STARTING)
1493 This->dsound->state = STATE_STOPPED;
1494 TRACE("new This->dsound->state=%s\n",captureStateString[This->dsound->state]);
1495
1496 LeaveCriticalSection(&(This->dsound->lock));
1497
1498 if (This->dsound->driver) {
1499 err = IDsCaptureDriverBuffer_Stop(This->dsound->hwbuf);
1500 if (err == DSERR_BUFFERLOST) {
1501 /* Wine-only: the driver wants us to reopen the device */
1502 IDsCaptureDriverBuffer_Release(This->dsound->hwbuf);
1503 err = IDsCaptureDriver_CreateCaptureBuffer(This->dsound->driver,
1504 This->dsound->pwfx,0,0,&(This->dsound->buflen),&(This->dsound->buffer),
1505 (LPVOID*)&(This->dsound->hwbuf));
1506 if (err != DS_OK) {
1507 WARN("IDsCaptureDriver_CreateCaptureBuffer failed\n");
1508 This->dsound->hwbuf = 0;
1509 }
1510 } else if (err != DS_OK)
1511 WARN("IDsCaptureDriverBuffer_Stop failed\n");
1512 } else if (This->dsound->hwi) {
1513 err = waveInStop(This->dsound->hwi);
1514 } else {
1515 WARN("no driver\n");
1516 err = DSERR_NODRIVER;
1517 }
1518
1519 TRACE( "(%p) returning 0x%08lx\n", This,err);
1520 return err;
1521 }
1522
1523 static HRESULT WINAPI
1524 IDirectSoundCaptureBufferImpl_Unlock(
1525 LPDIRECTSOUNDCAPTUREBUFFER8 iface,
1526 LPVOID lpvAudioPtr1,
1527 DWORD dwAudioBytes1,
1528 LPVOID lpvAudioPtr2,
1529 DWORD dwAudioBytes2 )
1530 {
1531 ICOM_THIS(IDirectSoundCaptureBufferImpl,iface);
1532 TRACE( "(%p,%p,%08lu,%p,%08lu)\n", This, lpvAudioPtr1, dwAudioBytes1,
1533 lpvAudioPtr2, dwAudioBytes2 );
1534
1535 if (This == NULL) {
1536 WARN("invalid parameter: This == NULL\n");
1537 return DSERR_INVALIDPARAM;
1538 }
1539
1540 if (lpvAudioPtr1 == NULL) {
1541 WARN("invalid parameter: lpvAudioPtr1 == NULL\n");
1542 return DSERR_INVALIDPARAM;
1543 }
1544
1545 if (This->dsound->driver) {
1546 HRESULT hres;
1547 hres = IDsCaptureDriverBuffer_Unlock(This->dsound->hwbuf, lpvAudioPtr1,
1548 dwAudioBytes1, lpvAudioPtr2, dwAudioBytes2);
1549 if (hres != DS_OK)
1550 WARN("IDsCaptureDriverBuffer_Unlock failed\n");
1551 return hres;
1552 } else if (This->dsound->hwi) {
1553 This->dsound->read_position = (This->dsound->read_position +
1554 (dwAudioBytes1 + dwAudioBytes2)) % This->dsound->buflen;
1555 } else {
1556 WARN("invalid call\n");
1557 return DSERR_INVALIDCALL;
1558 }
1559
1560 return DS_OK;
1561 }
1562
1563 static HRESULT WINAPI
1564 IDirectSoundCaptureBufferImpl_GetObjectInPath(
1565 LPDIRECTSOUNDCAPTUREBUFFER8 iface,
1566 REFGUID rguidObject,
1567 DWORD dwIndex,
1568 REFGUID rguidInterface,
1569 LPVOID* ppObject )
1570 {
1571 ICOM_THIS(IDirectSoundCaptureBufferImpl,iface);
1572
1573 FIXME( "(%p,%s,%lu,%s,%p): stub\n", This, debugstr_guid(rguidObject),
1574 dwIndex, debugstr_guid(rguidInterface), ppObject );
1575
1576 return DS_OK;
1577 }
1578
1579 static HRESULT WINAPI
1580 IDirectSoundCaptureBufferImpl_GetFXStatus(
1581 LPDIRECTSOUNDCAPTUREBUFFER8 iface,
1582 DWORD dwFXCount,
1583 LPDWORD pdwFXStatus )
1584 {
1585 ICOM_THIS(IDirectSoundCaptureBufferImpl,iface);
1586
1587 FIXME( "(%p,%lu,%p): stub\n", This, dwFXCount, pdwFXStatus );
1588
1589 return DS_OK;
1590 }
1591
1592 static ICOM_VTABLE(IDirectSoundCaptureBuffer8) dscbvt =
1593 {
1594 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1595 /* IUnknown methods */
1596 IDirectSoundCaptureBufferImpl_QueryInterface,
1597 IDirectSoundCaptureBufferImpl_AddRef,
1598 IDirectSoundCaptureBufferImpl_Release,
1599
1600 /* IDirectSoundCaptureBuffer methods */
1601 IDirectSoundCaptureBufferImpl_GetCaps,
1602 IDirectSoundCaptureBufferImpl_GetCurrentPosition,
1603 IDirectSoundCaptureBufferImpl_GetFormat,
1604 IDirectSoundCaptureBufferImpl_GetStatus,
1605 IDirectSoundCaptureBufferImpl_Initialize,
1606 IDirectSoundCaptureBufferImpl_Lock,
1607 IDirectSoundCaptureBufferImpl_Start,
1608 IDirectSoundCaptureBufferImpl_Stop,
1609 IDirectSoundCaptureBufferImpl_Unlock,
1610
1611 /* IDirectSoundCaptureBuffer methods */
1612 IDirectSoundCaptureBufferImpl_GetObjectInPath,
1613 IDirectSoundCaptureBufferImpl_GetFXStatus
1614 };
1615
1616 /*******************************************************************************
1617 * DirectSoundCapture ClassFactory
1618 */
1619
1620 static HRESULT WINAPI
1621 DSCCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj)
1622 {
1623 ICOM_THIS(IClassFactoryImpl,iface);
1624
1625 FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
1626 return E_NOINTERFACE;
1627 }
1628
1629 static ULONG WINAPI
1630 DSCCF_AddRef(LPCLASSFACTORY iface)
1631 {
1632 ICOM_THIS(IClassFactoryImpl,iface);
1633 TRACE("(%p) ref was %ld\n", This, This->ref);
1634 return ++(This->ref);
1635 }
1636
1637 static ULONG WINAPI
1638 DSCCF_Release(LPCLASSFACTORY iface)
1639 {
1640 ICOM_THIS(IClassFactoryImpl,iface);
1641 /* static class, won't be freed */
1642 TRACE("(%p) ref was %ld\n", This, This->ref);
1643 return --(This->ref);
1644 }
1645
1646 static HRESULT WINAPI
1647 DSCCF_CreateInstance(
1648 LPCLASSFACTORY iface,LPUNKNOWN pOuter,REFIID riid,LPVOID *ppobj )
1649 {
1650 ICOM_THIS(IClassFactoryImpl,iface);
1651 TRACE("(%p)->(%p,%s,%p)\n",This,pOuter,debugstr_guid(riid),ppobj);
1652
1653 if (ppobj == NULL) {
1654 WARN("invalid parameter\n");
1655 return E_INVALIDARG;
1656 }
1657
1658 *ppobj = NULL;
1659
1660 if ( IsEqualGUID( &IID_IDirectSoundCapture, riid ) ||
1661 IsEqualGUID( &IID_IDirectSoundCapture8, riid ) ) {
1662 return DirectSoundCaptureCreate8(0,(LPDIRECTSOUNDCAPTURE8*)ppobj,pOuter);
1663 }
1664
1665 WARN("(%p,%p,%s,%p) Interface not found!\n",This,pOuter,debugstr_guid(riid),ppobj);
1666 return E_NOINTERFACE;
1667 }
1668
1669 static HRESULT WINAPI
1670 DSCCF_LockServer(LPCLASSFACTORY iface,BOOL dolock)
1671 {
1672 ICOM_THIS(IClassFactoryImpl,iface);
1673 FIXME("(%p)->(%d),stub!\n",This,dolock);
1674 return S_OK;
1675 }
1676
1677 static ICOM_VTABLE(IClassFactory) DSCCF_Vtbl =
1678 {
1679 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1680 DSCCF_QueryInterface,
1681 DSCCF_AddRef,
1682 DSCCF_Release,
1683 DSCCF_CreateInstance,
1684 DSCCF_LockServer
1685 };
1686
1687 IClassFactoryImpl DSOUND_CAPTURE_CF = { &DSCCF_Vtbl, 1 };
1688
1689 /***************************************************************************
1690 * DirectSoundFullDuplexCreate [DSOUND.10]
1691 *
1692 * Create and initialize a DirectSoundFullDuplex interface.
1693 *
1694 * PARAMS
1695 * pcGuidCaptureDevice [I] Address of sound capture device GUID.
1696 * pcGuidRenderDevice [I] Address of sound render device GUID.
1697 * pcDSCBufferDesc [I] Address of capture buffer description.
1698 * pcDSBufferDesc [I] Address of render buffer description.
1699 * hWnd [I] Handle to application window.
1700 * dwLevel [I] Cooperative level.
1701 * ppDSFD [O] Address where full duplex interface returned.
1702 * ppDSCBuffer8 [0] Address where capture buffer interface returned.
1703 * ppDSBuffer8 [0] Address where render buffer interface returned.
1704 * pUnkOuter [I] Must be NULL.
1705 *
1706 * RETURNS
1707 * Success: DS_OK
1708 * Failure: DSERR_NOAGGREGATION, DSERR_ALLOCATED, DSERR_INVALIDPARAM,
1709 * DSERR_OUTOFMEMORY DSERR_INVALIDCALL DSERR_NODRIVER
1710 */
1711 HRESULT WINAPI
1712 DirectSoundFullDuplexCreate(
1713 LPCGUID pcGuidCaptureDevice,
1714 LPCGUID pcGuidRenderDevice,
1715 LPCDSCBUFFERDESC pcDSCBufferDesc,
1716 LPCDSBUFFERDESC pcDSBufferDesc,
1717 HWND hWnd,
1718 DWORD dwLevel,
1719 LPDIRECTSOUNDFULLDUPLEX *ppDSFD,
1720 LPDIRECTSOUNDCAPTUREBUFFER8 *ppDSCBuffer8,
1721 LPDIRECTSOUNDBUFFER8 *ppDSBuffer8,
1722 LPUNKNOWN pUnkOuter)
1723 {
1724 IDirectSoundFullDuplexImpl** ippDSFD=(IDirectSoundFullDuplexImpl**)ppDSFD;
1725 TRACE("(%s,%s,%p,%p,%lx,%lx,%p,%p,%p,%p)\n", debugstr_guid(pcGuidCaptureDevice),
1726 debugstr_guid(pcGuidRenderDevice), pcDSCBufferDesc, pcDSBufferDesc,
1727 (DWORD)hWnd, dwLevel, ppDSFD, ppDSCBuffer8, ppDSBuffer8, pUnkOuter);
1728
1729 if ( pUnkOuter ) {
1730 WARN("pUnkOuter != 0\n");
1731 return DSERR_NOAGGREGATION;
1732 }
1733
1734 *ippDSFD = (IDirectSoundFullDuplexImpl*)HeapAlloc(GetProcessHeap(),
1735 HEAP_ZERO_MEMORY, sizeof(IDirectSoundFullDuplexImpl));
1736
1737 if (*ippDSFD == NULL) {
1738 WARN("out of memory\n");
1739 return DSERR_OUTOFMEMORY;
1740 } else {
1741 HRESULT hres;
1742 ICOM_THIS(IDirectSoundFullDuplexImpl, *ippDSFD);
1743
1744 This->ref = 1;
1745 This->lpVtbl = &dsfdvt;
1746
1747 InitializeCriticalSection( &(This->lock) );
1748
1749 hres = IDirectSoundFullDuplexImpl_Initialize( (LPDIRECTSOUNDFULLDUPLEX)This,
1750 pcGuidCaptureDevice, pcGuidRenderDevice,
1751 pcDSCBufferDesc, pcDSBufferDesc,
1752 hWnd, dwLevel, ppDSCBuffer8, ppDSBuffer8);
1753 if (hres != DS_OK)
1754 WARN("IDirectSoundFullDuplexImpl_Initialize failed\n");
1755 return hres;
1756 }
1757
1758 return DSERR_GENERIC;
1759 }
1760
1761 static HRESULT WINAPI
1762 IDirectSoundFullDuplexImpl_QueryInterface(
1763 LPDIRECTSOUNDFULLDUPLEX iface,
1764 REFIID riid,
1765 LPVOID* ppobj )
1766 {
1767 ICOM_THIS(IDirectSoundFullDuplexImpl,iface);
1768 TRACE( "(%p,%s,%p)\n", This, debugstr_guid(riid), ppobj );
1769
1770 if (ppobj == NULL) {
1771 WARN("invalid parameter\n");
1772 return E_INVALIDARG;
1773 }
1774
1775 *ppobj = NULL;
1776 return E_NOINTERFACE;
1777 }
1778
1779 static ULONG WINAPI
1780 IDirectSoundFullDuplexImpl_AddRef( LPDIRECTSOUNDFULLDUPLEX iface )
1781 {
1782 ULONG uRef;
1783 ICOM_THIS(IDirectSoundFullDuplexImpl,iface);
1784 TRACE("(%p) ref was %ld, thread is %04lx\n",This, This->ref, GetCurrentThreadId());
1785
1786 EnterCriticalSection( &(This->lock) );
1787
1788 uRef = ++(This->ref);
1789
1790 LeaveCriticalSection( &(This->lock) );
1791
1792 return uRef;
1793 }
1794
1795 static ULONG WINAPI
1796 IDirectSoundFullDuplexImpl_Release( LPDIRECTSOUNDFULLDUPLEX iface )
1797 {
1798 ULONG uRef;
1799 ICOM_THIS(IDirectSoundFullDuplexImpl,iface);
1800 TRACE("(%p) ref was %ld, thread is %04lx\n",This, This->ref, GetCurrentThreadId());
1801
1802 EnterCriticalSection( &(This->lock) );
1803
1804 uRef = --(This->ref);
1805
1806 LeaveCriticalSection( &(This->lock) );
1807
1808 if ( uRef == 0 ) {
1809 DeleteCriticalSection( &(This->lock) );
1810 HeapFree( GetProcessHeap(), 0, This );
1811 TRACE("(%p) released\n",This);
1812 }
1813
1814 return uRef;
1815 }
1816
1817 static HRESULT WINAPI
1818 IDirectSoundFullDuplexImpl_Initialize(
1819 LPDIRECTSOUNDFULLDUPLEX iface,
1820 LPCGUID pCaptureGuid,
1821 LPCGUID pRendererGuid,
1822 LPCDSCBUFFERDESC lpDscBufferDesc,
1823 LPCDSBUFFERDESC lpDsBufferDesc,
1824 HWND hWnd,
1825 DWORD dwLevel,
1826 LPLPDIRECTSOUNDCAPTUREBUFFER8 lplpDirectSoundCaptureBuffer8,
1827 LPLPDIRECTSOUNDBUFFER8 lplpDirectSoundBuffer8 )
1828 {
1829 ICOM_THIS(IDirectSoundFullDuplexImpl,iface);
1830 IDirectSoundCaptureBufferImpl** ippdscb=(IDirectSoundCaptureBufferImpl**)lplpDirectSoundCaptureBuffer8;
1831 IDirectSoundBufferImpl** ippdsc=(IDirectSoundBufferImpl**)lplpDirectSoundBuffer8;
1832
1833 FIXME( "(%p,%s,%s,%p,%p,%lx,%lx,%p,%p) stub!\n", This, debugstr_guid(pCaptureGuid),
1834 debugstr_guid(pRendererGuid), lpDscBufferDesc, lpDsBufferDesc, (DWORD)hWnd, dwLevel,
1835 ippdscb, ippdsc);
1836
1837 return E_FAIL;
1838 }
1839
1840 static ICOM_VTABLE(IDirectSoundFullDuplex) dsfdvt =
1841 {
1842 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1843 /* IUnknown methods */
1844 IDirectSoundFullDuplexImpl_QueryInterface,
1845 IDirectSoundFullDuplexImpl_AddRef,
1846 IDirectSoundFullDuplexImpl_Release,
1847
1848 /* IDirectSoundFullDuplex methods */
1849 IDirectSoundFullDuplexImpl_Initialize
1850 };
1851
1852 /*******************************************************************************
1853 * DirectSoundFullDuplex ClassFactory
1854 */
1855
1856 static HRESULT WINAPI
1857 DSFDCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj)
1858 {
1859 ICOM_THIS(IClassFactoryImpl,iface);
1860
1861 FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
1862 return E_NOINTERFACE;
1863 }
1864
1865 static ULONG WINAPI
1866 DSFDCF_AddRef(LPCLASSFACTORY iface)
1867 {
1868 ICOM_THIS(IClassFactoryImpl,iface);
1869 TRACE("(%p) ref was %ld\n", This, This->ref);
1870 return ++(This->ref);
1871 }
1872
1873 static ULONG WINAPI
1874 DSFDCF_Release(LPCLASSFACTORY iface)
1875 {
1876 ICOM_THIS(IClassFactoryImpl,iface);
1877 /* static class, won't be freed */
1878 TRACE("(%p) ref was %ld\n", This, This->ref);
1879 return --(This->ref);
1880 }
1881
1882 static HRESULT WINAPI
1883 DSFDCF_CreateInstance(
1884 LPCLASSFACTORY iface,LPUNKNOWN pOuter,REFIID riid,LPVOID *ppobj )
1885 {
1886 ICOM_THIS(IClassFactoryImpl,iface);
1887
1888 TRACE("(%p)->(%p,%s,%p)\n",This,pOuter,debugstr_guid(riid),ppobj);
1889
1890 if (ppobj == NULL) {
1891 WARN("invalid parameter\n");
1892 return E_INVALIDARG;
1893 }
1894
1895 *ppobj = NULL;
1896
1897 if ( IsEqualGUID( &IID_IDirectSoundFullDuplex, riid ) ) {
1898 /* FIXME: how do we do this one ? */
1899 FIXME("not implemented\n");
1900 return E_NOINTERFACE;
1901 }
1902
1903 WARN("(%p,%p,%s,%p) Interface not found!\n",This,pOuter,debugstr_guid(riid),ppobj);
1904 return E_NOINTERFACE;
1905 }
1906
1907 static HRESULT WINAPI
1908 DSFDCF_LockServer(LPCLASSFACTORY iface,BOOL dolock)
1909 {
1910 ICOM_THIS(IClassFactoryImpl,iface);
1911 FIXME("(%p)->(%d),stub!\n",This,dolock);
1912 return S_OK;
1913 }
1914
1915 static ICOM_VTABLE(IClassFactory) DSFDCF_Vtbl =
1916 {
1917 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1918 DSFDCF_QueryInterface,
1919 DSFDCF_AddRef,
1920 DSFDCF_Release,
1921 DSFDCF_CreateInstance,
1922 DSFDCF_LockServer
1923 };
1924
1925 IClassFactoryImpl DSOUND_FULLDUPLEX_CF = { &DSFDCF_Vtbl, 1 };
Windows API implementation