?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 20030408.
[wine/gsoc-2012-control.git] / dlls / dsound / dsound_main.c
blob5cd20a00e76de4d0088716509dadd683e7278f37
1 /* DirectSound
2 *
3 * Copyright 1998 Marcus Meissner
4 * Copyright 1998 Rob Riggs
5 * Copyright 2000-2002 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 * Most thread locking is complete. There may be a few race
23 * conditions still lurking.
24 *
25 * Tested with a Soundblaster clone, a Gravis UltraSound Classic,
26 * and a Turtle Beach Tropez+.
27 *
28 * TODO:
29 * Implement SetCooperativeLevel properly (need to address focus issues)
30 * Implement DirectSound3DBuffers (stubs in place)
31 * Use hardware 3D support if available
32 * Add critical section locking inside Release and AddRef methods
33 * Handle static buffers - put those in hardware, non-static not in hardware
34 * Hardware DuplicateSoundBuffer
35 * Proper volume calculation, and setting volume in HEL primary buffer
36 * Optimize WINMM and negotiate fragment size, decrease DS_HEL_MARGIN
37 */
38
39 #include "config.h"
40 #include "wine/port.h"
41
42 #include <assert.h>
43 #include <stdio.h>
44 #include <sys/types.h>
45 #include <sys/fcntl.h>
46 #ifdef HAVE_UNISTD_H
47 # include <unistd.h>
48 #endif
49 #include <stdlib.h>
50 #include <string.h>
51 #include <math.h> /* Insomnia - pow() function */
52
53 #include "windef.h"
54 #include "winbase.h"
55 #include "winreg.h"
56 #include "winuser.h"
57 #include "wingdi.h"
58 #include "winuser.h"
59 #include "winerror.h"
60 #include "mmsystem.h"
61 #include "winternl.h"
62 #include "mmddk.h"
63 #include "wine/windef16.h"
64 #include "wine/winbase16.h"
65 #include "wine/debug.h"
66 #include "dsound.h"
67 #include "dsdriver.h"
68 #include "dsound_private.h"
69
70 WINE_DEFAULT_DEBUG_CHANNEL(dsound);
71
72 /* these are eligible for tuning... they must be high on slow machines... */
73 /* some stuff may get more responsive with lower values though... */
74 #define DS_EMULDRIVER 0 /* some games (Quake 2, UT) refuse to accept
75 emulated dsound devices. set to 0 ! */
76 #define DS_HEL_MARGIN 5 /* HEL only: number of waveOut fragments ahead to mix in new buffers
77 * (keep this close or equal to DS_HEL_QUEUE for best results) */
78 #define DS_HEL_QUEUE 5 /* HEL only: number of waveOut fragments ahead to queue to driver
79 * (this will affect HEL sound reliability and latency) */
80
81 #define DS_SND_QUEUE_MAX 28 /* max number of fragments to prebuffer */
82 #define DS_SND_QUEUE_MIN 12 /* min number of fragments to prebuffer */
83
84 IDirectSoundImpl* dsound = NULL;
85
86 HRESULT mmErr(UINT err)
87 {
88 switch(err) {
89 case MMSYSERR_NOERROR:
90 return DS_OK;
91 case MMSYSERR_ALLOCATED:
92 return DSERR_ALLOCATED;
93 case MMSYSERR_ERROR:
94 case MMSYSERR_INVALHANDLE:
95 case WAVERR_STILLPLAYING:
96 return DSERR_GENERIC; /* FIXME */
97 case MMSYSERR_NODRIVER:
98 return DSERR_NODRIVER;
99 case MMSYSERR_NOMEM:
100 return DSERR_OUTOFMEMORY;
101 case MMSYSERR_INVALPARAM:
102 case WAVERR_BADFORMAT:
103 case WAVERR_UNPREPARED:
104 return DSERR_INVALIDPARAM;
105 case MMSYSERR_NOTSUPPORTED:
106 return DSERR_UNSUPPORTED;
107 default:
108 FIXME("Unknown MMSYS error %d\n",err);
109 return DSERR_GENERIC;
110 }
111 }
112
113 int ds_emuldriver = DS_EMULDRIVER;
114 int ds_hel_margin = DS_HEL_MARGIN;
115 int ds_hel_queue = DS_HEL_QUEUE;
116 int ds_snd_queue_max = DS_SND_QUEUE_MAX;
117 int ds_snd_queue_min = DS_SND_QUEUE_MIN;
118 int ds_hw_accel = DS_HW_ACCEL_FULL;
119 int ds_default_playback = 0;
120 int ds_default_capture = 0;
121
122 /*
123 * Get a config key from either the app-specific or the default config
124 */
125
126 inline static DWORD get_config_key( HKEY defkey, HKEY appkey, const char *name,
127 char *buffer, DWORD size )
128 {
129 if (appkey && !RegQueryValueExA( appkey, name, 0, NULL, buffer, &size )) return 0;
130 return RegQueryValueExA( defkey, name, 0, NULL, buffer, &size );
131 }
132
133
134 /*
135 * Setup the dsound options.
136 */
137
138 void setup_dsound_options(void)
139 {
140 char buffer[MAX_PATH+1];
141 HKEY hkey, appkey = 0;
142
143 buffer[MAX_PATH]='\0';
144
145 if (RegCreateKeyExA( HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\dsound", 0, NULL,
146 REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, NULL ))
147 {
148 ERR("Cannot create config registry key\n" );
149 ExitProcess(1);
150 }
151
152 if (GetModuleFileNameA( 0, buffer, MAX_PATH ))
153 {
154 HKEY tmpkey;
155
156 if (!RegOpenKeyA( HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\AppDefaults", &tmpkey ))
157 {
158 char appname[MAX_PATH+16];
159 char *p = strrchr( buffer, '\\' );
160 if (p!=NULL) {
161 appname[MAX_PATH]='\0';
162 strncpy(appname,p+1,MAX_PATH);
163 strcat(appname,"\\dsound");
164 TRACE("appname = [%s] \n",appname);
165 if (RegOpenKeyA( tmpkey, appname, &appkey )) appkey = 0;
166 RegCloseKey( tmpkey );
167 }
168 }
169 }
170
171 /* get options */
172
173 if (!get_config_key( hkey, appkey, "EmulDriver", buffer, MAX_PATH ))
174 ds_emuldriver = strcmp(buffer, "N");
175
176 if (!get_config_key( hkey, appkey, "HELmargin", buffer, MAX_PATH ))
177 ds_hel_margin = atoi(buffer);
178
179 if (!get_config_key( hkey, appkey, "HELqueue", buffer, MAX_PATH ))
180 ds_hel_queue = atoi(buffer);
181
182 if (!get_config_key( hkey, appkey, "SndQueueMax", buffer, MAX_PATH ))
183 ds_snd_queue_max = atoi(buffer);
184
185 if (!get_config_key( hkey, appkey, "SndQueueMin", buffer, MAX_PATH ))
186 ds_snd_queue_min = atoi(buffer);
187
188 if (!get_config_key( hkey, appkey, "HardwareAcceleration", buffer, MAX_PATH )) {
189 if (strcmp(buffer, "Full") == 0)
190 ds_hw_accel = DS_HW_ACCEL_FULL;
191 else if (strcmp(buffer, "Standard") == 0)
192 ds_hw_accel = DS_HW_ACCEL_STANDARD;
193 else if (strcmp(buffer, "Basic") == 0)
194 ds_hw_accel = DS_HW_ACCEL_BASIC;
195 else if (strcmp(buffer, "Emulation") == 0)
196 ds_hw_accel = DS_HW_ACCEL_EMULATION;
197 }
198
199 if (!get_config_key( hkey, appkey, "DefaultPlayback", buffer, MAX_PATH ))
200 ds_default_playback = atoi(buffer);
201
202 if (!get_config_key( hkey, appkey, "DefaultCapture", buffer, MAX_PATH ))
203 ds_default_capture = atoi(buffer);
204
205 if (appkey) RegCloseKey( appkey );
206 RegCloseKey( hkey );
207
208 if (ds_emuldriver != DS_EMULDRIVER )
209 WARN("ds_emuldriver = %d (default=%d)\n",ds_emuldriver, DS_EMULDRIVER);
210 if (ds_hel_margin != DS_HEL_MARGIN )
211 WARN("ds_hel_margin = %d (default=%d)\n",ds_hel_margin, DS_HEL_MARGIN );
212 if (ds_hel_queue != DS_HEL_QUEUE )
213 WARN("ds_hel_queue = %d (default=%d)\n",ds_hel_queue, DS_HEL_QUEUE );
214 if (ds_snd_queue_max != DS_SND_QUEUE_MAX)
215 WARN("ds_snd_queue_max = %d (default=%d)\n",ds_snd_queue_max ,DS_SND_QUEUE_MAX);
216 if (ds_snd_queue_min != DS_SND_QUEUE_MIN)
217 WARN("ds_snd_queue_min = %d (default=%d)\n",ds_snd_queue_min ,DS_SND_QUEUE_MIN);
218 if (ds_hw_accel != DS_HW_ACCEL_FULL)
219 WARN("ds_hw_accel = %s (default=Full)\n",
220 ds_hw_accel==DS_HW_ACCEL_FULL ? "Full" :
221 ds_hw_accel==DS_HW_ACCEL_STANDARD ? "Standard" :
222 ds_hw_accel==DS_HW_ACCEL_BASIC ? "Basic" :
223 ds_hw_accel==DS_HW_ACCEL_EMULATION ? "Emulation" :
224 "Unknown");
225 if (ds_default_playback != 0)
226 WARN("ds_default_playback = %d (default=0)\n",ds_default_playback);
227 if (ds_default_capture != 0)
228 WARN("ds_default_capture = %d (default=0)\n",ds_default_playback);
229 }
230
231
232
233 /***************************************************************************
234 * GetDeviceId [DSOUND.2]
235 *
236 * Retrieves unique identifier of default device specified
237 *
238 * RETURNS
239 * Success: DS_OK
240 * Failure: DSERR_INVALIDPARAM
241 */
242 HRESULT WINAPI GetDeviceID(LPCGUID pGuidSrc, LPGUID pGuidDest)
243 {
244 if ( ( pGuidSrc == NULL) || (pGuidDest == NULL) ) {
245 WARN("invalid parameter\n");
246 return DSERR_INVALIDPARAM;
247 }
248
249 if ( IsEqualGUID( &DSDEVID_DefaultPlayback, pGuidSrc ) ||
250 IsEqualGUID( &DSDEVID_DefaultVoicePlayback, pGuidSrc ) ) {
251 GUID guid;
252 int err = mmErr(waveOutMessage((HWAVEOUT)ds_default_playback,DRV_QUERYDSOUNDGUID,(DWORD)&guid,0));
253 if (err == DS_OK) {
254 memcpy(pGuidDest, &guid, sizeof(GUID));
255 return DS_OK;
256 }
257 }
258
259 if ( IsEqualGUID( &DSDEVID_DefaultCapture, pGuidSrc ) ||
260 IsEqualGUID( &DSDEVID_DefaultVoiceCapture, pGuidSrc ) ) {
261 GUID guid;
262 int err = mmErr(waveInMessage((HWAVEIN)ds_default_capture,DRV_QUERYDSOUNDGUID,(DWORD)&guid,0));
263 if (err == DS_OK) {
264 memcpy(pGuidDest, &guid, sizeof(GUID));
265 return DS_OK;
266 }
267 }
268
269 memcpy(pGuidDest, pGuidSrc, sizeof(GUID));
270
271 return DS_OK;
272 }
273
274
275 /***************************************************************************
276 * DirectSoundEnumerateA [DSOUND.2]
277 *
278 * Enumerate all DirectSound drivers installed in the system
279 *
280 * RETURNS
281 * Success: DS_OK
282 * Failure: DSERR_INVALIDPARAM
283 */
284 HRESULT WINAPI DirectSoundEnumerateA(
285 LPDSENUMCALLBACKA lpDSEnumCallback,
286 LPVOID lpContext)
287 {
288 unsigned devs, wod;
289 DSDRIVERDESC desc;
290 GUID guid;
291 int err;
292
293 TRACE("lpDSEnumCallback = %p, lpContext = %p\n",
294 lpDSEnumCallback, lpContext);
295
296 if (lpDSEnumCallback == NULL) {
297 WARN("invalid parameter\n");
298 return DSERR_INVALIDPARAM;
299 }
300
301 devs = waveOutGetNumDevs();
302 if (devs > 0) {
303 if (GetDeviceID(&DSDEVID_DefaultPlayback, &guid) == DS_OK) {
304 GUID temp;
305 for (wod = 0; wod < devs; ++wod) {
306 err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDGUID,(DWORD)&temp,0));
307 if (err == DS_OK) {
308 if (IsEqualGUID( &guid, &temp ) ) {
309 err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDDESC,(DWORD)&desc,0));
310 if (err == DS_OK) {
311 TRACE("calling lpDSEnumCallback(%s,\"%s\",\"%s\",%p)\n",
312 debugstr_guid(&DSDEVID_DefaultPlayback),"Primary Sound Driver",desc.szDrvName,lpContext);
313 if (lpDSEnumCallback((LPGUID)&DSDEVID_DefaultPlayback, "Primary Sound Driver", desc.szDrvName, lpContext) == FALSE)
314 return DS_OK;
315 }
316 }
317 }
318 }
319 }
320 }
321
322 for (wod = 0; wod < devs; ++wod) {
323 err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDDESC,(DWORD)&desc,0));
324 if (err == DS_OK) {
325 err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDGUID,(DWORD)&guid,0));
326 if (err == DS_OK) {
327 TRACE("calling lpDSEnumCallback(%s,\"%s\",\"%s\",%p)\n",
328 debugstr_guid(&guid),desc.szDesc,desc.szDrvName,lpContext);
329 if (lpDSEnumCallback(&guid, desc.szDesc, desc.szDrvName, lpContext) == FALSE)
330 return DS_OK;
331 }
332 }
333 }
334 return DS_OK;
335 }
336
337 /***************************************************************************
338 * DirectSoundEnumerateW [DSOUND.3]
339 *
340 * Enumerate all DirectSound drivers installed in the system
341 *
342 * RETURNS
343 * Success: DS_OK
344 * Failure: DSERR_INVALIDPARAM
345 */
346 HRESULT WINAPI DirectSoundEnumerateW(
347 LPDSENUMCALLBACKW lpDSEnumCallback,
348 LPVOID lpContext )
349 {
350 unsigned devs, wod;
351 DSDRIVERDESC desc;
352 GUID guid;
353 int err;
354 WCHAR wDesc[MAXPNAMELEN];
355 WCHAR wName[MAXPNAMELEN];
356
357 TRACE("lpDSEnumCallback = %p, lpContext = %p\n",
358 lpDSEnumCallback, lpContext);
359
360 if (lpDSEnumCallback == NULL) {
361 WARN("invalid parameter\n");
362 return DSERR_INVALIDPARAM;
363 }
364
365 devs = waveOutGetNumDevs();
366 if (devs > 0) {
367 if (GetDeviceID(&DSDEVID_DefaultPlayback, &guid) == DS_OK) {
368 GUID temp;
369 for (wod = 0; wod < devs; ++wod) {
370 err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDGUID,(DWORD)&temp,0));
371 if (err == DS_OK) {
372 if (IsEqualGUID( &guid, &temp ) ) {
373 err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDDESC,(DWORD)&desc,0));
374 if (err == DS_OK) {
375 TRACE("calling lpDSEnumCallback(%s,\"%s\",\"%s\",%p)\n",
376 debugstr_guid(&DSDEVID_DefaultPlayback),"Primary Sound Driver",desc.szDrvName,lpContext);
377 MultiByteToWideChar( CP_ACP, 0, "Primary Sound Driver", -1,
378 wDesc, sizeof(wDesc)/sizeof(WCHAR) );
379 MultiByteToWideChar( CP_ACP, 0, desc.szDrvName, -1,
380 wName, sizeof(wName)/sizeof(WCHAR) );
381 if (lpDSEnumCallback((LPGUID)&DSDEVID_DefaultPlayback, wDesc, wName, lpContext) == FALSE)
382 return DS_OK;
383 }
384 }
385 }
386 }
387 }
388 }
389
390 for (wod = 0; wod < devs; ++wod) {
391 err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDDESC,(DWORD)&desc,0));
392 if (err == DS_OK) {
393 err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDGUID,(DWORD)&guid,0));
394 if (err == DS_OK) {
395 TRACE("calling lpDSEnumCallback(%s,\"%s\",\"%s\",%p)\n",
396 debugstr_guid(&guid),desc.szDesc,desc.szDrvName,lpContext);
397 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1,
398 wDesc, sizeof(wDesc)/sizeof(WCHAR) );
399 MultiByteToWideChar( CP_ACP, 0, desc.szDrvName, -1,
400 wName, sizeof(wName)/sizeof(WCHAR) );
401 if (lpDSEnumCallback(&guid, wDesc, wName, lpContext) == FALSE)
402 return DS_OK;
403 }
404 }
405 }
406 return DS_OK;
407 }
408
409
410 static void _dump_DSBCAPS(DWORD xmask) {
411 struct {
412 DWORD mask;
413 char *name;
414 } flags[] = {
415 #define FE(x) { x, #x },
416 FE(DSBCAPS_PRIMARYBUFFER)
417 FE(DSBCAPS_STATIC)
418 FE(DSBCAPS_LOCHARDWARE)
419 FE(DSBCAPS_LOCSOFTWARE)
420 FE(DSBCAPS_CTRL3D)
421 FE(DSBCAPS_CTRLFREQUENCY)
422 FE(DSBCAPS_CTRLPAN)
423 FE(DSBCAPS_CTRLVOLUME)
424 FE(DSBCAPS_CTRLPOSITIONNOTIFY)
425 FE(DSBCAPS_CTRLDEFAULT)
426 FE(DSBCAPS_CTRLALL)
427 FE(DSBCAPS_STICKYFOCUS)
428 FE(DSBCAPS_GLOBALFOCUS)
429 FE(DSBCAPS_GETCURRENTPOSITION2)
430 FE(DSBCAPS_MUTE3DATMAXDISTANCE)
431 #undef FE
432 };
433 int i;
434
435 for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
436 if ((flags[i].mask & xmask) == flags[i].mask)
437 DPRINTF("%s ",flags[i].name);
438 }
439
440 /*******************************************************************************
441 * IDirectSound
442 */
443
444 static HRESULT WINAPI IDirectSoundImpl_SetCooperativeLevel(
445 LPDIRECTSOUND8 iface,HWND hwnd,DWORD level
446 ) {
447 ICOM_THIS(IDirectSoundImpl,iface);
448
449 FIXME("(%p,%08lx,%ld):stub\n",This,(DWORD)hwnd,level);
450
451 This->priolevel = level;
452
453 return DS_OK;
454 }
455
456 static HRESULT WINAPI IDirectSoundImpl_CreateSoundBuffer(
457 LPDIRECTSOUND8 iface,LPDSBUFFERDESC dsbd,LPLPDIRECTSOUNDBUFFER8 ppdsb,LPUNKNOWN lpunk
458 ) {
459 ICOM_THIS(IDirectSoundImpl,iface);
460 LPWAVEFORMATEX wfex;
461
462 TRACE("(%p,%p,%p,%p)\n",This,dsbd,ppdsb,lpunk);
463
464 if ((This == NULL) || (dsbd == NULL) || (ppdsb == NULL))
465 return DSERR_INVALIDPARAM;
466
467 if (TRACE_ON(dsound)) {
468 TRACE("(structsize=%ld)\n",dsbd->dwSize);
469 TRACE("(flags=0x%08lx:\n",dsbd->dwFlags);
470 _dump_DSBCAPS(dsbd->dwFlags);
471 DPRINTF(")\n");
472 TRACE("(bufferbytes=%ld)\n",dsbd->dwBufferBytes);
473 TRACE("(lpwfxFormat=%p)\n",dsbd->lpwfxFormat);
474 }
475
476 wfex = dsbd->lpwfxFormat;
477
478 if (wfex)
479 TRACE("(formattag=0x%04x,chans=%d,samplerate=%ld,"
480 "bytespersec=%ld,blockalign=%d,bitspersamp=%d,cbSize=%d)\n",
481 wfex->wFormatTag, wfex->nChannels, wfex->nSamplesPerSec,
482 wfex->nAvgBytesPerSec, wfex->nBlockAlign,
483 wfex->wBitsPerSample, wfex->cbSize);
484
485 if (dsbd->dwFlags & DSBCAPS_PRIMARYBUFFER)
486 return PrimaryBuffer_Create(This, (PrimaryBufferImpl**)ppdsb, dsbd);
487 else
488 return SecondaryBuffer_Create(This, (IDirectSoundBufferImpl**)ppdsb, dsbd);
489 }
490
491 static HRESULT WINAPI IDirectSoundImpl_DuplicateSoundBuffer(
492 LPDIRECTSOUND8 iface,LPDIRECTSOUNDBUFFER8 pdsb,LPLPDIRECTSOUNDBUFFER8 ppdsb
493 ) {
494 ICOM_THIS(IDirectSoundImpl,iface);
495 IDirectSoundBufferImpl* ipdsb=(IDirectSoundBufferImpl*)pdsb;
496 IDirectSoundBufferImpl** ippdsb=(IDirectSoundBufferImpl**)ppdsb;
497 TRACE("(%p,%p,%p)\n",This,ipdsb,ippdsb);
498
499 if (ipdsb->dsbd.dwFlags & DSBCAPS_PRIMARYBUFFER) {
500 ERR("trying to duplicate primary buffer\n");
501 return DSERR_INVALIDCALL;
502 }
503
504 if (ipdsb->hwbuf) {
505 FIXME("need to duplicate hardware buffer\n");
506 }
507
508 if (ipdsb->dsbd.dwFlags & DSBCAPS_CTRL3D) {
509 FIXME("need to duplicate 3D buffer\n");
510 }
511
512 *ippdsb = (IDirectSoundBufferImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectSoundBufferImpl));
513
514 IDirectSoundBuffer8_AddRef(pdsb);
515 memcpy(*ippdsb, ipdsb, sizeof(IDirectSoundBufferImpl));
516 (*ippdsb)->ref = 1;
517 (*ippdsb)->state = STATE_STOPPED;
518 (*ippdsb)->playpos = 0;
519 (*ippdsb)->buf_mixpos = 0;
520 (*ippdsb)->dsound = This;
521 (*ippdsb)->parent = ipdsb;
522 (*ippdsb)->hwbuf = NULL;
523 (*ippdsb)->ds3db = NULL; /* FIXME? */
524 (*ippdsb)->iks = NULL; /* FIXME? */
525 memcpy(&((*ippdsb)->wfx), &(ipdsb->wfx), sizeof((*ippdsb)->wfx));
526 InitializeCriticalSection(&(*ippdsb)->lock);
527 /* register buffer */
528 RtlAcquireResourceExclusive(&(This->lock), TRUE);
529 {
530 IDirectSoundBufferImpl **newbuffers = (IDirectSoundBufferImpl**)HeapReAlloc(GetProcessHeap(),0,This->buffers,sizeof(IDirectSoundBufferImpl**)*(This->nrofbuffers+1));
531 if (newbuffers) {
532 This->buffers = newbuffers;
533 This->buffers[This->nrofbuffers] = *ippdsb;
534 This->nrofbuffers++;
535 TRACE("buffer count is now %d\n", This->nrofbuffers);
536 } else {
537 ERR("out of memory for buffer list! Current buffer count is %d\n", This->nrofbuffers);
538 /* FIXME: release buffer */
539 }
540 }
541 RtlReleaseResource(&(This->lock));
542 IDirectSound_AddRef(iface);
543 return DS_OK;
544 }
545
546
547 static HRESULT WINAPI IDirectSoundImpl_GetCaps(LPDIRECTSOUND8 iface,LPDSCAPS caps) {
548 ICOM_THIS(IDirectSoundImpl,iface);
549 TRACE("(%p,%p)\n",This,caps);
550
551 if (caps == NULL || caps->dwSize!=sizeof(*caps))
552 return DSERR_INVALIDPARAM;
553
554 caps->dwFlags = This->drvcaps.dwFlags;
555 TRACE("(flags=0x%08lx)\n",caps->dwFlags);
556
557 /* FIXME: copy caps from This->drvcaps */
558 caps->dwMinSecondarySampleRate = DSBFREQUENCY_MIN;
559 caps->dwMaxSecondarySampleRate = DSBFREQUENCY_MAX;
560
561 caps->dwPrimaryBuffers = 1;
562
563 caps->dwMaxHwMixingAllBuffers = 0;
564 caps->dwMaxHwMixingStaticBuffers = 0;
565 caps->dwMaxHwMixingStreamingBuffers = 0;
566
567 caps->dwFreeHwMixingAllBuffers = 0;
568 caps->dwFreeHwMixingStaticBuffers = 0;
569 caps->dwFreeHwMixingStreamingBuffers = 0;
570
571 caps->dwMaxHw3DAllBuffers = 0;
572 caps->dwMaxHw3DStaticBuffers = 0;
573 caps->dwMaxHw3DStreamingBuffers = 0;
574
575 caps->dwFreeHw3DAllBuffers = 0;
576 caps->dwFreeHw3DStaticBuffers = 0;
577 caps->dwFreeHw3DStreamingBuffers = 0;
578
579 caps->dwTotalHwMemBytes = 0;
580
581 caps->dwFreeHwMemBytes = 0;
582
583 caps->dwMaxContigFreeHwMemBytes = 0;
584
585 caps->dwUnlockTransferRateHwBuffers = 4096; /* But we have none... */
586
587 caps->dwPlayCpuOverheadSwBuffers = 1; /* 1% */
588
589 return DS_OK;
590 }
591
592 static ULONG WINAPI IDirectSoundImpl_AddRef(LPDIRECTSOUND8 iface) {
593 ICOM_THIS(IDirectSoundImpl,iface);
594 return ++(This->ref);
595 }
596
597 static ULONG WINAPI IDirectSoundImpl_Release(LPDIRECTSOUND8 iface) {
598 ICOM_THIS(IDirectSoundImpl,iface);
599 TRACE("(%p), ref was %ld\n",This,This->ref);
600 if (!--(This->ref)) {
601 UINT i;
602
603 timeKillEvent(This->timerID);
604 timeEndPeriod(DS_TIME_RES);
605
606 if (This->buffers) {
607 for( i=0;i<This->nrofbuffers;i++)
608 IDirectSoundBuffer8_Release((LPDIRECTSOUNDBUFFER8)This->buffers[i]);
609 }
610
611 DSOUND_PrimaryDestroy(This);
612
613 RtlDeleteResource(&This->lock);
614 DeleteCriticalSection(&This->mixlock);
615 if (This->driver) {
616 IDsDriver_Close(This->driver);
617 }
618 if (This->drvdesc.dwFlags & DSDDESC_DOMMSYSTEMOPEN) {
619 waveOutClose(This->hwo);
620 }
621 if (This->driver)
622 IDsDriver_Release(This->driver);
623
624 HeapFree(GetProcessHeap(),0,This);
625 dsound = NULL;
626 return 0;
627 }
628 return This->ref;
629 }
630
631 static HRESULT WINAPI IDirectSoundImpl_SetSpeakerConfig(
632 LPDIRECTSOUND8 iface,DWORD config
633 ) {
634 ICOM_THIS(IDirectSoundImpl,iface);
635 FIXME("(%p,0x%08lx):stub\n",This,config);
636 return DS_OK;
637 }
638
639 static HRESULT WINAPI IDirectSoundImpl_QueryInterface(
640 LPDIRECTSOUND8 iface,REFIID riid,LPVOID *ppobj
641 ) {
642 ICOM_THIS(IDirectSoundImpl,iface);
643
644 if ( IsEqualGUID( &IID_IDirectSound3DListener, riid ) ) {
645 ERR("app requested IDirectSound3DListener on dsound object\n");
646 *ppobj = NULL;
647 return E_FAIL;
648 }
649
650 FIXME("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
651 return E_NOINTERFACE;
652 }
653
654 static HRESULT WINAPI IDirectSoundImpl_Compact(
655 LPDIRECTSOUND8 iface)
656 {
657 ICOM_THIS(IDirectSoundImpl,iface);
658 TRACE("(%p)\n", This);
659 return DS_OK;
660 }
661
662 static HRESULT WINAPI IDirectSoundImpl_GetSpeakerConfig(
663 LPDIRECTSOUND8 iface,
664 LPDWORD lpdwSpeakerConfig)
665 {
666 ICOM_THIS(IDirectSoundImpl,iface);
667 TRACE("(%p, %p)\n", This, lpdwSpeakerConfig);
668 *lpdwSpeakerConfig = DSSPEAKER_STEREO | (DSSPEAKER_GEOMETRY_NARROW << 16);
669 return DS_OK;
670 }
671
672 static HRESULT WINAPI IDirectSoundImpl_Initialize(
673 LPDIRECTSOUND8 iface,
674 LPCGUID lpcGuid)
675 {
676 ICOM_THIS(IDirectSoundImpl,iface);
677 TRACE("(%p, %p)\n", This, lpcGuid);
678 return DS_OK;
679 }
680
681 static HRESULT WINAPI IDirectSoundImpl_VerifyCertification(
682 LPDIRECTSOUND8 iface,
683 LPDWORD pdwCertified)
684 {
685 ICOM_THIS(IDirectSoundImpl,iface);
686 TRACE("(%p, %p)\n", This, pdwCertified);
687 *pdwCertified = DS_CERTIFIED;
688 return DS_OK;
689 }
690
691 static ICOM_VTABLE(IDirectSound8) dsvt =
692 {
693 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
694 IDirectSoundImpl_QueryInterface,
695 IDirectSoundImpl_AddRef,
696 IDirectSoundImpl_Release,
697 IDirectSoundImpl_CreateSoundBuffer,
698 IDirectSoundImpl_GetCaps,
699 IDirectSoundImpl_DuplicateSoundBuffer,
700 IDirectSoundImpl_SetCooperativeLevel,
701 IDirectSoundImpl_Compact,
702 IDirectSoundImpl_GetSpeakerConfig,
703 IDirectSoundImpl_SetSpeakerConfig,
704 IDirectSoundImpl_Initialize,
705 IDirectSoundImpl_VerifyCertification
706 };
707
708
709 /*******************************************************************************
710 * DirectSoundCreate (DSOUND.1)
711 */
712 HRESULT WINAPI DirectSoundCreate8(LPCGUID lpcGUID,LPDIRECTSOUND8 *ppDS,IUnknown *pUnkOuter )
713 {
714 IDirectSoundImpl** ippDS=(IDirectSoundImpl**)ppDS;
715 PIDSDRIVER drv = NULL;
716 unsigned wod, wodn;
717 HRESULT err = DSERR_INVALIDPARAM;
718 GUID devGuid;
719 TRACE("(%p,%p,%p)\n",lpcGUID,ippDS,pUnkOuter);
720
721 if (ippDS == NULL) {
722 WARN("invalid parameter\n");
723 return DSERR_INVALIDPARAM;
724 }
725
726 /* Get dsound configuration */
727 setup_dsound_options();
728
729 /* Default device? */
730 if ( !lpcGUID || IsEqualGUID(lpcGUID, &GUID_NULL) )
731 lpcGUID = &DSDEVID_DefaultPlayback;
732
733 if (GetDeviceID(lpcGUID, &devGuid) != DS_OK) {
734 WARN("invalid parameter\n");
735 return DSERR_INVALIDPARAM;
736 }
737
738 if (dsound) {
739 if (IsEqualGUID(&devGuid, &dsound->guid) ) {
740 ERR("dsound already opened\n");
741 IDirectSound_AddRef((LPDIRECTSOUND)dsound);
742 *ippDS = dsound;
743 return DS_OK;
744 } else {
745 ERR("different dsound already opened\n");
746 }
747 }
748
749 /* Enumerate WINMM audio devices and find the one we want */
750 wodn = waveOutGetNumDevs();
751 if (!wodn) return DSERR_NODRIVER;
752
753 for (wod=0; wod<wodn; wod++) {
754 GUID guid;
755 err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDGUID,(DWORD)(&guid),0));
756 if (err != DS_OK) {
757 WARN("waveOutMessage failed; err=%lx\n",err);
758 return err;
759 }
760 if (IsEqualGUID( &devGuid, &guid) ) {
761 err = DS_OK;
762 break;
763 }
764 }
765
766 if (err != DS_OK) {
767 WARN("invalid parameter\n");
768 return DSERR_INVALIDPARAM;
769 }
770
771 /* DRV_QUERYDSOUNDIFACE is a "Wine extension" to get the DSound interface */
772 waveOutMessage((HWAVEOUT)wod, DRV_QUERYDSOUNDIFACE, (DWORD)&drv, 0);
773
774 /* Disable the direct sound driver to force emulation if requested. */
775 if (ds_hw_accel == DS_HW_ACCEL_EMULATION)
776 drv = NULL;
777
778 /* Allocate memory */
779 *ippDS = (IDirectSoundImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectSoundImpl));
780 if (*ippDS == NULL)
781 return DSERR_OUTOFMEMORY;
782
783 ICOM_VTBL(*ippDS) = &dsvt;
784 (*ippDS)->ref = 1;
785
786 (*ippDS)->driver = drv;
787 (*ippDS)->priolevel = DSSCL_NORMAL;
788 (*ippDS)->fraglen = 0;
789 (*ippDS)->hwbuf = NULL;
790 (*ippDS)->buffer = NULL;
791 (*ippDS)->buflen = 0;
792 (*ippDS)->writelead = 0;
793 (*ippDS)->state = STATE_STOPPED;
794 (*ippDS)->nrofbuffers = 0;
795 (*ippDS)->buffers = NULL;
796 (*ippDS)->listener = NULL;
797
798 (*ippDS)->prebuf = ds_snd_queue_max;
799 (*ippDS)->guid = devGuid;
800
801 /* Get driver description */
802 if (drv) {
803 IDsDriver_GetDriverDesc(drv,&((*ippDS)->drvdesc));
804 } else {
805 /* if no DirectSound interface available, use WINMM API instead */
806 (*ippDS)->drvdesc.dwFlags = DSDDESC_DOMMSYSTEMOPEN | DSDDESC_DOMMSYSTEMSETFORMAT;
807 }
808
809 (*ippDS)->drvdesc.dnDevNode = wod;
810
811 /* Set default wave format (may need it for waveOutOpen) */
812 (*ippDS)->wfx.wFormatTag = WAVE_FORMAT_PCM;
813 /* We rely on the sound driver to return the actual sound format of
814 * the device if it does not support 22050x8x2 and is given the
815 * WAVE_DIRECTSOUND flag.
816 */
817 (*ippDS)->wfx.nSamplesPerSec = 22050;
818 (*ippDS)->wfx.wBitsPerSample = 8;
819 (*ippDS)->wfx.nChannels = 2;
820 (*ippDS)->wfx.nBlockAlign = (*ippDS)->wfx.wBitsPerSample * (*ippDS)->wfx.nChannels / 8;
821 (*ippDS)->wfx.nAvgBytesPerSec = (*ippDS)->wfx.nSamplesPerSec * (*ippDS)->wfx.nBlockAlign;
822 (*ippDS)->wfx.cbSize = 0;
823
824 /* If the driver requests being opened through MMSYSTEM
825 * (which is recommended by the DDK), it is supposed to happen
826 * before the DirectSound interface is opened */
827 if ((*ippDS)->drvdesc.dwFlags & DSDDESC_DOMMSYSTEMOPEN)
828 {
829 DWORD flags = CALLBACK_FUNCTION;
830
831 /* disable direct sound if requested */
832 if (ds_hw_accel != DS_HW_ACCEL_EMULATION)
833 flags |= WAVE_DIRECTSOUND;
834
835 err = mmErr(waveOutOpen(&((*ippDS)->hwo),
836 (*ippDS)->drvdesc.dnDevNode, &((*ippDS)->wfx),
837 (DWORD)DSOUND_callback, (DWORD)(*ippDS),
838 flags));
839 }
840
841 if (drv && (err == DS_OK))
842 err = IDsDriver_Open(drv);
843
844 /* FIXME: do we want to handle a temporarily busy device? */
845 if (err != DS_OK) {
846 HeapFree(GetProcessHeap(),0,*ippDS);
847 *ippDS = NULL;
848 return err;
849 }
850
851 /* the driver is now open, so it's now allowed to call GetCaps */
852 if (drv) {
853 IDsDriver_GetCaps(drv,&((*ippDS)->drvcaps));
854 } else {
855 /* FIXME: We should check the device capabilities */
856 (*ippDS)->drvcaps.dwFlags =
857 DSCAPS_PRIMARY16BIT | DSCAPS_PRIMARYSTEREO;
858 if (ds_emuldriver)
859 (*ippDS)->drvcaps.dwFlags |= DSCAPS_EMULDRIVER;
860 }
861
862 DSOUND_RecalcVolPan(&((*ippDS)->volpan));
863
864 InitializeCriticalSection(&((*ippDS)->mixlock));
865 RtlInitializeResource(&((*ippDS)->lock));
866
867 if (!dsound) {
868 dsound = (*ippDS);
869 DSOUND_PrimaryCreate(dsound);
870 timeBeginPeriod(DS_TIME_RES);
871 dsound->timerID = timeSetEvent(DS_TIME_DEL, DS_TIME_RES, DSOUND_timer,
872 (DWORD)dsound, TIME_PERIODIC | TIME_CALLBACK_FUNCTION);
873 }
874 return DS_OK;
875 }
876
877
878 /*******************************************************************************
879 * DirectSound ClassFactory
880 */
881 typedef struct
882 {
883 /* IUnknown fields */
884 ICOM_VFIELD(IClassFactory);
885 DWORD ref;
886 } IClassFactoryImpl;
887
888 static HRESULT WINAPI
889 DSCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
890 ICOM_THIS(IClassFactoryImpl,iface);
891
892 FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
893 return E_NOINTERFACE;
894 }
895
896 static ULONG WINAPI
897 DSCF_AddRef(LPCLASSFACTORY iface) {
898 ICOM_THIS(IClassFactoryImpl,iface);
899 return ++(This->ref);
900 }
901
902 static ULONG WINAPI DSCF_Release(LPCLASSFACTORY iface) {
903 ICOM_THIS(IClassFactoryImpl,iface);
904 /* static class, won't be freed */
905 return --(This->ref);
906 }
907
908 static HRESULT WINAPI DSCF_CreateInstance(
909 LPCLASSFACTORY iface,LPUNKNOWN pOuter,REFIID riid,LPVOID *ppobj
910 ) {
911 ICOM_THIS(IClassFactoryImpl,iface);
912
913 TRACE("(%p)->(%p,%s,%p)\n",This,pOuter,debugstr_guid(riid),ppobj);
914 if ( IsEqualGUID( &IID_IDirectSound, riid ) ||
915 IsEqualGUID( &IID_IDirectSound8, riid ) ) {
916 /* FIXME: reuse already created dsound if present? */
917 return DirectSoundCreate8(riid,(LPDIRECTSOUND8*)ppobj,pOuter);
918 }
919 if ( IsEqualGUID( &IID_IDirectSoundCapture, riid ) ||
920 IsEqualGUID( &IID_IDirectSoundCapture8, riid ) ) {
921 return DirectSoundCaptureCreate8(0,(LPDIRECTSOUNDCAPTURE8*)ppobj,pOuter);
922 }
923 /* DxDiag tries to create this */
924 if ( IsEqualGUID( &IID_IKsPropertySet, riid ) ) {
925 FIXME("(%p,%p,%s,%p) IID_IKsPropertySet not implemented\n",
926 This,pOuter,debugstr_guid(riid),ppobj);
927 /* FIXME: what is DxDiag looking for here? */
928 #if 0
929 return IKsPropertySetImpl_Create(0,(IKsPropertySetImpl**)ppobj);
930 #else
931 return E_NOINTERFACE;
932 #endif
933 }
934
935 FIXME("(%p,%p,%s,%p) Interface not found!\n",This,pOuter,debugstr_guid(riid),ppobj);
936 return E_NOINTERFACE;
937 }
938
939 static HRESULT WINAPI DSCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
940 ICOM_THIS(IClassFactoryImpl,iface);
941 FIXME("(%p)->(%d),stub!\n",This,dolock);
942 return S_OK;
943 }
944
945 static ICOM_VTABLE(IClassFactory) DSCF_Vtbl = {
946 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
947 DSCF_QueryInterface,
948 DSCF_AddRef,
949 DSCF_Release,
950 DSCF_CreateInstance,
951 DSCF_LockServer
952 };
953 static IClassFactoryImpl DSOUND_CF = {&DSCF_Vtbl, 1 };
954
955 /*******************************************************************************
956 * DllGetClassObject [DSOUND.5]
957 * Retrieves class object from a DLL object
958 *
959 * NOTES
960 * Docs say returns STDAPI
961 *
962 * PARAMS
963 * rclsid [I] CLSID for the class object
964 * riid [I] Reference to identifier of interface for class object
965 * ppv [O] Address of variable to receive interface pointer for riid
966 *
967 * RETURNS
968 * Success: S_OK
969 * Failure: CLASS_E_CLASSNOTAVAILABLE, E_OUTOFMEMORY, E_INVALIDARG,
970 * E_UNEXPECTED
971 */
972 DWORD WINAPI DSOUND_DllGetClassObject(REFCLSID rclsid,REFIID riid,LPVOID *ppv)
973 {
974 TRACE("(%p,%p,%p)\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
975 if ( IsEqualCLSID( &IID_IClassFactory, riid ) ) {
976 *ppv = (LPVOID)&DSOUND_CF;
977 IClassFactory_AddRef((IClassFactory*)*ppv);
978 return S_OK;
979 }
980
981 FIXME("(%p,%p,%p): no interface found.\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
982 return CLASS_E_CLASSNOTAVAILABLE;
983 }
984
985
986 /*******************************************************************************
987 * DllCanUnloadNow [DSOUND.4] Determines whether the DLL is in use.
988 *
989 * RETURNS
990 * Success: S_OK
991 * Failure: S_FALSE
992 */
993 DWORD WINAPI DSOUND_DllCanUnloadNow(void)
994 {
995 FIXME("(void): stub\n");
996 return S_FALSE;
997 }
GSOC 2012 project to enhance the control panel