[AUDIO-BRINGUP]
[reactos.git] / dll / directx / dsound / dsound.c
1 /* DirectSound
2 *
3 * Copyright 1998 Marcus Meissner
4 * Copyright 1998 Rob Riggs
5 * Copyright 2000-2002 TransGaming Technologies, Inc.
6 * Copyright 2004 Robert Reif
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23 #include <stdarg.h>
24 #include <stdio.h>
25
26 #define NONAMELESSSTRUCT
27 #define NONAMELESSUNION
28 #include "windef.h"
29 #include "winbase.h"
30 #include "winuser.h"
31 #include "mmsystem.h"
32 #include "winternl.h"
33 #include "mmddk.h"
34 #include "wingdi.h"
35 #include "mmreg.h"
36 #include "ks.h"
37 #include "ksmedia.h"
38 #include "wine/debug.h"
39 #include "dsound.h"
40 #include "dsdriver.h"
41 #include "dsound_private.h"
42
43 WINE_DEFAULT_DEBUG_CHANNEL(dsound);
44
45 /*****************************************************************************
46 * IDirectSound COM components
47 */
48 struct IDirectSound_IUnknown {
49 const IUnknownVtbl *lpVtbl;
50 LONG ref;
51 LPDIRECTSOUND8 pds;
52 };
53
54 static HRESULT IDirectSound_IUnknown_Create(LPDIRECTSOUND8 pds, LPUNKNOWN * ppunk);
55
56 struct IDirectSound_IDirectSound {
57 const IDirectSoundVtbl *lpVtbl;
58 LONG ref;
59 LPDIRECTSOUND8 pds;
60 };
61
62 static HRESULT IDirectSound_IDirectSound_Create(LPDIRECTSOUND8 pds, LPDIRECTSOUND * ppds);
63
64 /*****************************************************************************
65 * IDirectSound8 COM components
66 */
67 struct IDirectSound8_IUnknown {
68 const IUnknownVtbl *lpVtbl;
69 LONG ref;
70 LPDIRECTSOUND8 pds;
71 };
72
73 static HRESULT IDirectSound8_IUnknown_Create(LPDIRECTSOUND8 pds, LPUNKNOWN * ppunk);
74 static ULONG WINAPI IDirectSound8_IUnknown_AddRef(LPUNKNOWN iface);
75
76 struct IDirectSound8_IDirectSound {
77 const IDirectSoundVtbl *lpVtbl;
78 LONG ref;
79 LPDIRECTSOUND8 pds;
80 };
81
82 static HRESULT IDirectSound8_IDirectSound_Create(LPDIRECTSOUND8 pds, LPDIRECTSOUND * ppds);
83 static ULONG WINAPI IDirectSound8_IDirectSound_AddRef(LPDIRECTSOUND iface);
84
85 struct IDirectSound8_IDirectSound8 {
86 const IDirectSound8Vtbl *lpVtbl;
87 LONG ref;
88 LPDIRECTSOUND8 pds;
89 };
90
91 static HRESULT IDirectSound8_IDirectSound8_Create(LPDIRECTSOUND8 pds, LPDIRECTSOUND8 * ppds);
92 static ULONG WINAPI IDirectSound8_IDirectSound8_AddRef(LPDIRECTSOUND8 iface);
93
94 /*****************************************************************************
95 * IDirectSound implementation structure
96 */
97 struct IDirectSoundImpl
98 {
99 LONG ref;
100
101 DirectSoundDevice *device;
102 LPUNKNOWN pUnknown;
103 LPDIRECTSOUND pDS;
104 LPDIRECTSOUND8 pDS8;
105 };
106
107 static HRESULT IDirectSoundImpl_Create(LPDIRECTSOUND8 * ppds);
108
109 static ULONG WINAPI IDirectSound_IUnknown_AddRef(LPUNKNOWN iface);
110 static ULONG WINAPI IDirectSound_IDirectSound_AddRef(LPDIRECTSOUND iface);
111
112 static HRESULT DirectSoundDevice_VerifyCertification(DirectSoundDevice * device, LPDWORD pdwCertified);
113
114 const char * dumpCooperativeLevel(DWORD level)
115 {
116 static char unknown[32];
117 #define LE(x) case x: return #x
118 switch (level) {
119 LE(DSSCL_NORMAL);
120 LE(DSSCL_PRIORITY);
121 LE(DSSCL_EXCLUSIVE);
122 LE(DSSCL_WRITEPRIMARY);
123 }
124 #undef LE
125 sprintf(unknown, "Unknown(%08x)", (UINT)level);
126 return unknown;
127 }
128
129 static void _dump_DSCAPS(DWORD xmask) {
130 struct {
131 DWORD mask;
132 const char *name;
133 } flags[] = {
134 #define FE(x) { x, #x },
135 FE(DSCAPS_PRIMARYMONO)
136 FE(DSCAPS_PRIMARYSTEREO)
137 FE(DSCAPS_PRIMARY8BIT)
138 FE(DSCAPS_PRIMARY16BIT)
139 FE(DSCAPS_CONTINUOUSRATE)
140 FE(DSCAPS_EMULDRIVER)
141 FE(DSCAPS_CERTIFIED)
142 FE(DSCAPS_SECONDARYMONO)
143 FE(DSCAPS_SECONDARYSTEREO)
144 FE(DSCAPS_SECONDARY8BIT)
145 FE(DSCAPS_SECONDARY16BIT)
146 #undef FE
147 };
148 unsigned int i;
149
150 for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
151 if ((flags[i].mask & xmask) == flags[i].mask)
152 TRACE("%s ",flags[i].name);
153 }
154
155 static void _dump_DSBCAPS(DWORD xmask) {
156 struct {
157 DWORD mask;
158 const char *name;
159 } flags[] = {
160 #define FE(x) { x, #x },
161 FE(DSBCAPS_PRIMARYBUFFER)
162 FE(DSBCAPS_STATIC)
163 FE(DSBCAPS_LOCHARDWARE)
164 FE(DSBCAPS_LOCSOFTWARE)
165 FE(DSBCAPS_CTRL3D)
166 FE(DSBCAPS_CTRLFREQUENCY)
167 FE(DSBCAPS_CTRLPAN)
168 FE(DSBCAPS_CTRLVOLUME)
169 FE(DSBCAPS_CTRLPOSITIONNOTIFY)
170 FE(DSBCAPS_STICKYFOCUS)
171 FE(DSBCAPS_GLOBALFOCUS)
172 FE(DSBCAPS_GETCURRENTPOSITION2)
173 FE(DSBCAPS_MUTE3DATMAXDISTANCE)
174 #undef FE
175 };
176 unsigned int i;
177
178 for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
179 if ((flags[i].mask & xmask) == flags[i].mask)
180 TRACE("%s ",flags[i].name);
181 }
182
183 /*******************************************************************************
184 * IDirectSoundImpl_DirectSound
185 */
186 static HRESULT DSOUND_QueryInterface(
187 LPDIRECTSOUND8 iface,
188 REFIID riid,
189 LPVOID * ppobj)
190 {
191 IDirectSoundImpl *This = (IDirectSoundImpl *)iface;
192 TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
193
194 if (ppobj == NULL) {
195 WARN("invalid parameter\n");
196 return E_INVALIDARG;
197 }
198
199 if (IsEqualIID(riid, &IID_IUnknown)) {
200 if (!This->pUnknown) {
201 IDirectSound_IUnknown_Create(iface, &This->pUnknown);
202 if (!This->pUnknown) {
203 WARN("IDirectSound_IUnknown_Create() failed\n");
204 *ppobj = NULL;
205 return E_NOINTERFACE;
206 }
207 }
208 IDirectSound_IUnknown_AddRef(This->pUnknown);
209 *ppobj = This->pUnknown;
210 return S_OK;
211 } else if (IsEqualIID(riid, &IID_IDirectSound)) {
212 if (!This->pDS) {
213 IDirectSound_IDirectSound_Create(iface, &This->pDS);
214 if (!This->pDS) {
215 WARN("IDirectSound_IDirectSound_Create() failed\n");
216 *ppobj = NULL;
217 return E_NOINTERFACE;
218 }
219 }
220 IDirectSound_IDirectSound_AddRef(This->pDS);
221 *ppobj = This->pDS;
222 return S_OK;
223 }
224
225 *ppobj = NULL;
226 WARN("Unknown IID %s\n",debugstr_guid(riid));
227 return E_NOINTERFACE;
228 }
229
230 static HRESULT DSOUND_QueryInterface8(
231 LPDIRECTSOUND8 iface,
232 REFIID riid,
233 LPVOID * ppobj)
234 {
235 IDirectSoundImpl *This = (IDirectSoundImpl *)iface;
236 TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
237
238 if (ppobj == NULL) {
239 WARN("invalid parameter\n");
240 return E_INVALIDARG;
241 }
242
243 if (IsEqualIID(riid, &IID_IUnknown)) {
244 if (!This->pUnknown) {
245 IDirectSound8_IUnknown_Create(iface, &This->pUnknown);
246 if (!This->pUnknown) {
247 WARN("IDirectSound8_IUnknown_Create() failed\n");
248 *ppobj = NULL;
249 return E_NOINTERFACE;
250 }
251 }
252 IDirectSound8_IUnknown_AddRef(This->pUnknown);
253 *ppobj = This->pUnknown;
254 return S_OK;
255 } else if (IsEqualIID(riid, &IID_IDirectSound)) {
256 if (!This->pDS) {
257 IDirectSound8_IDirectSound_Create(iface, &This->pDS);
258 if (!This->pDS) {
259 WARN("IDirectSound8_IDirectSound_Create() failed\n");
260 *ppobj = NULL;
261 return E_NOINTERFACE;
262 }
263 }
264 IDirectSound8_IDirectSound_AddRef(This->pDS);
265 *ppobj = This->pDS;
266 return S_OK;
267 } else if (IsEqualIID(riid, &IID_IDirectSound8)) {
268 if (!This->pDS8) {
269 IDirectSound8_IDirectSound8_Create(iface, &This->pDS8);
270 if (!This->pDS8) {
271 WARN("IDirectSound8_IDirectSound8_Create() failed\n");
272 *ppobj = NULL;
273 return E_NOINTERFACE;
274 }
275 }
276 IDirectSound8_IDirectSound8_AddRef(This->pDS8);
277 *ppobj = This->pDS8;
278 return S_OK;
279 }
280
281 *ppobj = NULL;
282 WARN("Unknown IID %s\n",debugstr_guid(riid));
283 return E_NOINTERFACE;
284 }
285
286 static ULONG IDirectSoundImpl_AddRef(
287 LPDIRECTSOUND8 iface)
288 {
289 IDirectSoundImpl *This = (IDirectSoundImpl *)iface;
290 ULONG ref = InterlockedIncrement(&(This->ref));
291 TRACE("(%p) ref was %d\n", This, ref - 1);
292 return ref;
293 }
294
295 static ULONG IDirectSoundImpl_Release(
296 LPDIRECTSOUND8 iface)
297 {
298 IDirectSoundImpl *This = (IDirectSoundImpl *)iface;
299 ULONG ref = InterlockedDecrement(&(This->ref));
300 TRACE("(%p) ref was %d\n", This, ref + 1);
301
302 if (!ref) {
303 if (This->device)
304 DirectSoundDevice_Release(This->device);
305 HeapFree(GetProcessHeap(),0,This);
306 TRACE("(%p) released\n", This);
307 }
308 return ref;
309 }
310
311 static HRESULT IDirectSoundImpl_Create(
312 LPDIRECTSOUND8 * ppDS)
313 {
314 IDirectSoundImpl* pDS;
315 TRACE("(%p)\n",ppDS);
316
317 /* Allocate memory */
318 pDS = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectSoundImpl));
319 if (pDS == NULL) {
320 WARN("out of memory\n");
321 *ppDS = NULL;
322 return DSERR_OUTOFMEMORY;
323 }
324
325 pDS->ref = 0;
326 pDS->device = NULL;
327
328 *ppDS = (LPDIRECTSOUND8)pDS;
329
330 return DS_OK;
331 }
332
333 /*******************************************************************************
334 * IDirectSound_IUnknown
335 */
336 static HRESULT WINAPI IDirectSound_IUnknown_QueryInterface(
337 LPUNKNOWN iface,
338 REFIID riid,
339 LPVOID * ppobj)
340 {
341 IDirectSound_IUnknown *This = (IDirectSound_IUnknown *)iface;
342 TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
343 return DSOUND_QueryInterface(This->pds, riid, ppobj);
344 }
345
346 static ULONG WINAPI IDirectSound_IUnknown_AddRef(
347 LPUNKNOWN iface)
348 {
349 IDirectSound_IUnknown *This = (IDirectSound_IUnknown *)iface;
350 ULONG ref = InterlockedIncrement(&(This->ref));
351 TRACE("(%p) ref was %d\n", This, ref - 1);
352 return ref;
353 }
354
355 static ULONG WINAPI IDirectSound_IUnknown_Release(
356 LPUNKNOWN iface)
357 {
358 IDirectSound_IUnknown *This = (IDirectSound_IUnknown *)iface;
359 ULONG ref = InterlockedDecrement(&(This->ref));
360 TRACE("(%p) ref was %d\n", This, ref + 1);
361 if (!ref) {
362 ((IDirectSoundImpl*)This->pds)->pUnknown = NULL;
363 IDirectSoundImpl_Release(This->pds);
364 HeapFree(GetProcessHeap(), 0, This);
365 TRACE("(%p) released\n", This);
366 }
367 return ref;
368 }
369
370 static const IUnknownVtbl DirectSound_Unknown_Vtbl =
371 {
372 IDirectSound_IUnknown_QueryInterface,
373 IDirectSound_IUnknown_AddRef,
374 IDirectSound_IUnknown_Release
375 };
376
377 static HRESULT IDirectSound_IUnknown_Create(
378 LPDIRECTSOUND8 pds,
379 LPUNKNOWN * ppunk)
380 {
381 IDirectSound_IUnknown * pdsunk;
382 TRACE("(%p,%p)\n",pds,ppunk);
383
384 if (ppunk == NULL) {
385 ERR("invalid parameter: ppunk == NULL\n");
386 return DSERR_INVALIDPARAM;
387 }
388
389 if (pds == NULL) {
390 ERR("invalid parameter: pds == NULL\n");
391 *ppunk = NULL;
392 return DSERR_INVALIDPARAM;
393 }
394
395 pdsunk = HeapAlloc(GetProcessHeap(),0,sizeof(*pdsunk));
396 if (pdsunk == NULL) {
397 WARN("out of memory\n");
398 *ppunk = NULL;
399 return DSERR_OUTOFMEMORY;
400 }
401
402 pdsunk->lpVtbl = &DirectSound_Unknown_Vtbl;
403 pdsunk->ref = 0;
404 pdsunk->pds = pds;
405
406 IDirectSoundImpl_AddRef(pds);
407 *ppunk = (LPUNKNOWN)pdsunk;
408
409 return DS_OK;
410 }
411
412 /*******************************************************************************
413 * IDirectSound_IDirectSound
414 */
415 static HRESULT WINAPI IDirectSound_IDirectSound_QueryInterface(
416 LPDIRECTSOUND iface,
417 REFIID riid,
418 LPVOID * ppobj)
419 {
420 IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface;
421 TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
422 return DSOUND_QueryInterface(This->pds, riid, ppobj);
423 }
424
425 static ULONG WINAPI IDirectSound_IDirectSound_AddRef(
426 LPDIRECTSOUND iface)
427 {
428 IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface;
429 ULONG ref = InterlockedIncrement(&(This->ref));
430 TRACE("(%p) ref was %d\n", This, ref - 1);
431 return ref;
432 }
433
434 static ULONG WINAPI IDirectSound_IDirectSound_Release(
435 LPDIRECTSOUND iface)
436 {
437 IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface;
438 ULONG ref = InterlockedDecrement(&(This->ref));
439 TRACE("(%p) ref was %d\n", This, ref + 1);
440 if (!ref) {
441 ((IDirectSoundImpl*)This->pds)->pDS = NULL;
442 IDirectSoundImpl_Release(This->pds);
443 HeapFree(GetProcessHeap(), 0, This);
444 TRACE("(%p) released\n", This);
445 }
446 return ref;
447 }
448
449 static HRESULT WINAPI IDirectSound_IDirectSound_CreateSoundBuffer(
450 LPDIRECTSOUND iface,
451 LPCDSBUFFERDESC dsbd,
452 LPLPDIRECTSOUNDBUFFER ppdsb,
453 LPUNKNOWN lpunk)
454 {
455 IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface;
456 TRACE("(%p,%p,%p,%p)\n",This,dsbd,ppdsb,lpunk);
457 return DirectSoundDevice_CreateSoundBuffer(((IDirectSoundImpl *)This->pds)->device,dsbd,ppdsb,lpunk,FALSE);
458 }
459
460 static HRESULT WINAPI IDirectSound_IDirectSound_GetCaps(
461 LPDIRECTSOUND iface,
462 LPDSCAPS lpDSCaps)
463 {
464 IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface;
465 TRACE("(%p,%p)\n",This,lpDSCaps);
466 return DirectSoundDevice_GetCaps(((IDirectSoundImpl *)This->pds)->device, lpDSCaps);
467 }
468
469 static HRESULT WINAPI IDirectSound_IDirectSound_DuplicateSoundBuffer(
470 LPDIRECTSOUND iface,
471 LPDIRECTSOUNDBUFFER psb,
472 LPLPDIRECTSOUNDBUFFER ppdsb)
473 {
474 IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface;
475 TRACE("(%p,%p,%p)\n",This,psb,ppdsb);
476 return DirectSoundDevice_DuplicateSoundBuffer(((IDirectSoundImpl *)This->pds)->device,psb,ppdsb);
477 }
478
479 static HRESULT WINAPI IDirectSound_IDirectSound_SetCooperativeLevel(
480 LPDIRECTSOUND iface,
481 HWND hwnd,
482 DWORD level)
483 {
484 IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface;
485 TRACE("(%p,%p,%s)\n",This,hwnd,dumpCooperativeLevel(level));
486 return DirectSoundDevice_SetCooperativeLevel(((IDirectSoundImpl *)This->pds)->device, hwnd, level);
487 }
488
489 static HRESULT WINAPI IDirectSound_IDirectSound_Compact(
490 LPDIRECTSOUND iface)
491 {
492 IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface;
493 TRACE("(%p)\n", This);
494 return DirectSoundDevice_Compact(((IDirectSoundImpl *)This->pds)->device);
495 }
496
497 static HRESULT WINAPI IDirectSound_IDirectSound_GetSpeakerConfig(
498 LPDIRECTSOUND iface,
499 LPDWORD lpdwSpeakerConfig)
500 {
501 IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface;
502 TRACE("(%p, %p)\n", This, lpdwSpeakerConfig);
503 return DirectSoundDevice_GetSpeakerConfig(((IDirectSoundImpl *)This->pds)->device,lpdwSpeakerConfig);
504 }
505
506 static HRESULT WINAPI IDirectSound_IDirectSound_SetSpeakerConfig(
507 LPDIRECTSOUND iface,
508 DWORD config)
509 {
510 IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface;
511 TRACE("(%p,0x%08x)\n",This,config);
512 return DirectSoundDevice_SetSpeakerConfig(((IDirectSoundImpl *)This->pds)->device,config);
513 }
514
515 static HRESULT WINAPI IDirectSound_IDirectSound_Initialize(
516 LPDIRECTSOUND iface,
517 LPCGUID lpcGuid)
518 {
519 IDirectSound_IDirectSound *This = (IDirectSound_IDirectSound *)iface;
520 TRACE("(%p, %s)\n", This, debugstr_guid(lpcGuid));
521 return DirectSoundDevice_Initialize(&((IDirectSoundImpl *)This->pds)->device,lpcGuid);
522 }
523
524 static const IDirectSoundVtbl DirectSound_DirectSound_Vtbl =
525 {
526 IDirectSound_IDirectSound_QueryInterface,
527 IDirectSound_IDirectSound_AddRef,
528 IDirectSound_IDirectSound_Release,
529 IDirectSound_IDirectSound_CreateSoundBuffer,
530 IDirectSound_IDirectSound_GetCaps,
531 IDirectSound_IDirectSound_DuplicateSoundBuffer,
532 IDirectSound_IDirectSound_SetCooperativeLevel,
533 IDirectSound_IDirectSound_Compact,
534 IDirectSound_IDirectSound_GetSpeakerConfig,
535 IDirectSound_IDirectSound_SetSpeakerConfig,
536 IDirectSound_IDirectSound_Initialize
537 };
538
539 static HRESULT IDirectSound_IDirectSound_Create(
540 LPDIRECTSOUND8 pds,
541 LPDIRECTSOUND * ppds)
542 {
543 IDirectSound_IDirectSound * pdsds;
544 TRACE("(%p,%p)\n",pds,ppds);
545
546 if (ppds == NULL) {
547 ERR("invalid parameter: ppds == NULL\n");
548 return DSERR_INVALIDPARAM;
549 }
550
551 if (pds == NULL) {
552 ERR("invalid parameter: pds == NULL\n");
553 *ppds = NULL;
554 return DSERR_INVALIDPARAM;
555 }
556
557 pdsds = HeapAlloc(GetProcessHeap(),0,sizeof(*pdsds));
558 if (pdsds == NULL) {
559 WARN("out of memory\n");
560 *ppds = NULL;
561 return DSERR_OUTOFMEMORY;
562 }
563
564 pdsds->lpVtbl = &DirectSound_DirectSound_Vtbl;
565 pdsds->ref = 0;
566 pdsds->pds = pds;
567
568 IDirectSoundImpl_AddRef(pds);
569 *ppds = (LPDIRECTSOUND)pdsds;
570
571 return DS_OK;
572 }
573
574 /*******************************************************************************
575 * IDirectSound8_IUnknown
576 */
577 static HRESULT WINAPI IDirectSound8_IUnknown_QueryInterface(
578 LPUNKNOWN iface,
579 REFIID riid,
580 LPVOID * ppobj)
581 {
582 IDirectSound_IUnknown *This = (IDirectSound_IUnknown *)iface;
583 TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
584 return DSOUND_QueryInterface8(This->pds, riid, ppobj);
585 }
586
587 static ULONG WINAPI IDirectSound8_IUnknown_AddRef(
588 LPUNKNOWN iface)
589 {
590 IDirectSound_IUnknown *This = (IDirectSound_IUnknown *)iface;
591 ULONG ref = InterlockedIncrement(&(This->ref));
592 TRACE("(%p) ref was %d\n", This, ref - 1);
593 return ref;
594 }
595
596 static ULONG WINAPI IDirectSound8_IUnknown_Release(
597 LPUNKNOWN iface)
598 {
599 IDirectSound_IUnknown *This = (IDirectSound_IUnknown *)iface;
600 ULONG ref = InterlockedDecrement(&(This->ref));
601 TRACE("(%p) ref was %d\n", This, ref + 1);
602 if (!ref) {
603 ((IDirectSoundImpl*)This->pds)->pUnknown = NULL;
604 IDirectSoundImpl_Release(This->pds);
605 HeapFree(GetProcessHeap(), 0, This);
606 TRACE("(%p) released\n", This);
607 }
608 return ref;
609 }
610
611 static const IUnknownVtbl DirectSound8_Unknown_Vtbl =
612 {
613 IDirectSound8_IUnknown_QueryInterface,
614 IDirectSound8_IUnknown_AddRef,
615 IDirectSound8_IUnknown_Release
616 };
617
618 static HRESULT IDirectSound8_IUnknown_Create(
619 LPDIRECTSOUND8 pds,
620 LPUNKNOWN * ppunk)
621 {
622 IDirectSound8_IUnknown * pdsunk;
623 TRACE("(%p,%p)\n",pds,ppunk);
624
625 if (ppunk == NULL) {
626 ERR("invalid parameter: ppunk == NULL\n");
627 return DSERR_INVALIDPARAM;
628 }
629
630 if (pds == NULL) {
631 ERR("invalid parameter: pds == NULL\n");
632 *ppunk = NULL;
633 return DSERR_INVALIDPARAM;
634 }
635
636 pdsunk = HeapAlloc(GetProcessHeap(),0,sizeof(*pdsunk));
637 if (pdsunk == NULL) {
638 WARN("out of memory\n");
639 *ppunk = NULL;
640 return DSERR_OUTOFMEMORY;
641 }
642
643 pdsunk->lpVtbl = &DirectSound8_Unknown_Vtbl;
644 pdsunk->ref = 0;
645 pdsunk->pds = pds;
646
647 IDirectSoundImpl_AddRef(pds);
648 *ppunk = (LPUNKNOWN)pdsunk;
649
650 return DS_OK;
651 }
652
653 /*******************************************************************************
654 * IDirectSound8_IDirectSound
655 */
656 static HRESULT WINAPI IDirectSound8_IDirectSound_QueryInterface(
657 LPDIRECTSOUND iface,
658 REFIID riid,
659 LPVOID * ppobj)
660 {
661 IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface;
662 TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
663 return DSOUND_QueryInterface8(This->pds, riid, ppobj);
664 }
665
666 static ULONG WINAPI IDirectSound8_IDirectSound_AddRef(
667 LPDIRECTSOUND iface)
668 {
669 IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface;
670 ULONG ref = InterlockedIncrement(&(This->ref));
671 TRACE("(%p) ref was %d\n", This, ref - 1);
672 return ref;
673 }
674
675 static ULONG WINAPI IDirectSound8_IDirectSound_Release(
676 LPDIRECTSOUND iface)
677 {
678 IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface;
679 ULONG ref = InterlockedDecrement(&(This->ref));
680 TRACE("(%p) ref was %d\n", This, ref + 1);
681 if (!ref) {
682 ((IDirectSoundImpl*)This->pds)->pDS = NULL;
683 IDirectSoundImpl_Release(This->pds);
684 HeapFree(GetProcessHeap(), 0, This);
685 TRACE("(%p) released\n", This);
686 }
687 return ref;
688 }
689
690 static HRESULT WINAPI IDirectSound8_IDirectSound_CreateSoundBuffer(
691 LPDIRECTSOUND iface,
692 LPCDSBUFFERDESC dsbd,
693 LPLPDIRECTSOUNDBUFFER ppdsb,
694 LPUNKNOWN lpunk)
695 {
696 IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface;
697 TRACE("(%p,%p,%p,%p)\n",This,dsbd,ppdsb,lpunk);
698 return DirectSoundDevice_CreateSoundBuffer(((IDirectSoundImpl *)This->pds)->device,dsbd,ppdsb,lpunk,TRUE);
699 }
700
701 static HRESULT WINAPI IDirectSound8_IDirectSound_GetCaps(
702 LPDIRECTSOUND iface,
703 LPDSCAPS lpDSCaps)
704 {
705 IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface;
706 TRACE("(%p,%p)\n",This,lpDSCaps);
707 return DirectSoundDevice_GetCaps(((IDirectSoundImpl *)This->pds)->device, lpDSCaps);
708 }
709
710 static HRESULT WINAPI IDirectSound8_IDirectSound_DuplicateSoundBuffer(
711 LPDIRECTSOUND iface,
712 LPDIRECTSOUNDBUFFER psb,
713 LPLPDIRECTSOUNDBUFFER ppdsb)
714 {
715 IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface;
716 TRACE("(%p,%p,%p)\n",This,psb,ppdsb);
717 return DirectSoundDevice_DuplicateSoundBuffer(((IDirectSoundImpl *)This->pds)->device,psb,ppdsb);
718 }
719
720 static HRESULT WINAPI IDirectSound8_IDirectSound_SetCooperativeLevel(
721 LPDIRECTSOUND iface,
722 HWND hwnd,
723 DWORD level)
724 {
725 IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface;
726 TRACE("(%p,%p,%s)\n",This,hwnd,dumpCooperativeLevel(level));
727 return DirectSoundDevice_SetCooperativeLevel(((IDirectSoundImpl *)This->pds)->device, hwnd, level);
728 }
729
730 static HRESULT WINAPI IDirectSound8_IDirectSound_Compact(
731 LPDIRECTSOUND iface)
732 {
733 IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface;
734 TRACE("(%p)\n", This);
735 return DirectSoundDevice_Compact(((IDirectSoundImpl *)This->pds)->device);
736 }
737
738 static HRESULT WINAPI IDirectSound8_IDirectSound_GetSpeakerConfig(
739 LPDIRECTSOUND iface,
740 LPDWORD lpdwSpeakerConfig)
741 {
742 IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface;
743 TRACE("(%p, %p)\n", This, lpdwSpeakerConfig);
744 return DirectSoundDevice_GetSpeakerConfig(((IDirectSoundImpl *)This->pds)->device,lpdwSpeakerConfig);
745 }
746
747 static HRESULT WINAPI IDirectSound8_IDirectSound_SetSpeakerConfig(
748 LPDIRECTSOUND iface,
749 DWORD config)
750 {
751 IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface;
752 TRACE("(%p,0x%08x)\n",This,config);
753 return DirectSoundDevice_SetSpeakerConfig(((IDirectSoundImpl *)This->pds)->device,config);
754 }
755
756 static HRESULT WINAPI IDirectSound8_IDirectSound_Initialize(
757 LPDIRECTSOUND iface,
758 LPCGUID lpcGuid)
759 {
760 IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface;
761 TRACE("(%p, %s)\n", This, debugstr_guid(lpcGuid));
762 return DirectSoundDevice_Initialize(&((IDirectSoundImpl *)This->pds)->device,lpcGuid);
763 }
764
765 static const IDirectSoundVtbl DirectSound8_DirectSound_Vtbl =
766 {
767 IDirectSound8_IDirectSound_QueryInterface,
768 IDirectSound8_IDirectSound_AddRef,
769 IDirectSound8_IDirectSound_Release,
770 IDirectSound8_IDirectSound_CreateSoundBuffer,
771 IDirectSound8_IDirectSound_GetCaps,
772 IDirectSound8_IDirectSound_DuplicateSoundBuffer,
773 IDirectSound8_IDirectSound_SetCooperativeLevel,
774 IDirectSound8_IDirectSound_Compact,
775 IDirectSound8_IDirectSound_GetSpeakerConfig,
776 IDirectSound8_IDirectSound_SetSpeakerConfig,
777 IDirectSound8_IDirectSound_Initialize
778 };
779
780 static HRESULT IDirectSound8_IDirectSound_Create(
781 LPDIRECTSOUND8 pds,
782 LPDIRECTSOUND * ppds)
783 {
784 IDirectSound8_IDirectSound * pdsds;
785 TRACE("(%p,%p)\n",pds,ppds);
786
787 if (ppds == NULL) {
788 ERR("invalid parameter: ppds == NULL\n");
789 return DSERR_INVALIDPARAM;
790 }
791
792 if (pds == NULL) {
793 ERR("invalid parameter: pds == NULL\n");
794 *ppds = NULL;
795 return DSERR_INVALIDPARAM;
796 }
797
798 pdsds = HeapAlloc(GetProcessHeap(),0,sizeof(*pdsds));
799 if (pdsds == NULL) {
800 WARN("out of memory\n");
801 *ppds = NULL;
802 return DSERR_OUTOFMEMORY;
803 }
804
805 pdsds->lpVtbl = &DirectSound8_DirectSound_Vtbl;
806 pdsds->ref = 0;
807 pdsds->pds = pds;
808
809 IDirectSoundImpl_AddRef(pds);
810 *ppds = (LPDIRECTSOUND)pdsds;
811
812 return DS_OK;
813 }
814
815 /*******************************************************************************
816 * IDirectSound8_IDirectSound8
817 */
818 static HRESULT WINAPI IDirectSound8_IDirectSound8_QueryInterface(
819 LPDIRECTSOUND8 iface,
820 REFIID riid,
821 LPVOID * ppobj)
822 {
823 IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface;
824 TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
825 return DSOUND_QueryInterface8(This->pds, riid, ppobj);
826 }
827
828 static ULONG WINAPI IDirectSound8_IDirectSound8_AddRef(
829 LPDIRECTSOUND8 iface)
830 {
831 IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface;
832 ULONG ref = InterlockedIncrement(&(This->ref));
833 TRACE("(%p) ref was %d\n", This, ref - 1);
834 return ref;
835 }
836
837 static ULONG WINAPI IDirectSound8_IDirectSound8_Release(
838 LPDIRECTSOUND8 iface)
839 {
840 IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface;
841 ULONG ref = InterlockedDecrement(&(This->ref));
842 TRACE("(%p) ref was %d\n", This, ref + 1);
843 if (!ref) {
844 ((IDirectSoundImpl*)This->pds)->pDS8 = NULL;
845 IDirectSoundImpl_Release(This->pds);
846 HeapFree(GetProcessHeap(), 0, This);
847 TRACE("(%p) released\n", This);
848 }
849 return ref;
850 }
851
852 static HRESULT WINAPI IDirectSound8_IDirectSound8_CreateSoundBuffer(
853 LPDIRECTSOUND8 iface,
854 LPCDSBUFFERDESC dsbd,
855 LPLPDIRECTSOUNDBUFFER ppdsb,
856 LPUNKNOWN lpunk)
857 {
858 IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface;
859 TRACE("(%p,%p,%p,%p)\n",This,dsbd,ppdsb,lpunk);
860 return DirectSoundDevice_CreateSoundBuffer(((IDirectSoundImpl *)This->pds)->device,dsbd,ppdsb,lpunk,TRUE);
861 }
862
863 static HRESULT WINAPI IDirectSound8_IDirectSound8_GetCaps(
864 LPDIRECTSOUND8 iface,
865 LPDSCAPS lpDSCaps)
866 {
867 IDirectSound8_IDirectSound *This = (IDirectSound8_IDirectSound *)iface;
868 TRACE("(%p,%p)\n",This,lpDSCaps);
869 return DirectSoundDevice_GetCaps(((IDirectSoundImpl *)This->pds)->device, lpDSCaps);
870 }
871
872 static HRESULT WINAPI IDirectSound8_IDirectSound8_DuplicateSoundBuffer(
873 LPDIRECTSOUND8 iface,
874 LPDIRECTSOUNDBUFFER psb,
875 LPLPDIRECTSOUNDBUFFER ppdsb)
876 {
877 IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface;
878 TRACE("(%p,%p,%p)\n",This,psb,ppdsb);
879 return DirectSoundDevice_DuplicateSoundBuffer(((IDirectSoundImpl *)This->pds)->device,psb,ppdsb);
880 }
881
882 static HRESULT WINAPI IDirectSound8_IDirectSound8_SetCooperativeLevel(
883 LPDIRECTSOUND8 iface,
884 HWND hwnd,
885 DWORD level)
886 {
887 IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface;
888 TRACE("(%p,%p,%s)\n",This,hwnd,dumpCooperativeLevel(level));
889 return DirectSoundDevice_SetCooperativeLevel(((IDirectSoundImpl *)This->pds)->device, hwnd, level);
890 }
891
892 static HRESULT WINAPI IDirectSound8_IDirectSound8_Compact(
893 LPDIRECTSOUND8 iface)
894 {
895 IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface;
896 TRACE("(%p)\n", This);
897 return DirectSoundDevice_Compact(((IDirectSoundImpl *)This->pds)->device);
898 }
899
900 static HRESULT WINAPI IDirectSound8_IDirectSound8_GetSpeakerConfig(
901 LPDIRECTSOUND8 iface,
902 LPDWORD lpdwSpeakerConfig)
903 {
904 IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface;
905 TRACE("(%p, %p)\n", This, lpdwSpeakerConfig);
906 return DirectSoundDevice_GetSpeakerConfig(((IDirectSoundImpl *)This->pds)->device,lpdwSpeakerConfig);
907 }
908
909 static HRESULT WINAPI IDirectSound8_IDirectSound8_SetSpeakerConfig(
910 LPDIRECTSOUND8 iface,
911 DWORD config)
912 {
913 IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface;
914 TRACE("(%p,0x%08x)\n",This,config);
915 return DirectSoundDevice_SetSpeakerConfig(((IDirectSoundImpl *)This->pds)->device,config);
916 }
917
918 static HRESULT WINAPI IDirectSound8_IDirectSound8_Initialize(
919 LPDIRECTSOUND8 iface,
920 LPCGUID lpcGuid)
921 {
922 IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface;
923 TRACE("(%p, %s)\n", This, debugstr_guid(lpcGuid));
924 return DirectSoundDevice_Initialize(&((IDirectSoundImpl *)This->pds)->device,lpcGuid);
925 }
926
927 static HRESULT WINAPI IDirectSound8_IDirectSound8_VerifyCertification(
928 LPDIRECTSOUND8 iface,
929 LPDWORD pdwCertified)
930 {
931 IDirectSound8_IDirectSound8 *This = (IDirectSound8_IDirectSound8 *)iface;
932 TRACE("(%p, %p)\n", This, pdwCertified);
933 return DirectSoundDevice_VerifyCertification(((IDirectSoundImpl *)This->pds)->device,pdwCertified);
934 }
935
936 static const IDirectSound8Vtbl DirectSound8_DirectSound8_Vtbl =
937 {
938 IDirectSound8_IDirectSound8_QueryInterface,
939 IDirectSound8_IDirectSound8_AddRef,
940 IDirectSound8_IDirectSound8_Release,
941 IDirectSound8_IDirectSound8_CreateSoundBuffer,
942 IDirectSound8_IDirectSound8_GetCaps,
943 IDirectSound8_IDirectSound8_DuplicateSoundBuffer,
944 IDirectSound8_IDirectSound8_SetCooperativeLevel,
945 IDirectSound8_IDirectSound8_Compact,
946 IDirectSound8_IDirectSound8_GetSpeakerConfig,
947 IDirectSound8_IDirectSound8_SetSpeakerConfig,
948 IDirectSound8_IDirectSound8_Initialize,
949 IDirectSound8_IDirectSound8_VerifyCertification
950 };
951
952 static HRESULT IDirectSound8_IDirectSound8_Create(
953 LPDIRECTSOUND8 pds,
954 LPDIRECTSOUND8 * ppds)
955 {
956 IDirectSound8_IDirectSound8 * pdsds;
957 TRACE("(%p,%p)\n",pds,ppds);
958
959 if (ppds == NULL) {
960 ERR("invalid parameter: ppds == NULL\n");
961 return DSERR_INVALIDPARAM;
962 }
963
964 if (pds == NULL) {
965 ERR("invalid parameter: pds == NULL\n");
966 *ppds = NULL;
967 return DSERR_INVALIDPARAM;
968 }
969
970 pdsds = HeapAlloc(GetProcessHeap(),0,sizeof(*pdsds));
971 if (pdsds == NULL) {
972 WARN("out of memory\n");
973 *ppds = NULL;
974 return DSERR_OUTOFMEMORY;
975 }
976
977 pdsds->lpVtbl = &DirectSound8_DirectSound8_Vtbl;
978 pdsds->ref = 0;
979 pdsds->pds = pds;
980
981 IDirectSoundImpl_AddRef(pds);
982 *ppds = (LPDIRECTSOUND8)pdsds;
983
984 return DS_OK;
985 }
986
987 HRESULT DSOUND_Create(
988 REFIID riid,
989 LPDIRECTSOUND *ppDS)
990 {
991 LPDIRECTSOUND8 pDS;
992 HRESULT hr;
993 TRACE("(%s, %p)\n", debugstr_guid(riid), ppDS);
994
995 if (!IsEqualIID(riid, &IID_IUnknown) &&
996 !IsEqualIID(riid, &IID_IDirectSound)) {
997 *ppDS = 0;
998 return E_NOINTERFACE;
999 }
1000
1001 /* Get dsound configuration */
1002 setup_dsound_options();
1003
1004 hr = IDirectSoundImpl_Create(&pDS);
1005 if (hr == DS_OK) {
1006 hr = IDirectSound_IDirectSound_Create(pDS, ppDS);
1007 if (*ppDS)
1008 IDirectSound_IDirectSound_AddRef(*ppDS);
1009 else {
1010 WARN("IDirectSound_IDirectSound_Create failed\n");
1011 IDirectSound8_Release(pDS);
1012 }
1013 } else {
1014 WARN("IDirectSoundImpl_Create failed\n");
1015 *ppDS = 0;
1016 }
1017
1018 return hr;
1019 }
1020
1021 /*******************************************************************************
1022 * DirectSoundCreate (DSOUND.1)
1023 *
1024 * Creates and initializes a DirectSound interface.
1025 *
1026 * PARAMS
1027 * lpcGUID [I] Address of the GUID that identifies the sound device.
1028 * ppDS [O] Address of a variable to receive the interface pointer.
1029 * pUnkOuter [I] Must be NULL.
1030 *
1031 * RETURNS
1032 * Success: DS_OK
1033 * Failure: DSERR_ALLOCATED, DSERR_INVALIDPARAM, DSERR_NOAGGREGATION,
1034 * DSERR_NODRIVER, DSERR_OUTOFMEMORY
1035 */
1036 HRESULT WINAPI DirectSoundCreate(
1037 LPCGUID lpcGUID,
1038 LPDIRECTSOUND *ppDS,
1039 IUnknown *pUnkOuter)
1040 {
1041 HRESULT hr;
1042 LPDIRECTSOUND pDS;
1043
1044 TRACE("(%s,%p,%p)\n",debugstr_guid(lpcGUID),ppDS,pUnkOuter);
1045
1046 if (ppDS == NULL) {
1047 WARN("invalid parameter: ppDS == NULL\n");
1048 return DSERR_INVALIDPARAM;
1049 }
1050
1051 if (pUnkOuter != NULL) {
1052 WARN("invalid parameter: pUnkOuter != NULL\n");
1053 *ppDS = 0;
1054 return DSERR_INVALIDPARAM;
1055 }
1056
1057 hr = DSOUND_Create(&IID_IDirectSound, &pDS);
1058 if (hr == DS_OK) {
1059 hr = IDirectSound_Initialize(pDS, lpcGUID);
1060 if (hr != DS_OK) {
1061 if (hr != DSERR_ALREADYINITIALIZED) {
1062 IDirectSound_Release(pDS);
1063 pDS = 0;
1064 } else
1065 hr = DS_OK;
1066 }
1067 }
1068
1069 *ppDS = pDS;
1070
1071 return hr;
1072 }
1073
1074 HRESULT DSOUND_Create8(
1075 REFIID riid,
1076 LPDIRECTSOUND8 *ppDS)
1077 {
1078 LPDIRECTSOUND8 pDS;
1079 HRESULT hr;
1080 TRACE("(%s, %p)\n", debugstr_guid(riid), ppDS);
1081
1082 if (!IsEqualIID(riid, &IID_IUnknown) &&
1083 !IsEqualIID(riid, &IID_IDirectSound) &&
1084 !IsEqualIID(riid, &IID_IDirectSound8)) {
1085 *ppDS = 0;
1086 return E_NOINTERFACE;
1087 }
1088
1089 /* Get dsound configuration */
1090 setup_dsound_options();
1091
1092 hr = IDirectSoundImpl_Create(&pDS);
1093 if (hr == DS_OK) {
1094 hr = IDirectSound8_IDirectSound8_Create(pDS, ppDS);
1095 if (*ppDS)
1096 IDirectSound8_IDirectSound8_AddRef(*ppDS);
1097 else {
1098 WARN("IDirectSound8_IDirectSound8_Create failed\n");
1099 IDirectSound8_Release(pDS);
1100 }
1101 } else {
1102 WARN("IDirectSoundImpl_Create failed\n");
1103 *ppDS = 0;
1104 }
1105
1106 return hr;
1107 }
1108
1109 /*******************************************************************************
1110 * DirectSoundCreate8 (DSOUND.11)
1111 *
1112 * Creates and initializes a DirectSound8 interface.
1113 *
1114 * PARAMS
1115 * lpcGUID [I] Address of the GUID that identifies the sound device.
1116 * ppDS [O] Address of a variable to receive the interface pointer.
1117 * pUnkOuter [I] Must be NULL.
1118 *
1119 * RETURNS
1120 * Success: DS_OK
1121 * Failure: DSERR_ALLOCATED, DSERR_INVALIDPARAM, DSERR_NOAGGREGATION,
1122 * DSERR_NODRIVER, DSERR_OUTOFMEMORY
1123 */
1124 HRESULT WINAPI DirectSoundCreate8(
1125 LPCGUID lpcGUID,
1126 LPDIRECTSOUND8 *ppDS,
1127 IUnknown *pUnkOuter)
1128 {
1129 HRESULT hr;
1130 LPDIRECTSOUND8 pDS;
1131
1132 TRACE("(%s,%p,%p)\n",debugstr_guid(lpcGUID),ppDS,pUnkOuter);
1133
1134 if (ppDS == NULL) {
1135 WARN("invalid parameter: ppDS == NULL\n");
1136 return DSERR_INVALIDPARAM;
1137 }
1138
1139 if (pUnkOuter != NULL) {
1140 WARN("invalid parameter: pUnkOuter != NULL\n");
1141 *ppDS = 0;
1142 return DSERR_INVALIDPARAM;
1143 }
1144
1145 hr = DSOUND_Create8(&IID_IDirectSound8, &pDS);
1146 if (hr == DS_OK) {
1147 hr = IDirectSound8_Initialize(pDS, lpcGUID);
1148 if (hr != DS_OK) {
1149 if (hr != DSERR_ALREADYINITIALIZED) {
1150 IDirectSound8_Release(pDS);
1151 pDS = 0;
1152 } else
1153 hr = DS_OK;
1154 }
1155 }
1156
1157 *ppDS = pDS;
1158
1159 return hr;
1160 }
1161
1162 /*******************************************************************************
1163 * DirectSoundDevice
1164 */
1165 static HRESULT DirectSoundDevice_Create(DirectSoundDevice ** ppDevice)
1166 {
1167 DirectSoundDevice * device;
1168 TRACE("(%p)\n", ppDevice);
1169
1170 /* Allocate memory */
1171 device = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(DirectSoundDevice));
1172 if (device == NULL) {
1173 WARN("out of memory\n");
1174 return DSERR_OUTOFMEMORY;
1175 }
1176
1177 device->ref = 1;
1178 device->priolevel = DSSCL_NORMAL;
1179 device->state = STATE_STOPPED;
1180 device->speaker_config = DSSPEAKER_STEREO | (DSSPEAKER_GEOMETRY_NARROW << 16);
1181
1182 /* 3D listener initial parameters */
1183 device->ds3dl.dwSize = sizeof(DS3DLISTENER);
1184 device->ds3dl.vPosition.x = 0.0;
1185 device->ds3dl.vPosition.y = 0.0;
1186 device->ds3dl.vPosition.z = 0.0;
1187 device->ds3dl.vVelocity.x = 0.0;
1188 device->ds3dl.vVelocity.y = 0.0;
1189 device->ds3dl.vVelocity.z = 0.0;
1190 device->ds3dl.vOrientFront.x = 0.0;
1191 device->ds3dl.vOrientFront.y = 0.0;
1192 device->ds3dl.vOrientFront.z = 1.0;
1193 device->ds3dl.vOrientTop.x = 0.0;
1194 device->ds3dl.vOrientTop.y = 1.0;
1195 device->ds3dl.vOrientTop.z = 0.0;
1196 device->ds3dl.flDistanceFactor = DS3D_DEFAULTDISTANCEFACTOR;
1197 device->ds3dl.flRolloffFactor = DS3D_DEFAULTROLLOFFFACTOR;
1198 device->ds3dl.flDopplerFactor = DS3D_DEFAULTDOPPLERFACTOR;
1199
1200 device->prebuf = ds_snd_queue_max;
1201 device->guid = GUID_NULL;
1202
1203 /* Set default wave format (may need it for waveOutOpen) */
1204 device->pwfx = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(WAVEFORMATEX));
1205 if (device->pwfx == NULL) {
1206 WARN("out of memory\n");
1207 HeapFree(GetProcessHeap(),0,device);
1208 return DSERR_OUTOFMEMORY;
1209 }
1210
1211 /* We rely on the sound driver to return the actual sound format of
1212 * the device if it does not support 22050x8x2 and is given the
1213 * WAVE_DIRECTSOUND flag.
1214 */
1215 device->pwfx->wFormatTag = WAVE_FORMAT_PCM;
1216 device->pwfx->nSamplesPerSec = ds_default_sample_rate;
1217 device->pwfx->wBitsPerSample = ds_default_bits_per_sample;
1218 device->pwfx->nChannels = 2;
1219 device->pwfx->nBlockAlign = device->pwfx->wBitsPerSample * device->pwfx->nChannels / 8;
1220 device->pwfx->nAvgBytesPerSec = device->pwfx->nSamplesPerSec * device->pwfx->nBlockAlign;
1221 device->pwfx->cbSize = 0;
1222
1223 InitializeCriticalSection(&(device->mixlock));
1224 device->mixlock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": DirectSoundDevice.mixlock");
1225
1226 RtlInitializeResource(&(device->buffer_list_lock));
1227
1228 *ppDevice = device;
1229
1230 return DS_OK;
1231 }
1232
1233 static ULONG DirectSoundDevice_AddRef(DirectSoundDevice * device)
1234 {
1235 ULONG ref = InterlockedIncrement(&(device->ref));
1236 TRACE("(%p) ref was %d\n", device, ref - 1);
1237 return ref;
1238 }
1239
1240 ULONG DirectSoundDevice_Release(DirectSoundDevice * device)
1241 {
1242 HRESULT hr;
1243 ULONG ref = InterlockedDecrement(&(device->ref));
1244 TRACE("(%p) ref was %u\n", device, ref + 1);
1245 if (!ref) {
1246 int i;
1247 timeKillEvent(device->timerID);
1248 timeEndPeriod(DS_TIME_RES);
1249
1250 /* The kill event should have allowed the timer process to expire
1251 * but try to grab the lock just in case. Can't hold lock because
1252 * IDirectSoundBufferImpl_Destroy also grabs the lock */
1253 RtlAcquireResourceShared(&(device->buffer_list_lock), TRUE);
1254 RtlReleaseResource(&(device->buffer_list_lock));
1255
1256 /* It is allowed to release this object even when buffers are playing */
1257 if (device->buffers) {
1258 WARN("%d secondary buffers not released\n", device->nrofbuffers);
1259 for( i=0;i<device->nrofbuffers;i++)
1260 IDirectSoundBufferImpl_Destroy(device->buffers[i]);
1261 }
1262
1263 if (device->primary) {
1264 WARN("primary buffer not released\n");
1265 IDirectSoundBuffer8_Release((LPDIRECTSOUNDBUFFER8)device->primary);
1266 }
1267
1268 hr = DSOUND_PrimaryDestroy(device);
1269 if (hr != DS_OK)
1270 WARN("DSOUND_PrimaryDestroy failed\n");
1271
1272 if (device->driver)
1273 IDsDriver_Close(device->driver);
1274
1275 if (device->drvdesc.dwFlags & DSDDESC_DOMMSYSTEMOPEN)
1276 waveOutClose(device->hwo);
1277
1278 if (device->driver)
1279 IDsDriver_Release(device->driver);
1280
1281 DSOUND_renderer[device->drvdesc.dnDevNode] = NULL;
1282
1283 HeapFree(GetProcessHeap(), 0, device->tmp_buffer);
1284 HeapFree(GetProcessHeap(), 0, device->mix_buffer);
1285 if (device->drvdesc.dwFlags & DSDDESC_USESYSTEMMEMORY)
1286 HeapFree(GetProcessHeap(), 0, device->buffer);
1287 RtlDeleteResource(&device->buffer_list_lock);
1288 device->mixlock.DebugInfo->Spare[0] = 0;
1289 DeleteCriticalSection(&device->mixlock);
1290 HeapFree(GetProcessHeap(),0,device);
1291 TRACE("(%p) released\n", device);
1292 }
1293 return ref;
1294 }
1295
1296 HRESULT DirectSoundDevice_GetCaps(
1297 DirectSoundDevice * device,
1298 LPDSCAPS lpDSCaps)
1299 {
1300 TRACE("(%p,%p)\n",device,lpDSCaps);
1301
1302 if (device == NULL) {
1303 WARN("not initialized\n");
1304 return DSERR_UNINITIALIZED;
1305 }
1306
1307 if (lpDSCaps == NULL) {
1308 WARN("invalid parameter: lpDSCaps = NULL\n");
1309 return DSERR_INVALIDPARAM;
1310 }
1311
1312 /* check if there is enough room */
1313 if (lpDSCaps->dwSize < sizeof(*lpDSCaps)) {
1314 WARN("invalid parameter: lpDSCaps->dwSize = %d\n", lpDSCaps->dwSize);
1315 return DSERR_INVALIDPARAM;
1316 }
1317
1318 lpDSCaps->dwFlags = device->drvcaps.dwFlags;
1319 if (TRACE_ON(dsound)) {
1320 TRACE("(flags=0x%08x:\n",lpDSCaps->dwFlags);
1321 _dump_DSCAPS(lpDSCaps->dwFlags);
1322 TRACE(")\n");
1323 }
1324 lpDSCaps->dwMinSecondarySampleRate = device->drvcaps.dwMinSecondarySampleRate;
1325 lpDSCaps->dwMaxSecondarySampleRate = device->drvcaps.dwMaxSecondarySampleRate;
1326 lpDSCaps->dwPrimaryBuffers = device->drvcaps.dwPrimaryBuffers;
1327 lpDSCaps->dwMaxHwMixingAllBuffers = device->drvcaps.dwMaxHwMixingAllBuffers;
1328 lpDSCaps->dwMaxHwMixingStaticBuffers = device->drvcaps.dwMaxHwMixingStaticBuffers;
1329 lpDSCaps->dwMaxHwMixingStreamingBuffers = device->drvcaps.dwMaxHwMixingStreamingBuffers;
1330 lpDSCaps->dwFreeHwMixingAllBuffers = device->drvcaps.dwFreeHwMixingAllBuffers;
1331 lpDSCaps->dwFreeHwMixingStaticBuffers = device->drvcaps.dwFreeHwMixingStaticBuffers;
1332 lpDSCaps->dwFreeHwMixingStreamingBuffers = device->drvcaps.dwFreeHwMixingStreamingBuffers;
1333 lpDSCaps->dwMaxHw3DAllBuffers = device->drvcaps.dwMaxHw3DAllBuffers;
1334 lpDSCaps->dwMaxHw3DStaticBuffers = device->drvcaps.dwMaxHw3DStaticBuffers;
1335 lpDSCaps->dwMaxHw3DStreamingBuffers = device->drvcaps.dwMaxHw3DStreamingBuffers;
1336 lpDSCaps->dwFreeHw3DAllBuffers = device->drvcaps.dwFreeHw3DAllBuffers;
1337 lpDSCaps->dwFreeHw3DStaticBuffers = device->drvcaps.dwFreeHw3DStaticBuffers;
1338 lpDSCaps->dwFreeHw3DStreamingBuffers = device->drvcaps.dwFreeHw3DStreamingBuffers;
1339 lpDSCaps->dwTotalHwMemBytes = device->drvcaps.dwTotalHwMemBytes;
1340 lpDSCaps->dwFreeHwMemBytes = device->drvcaps.dwFreeHwMemBytes;
1341 lpDSCaps->dwMaxContigFreeHwMemBytes = device->drvcaps.dwMaxContigFreeHwMemBytes;
1342
1343 /* driver doesn't have these */
1344 lpDSCaps->dwUnlockTransferRateHwBuffers = 4096; /* But we have none... */
1345 lpDSCaps->dwPlayCpuOverheadSwBuffers = 1; /* 1% */
1346
1347 return DS_OK;
1348 }
1349
1350 HRESULT DirectSoundDevice_Initialize(DirectSoundDevice ** ppDevice, LPCGUID lpcGUID)
1351 {
1352 HRESULT hr = DS_OK;
1353 unsigned wod, wodn;
1354 BOOLEAN found = FALSE;
1355 GUID devGUID;
1356 DirectSoundDevice * device = *ppDevice;
1357 TRACE("(%p,%s)\n",ppDevice,debugstr_guid(lpcGUID));
1358
1359 if (*ppDevice != NULL) {
1360 WARN("already initialized\n");
1361 return DSERR_ALREADYINITIALIZED;
1362 }
1363
1364 /* Default device? */
1365 if (!lpcGUID || IsEqualGUID(lpcGUID, &GUID_NULL))
1366 lpcGUID = &DSDEVID_DefaultPlayback;
1367
1368 if (GetDeviceID(lpcGUID, &devGUID) != DS_OK) {
1369 WARN("invalid parameter: lpcGUID\n");
1370 return DSERR_INVALIDPARAM;
1371 }
1372
1373 /* Enumerate WINMM audio devices and find the one we want */
1374 wodn = waveOutGetNumDevs();
1375 if (!wodn) {
1376 WARN("no driver\n");
1377 return DSERR_NODRIVER;
1378 }
1379
1380 for (wod=0; wod<wodn; wod++) {
1381 if (IsEqualGUID( &devGUID, &DSOUND_renderer_guids[wod])) {
1382 found = TRUE;
1383 break;
1384 }
1385 }
1386
1387 if (found == FALSE) {
1388 WARN("No device found matching given ID!\n");
1389 return DSERR_NODRIVER;
1390 }
1391
1392 if (DSOUND_renderer[wod]) {
1393 if (IsEqualGUID(&devGUID, &DSOUND_renderer[wod]->guid)) {
1394 device = DSOUND_renderer[wod];
1395 DirectSoundDevice_AddRef(device);
1396 *ppDevice = device;
1397 return DS_OK;
1398 } else {
1399 ERR("device GUID doesn't match\n");
1400 hr = DSERR_GENERIC;
1401 return hr;
1402 }
1403 } else {
1404 hr = DirectSoundDevice_Create(&device);
1405 if (hr != DS_OK) {
1406 WARN("DirectSoundDevice_Create failed\n");
1407 return hr;
1408 }
1409 }
1410
1411 *ppDevice = device;
1412 device->guid = devGUID;
1413 device->driver = NULL;
1414
1415 device->drvdesc.dnDevNode = wod;
1416 hr = DSOUND_ReopenDevice(device, FALSE);
1417 if (FAILED(hr))
1418 {
1419 WARN("DSOUND_ReopenDevice failed: %08x\n", hr);
1420 return hr;
1421 }
1422
1423 if (device->driver) {
1424 /* the driver is now open, so it's now allowed to call GetCaps */
1425 hr = IDsDriver_GetCaps(device->driver,&(device->drvcaps));
1426 if (hr != DS_OK) {
1427 WARN("IDsDriver_GetCaps failed\n");
1428 return hr;
1429 }
1430 } else {
1431 WAVEOUTCAPSA woc;
1432 hr = mmErr(waveOutGetDevCapsA(device->drvdesc.dnDevNode, &woc, sizeof(woc)));
1433 if (hr != DS_OK) {
1434 WARN("waveOutGetDevCaps failed\n");
1435 return hr;
1436 }
1437 ZeroMemory(&device->drvcaps, sizeof(device->drvcaps));
1438 if ((woc.dwFormats & WAVE_FORMAT_1M08) ||
1439 (woc.dwFormats & WAVE_FORMAT_2M08) ||
1440 (woc.dwFormats & WAVE_FORMAT_4M08) ||
1441 (woc.dwFormats & WAVE_FORMAT_48M08) ||
1442 (woc.dwFormats & WAVE_FORMAT_96M08)) {
1443 device->drvcaps.dwFlags |= DSCAPS_PRIMARY8BIT;
1444 device->drvcaps.dwFlags |= DSCAPS_PRIMARYMONO;
1445 }
1446 if ((woc.dwFormats & WAVE_FORMAT_1M16) ||
1447 (woc.dwFormats & WAVE_FORMAT_2M16) ||
1448 (woc.dwFormats & WAVE_FORMAT_4M16) ||
1449 (woc.dwFormats & WAVE_FORMAT_48M16) ||
1450 (woc.dwFormats & WAVE_FORMAT_96M16)) {
1451 device->drvcaps.dwFlags |= DSCAPS_PRIMARY16BIT;
1452 device->drvcaps.dwFlags |= DSCAPS_PRIMARYMONO;
1453 }
1454 if ((woc.dwFormats & WAVE_FORMAT_1S08) ||
1455 (woc.dwFormats & WAVE_FORMAT_2S08) ||
1456 (woc.dwFormats & WAVE_FORMAT_4S08) ||
1457 (woc.dwFormats & WAVE_FORMAT_48S08) ||
1458 (woc.dwFormats & WAVE_FORMAT_96S08)) {
1459 device->drvcaps.dwFlags |= DSCAPS_PRIMARY8BIT;
1460 device->drvcaps.dwFlags |= DSCAPS_PRIMARYSTEREO;
1461 }
1462 if ((woc.dwFormats & WAVE_FORMAT_1S16) ||
1463 (woc.dwFormats & WAVE_FORMAT_2S16) ||
1464 (woc.dwFormats & WAVE_FORMAT_4S16) ||
1465 (woc.dwFormats & WAVE_FORMAT_48S16) ||
1466 (woc.dwFormats & WAVE_FORMAT_96S16)) {
1467 device->drvcaps.dwFlags |= DSCAPS_PRIMARY16BIT;
1468 device->drvcaps.dwFlags |= DSCAPS_PRIMARYSTEREO;
1469 }
1470 if (ds_emuldriver)
1471 device->drvcaps.dwFlags |= DSCAPS_EMULDRIVER;
1472 device->drvcaps.dwMinSecondarySampleRate = DSBFREQUENCY_MIN;
1473 device->drvcaps.dwMaxSecondarySampleRate = DSBFREQUENCY_MAX;
1474 ZeroMemory(&device->volpan, sizeof(device->volpan));
1475 }
1476
1477 hr = DSOUND_PrimaryCreate(device);
1478 if (hr == DS_OK) {
1479 UINT triggertime = DS_TIME_DEL, res = DS_TIME_RES, id;
1480 TIMECAPS time;
1481
1482 DSOUND_renderer[device->drvdesc.dnDevNode] = device;
1483 timeGetDevCaps(&time, sizeof(TIMECAPS));
1484 TRACE("Minimum timer resolution: %u, max timer: %u\n", time.wPeriodMin, time.wPeriodMax);
1485 if (triggertime < time.wPeriodMin)
1486 triggertime = time.wPeriodMin;
1487 if (res < time.wPeriodMin)
1488 res = time.wPeriodMin;
1489 if (timeBeginPeriod(res) == TIMERR_NOCANDO)
1490 WARN("Could not set minimum resolution, don't expect sound\n");
1491 id = timeSetEvent(triggertime, res, DSOUND_timer, (DWORD_PTR)device, TIME_PERIODIC | TIME_KILL_SYNCHRONOUS);
1492 if (!id)
1493 {
1494 WARN("Timer not created! Retrying without TIME_KILL_SYNCHRONOUS\n");
1495 id = timeSetEvent(triggertime, res, DSOUND_timer, (DWORD_PTR)device, TIME_PERIODIC);
1496 if (!id) ERR("Could not create timer, sound playback will not occur\n");
1497 }
1498 DSOUND_renderer[device->drvdesc.dnDevNode]->timerID = id;
1499 } else {
1500 WARN("DSOUND_PrimaryCreate failed\n");
1501 }
1502
1503 return hr;
1504 }
1505
1506 HRESULT DirectSoundDevice_CreateSoundBuffer(
1507 DirectSoundDevice * device,
1508 LPCDSBUFFERDESC dsbd,
1509 LPLPDIRECTSOUNDBUFFER ppdsb,
1510 LPUNKNOWN lpunk,
1511 BOOL from8)
1512 {
1513 HRESULT hres = DS_OK;
1514 TRACE("(%p,%p,%p,%p)\n",device,dsbd,ppdsb,lpunk);
1515
1516 if (device == NULL) {
1517 WARN("not initialized\n");
1518 return DSERR_UNINITIALIZED;
1519 }
1520
1521 if (dsbd == NULL) {
1522 WARN("invalid parameter: dsbd == NULL\n");
1523 return DSERR_INVALIDPARAM;
1524 }
1525
1526 if (dsbd->dwSize != sizeof(DSBUFFERDESC) &&
1527 dsbd->dwSize != sizeof(DSBUFFERDESC1)) {
1528 WARN("invalid parameter: dsbd\n");
1529 return DSERR_INVALIDPARAM;
1530 }
1531
1532 if (ppdsb == NULL) {
1533 WARN("invalid parameter: ppdsb == NULL\n");
1534 return DSERR_INVALIDPARAM;
1535 }
1536 *ppdsb = NULL;
1537
1538 if (TRACE_ON(dsound)) {
1539 TRACE("(structsize=%d)\n",dsbd->dwSize);
1540 TRACE("(flags=0x%08x:\n",dsbd->dwFlags);
1541 _dump_DSBCAPS(dsbd->dwFlags);
1542 TRACE(")\n");
1543 TRACE("(bufferbytes=%d)\n",dsbd->dwBufferBytes);
1544 TRACE("(lpwfxFormat=%p)\n",dsbd->lpwfxFormat);
1545 }
1546
1547 if (dsbd->dwFlags & DSBCAPS_PRIMARYBUFFER) {
1548 if (dsbd->lpwfxFormat != NULL) {
1549 WARN("invalid parameter: dsbd->lpwfxFormat must be NULL for "
1550 "primary buffer\n");
1551 return DSERR_INVALIDPARAM;
1552 }
1553
1554 if (device->primary) {
1555 WARN("Primary Buffer already created\n");
1556 IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER8)(device->primary));
1557 *ppdsb = (LPDIRECTSOUNDBUFFER)(device->primary);
1558 } else {
1559 device->dsbd = *dsbd;
1560 device->dsbd.dwFlags &= ~(DSBCAPS_LOCHARDWARE | DSBCAPS_LOCSOFTWARE);
1561 if (device->hwbuf)
1562 device->dsbd.dwFlags |= DSBCAPS_LOCHARDWARE;
1563 else device->dsbd.dwFlags |= DSBCAPS_LOCSOFTWARE;
1564 hres = PrimaryBufferImpl_Create(device, &(device->primary), &(device->dsbd));
1565 if (device->primary) {
1566 IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER8)(device->primary));
1567 *ppdsb = (LPDIRECTSOUNDBUFFER)(device->primary);
1568 } else
1569 WARN("PrimaryBufferImpl_Create failed\n");
1570 }
1571 } else {
1572 IDirectSoundBufferImpl * dsb;
1573 WAVEFORMATEXTENSIBLE *pwfxe;
1574
1575 if (dsbd->lpwfxFormat == NULL) {
1576 WARN("invalid parameter: dsbd->lpwfxFormat can't be NULL for "
1577 "secondary buffer\n");
1578 return DSERR_INVALIDPARAM;
1579 }
1580 pwfxe = (WAVEFORMATEXTENSIBLE*)dsbd->lpwfxFormat;
1581
1582 if (pwfxe->Format.wBitsPerSample != 16 && pwfxe->Format.wBitsPerSample != 8 && pwfxe->Format.wFormatTag != WAVE_FORMAT_EXTENSIBLE)
1583 {
1584 WARN("wBitsPerSample=%d needs a WAVEFORMATEXTENSIBLE\n", dsbd->lpwfxFormat->wBitsPerSample);
1585 return DSERR_CONTROLUNAVAIL;
1586 }
1587 if (pwfxe->Format.wFormatTag == WAVE_FORMAT_EXTENSIBLE)
1588 {
1589 if (pwfxe->Format.cbSize < (sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX)))
1590 {
1591 WARN("Too small a cbSize %u\n", pwfxe->Format.cbSize);
1592 return DSERR_INVALIDPARAM;
1593 }
1594
1595 if (pwfxe->Format.cbSize > (sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX)))
1596 {
1597 WARN("Too big a cbSize %u\n", pwfxe->Format.cbSize);
1598 return DSERR_CONTROLUNAVAIL;
1599 }
1600
1601 if (!IsEqualGUID(&pwfxe->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM))
1602 {
1603 if (!IsEqualGUID(&pwfxe->SubFormat, &GUID_NULL))
1604 FIXME("SubFormat %s not supported right now.\n", debugstr_guid(&pwfxe->SubFormat));
1605 return DSERR_INVALIDPARAM;
1606 }
1607 if (pwfxe->Samples.wValidBitsPerSample > dsbd->lpwfxFormat->wBitsPerSample)
1608 {
1609 WARN("Samples.wValidBitsPerSample(%d) > Format.wBitsPerSample (%d)\n", pwfxe->Samples.wValidBitsPerSample, pwfxe->Format.wBitsPerSample);
1610 return DSERR_INVALIDPARAM;
1611 }
1612 if (pwfxe->Samples.wValidBitsPerSample && pwfxe->Samples.wValidBitsPerSample < dsbd->lpwfxFormat->wBitsPerSample)
1613 {
1614 FIXME("Non-packed formats not supported right now: %d/%d\n", pwfxe->Samples.wValidBitsPerSample, dsbd->lpwfxFormat->wBitsPerSample);
1615 return DSERR_CONTROLUNAVAIL;
1616 }
1617 }
1618
1619 TRACE("(formattag=0x%04x,chans=%d,samplerate=%d,"
1620 "bytespersec=%d,blockalign=%d,bitspersamp=%d,cbSize=%d)\n",
1621 dsbd->lpwfxFormat->wFormatTag, dsbd->lpwfxFormat->nChannels,
1622 dsbd->lpwfxFormat->nSamplesPerSec,
1623 dsbd->lpwfxFormat->nAvgBytesPerSec,
1624 dsbd->lpwfxFormat->nBlockAlign,
1625 dsbd->lpwfxFormat->wBitsPerSample, dsbd->lpwfxFormat->cbSize);
1626
1627 if (from8 && (dsbd->dwFlags & DSBCAPS_CTRL3D) && (dsbd->lpwfxFormat->nChannels != 1)) {
1628 WARN("invalid parameter: 3D buffer format must be mono\n");
1629 return DSERR_INVALIDPARAM;
1630 }
1631
1632 hres = IDirectSoundBufferImpl_Create(device, &dsb, dsbd);
1633 if (dsb) {
1634 hres = SecondaryBufferImpl_Create(dsb, (SecondaryBufferImpl**)ppdsb);
1635 if (*ppdsb) {
1636 dsb->secondary = (SecondaryBufferImpl*)*ppdsb;
1637 IDirectSoundBuffer_AddRef(*ppdsb);
1638 } else
1639 WARN("SecondaryBufferImpl_Create failed\n");
1640 } else
1641 WARN("IDirectSoundBufferImpl_Create failed\n");
1642 }
1643
1644 return hres;
1645 }
1646
1647 HRESULT DirectSoundDevice_DuplicateSoundBuffer(
1648 DirectSoundDevice * device,
1649 LPDIRECTSOUNDBUFFER psb,
1650 LPLPDIRECTSOUNDBUFFER ppdsb)
1651 {
1652 HRESULT hres = DS_OK;
1653 IDirectSoundBufferImpl* dsb;
1654 TRACE("(%p,%p,%p)\n",device,psb,ppdsb);
1655
1656 if (device == NULL) {
1657 WARN("not initialized\n");
1658 return DSERR_UNINITIALIZED;
1659 }
1660
1661 if (psb == NULL) {
1662 WARN("invalid parameter: psb == NULL\n");
1663 return DSERR_INVALIDPARAM;
1664 }
1665
1666 if (ppdsb == NULL) {
1667 WARN("invalid parameter: ppdsb == NULL\n");
1668 return DSERR_INVALIDPARAM;
1669 }
1670
1671 /* make sure we have a secondary buffer */
1672 if ((PrimaryBufferImpl *)psb == device->primary) {
1673 WARN("trying to duplicate primary buffer\n");
1674 *ppdsb = NULL;
1675 return DSERR_INVALIDCALL;
1676 }
1677
1678 /* duplicate the actual buffer implementation */
1679 hres = IDirectSoundBufferImpl_Duplicate(device, &dsb,
1680 ((SecondaryBufferImpl *)psb)->dsb);
1681
1682 if (hres == DS_OK) {
1683 /* create a new secondary buffer using the new implementation */
1684 hres = SecondaryBufferImpl_Create(dsb, (SecondaryBufferImpl**)ppdsb);
1685 if (*ppdsb) {
1686 dsb->secondary = (SecondaryBufferImpl*)*ppdsb;
1687 IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER8)*ppdsb);
1688 } else {
1689 WARN("SecondaryBufferImpl_Create failed\n");
1690 IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER8)dsb);
1691 IDirectSoundBuffer_Release((LPDIRECTSOUNDBUFFER8)dsb);
1692 }
1693 }
1694
1695 return hres;
1696 }
1697
1698 HRESULT DirectSoundDevice_SetCooperativeLevel(
1699 DirectSoundDevice * device,
1700 HWND hwnd,
1701 DWORD level)
1702 {
1703 TRACE("(%p,%p,%s)\n",device,hwnd,dumpCooperativeLevel(level));
1704
1705 if (device == NULL) {
1706 WARN("not initialized\n");
1707 return DSERR_UNINITIALIZED;
1708 }
1709
1710 if (level==DSSCL_PRIORITY || level==DSSCL_EXCLUSIVE) {
1711 WARN("level=%s not fully supported\n",
1712 level==DSSCL_PRIORITY ? "DSSCL_PRIORITY" : "DSSCL_EXCLUSIVE");
1713 }
1714
1715 device->priolevel = level;
1716 return DS_OK;
1717 }
1718
1719 HRESULT DirectSoundDevice_Compact(
1720 DirectSoundDevice * device)
1721 {
1722 TRACE("(%p)\n", device);
1723
1724 if (device == NULL) {
1725 WARN("not initialized\n");
1726 return DSERR_UNINITIALIZED;
1727 }
1728
1729 if (device->priolevel < DSSCL_PRIORITY) {
1730 WARN("incorrect priority level\n");
1731 return DSERR_PRIOLEVELNEEDED;
1732 }
1733
1734 return DS_OK;
1735 }
1736
1737 HRESULT DirectSoundDevice_GetSpeakerConfig(
1738 DirectSoundDevice * device,
1739 LPDWORD lpdwSpeakerConfig)
1740 {
1741 TRACE("(%p, %p)\n", device, lpdwSpeakerConfig);
1742
1743 if (device == NULL) {
1744 WARN("not initialized\n");
1745 return DSERR_UNINITIALIZED;
1746 }
1747
1748 if (lpdwSpeakerConfig == NULL) {
1749 WARN("invalid parameter: lpdwSpeakerConfig == NULL\n");
1750 return DSERR_INVALIDPARAM;
1751 }
1752
1753 WARN("not fully functional\n");
1754 *lpdwSpeakerConfig = device->speaker_config;
1755 return DS_OK;
1756 }
1757
1758 HRESULT DirectSoundDevice_SetSpeakerConfig(
1759 DirectSoundDevice * device,
1760 DWORD config)
1761 {
1762 TRACE("(%p,0x%08x)\n",device,config);
1763
1764 if (device == NULL) {
1765 WARN("not initialized\n");
1766 return DSERR_UNINITIALIZED;
1767 }
1768
1769 device->speaker_config = config;
1770 WARN("not fully functional\n");
1771 return DS_OK;
1772 }
1773
1774 static HRESULT DirectSoundDevice_VerifyCertification(
1775 DirectSoundDevice * device,
1776 LPDWORD pdwCertified)
1777 {
1778 TRACE("(%p, %p)\n",device,pdwCertified);
1779
1780 if (device == NULL) {
1781 WARN("not initialized\n");
1782 return DSERR_UNINITIALIZED;
1783 }
1784
1785 if (device->drvcaps.dwFlags & DSCAPS_CERTIFIED)
1786 *pdwCertified = DS_CERTIFIED;
1787 else
1788 *pdwCertified = DS_UNCERTIFIED;
1789
1790 return DS_OK;
1791 }
1792
1793 /*
1794 * Add secondary buffer to buffer list.
1795 * Gets exclusive access to buffer for writing.
1796 */
1797 HRESULT DirectSoundDevice_AddBuffer(
1798 DirectSoundDevice * device,
1799 IDirectSoundBufferImpl * pDSB)
1800 {
1801 IDirectSoundBufferImpl **newbuffers;
1802 HRESULT hr = DS_OK;
1803
1804 TRACE("(%p, %p)\n", device, pDSB);
1805
1806 RtlAcquireResourceExclusive(&(device->buffer_list_lock), TRUE);
1807
1808 if (device->buffers)
1809 newbuffers = HeapReAlloc(GetProcessHeap(),0,device->buffers,sizeof(IDirectSoundBufferImpl*)*(device->nrofbuffers+1));
1810 else
1811 newbuffers = HeapAlloc(GetProcessHeap(),0,sizeof(IDirectSoundBufferImpl*)*(device->nrofbuffers+1));
1812
1813 if (newbuffers) {
1814 device->buffers = newbuffers;
1815 device->buffers[device->nrofbuffers] = pDSB;
1816 device->nrofbuffers++;
1817 TRACE("buffer count is now %d\n", device->nrofbuffers);
1818 } else {
1819 ERR("out of memory for buffer list! Current buffer count is %d\n", device->nrofbuffers);
1820 hr = DSERR_OUTOFMEMORY;
1821 }
1822
1823 RtlReleaseResource(&(device->buffer_list_lock));
1824
1825 return hr;
1826 }
1827
1828 /*
1829 * Remove secondary buffer from buffer list.
1830 * Gets exclusive access to buffer for writing.
1831 */
1832 HRESULT DirectSoundDevice_RemoveBuffer(
1833 DirectSoundDevice * device,
1834 IDirectSoundBufferImpl * pDSB)
1835 {
1836 int i;
1837 HRESULT hr = DS_OK;
1838
1839 TRACE("(%p, %p)\n", device, pDSB);
1840
1841 RtlAcquireResourceExclusive(&(device->buffer_list_lock), TRUE);
1842
1843 for (i = 0; i < device->nrofbuffers; i++)
1844 if (device->buffers[i] == pDSB)
1845 break;
1846
1847 if (i < device->nrofbuffers) {
1848 /* Put the last buffer of the list in the (now empty) position */
1849 device->buffers[i] = device->buffers[device->nrofbuffers - 1];
1850 device->nrofbuffers--;
1851 device->buffers = HeapReAlloc(GetProcessHeap(),0,device->buffers,sizeof(LPDIRECTSOUNDBUFFER8)*device->nrofbuffers);
1852 TRACE("buffer count is now %d\n", device->nrofbuffers);
1853 }
1854
1855 if (device->nrofbuffers == 0) {
1856 HeapFree(GetProcessHeap(),0,device->buffers);
1857 device->buffers = NULL;
1858 }
1859
1860 RtlReleaseResource(&(device->buffer_list_lock));
1861
1862 return hr;
1863 }