?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
If we have a drive pointing to /, we must not remove the final / or we
[wine/dcerpc.git] / dlls / dsound / dsound_main.c
blob41246d493cc2704f0811b005c80e878aead53945
1 /* DirectSound
2 *
3 * Copyright 1998 Marcus Meissner
4 * Copyright 1998 Rob Riggs
5 * Copyright 2000 Ove Kåven, TransGaming Technologies, Inc.
6 */
7 /*
8 * Most thread locking is complete. There may be a few race
9 * conditions still lurking.
10 *
11 * Tested with a Soundblaster clone, a Gravis UltraSound Classic,
12 * and a Turtle Beach Tropez+.
13 *
14 * TODO:
15 * Implement DirectSoundCapture API
16 * Implement SetCooperativeLevel properly (need to address focus issues)
17 * Implement DirectSound3DBuffers (stubs in place)
18 * Use hardware 3D support if available
19 * Add critical section locking inside Release and AddRef methods
20 * Handle static buffers - put those in hardware, non-static not in hardware
21 * Hardware DuplicateSoundBuffer
22 * Proper volume calculation, and setting volume in HEL primary buffer
23 * Optimize WINMM and negotiate fragment size, decrease DS_HEL_MARGIN
24 */
25
26 #include "config.h"
27 #include <assert.h>
28 #include <stdio.h>
29 #include <sys/types.h>
30 #include <sys/fcntl.h>
31 #include <unistd.h>
32 #include <stdlib.h>
33 #include <string.h>
34 #include <math.h> /* Insomnia - pow() function */
35
36 #include "windef.h"
37 #include "wingdi.h"
38 #include "winuser.h"
39 #include "winerror.h"
40 #include "mmsystem.h"
41 #include "wine/windef16.h"
42 #include "debugtools.h"
43
44 #include "initguid.h"
45 #include "dsound.h"
46 #include "dsdriver.h"
47
48 DEFAULT_DEBUG_CHANNEL(dsound);
49
50 /* these are eligible for tuning... they must be high on slow machines... */
51 /* especially since the WINMM overhead is pretty high, and could be improved quite a bit;
52 * the high DS_HEL_MARGIN reflects the currently high wineoss/HEL latency */
53 #define DS_HEL_FRAGS 48 /* HEL only: number of waveOut fragments in primary buffer */
54 #define DS_HEL_QUEUE 28 /* HEL only: number of waveOut fragments to prebuffer */
55 /* (Starcraft videos won't work with higher than 32 x10ms) */
56 #define DS_HEL_MARGIN 4 /* HEL only: number of waveOut fragments ahead to mix in new buffers */
57
58 #define DS_HAL_QUEUE 28 /* HAL only: max number of fragments to prebuffer */
59
60 /* Linux does not support better timing than 10ms */
61 #define DS_TIME_RES 10 /* Resolution of multimedia timer */
62 #define DS_TIME_DEL 10 /* Delay of multimedia timer callback, and duration of HEL fragment */
63
64 /*****************************************************************************
65 * Predeclare the interface implementation structures
66 */
67 typedef struct IDirectSoundImpl IDirectSoundImpl;
68 typedef struct IDirectSoundBufferImpl IDirectSoundBufferImpl;
69 typedef struct IDirectSoundNotifyImpl IDirectSoundNotifyImpl;
70 typedef struct IDirectSound3DListenerImpl IDirectSound3DListenerImpl;
71 typedef struct IDirectSound3DBufferImpl IDirectSound3DBufferImpl;
72 typedef struct IDirectSoundCaptureImpl IDirectSoundCaptureImpl;
73 typedef struct IDirectSoundCaptureBufferImpl IDirectSoundCaptureBufferImpl;
74
75 /*****************************************************************************
76 * IDirectSound implementation structure
77 */
78 struct IDirectSoundImpl
79 {
80 /* IUnknown fields */
81 ICOM_VFIELD(IDirectSound);
82 DWORD ref;
83 /* IDirectSoundImpl fields */
84 PIDSDRIVER driver;
85 DSDRIVERDESC drvdesc;
86 DSDRIVERCAPS drvcaps;
87 HWAVEOUT hwo;
88 LPWAVEHDR pwave[DS_HEL_FRAGS];
89 UINT timerID, pwplay, pwwrite, pwqueue;
90 DWORD fraglen;
91 DWORD priolevel;
92 int nrofbuffers;
93 IDirectSoundBufferImpl** buffers;
94 IDirectSoundBufferImpl* primary;
95 IDirectSound3DListenerImpl* listener;
96 WAVEFORMATEX wfx; /* current main waveformat */
97 CRITICAL_SECTION lock;
98 };
99
100 /*****************************************************************************
101 * IDirectSoundBuffer implementation structure
102 */
103 struct IDirectSoundBufferImpl
104 {
105 /* IUnknown fields */
106 ICOM_VFIELD(IDirectSoundBuffer);
107 DWORD ref;
108 /* IDirectSoundBufferImpl fields */
109 PIDSDRIVERBUFFER hwbuf;
110 WAVEFORMATEX wfx;
111 LPBYTE buffer;
112 IDirectSound3DBufferImpl* ds3db;
113 DWORD playflags,state,leadin;
114 DWORD playpos,mixpos,startpos,writelead,buflen;
115 DWORD nAvgBytesPerSec;
116 DWORD freq;
117 ULONG freqAdjust;
118 DSVOLUMEPAN volpan;
119 IDirectSoundBufferImpl* parent; /* for duplicates */
120 IDirectSoundImpl* dsound;
121 DSBUFFERDESC dsbd;
122 LPDSBPOSITIONNOTIFY notifies;
123 int nrofnotifies;
124 CRITICAL_SECTION lock;
125 };
126
127 #define STATE_STOPPED 0
128 #define STATE_STARTING 1
129 #define STATE_PLAYING 2
130 #define STATE_STOPPING 3
131
132 /*****************************************************************************
133 * IDirectSoundNotify implementation structure
134 */
135 struct IDirectSoundNotifyImpl
136 {
137 /* IUnknown fields */
138 ICOM_VFIELD(IDirectSoundNotify);
139 DWORD ref;
140 /* IDirectSoundNotifyImpl fields */
141 IDirectSoundBufferImpl* dsb;
142 };
143
144 /*****************************************************************************
145 * IDirectSound3DListener implementation structure
146 */
147 struct IDirectSound3DListenerImpl
148 {
149 /* IUnknown fields */
150 ICOM_VFIELD(IDirectSound3DListener);
151 DWORD ref;
152 /* IDirectSound3DListenerImpl fields */
153 IDirectSoundBufferImpl* dsb;
154 DS3DLISTENER ds3dl;
155 CRITICAL_SECTION lock;
156 };
157
158 /*****************************************************************************
159 * IDirectSound3DBuffer implementation structure
160 */
161 struct IDirectSound3DBufferImpl
162 {
163 /* IUnknown fields */
164 ICOM_VFIELD(IDirectSound3DBuffer);
165 DWORD ref;
166 /* IDirectSound3DBufferImpl fields */
167 IDirectSoundBufferImpl* dsb;
168 DS3DBUFFER ds3db;
169 LPBYTE buffer;
170 DWORD buflen;
171 CRITICAL_SECTION lock;
172 };
173
174
175 /*****************************************************************************
176 * IDirectSoundCapture implementation structure
177 */
178 struct IDirectSoundCaptureImpl
179 {
180 /* IUnknown fields */
181 ICOM_VFIELD(IDirectSoundCapture);
182 DWORD ref;
183
184 /* IDirectSoundCaptureImpl fields */
185 CRITICAL_SECTION lock;
186 };
187
188 /*****************************************************************************
189 * IDirectSoundCapture implementation structure
190 */
191 struct IDirectSoundCaptureBufferImpl
192 {
193 /* IUnknown fields */
194 ICOM_VFIELD(IDirectSoundCaptureBuffer);
195 DWORD ref;
196
197 /* IDirectSoundCaptureBufferImpl fields */
198 CRITICAL_SECTION lock;
199 };
200
201
202 /* #define USE_DSOUND3D 1 */
203
204 #define DSOUND_FREQSHIFT (14)
205
206 static IDirectSoundImpl* dsound = NULL;
207
208 static IDirectSoundBufferImpl* primarybuf = NULL;
209
210 static void DSOUND_CheckEvent(IDirectSoundBufferImpl *dsb, int len);
211
212 static HRESULT DSOUND_CreateDirectSoundCapture( LPVOID* ppobj );
213 static HRESULT DSOUND_CreateDirectSoundCaptureBuffer( LPCDSCBUFFERDESC lpcDSCBufferDesc, LPVOID* ppobj );
214
215 static ICOM_VTABLE(IDirectSoundCapture) dscvt;
216 static ICOM_VTABLE(IDirectSoundCaptureBuffer) dscbvt;
217
218 static HRESULT mmErr(UINT err)
219 {
220 switch(err) {
221 case MMSYSERR_NOERROR:
222 return DS_OK;
223 case MMSYSERR_ALLOCATED:
224 return DSERR_ALLOCATED;
225 case MMSYSERR_INVALHANDLE:
226 return DSERR_GENERIC; /* FIXME */
227 case MMSYSERR_NODRIVER:
228 return DSERR_NODRIVER;
229 case MMSYSERR_NOMEM:
230 return DSERR_OUTOFMEMORY;
231 case MMSYSERR_INVALPARAM:
232 return DSERR_INVALIDPARAM;
233 default:
234 FIXME("Unknown MMSYS error %d\n",err);
235 return DSERR_GENERIC;
236 }
237 }
238
239 /***************************************************************************
240 * DirectSoundEnumerateA [DSOUND.2]
241 *
242 * Enumerate all DirectSound drivers installed in the system
243 *
244 * RETURNS
245 * Success: DS_OK
246 * Failure: DSERR_INVALIDPARAM
247 */
248 HRESULT WINAPI DirectSoundEnumerateA(
249 LPDSENUMCALLBACKA lpDSEnumCallback,
250 LPVOID lpContext)
251 {
252 TRACE("lpDSEnumCallback = %p, lpContext = %p\n",
253 lpDSEnumCallback, lpContext);
254
255 #ifdef HAVE_OSS
256 if (lpDSEnumCallback != NULL)
257 lpDSEnumCallback(NULL,"WINE DirectSound using Open Sound System",
258 "sound",lpContext);
259 #endif
260
261 return DS_OK;
262 }
263
264 /***************************************************************************
265 * DirectSoundEnumerateW [DSOUND.3]
266 *
267 * Enumerate all DirectSound drivers installed in the system
268 *
269 * RETURNS
270 * Success: DS_OK
271 * Failure: DSERR_INVALIDPARAM
272 */
273 HRESULT WINAPI DirectSoundEnumerateW(
274 LPDSENUMCALLBACKW lpDSEnumCallback,
275 LPVOID lpContext )
276 {
277 FIXME("lpDSEnumCallback = %p, lpContext = %p: stub\n",
278 lpDSEnumCallback, lpContext);
279
280 return DS_OK;
281 }
282
283
284 static void _dump_DSBCAPS(DWORD xmask) {
285 struct {
286 DWORD mask;
287 char *name;
288 } flags[] = {
289 #define FE(x) { x, #x },
290 FE(DSBCAPS_PRIMARYBUFFER)
291 FE(DSBCAPS_STATIC)
292 FE(DSBCAPS_LOCHARDWARE)
293 FE(DSBCAPS_LOCSOFTWARE)
294 FE(DSBCAPS_CTRL3D)
295 FE(DSBCAPS_CTRLFREQUENCY)
296 FE(DSBCAPS_CTRLPAN)
297 FE(DSBCAPS_CTRLVOLUME)
298 FE(DSBCAPS_CTRLPOSITIONNOTIFY)
299 FE(DSBCAPS_CTRLDEFAULT)
300 FE(DSBCAPS_CTRLALL)
301 FE(DSBCAPS_STICKYFOCUS)
302 FE(DSBCAPS_GLOBALFOCUS)
303 FE(DSBCAPS_GETCURRENTPOSITION2)
304 FE(DSBCAPS_MUTE3DATMAXDISTANCE)
305 #undef FE
306 };
307 int i;
308
309 for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
310 if ((flags[i].mask & xmask) == flags[i].mask)
311 DPRINTF("%s ",flags[i].name);
312 }
313
314 /*******************************************************************************
315 * IDirectSound3DBuffer
316 */
317
318 /* IUnknown methods */
319 #ifdef USE_DSOUND3D
320 static HRESULT WINAPI IDirectSound3DBufferImpl_QueryInterface(
321 LPDIRECTSOUND3DBUFFER iface, REFIID riid, LPVOID *ppobj)
322 {
323 ICOM_THIS(IDirectSound3DBufferImpl,iface);
324
325 TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
326 return E_FAIL;
327 }
328 #endif
329
330 #ifdef USE_DSOUND3D
331 static ULONG WINAPI IDirectSound3DBufferImpl_AddRef(LPDIRECTSOUND3DBUFFER iface)
332 {
333 ICOM_THIS(IDirectSound3DBufferImpl,iface);
334 This->ref++;
335 return This->ref;
336 }
337 #endif
338
339 #ifdef USE_DSOUND3D
340 static ULONG WINAPI IDirectSound3DBufferImpl_Release(LPDIRECTSOUND3DBUFFER iface)
341 {
342 ICOM_THIS(IDirectSound3DBufferImpl,iface);
343
344 TRACE("(%p) ref was %ld\n", This, This->ref);
345
346 if(--This->ref)
347 return This->ref;
348
349 if (This->dsb)
350 IDirectSoundBuffer_Release((LPDIRECTSOUNDBUFFER)This->dsb);
351
352 DeleteCriticalSection(&This->lock);
353
354 HeapFree(GetProcessHeap(),0,This->buffer);
355 HeapFree(GetProcessHeap(),0,This);
356
357 return 0;
358 }
359 #endif
360
361 /* IDirectSound3DBuffer methods */
362 #ifdef USE_DSOUND3D
363 static HRESULT WINAPI IDirectSound3DBufferImpl_GetAllParameters(
364 LPDIRECTSOUND3DBUFFER iface,
365 LPDS3DBUFFER lpDs3dBuffer)
366 {
367 FIXME("stub\n");
368 return DS_OK;
369 }
370 #endif
371
372 #ifdef USE_DSOUND3D
373 static HRESULT WINAPI IDirectSound3DBufferImpl_GetConeAngles(
374 LPDIRECTSOUND3DBUFFER iface,
375 LPDWORD lpdwInsideConeAngle,
376 LPDWORD lpdwOutsideConeAngle)
377 {
378 FIXME("stub\n");
379 return DS_OK;
380 }
381 #endif
382
383 #ifdef USE_DSOUND3D
384 static HRESULT WINAPI IDirectSound3DBufferImpl_GetConeOrientation(
385 LPDIRECTSOUND3DBUFFER iface,
386 LPD3DVECTOR lpvConeOrientation)
387 {
388 FIXME("stub\n");
389 return DS_OK;
390 }
391 #endif
392
393 #ifdef USE_DSOUND3D
394 static HRESULT WINAPI IDirectSound3DBufferImpl_GetConeOutsideVolume(
395 LPDIRECTSOUND3DBUFFER iface,
396 LPLONG lplConeOutsideVolume)
397 {
398 FIXME("stub\n");
399 return DS_OK;
400 }
401 #endif
402
403 #ifdef USE_DSOUND3D
404 static HRESULT WINAPI IDirectSound3DBufferImpl_GetMaxDistance(
405 LPDIRECTSOUND3DBUFFER iface,
406 LPD3DVALUE lpfMaxDistance)
407 {
408 FIXME("stub\n");
409 return DS_OK;
410 }
411 #endif
412
413 #ifdef USE_DSOUND3D
414 static HRESULT WINAPI IDirectSound3DBufferImpl_GetMinDistance(
415 LPDIRECTSOUND3DBUFFER iface,
416 LPD3DVALUE lpfMinDistance)
417 {
418 FIXME("stub\n");
419 return DS_OK;
420 }
421 #endif
422
423 #ifdef USE_DSOUND3D
424 static HRESULT WINAPI IDirectSound3DBufferImpl_GetMode(
425 LPDIRECTSOUND3DBUFFER iface,
426 LPDWORD lpdwMode)
427 {
428 FIXME("stub\n");
429 return DS_OK;
430 }
431 #endif
432
433 #ifdef USE_DSOUND3D
434 static HRESULT WINAPI IDirectSound3DBufferImpl_GetPosition(
435 LPDIRECTSOUND3DBUFFER iface,
436 LPD3DVECTOR lpvPosition)
437 {
438 FIXME("stub\n");
439 return DS_OK;
440 }
441 #endif
442
443 #ifdef USE_DSOUND3D
444 static HRESULT WINAPI IDirectSound3DBufferImpl_GetVelocity(
445 LPDIRECTSOUND3DBUFFER iface,
446 LPD3DVECTOR lpvVelocity)
447 {
448 FIXME("stub\n");
449 return DS_OK;
450 }
451 #endif
452
453 #ifdef USE_DSOUND3D
454 static HRESULT WINAPI IDirectSound3DBufferImpl_SetAllParameters(
455 LPDIRECTSOUND3DBUFFER iface,
456 LPCDS3DBUFFER lpcDs3dBuffer,
457 DWORD dwApply)
458 {
459 FIXME("stub\n");
460 return DS_OK;
461 }
462 #endif
463
464 #ifdef USE_DSOUND3D
465 static HRESULT WINAPI IDirectSound3DBufferImpl_SetConeAngles(
466 LPDIRECTSOUND3DBUFFER iface,
467 DWORD dwInsideConeAngle,
468 DWORD dwOutsideConeAngle,
469 DWORD dwApply)
470 {
471 FIXME("stub\n");
472 return DS_OK;
473 }
474 #endif
475
476 #ifdef USE_DSOUND3D
477 static HRESULT WINAPI IDirectSound3DBufferImpl_SetConeOrientation(
478 LPDIRECTSOUND3DBUFFER iface,
479 D3DVALUE x, D3DVALUE y, D3DVALUE z,
480 DWORD dwApply)
481 {
482 FIXME("stub\n");
483 return DS_OK;
484 }
485 #endif
486
487 #ifdef USE_DSOUND3D
488 static HRESULT WINAPI IDirectSound3DBufferImpl_SetConeOutsideVolume(
489 LPDIRECTSOUND3DBUFFER iface,
490 LONG lConeOutsideVolume,
491 DWORD dwApply)
492 {
493 FIXME("stub\n");
494 return DS_OK;
495 }
496 #endif
497
498 #ifdef USE_DSOUND3D
499 static HRESULT WINAPI IDirectSound3DBufferImpl_SetMaxDistance(
500 LPDIRECTSOUND3DBUFFER iface,
501 D3DVALUE fMaxDistance,
502 DWORD dwApply)
503 {
504 FIXME("stub\n");
505 return DS_OK;
506 }
507 #endif
508
509 #ifdef USE_DSOUND3D
510 static HRESULT WINAPI IDirectSound3DBufferImpl_SetMinDistance(
511 LPDIRECTSOUND3DBUFFER iface,
512 D3DVALUE fMinDistance,
513 DWORD dwApply)
514 {
515 FIXME("stub\n");
516 return DS_OK;
517 }
518 #endif
519
520 #ifdef USE_DSOUND3D
521 static HRESULT WINAPI IDirectSound3DBufferImpl_SetMode(
522 LPDIRECTSOUND3DBUFFER iface,
523 DWORD dwMode,
524 DWORD dwApply)
525 {
526 ICOM_THIS(IDirectSound3DBufferImpl,iface);
527 TRACE("mode = %lx\n", dwMode);
528 This->ds3db.dwMode = dwMode;
529 return DS_OK;
530 }
531 #endif
532
533 #ifdef USE_DSOUND3D
534 static HRESULT WINAPI IDirectSound3DBufferImpl_SetPosition(
535 LPDIRECTSOUND3DBUFFER iface,
536 D3DVALUE x, D3DVALUE y, D3DVALUE z,
537 DWORD dwApply)
538 {
539 FIXME("stub\n");
540 return DS_OK;
541 }
542 #endif
543
544 #ifdef USE_DSOUND3D
545 static HRESULT WINAPI IDirectSound3DBufferImpl_SetVelocity(
546 LPDIRECTSOUND3DBUFFER iface,
547 D3DVALUE x, D3DVALUE y, D3DVALUE z,
548 DWORD dwApply)
549 {
550 FIXME("stub\n");
551 return DS_OK;
552 }
553 #endif
554
555 #ifdef USE_DSOUND3D
556 static ICOM_VTABLE(IDirectSound3DBuffer) ds3dbvt =
557 {
558 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
559 /* IUnknown methods */
560 IDirectSound3DBufferImpl_QueryInterface,
561 IDirectSound3DBufferImpl_AddRef,
562 IDirectSound3DBufferImpl_Release,
563 /* IDirectSound3DBuffer methods */
564 IDirectSound3DBufferImpl_GetAllParameters,
565 IDirectSound3DBufferImpl_GetConeAngles,
566 IDirectSound3DBufferImpl_GetConeOrientation,
567 IDirectSound3DBufferImpl_GetConeOutsideVolume,
568 IDirectSound3DBufferImpl_GetMaxDistance,
569 IDirectSound3DBufferImpl_GetMinDistance,
570 IDirectSound3DBufferImpl_GetMode,
571 IDirectSound3DBufferImpl_GetPosition,
572 IDirectSound3DBufferImpl_GetVelocity,
573 IDirectSound3DBufferImpl_SetAllParameters,
574 IDirectSound3DBufferImpl_SetConeAngles,
575 IDirectSound3DBufferImpl_SetConeOrientation,
576 IDirectSound3DBufferImpl_SetConeOutsideVolume,
577 IDirectSound3DBufferImpl_SetMaxDistance,
578 IDirectSound3DBufferImpl_SetMinDistance,
579 IDirectSound3DBufferImpl_SetMode,
580 IDirectSound3DBufferImpl_SetPosition,
581 IDirectSound3DBufferImpl_SetVelocity,
582 };
583 #endif
584
585 #ifdef USE_DSOUND3D
586 static int DSOUND_Create3DBuffer(IDirectSoundBufferImpl* dsb)
587 {
588 DWORD i, temp, iSize, oSize, offset;
589 LPBYTE bIbuf, bObuf, bTbuf = NULL;
590 LPWORD wIbuf, wObuf, wTbuf = NULL;
591
592 /* Inside DirectX says it's stupid but allowed */
593 if (dsb->wfx.nChannels == 2) {
594 /* Convert to mono */
595 if (dsb->wfx.wBitsPerSample == 16) {
596 iSize = dsb->buflen / 4;
597 wTbuf = malloc(dsb->buflen / 2);
598 if (wTbuf == NULL)
599 return DSERR_OUTOFMEMORY;
600 for (i = 0; i < iSize; i++)
601 wTbuf[i] = (dsb->buffer[i] + dsb->buffer[(i * 2) + 1]) / 2;
602 wIbuf = wTbuf;
603 } else {
604 iSize = dsb->buflen / 2;
605 bTbuf = malloc(dsb->buflen / 2);
606 if (bTbuf == NULL)
607 return DSERR_OUTOFMEMORY;
608 for (i = 0; i < iSize; i++)
609 bTbuf[i] = (dsb->buffer[i] + dsb->buffer[(i * 2) + 1]) / 2;
610 bIbuf = bTbuf;
611 }
612 } else {
613 if (dsb->wfx.wBitsPerSample == 16) {
614 iSize = dsb->buflen / 2;
615 wIbuf = (LPWORD) dsb->buffer;
616 } else {
617 bIbuf = (LPBYTE) dsb->buffer;
618 iSize = dsb->buflen;
619 }
620 }
621
622 if (primarybuf->wfx.wBitsPerSample == 16) {
623 wObuf = (LPWORD) dsb->ds3db->buffer;
624 oSize = dsb->ds3db->buflen / 2;
625 } else {
626 bObuf = (LPBYTE) dsb->ds3db->buffer;
627 oSize = dsb->ds3db->buflen;
628 }
629
630 offset = primarybuf->wfx.nSamplesPerSec / 100; /* 10ms */
631 if (primarybuf->wfx.wBitsPerSample == 16 && dsb->wfx.wBitsPerSample == 16)
632 for (i = 0; i < iSize; i++) {
633 temp = wIbuf[i];
634 if (i >= offset)
635 temp += wIbuf[i - offset] >> 9;
636 else
637 temp += wIbuf[i + iSize - offset] >> 9;
638 wObuf[i * 2] = temp;
639 wObuf[(i * 2) + 1] = temp;
640 }
641 else if (primarybuf->wfx.wBitsPerSample == 8 && dsb->wfx.wBitsPerSample == 8)
642 for (i = 0; i < iSize; i++) {
643 temp = bIbuf[i];
644 if (i >= offset)
645 temp += bIbuf[i - offset] >> 5;
646 else
647 temp += bIbuf[i + iSize - offset] >> 5;
648 bObuf[i * 2] = temp;
649 bObuf[(i * 2) + 1] = temp;
650 }
651
652 if (wTbuf)
653 free(wTbuf);
654 if (bTbuf)
655 free(bTbuf);
656
657 return DS_OK;
658 }
659 #endif
660 /*******************************************************************************
661 * IDirectSound3DListener
662 */
663
664 /* IUnknown methods */
665 static HRESULT WINAPI IDirectSound3DListenerImpl_QueryInterface(
666 LPDIRECTSOUND3DLISTENER iface, REFIID riid, LPVOID *ppobj)
667 {
668 ICOM_THIS(IDirectSound3DListenerImpl,iface);
669
670 TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
671 return E_FAIL;
672 }
673
674 static ULONG WINAPI IDirectSound3DListenerImpl_AddRef(LPDIRECTSOUND3DLISTENER iface)
675 {
676 ICOM_THIS(IDirectSound3DListenerImpl,iface);
677 This->ref++;
678 return This->ref;
679 }
680
681 static ULONG WINAPI IDirectSound3DListenerImpl_Release(LPDIRECTSOUND3DLISTENER iface)
682 {
683 ULONG ulReturn;
684 ICOM_THIS(IDirectSound3DListenerImpl,iface);
685
686 TRACE("(%p) ref was %ld\n", This, This->ref);
687
688 ulReturn = --This->ref;
689
690 /* Free all resources */
691 if( ulReturn == 0 ) {
692 if(This->dsb)
693 IDirectSoundBuffer_Release((LPDIRECTSOUNDBUFFER)This->dsb);
694 DeleteCriticalSection(&This->lock);
695 HeapFree(GetProcessHeap(),0,This);
696 }
697
698 return ulReturn;
699 }
700
701 /* IDirectSound3DListener methods */
702 static HRESULT WINAPI IDirectSound3DListenerImpl_GetAllParameter(
703 LPDIRECTSOUND3DLISTENER iface,
704 LPDS3DLISTENER lpDS3DL)
705 {
706 FIXME("stub\n");
707 return DS_OK;
708 }
709
710 static HRESULT WINAPI IDirectSound3DListenerImpl_GetDistanceFactor(
711 LPDIRECTSOUND3DLISTENER iface,
712 LPD3DVALUE lpfDistanceFactor)
713 {
714 FIXME("stub\n");
715 return DS_OK;
716 }
717
718 static HRESULT WINAPI IDirectSound3DListenerImpl_GetDopplerFactor(
719 LPDIRECTSOUND3DLISTENER iface,
720 LPD3DVALUE lpfDopplerFactor)
721 {
722 FIXME("stub\n");
723 return DS_OK;
724 }
725
726 static HRESULT WINAPI IDirectSound3DListenerImpl_GetOrientation(
727 LPDIRECTSOUND3DLISTENER iface,
728 LPD3DVECTOR lpvOrientFront,
729 LPD3DVECTOR lpvOrientTop)
730 {
731 FIXME("stub\n");
732 return DS_OK;
733 }
734
735 static HRESULT WINAPI IDirectSound3DListenerImpl_GetPosition(
736 LPDIRECTSOUND3DLISTENER iface,
737 LPD3DVECTOR lpvPosition)
738 {
739 FIXME("stub\n");
740 return DS_OK;
741 }
742
743 static HRESULT WINAPI IDirectSound3DListenerImpl_GetRolloffFactor(
744 LPDIRECTSOUND3DLISTENER iface,
745 LPD3DVALUE lpfRolloffFactor)
746 {
747 FIXME("stub\n");
748 return DS_OK;
749 }
750
751 static HRESULT WINAPI IDirectSound3DListenerImpl_GetVelocity(
752 LPDIRECTSOUND3DLISTENER iface,
753 LPD3DVECTOR lpvVelocity)
754 {
755 FIXME("stub\n");
756 return DS_OK;
757 }
758
759 static HRESULT WINAPI IDirectSound3DListenerImpl_SetAllParameters(
760 LPDIRECTSOUND3DLISTENER iface,
761 LPCDS3DLISTENER lpcDS3DL,
762 DWORD dwApply)
763 {
764 FIXME("stub\n");
765 return DS_OK;
766 }
767
768 static HRESULT WINAPI IDirectSound3DListenerImpl_SetDistanceFactor(
769 LPDIRECTSOUND3DLISTENER iface,
770 D3DVALUE fDistanceFactor,
771 DWORD dwApply)
772 {
773 FIXME("stub\n");
774 return DS_OK;
775 }
776
777 static HRESULT WINAPI IDirectSound3DListenerImpl_SetDopplerFactor(
778 LPDIRECTSOUND3DLISTENER iface,
779 D3DVALUE fDopplerFactor,
780 DWORD dwApply)
781 {
782 FIXME("stub\n");
783 return DS_OK;
784 }
785
786 static HRESULT WINAPI IDirectSound3DListenerImpl_SetOrientation(
787 LPDIRECTSOUND3DLISTENER iface,
788 D3DVALUE xFront, D3DVALUE yFront, D3DVALUE zFront,
789 D3DVALUE xTop, D3DVALUE yTop, D3DVALUE zTop,
790 DWORD dwApply)
791 {
792 FIXME("stub\n");
793 return DS_OK;
794 }
795
796 static HRESULT WINAPI IDirectSound3DListenerImpl_SetPosition(
797 LPDIRECTSOUND3DLISTENER iface,
798 D3DVALUE x, D3DVALUE y, D3DVALUE z,
799 DWORD dwApply)
800 {
801 FIXME("stub\n");
802 return DS_OK;
803 }
804
805 static HRESULT WINAPI IDirectSound3DListenerImpl_SetRolloffFactor(
806 LPDIRECTSOUND3DLISTENER iface,
807 D3DVALUE fRolloffFactor,
808 DWORD dwApply)
809 {
810 FIXME("stub\n");
811 return DS_OK;
812 }
813
814 static HRESULT WINAPI IDirectSound3DListenerImpl_SetVelocity(
815 LPDIRECTSOUND3DLISTENER iface,
816 D3DVALUE x, D3DVALUE y, D3DVALUE z,
817 DWORD dwApply)
818 {
819 FIXME("stub\n");
820 return DS_OK;
821 }
822
823 static HRESULT WINAPI IDirectSound3DListenerImpl_CommitDeferredSettings(
824 LPDIRECTSOUND3DLISTENER iface)
825
826 {
827 FIXME("stub\n");
828 return DS_OK;
829 }
830
831 static ICOM_VTABLE(IDirectSound3DListener) ds3dlvt =
832 {
833 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
834 /* IUnknown methods */
835 IDirectSound3DListenerImpl_QueryInterface,
836 IDirectSound3DListenerImpl_AddRef,
837 IDirectSound3DListenerImpl_Release,
838 /* IDirectSound3DListener methods */
839 IDirectSound3DListenerImpl_GetAllParameter,
840 IDirectSound3DListenerImpl_GetDistanceFactor,
841 IDirectSound3DListenerImpl_GetDopplerFactor,
842 IDirectSound3DListenerImpl_GetOrientation,
843 IDirectSound3DListenerImpl_GetPosition,
844 IDirectSound3DListenerImpl_GetRolloffFactor,
845 IDirectSound3DListenerImpl_GetVelocity,
846 IDirectSound3DListenerImpl_SetAllParameters,
847 IDirectSound3DListenerImpl_SetDistanceFactor,
848 IDirectSound3DListenerImpl_SetDopplerFactor,
849 IDirectSound3DListenerImpl_SetOrientation,
850 IDirectSound3DListenerImpl_SetPosition,
851 IDirectSound3DListenerImpl_SetRolloffFactor,
852 IDirectSound3DListenerImpl_SetVelocity,
853 IDirectSound3DListenerImpl_CommitDeferredSettings,
854 };
855
856 /*******************************************************************************
857 * IDirectSoundNotify
858 */
859 static HRESULT WINAPI IDirectSoundNotifyImpl_QueryInterface(
860 LPDIRECTSOUNDNOTIFY iface,REFIID riid,LPVOID *ppobj
861 ) {
862 ICOM_THIS(IDirectSoundNotifyImpl,iface);
863
864 TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
865 return E_FAIL;
866 }
867
868 static ULONG WINAPI IDirectSoundNotifyImpl_AddRef(LPDIRECTSOUNDNOTIFY iface) {
869 ICOM_THIS(IDirectSoundNotifyImpl,iface);
870 return ++(This->ref);
871 }
872
873 static ULONG WINAPI IDirectSoundNotifyImpl_Release(LPDIRECTSOUNDNOTIFY iface) {
874 ICOM_THIS(IDirectSoundNotifyImpl,iface);
875
876 TRACE("(%p) ref was %ld\n", This, This->ref);
877
878 This->ref--;
879 if (!This->ref) {
880 IDirectSoundBuffer_Release((LPDIRECTSOUNDBUFFER)This->dsb);
881 HeapFree(GetProcessHeap(),0,This);
882 return 0;
883 }
884 return This->ref;
885 }
886
887 static HRESULT WINAPI IDirectSoundNotifyImpl_SetNotificationPositions(
888 LPDIRECTSOUNDNOTIFY iface,DWORD howmuch,LPCDSBPOSITIONNOTIFY notify
889 ) {
890 ICOM_THIS(IDirectSoundNotifyImpl,iface);
891 int i;
892
893 if (TRACE_ON(dsound)) {
894 TRACE("(%p,0x%08lx,%p)\n",This,howmuch,notify);
895 for (i=0;i<howmuch;i++)
896 TRACE("notify at %ld to 0x%08lx\n",
897 notify[i].dwOffset,(DWORD)notify[i].hEventNotify);
898 }
899 This->dsb->notifies = HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,This->dsb->notifies,(This->dsb->nrofnotifies+howmuch)*sizeof(DSBPOSITIONNOTIFY));
900 memcpy( This->dsb->notifies+This->dsb->nrofnotifies,
901 notify,
902 howmuch*sizeof(DSBPOSITIONNOTIFY)
903 );
904 This->dsb->nrofnotifies+=howmuch;
905
906 return S_OK;
907 }
908
909 static ICOM_VTABLE(IDirectSoundNotify) dsnvt =
910 {
911 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
912 IDirectSoundNotifyImpl_QueryInterface,
913 IDirectSoundNotifyImpl_AddRef,
914 IDirectSoundNotifyImpl_Release,
915 IDirectSoundNotifyImpl_SetNotificationPositions,
916 };
917
918 /*******************************************************************************
919 * IDirectSoundBuffer
920 */
921
922 static void DSOUND_RecalcVolPan(PDSVOLUMEPAN volpan)
923 {
924 double temp;
925
926 /* the AmpFactors are expressed in 16.16 fixed point */
927 volpan->dwVolAmpFactor = (ULONG) (pow(2.0, volpan->lVolume / 600.0) * 65536);
928 /* FIXME: dwPan{Left|Right}AmpFactor */
929
930 /* FIXME: use calculated vol and pan ampfactors */
931 temp = (double) (volpan->lVolume - (volpan->lPan > 0 ? volpan->lPan : 0));
932 volpan->dwTotalLeftAmpFactor = (ULONG) (pow(2.0, temp / 600.0) * 65536);
933 temp = (double) (volpan->lVolume + (volpan->lPan < 0 ? volpan->lPan : 0));
934 volpan->dwTotalRightAmpFactor = (ULONG) (pow(2.0, temp / 600.0) * 65536);
935
936 TRACE("left = %lx, right = %lx\n", volpan->dwTotalLeftAmpFactor, volpan->dwTotalRightAmpFactor);
937 }
938
939 static void DSOUND_RecalcFormat(IDirectSoundBufferImpl *dsb)
940 {
941 DWORD sw;
942
943 sw = dsb->wfx.nChannels * (dsb->wfx.wBitsPerSample / 8);
944 if ((dsb->dsbd.dwFlags & DSBCAPS_PRIMARYBUFFER) && dsb->hwbuf) {
945 DWORD fraglen;
946 /* let fragment size approximate the timer delay */
947 fraglen = (dsb->freq * DS_TIME_DEL / 1000) * sw;
948 /* reduce fragment size until an integer number of them fits in the buffer */
949 /* (FIXME: this may or may not be a good idea) */
950 while (dsb->buflen % fraglen) fraglen -= sw;
951 dsb->dsound->fraglen = fraglen;
952 TRACE("fraglen=%ld\n", dsb->dsound->fraglen);
953 }
954 /* calculate the 10ms write lead */
955 dsb->writelead = (dsb->freq / 100) * sw;
956 }
957
958 static HRESULT DSOUND_PrimaryOpen(IDirectSoundBufferImpl *dsb)
959 {
960 HRESULT err = DS_OK;
961
962 /* are we using waveOut stuff? */
963 if (!dsb->hwbuf) {
964 LPBYTE newbuf;
965 DWORD buflen;
966 HRESULT merr = DS_OK;
967 /* Start in pause mode, to allow buffers to get filled */
968 waveOutPause(dsb->dsound->hwo);
969 /* use fragments of 10ms (1/100s) each (which should get us within
970 * the documented write cursor lead of 10-15ms) */
971 buflen = ((dsb->wfx.nAvgBytesPerSec / 100) & ~3) * DS_HEL_FRAGS;
972 TRACE("desired buflen=%ld, old buffer=%p\n", buflen, dsb->buffer);
973 /* reallocate emulated primary buffer */
974 newbuf = (LPBYTE)HeapReAlloc(GetProcessHeap(),0,dsb->buffer,buflen);
975 if (newbuf == NULL) {
976 ERR("failed to allocate primary buffer\n");
977 merr = DSERR_OUTOFMEMORY;
978 /* but the old buffer might still exists and must be re-prepared */
979 } else {
980 dsb->buffer = newbuf;
981 dsb->buflen = buflen;
982 }
983 if (dsb->buffer) {
984 unsigned c;
985 IDirectSoundImpl *ds = dsb->dsound;
986
987 ds->fraglen = dsb->buflen / DS_HEL_FRAGS;
988
989 /* prepare fragment headers */
990 for (c=0; c<DS_HEL_FRAGS; c++) {
991 ds->pwave[c]->lpData = dsb->buffer + c*ds->fraglen;
992 ds->pwave[c]->dwBufferLength = ds->fraglen;
993 ds->pwave[c]->dwUser = (DWORD)dsb;
994 ds->pwave[c]->dwFlags = 0;
995 ds->pwave[c]->dwLoops = 0;
996 err = mmErr(waveOutPrepareHeader(ds->hwo,ds->pwave[c],sizeof(WAVEHDR)));
997 if (err != DS_OK) {
998 while (c--)
999 waveOutUnprepareHeader(ds->hwo,ds->pwave[c],sizeof(WAVEHDR));
1000 break;
1001 }
1002 }
1003
1004 ds->pwplay = 0;
1005 ds->pwwrite = 0;
1006 ds->pwqueue = 0;
1007 memset(dsb->buffer, (dsb->wfx.wBitsPerSample == 16) ? 0 : 128, dsb->buflen);
1008 TRACE("fraglen=%ld\n", ds->fraglen);
1009 }
1010 if ((err == DS_OK) && (merr != DS_OK))
1011 err = merr;
1012 }
1013 return err;
1014 }
1015
1016
1017 static void DSOUND_PrimaryClose(IDirectSoundBufferImpl *dsb)
1018 {
1019 /* are we using waveOut stuff? */
1020 if (!dsb->hwbuf) {
1021 unsigned c;
1022 IDirectSoundImpl *ds = dsb->dsound;
1023
1024 waveOutReset(ds->hwo);
1025 for (c=0; c<DS_HEL_FRAGS; c++)
1026 waveOutUnprepareHeader(ds->hwo, ds->pwave[c], sizeof(WAVEHDR));
1027 }
1028 }
1029
1030 /* This sets this format for the <em>Primary Buffer Only</em> */
1031 /* See file:///cdrom/sdk52/docs/worddoc/dsound.doc page 120 */
1032 static HRESULT WINAPI IDirectSoundBufferImpl_SetFormat(
1033 LPDIRECTSOUNDBUFFER iface,LPWAVEFORMATEX wfex
1034 ) {
1035 ICOM_THIS(IDirectSoundBufferImpl,iface);
1036 IDirectSoundBufferImpl** dsb;
1037 HRESULT err = DS_OK;
1038 int i;
1039
1040 /* Let's be pedantic! */
1041 if ((wfex == NULL) ||
1042 (wfex->wFormatTag != WAVE_FORMAT_PCM) ||
1043 (wfex->nChannels < 1) || (wfex->nChannels > 2) ||
1044 (wfex->nSamplesPerSec < 1) ||
1045 (wfex->nBlockAlign < 1) || (wfex->nChannels > 4) ||
1046 ((wfex->wBitsPerSample != 8) && (wfex->wBitsPerSample != 16))) {
1047 TRACE("failed pedantic check!\n");
1048 return DSERR_INVALIDPARAM;
1049 }
1050
1051 /* **** */
1052 EnterCriticalSection(&(This->dsound->lock));
1053
1054 if (primarybuf->wfx.nSamplesPerSec != wfex->nSamplesPerSec) {
1055 dsb = dsound->buffers;
1056 for (i = 0; i < dsound->nrofbuffers; i++, dsb++) {
1057 /* **** */
1058 EnterCriticalSection(&((*dsb)->lock));
1059
1060 (*dsb)->freqAdjust = ((*dsb)->freq << DSOUND_FREQSHIFT) /
1061 wfex->nSamplesPerSec;
1062
1063 LeaveCriticalSection(&((*dsb)->lock));
1064 /* **** */
1065 }
1066 }
1067
1068 memcpy(&(primarybuf->wfx), wfex, sizeof(primarybuf->wfx));
1069
1070 TRACE("(formattag=0x%04x,chans=%d,samplerate=%ld,"
1071 "bytespersec=%ld,blockalign=%d,bitspersamp=%d,cbSize=%d)\n",
1072 wfex->wFormatTag, wfex->nChannels, wfex->nSamplesPerSec,
1073 wfex->nAvgBytesPerSec, wfex->nBlockAlign,
1074 wfex->wBitsPerSample, wfex->cbSize);
1075
1076 primarybuf->wfx.nAvgBytesPerSec =
1077 This->wfx.nSamplesPerSec * This->wfx.nBlockAlign;
1078 if (primarybuf->dsound->drvdesc.dwFlags & DSDDESC_DOMMSYSTEMSETFORMAT) {
1079 /* FIXME: check for errors */
1080 DSOUND_PrimaryClose(primarybuf);
1081 waveOutClose(This->dsound->hwo);
1082 This->dsound->hwo = 0;
1083 waveOutOpen(&(This->dsound->hwo), This->dsound->drvdesc.dnDevNode,
1084 &(primarybuf->wfx), 0, 0, CALLBACK_NULL | WAVE_DIRECTSOUND);
1085 DSOUND_PrimaryOpen(primarybuf);
1086 }
1087 if (primarybuf->hwbuf) {
1088 err = IDsDriverBuffer_SetFormat(primarybuf->hwbuf, &(primarybuf->wfx));
1089 if (err == DSERR_BUFFERLOST) {
1090 /* Wine-only: the driver wants us to recreate the HW buffer */
1091 IDsDriverBuffer_Release(primarybuf->hwbuf);
1092 err = IDsDriver_CreateSoundBuffer(primarybuf->dsound->driver,&(primarybuf->wfx),primarybuf->dsbd.dwFlags,0,
1093 &(primarybuf->buflen),&(primarybuf->buffer),
1094 (LPVOID)&(primarybuf->hwbuf));
1095 }
1096 }
1097 DSOUND_RecalcFormat(primarybuf);
1098
1099 LeaveCriticalSection(&(This->dsound->lock));
1100 /* **** */
1101
1102 return DS_OK;
1103 }
1104
1105 static HRESULT WINAPI IDirectSoundBufferImpl_SetVolume(
1106 LPDIRECTSOUNDBUFFER iface,LONG vol
1107 ) {
1108 ICOM_THIS(IDirectSoundBufferImpl,iface);
1109
1110 TRACE("(%p,%ld)\n",This,vol);
1111
1112 /* I'm not sure if we need this for primary buffer */
1113 if (!(This->dsbd.dwFlags & DSBCAPS_CTRLVOLUME))
1114 return DSERR_CONTROLUNAVAIL;
1115
1116 if ((vol > DSBVOLUME_MAX) || (vol < DSBVOLUME_MIN))
1117 return DSERR_INVALIDPARAM;
1118
1119 /* **** */
1120 EnterCriticalSection(&(This->lock));
1121
1122 This->volpan.lVolume = vol;
1123
1124 DSOUND_RecalcVolPan(&(This->volpan));
1125
1126 if (This->hwbuf) {
1127 IDsDriverBuffer_SetVolumePan(This->hwbuf, &(This->volpan));
1128 }
1129 else if (This->dsbd.dwFlags & DSBCAPS_PRIMARYBUFFER) {
1130 #if 0 /* should we really do this? */
1131 /* the DS volume ranges from 0 (max, 0dB attenuation) to -10000 (min, 100dB attenuation) */
1132 /* the MM volume ranges from 0 to 0xffff in an unspecified logarithmic scale */
1133 WORD cvol = 0xffff + vol*6 + vol/2;
1134 DWORD vol = cvol | ((DWORD)cvol << 16)
1135 waveOutSetVolume(This->dsound->hwo, vol);
1136 #endif
1137 }
1138
1139 LeaveCriticalSection(&(This->lock));
1140 /* **** */
1141
1142 return DS_OK;
1143 }
1144
1145 static HRESULT WINAPI IDirectSoundBufferImpl_GetVolume(
1146 LPDIRECTSOUNDBUFFER iface,LPLONG vol
1147 ) {
1148 ICOM_THIS(IDirectSoundBufferImpl,iface);
1149 TRACE("(%p,%p)\n",This,vol);
1150
1151 if (vol == NULL)
1152 return DSERR_INVALIDPARAM;
1153
1154 *vol = This->volpan.lVolume;
1155 return DS_OK;
1156 }
1157
1158 static HRESULT WINAPI IDirectSoundBufferImpl_SetFrequency(
1159 LPDIRECTSOUNDBUFFER iface,DWORD freq
1160 ) {
1161 ICOM_THIS(IDirectSoundBufferImpl,iface);
1162 TRACE("(%p,%ld)\n",This,freq);
1163
1164 /* You cannot set the frequency of the primary buffer */
1165 if (!(This->dsbd.dwFlags & DSBCAPS_CTRLFREQUENCY) ||
1166 (This->dsbd.dwFlags & DSBCAPS_PRIMARYBUFFER))
1167 return DSERR_CONTROLUNAVAIL;
1168
1169 if (!freq) freq = This->wfx.nSamplesPerSec;
1170
1171 if ((freq < DSBFREQUENCY_MIN) || (freq > DSBFREQUENCY_MAX))
1172 return DSERR_INVALIDPARAM;
1173
1174 /* **** */
1175 EnterCriticalSection(&(This->lock));
1176
1177 This->freq = freq;
1178 This->freqAdjust = (freq << DSOUND_FREQSHIFT) / primarybuf->wfx.nSamplesPerSec;
1179 This->nAvgBytesPerSec = freq * This->wfx.nBlockAlign;
1180 DSOUND_RecalcFormat(This);
1181
1182 LeaveCriticalSection(&(This->lock));
1183 /* **** */
1184
1185 return DS_OK;
1186 }
1187
1188 static HRESULT WINAPI IDirectSoundBufferImpl_Play(
1189 LPDIRECTSOUNDBUFFER iface,DWORD reserved1,DWORD reserved2,DWORD flags
1190 ) {
1191 ICOM_THIS(IDirectSoundBufferImpl,iface);
1192 TRACE("(%p,%08lx,%08lx,%08lx)\n",
1193 This,reserved1,reserved2,flags
1194 );
1195 This->playflags = flags;
1196 if (This->state == STATE_STOPPED) {
1197 This->leadin = TRUE;
1198 This->startpos = This->mixpos;
1199 This->state = STATE_STARTING;
1200 } else if (This->state == STATE_STOPPING)
1201 This->state = STATE_PLAYING;
1202 if (!(This->dsbd.dwFlags & DSBCAPS_PRIMARYBUFFER) && This->hwbuf) {
1203 IDsDriverBuffer_Play(This->hwbuf, 0, 0, This->playflags);
1204 This->state = STATE_PLAYING;
1205 }
1206 return DS_OK;
1207 }
1208
1209 static HRESULT WINAPI IDirectSoundBufferImpl_Stop(LPDIRECTSOUNDBUFFER iface)
1210 {
1211 ICOM_THIS(IDirectSoundBufferImpl,iface);
1212 TRACE("(%p)\n",This);
1213
1214 /* **** */
1215 EnterCriticalSection(&(This->lock));
1216
1217 if (This->state == STATE_PLAYING)
1218 This->state = STATE_STOPPING;
1219 else if (This->state == STATE_STARTING)
1220 This->state = STATE_STOPPED;
1221 if (!(This->dsbd.dwFlags & DSBCAPS_PRIMARYBUFFER) && This->hwbuf) {
1222 IDsDriverBuffer_Stop(This->hwbuf);
1223 This->state = STATE_STOPPED;
1224 }
1225 DSOUND_CheckEvent(This, 0);
1226
1227 LeaveCriticalSection(&(This->lock));
1228 /* **** */
1229
1230 return DS_OK;
1231 }
1232
1233 static DWORD WINAPI IDirectSoundBufferImpl_AddRef(LPDIRECTSOUNDBUFFER iface) {
1234 ICOM_THIS(IDirectSoundBufferImpl,iface);
1235 DWORD ref;
1236
1237 TRACE("(%p) ref was %ld, thread is %lx\n",This, This->ref, GetCurrentThreadId());
1238
1239 ref = InterlockedIncrement(&(This->ref));
1240 if (!ref) {
1241 FIXME("thread-safety alert! AddRef-ing with a zero refcount!\n");
1242 }
1243 return ref;
1244 }
1245 static DWORD WINAPI IDirectSoundBufferImpl_Release(LPDIRECTSOUNDBUFFER iface) {
1246 ICOM_THIS(IDirectSoundBufferImpl,iface);
1247 int i;
1248 DWORD ref;
1249
1250 TRACE("(%p) ref was %ld, thread is %lx\n",This, This->ref, GetCurrentThreadId());
1251
1252 ref = InterlockedDecrement(&(This->ref));
1253 if (ref) return ref;
1254
1255 EnterCriticalSection(&(This->dsound->lock));
1256 for (i=0;i<This->dsound->nrofbuffers;i++)
1257 if (This->dsound->buffers[i] == This)
1258 break;
1259
1260 if (i < This->dsound->nrofbuffers) {
1261 /* Put the last buffer of the list in the (now empty) position */
1262 This->dsound->buffers[i] = This->dsound->buffers[This->dsound->nrofbuffers - 1];
1263 This->dsound->nrofbuffers--;
1264 This->dsound->buffers = HeapReAlloc(GetProcessHeap(),0,This->dsound->buffers,sizeof(LPDIRECTSOUNDBUFFER)*This->dsound->nrofbuffers);
1265 TRACE("buffer count is now %d\n", This->dsound->nrofbuffers);
1266 IDirectSound_Release((LPDIRECTSOUND)This->dsound);
1267 }
1268 LeaveCriticalSection(&(This->dsound->lock));
1269
1270 DeleteCriticalSection(&(This->lock));
1271 if (This->dsbd.dwFlags & DSBCAPS_PRIMARYBUFFER)
1272 DSOUND_PrimaryClose(This);
1273 if (This->hwbuf) {
1274 IDsDriverBuffer_Release(This->hwbuf);
1275 }
1276 if (This->ds3db)
1277 IDirectSound3DBuffer_Release((LPDIRECTSOUND3DBUFFER)This->ds3db);
1278 if (This->parent)
1279 /* this is a duplicate buffer */
1280 IDirectSoundBuffer_Release((LPDIRECTSOUNDBUFFER)This->parent);
1281 else
1282 /* this is a toplevel buffer */
1283 HeapFree(GetProcessHeap(),0,This->buffer);
1284
1285 HeapFree(GetProcessHeap(),0,This);
1286
1287 if (This == primarybuf)
1288 primarybuf = NULL;
1289
1290 return 0;
1291 }
1292
1293 static HRESULT WINAPI IDirectSoundBufferImpl_GetCurrentPosition(
1294 LPDIRECTSOUNDBUFFER iface,LPDWORD playpos,LPDWORD writepos
1295 ) {
1296 ICOM_THIS(IDirectSoundBufferImpl,iface);
1297 TRACE("(%p,%p,%p)\n",This,playpos,writepos);
1298 if (This->hwbuf) {
1299 IDsDriverBuffer_GetPosition(This->hwbuf, playpos, writepos);
1300 }
1301 else if (This->dsbd.dwFlags & DSBCAPS_PRIMARYBUFFER) {
1302 if (playpos && (This->dsbd.dwFlags & DSBCAPS_GETCURRENTPOSITION2)) {
1303 MMTIME mtime;
1304 mtime.wType = TIME_BYTES;
1305 waveOutGetPosition(This->dsound->hwo, &mtime, sizeof(mtime));
1306 mtime.u.cb = mtime.u.cb % This->buflen;
1307 *playpos = mtime.u.cb;
1308 }
1309 /* don't know how exactly non-GETCURRENTPOSITION2 behaves,
1310 * but I think this works for Starcraft */
1311 else if (playpos) *playpos = This->playpos;
1312 if (writepos) {
1313 /* the writepos should only be used by apps with WRITEPRIMARY priority,
1314 * in which case our software mixer is disabled anyway */
1315 *writepos = This->playpos + DS_HEL_MARGIN * This->dsound->fraglen;
1316 while (*writepos >= This->buflen)
1317 *writepos -= This->buflen;
1318 }
1319 } else {
1320 if (playpos && (This->state != STATE_PLAYING)) {
1321 /* we haven't been merged into the primary buffer (yet) */
1322 *playpos = This->mixpos;
1323 }
1324 else if (playpos) {
1325 DWORD pplay, lplay, splay, tplay, pstate;
1326 /* let's get this exact; first, recursively call GetPosition on the primary */
1327 EnterCriticalSection(&(primarybuf->lock));
1328 if ((This->dsbd.dwFlags & DSBCAPS_GETCURRENTPOSITION2) || primarybuf->hwbuf) {
1329 IDirectSoundBufferImpl_GetCurrentPosition((LPDIRECTSOUNDBUFFER)primarybuf, &pplay, NULL);
1330 } else {
1331 /* (unless the app isn't using GETCURRENTPOSITION2) */
1332 /* don't know exactly how this should be handled either */
1333 pplay = primarybuf->playpos;
1334 }
1335 /* get last mixed primary play position */
1336 lplay = primarybuf->mixpos;
1337 pstate = primarybuf->state;
1338 /* detect HEL mode underrun */
1339 if (!(primarybuf->hwbuf || primarybuf->dsound->pwqueue)) {
1340 TRACE("detected an underrun\n");
1341 pplay = lplay;
1342 if (pstate == STATE_PLAYING)
1343 pstate = STATE_STARTING;
1344 else if (pstate == STATE_STOPPING)
1345 pstate = STATE_STOPPED;
1346 }
1347 /* get our own last mixed position while we still have the lock */
1348 splay = This->mixpos;
1349 LeaveCriticalSection(&(primarybuf->lock));
1350 TRACE("primary playpos=%ld, mixpos=%ld\n", pplay, lplay);
1351 TRACE("this mixpos=%ld\n", splay);
1352
1353 /* the actual primary play position (pplay) is always behind last mixed (lplay),
1354 * unless the computer is too slow or something */
1355 /* we need to know how far away we are from there */
1356 if (lplay == pplay) {
1357 if ((pstate == STATE_PLAYING) || (pstate == STATE_STOPPING)) {
1358 /* wow, the software mixer is really doing well,
1359 * seems the entire primary buffer is filled! */
1360 lplay += primarybuf->buflen;
1361 }
1362 /* else: the primary buffer is not playing, so probably empty */
1363 }
1364 if (lplay < pplay) lplay += primarybuf->buflen; /* wraparound */
1365 lplay -= pplay;
1366 /* detect HAL mode underrun */
1367 if (primarybuf->hwbuf &&
1368 (lplay > ((DS_HAL_QUEUE + 1) * primarybuf->dsound->fraglen + primarybuf->writelead))) {
1369 TRACE("detected an underrun: primary queue was %ld\n",lplay);
1370 lplay = 0;
1371 }
1372 /* divide the offset by its sample size */
1373 lplay /= primarybuf->wfx.nChannels * (primarybuf->wfx.wBitsPerSample / 8);
1374 TRACE("primary back-samples=%ld\n",lplay);
1375 /* adjust for our frequency */
1376 lplay = (lplay * This->freqAdjust) >> DSOUND_FREQSHIFT;
1377 /* multiply by our own sample size */
1378 lplay *= This->wfx.nChannels * (This->wfx.wBitsPerSample / 8);
1379 TRACE("this back-offset=%ld\n", lplay);
1380 /* subtract from our last mixed position */
1381 tplay = splay;
1382 while (tplay < lplay) tplay += This->buflen; /* wraparound */
1383 tplay -= lplay;
1384 if (This->leadin && ((tplay < This->startpos) || (tplay > splay))) {
1385 /* seems we haven't started playing yet */
1386 TRACE("this still in lead-in phase\n");
1387 tplay = This->startpos;
1388 }
1389 /* return the result */
1390 *playpos = tplay;
1391 }
1392 if (writepos) *writepos = This->mixpos;
1393 }
1394 if (writepos) {
1395 if (This->state != STATE_STOPPED)
1396 /* apply the documented 10ms lead to writepos */
1397 *writepos += This->writelead;
1398 while (*writepos >= This->buflen) *writepos -= This->buflen;
1399 }
1400 TRACE("playpos = %ld, writepos = %ld (%p, time=%ld)\n", playpos?*playpos:0, writepos?*writepos:0, This, GetTickCount());
1401 return DS_OK;
1402 }
1403
1404 static HRESULT WINAPI IDirectSoundBufferImpl_GetStatus(
1405 LPDIRECTSOUNDBUFFER iface,LPDWORD status
1406 ) {
1407 ICOM_THIS(IDirectSoundBufferImpl,iface);
1408 TRACE("(%p,%p), thread is %lx\n",This,status,GetCurrentThreadId());
1409
1410 if (status == NULL)
1411 return DSERR_INVALIDPARAM;
1412
1413 *status = 0;
1414 if ((This->state == STATE_STARTING) || (This->state == STATE_PLAYING))
1415 *status |= DSBSTATUS_PLAYING;
1416 if (This->playflags & DSBPLAY_LOOPING)
1417 *status |= DSBSTATUS_LOOPING;
1418
1419 TRACE("status=%lx\n", *status);
1420 return DS_OK;
1421 }
1422
1423
1424 static HRESULT WINAPI IDirectSoundBufferImpl_GetFormat(
1425 LPDIRECTSOUNDBUFFER iface,LPWAVEFORMATEX lpwf,DWORD wfsize,LPDWORD wfwritten
1426 ) {
1427 ICOM_THIS(IDirectSoundBufferImpl,iface);
1428 TRACE("(%p,%p,%ld,%p)\n",This,lpwf,wfsize,wfwritten);
1429
1430 if (wfsize>sizeof(This->wfx))
1431 wfsize = sizeof(This->wfx);
1432 if (lpwf) { /* NULL is valid */
1433 memcpy(lpwf,&(This->wfx),wfsize);
1434 if (wfwritten)
1435 *wfwritten = wfsize;
1436 } else
1437 if (wfwritten)
1438 *wfwritten = sizeof(This->wfx);
1439 else
1440 return DSERR_INVALIDPARAM;
1441
1442 return DS_OK;
1443 }
1444
1445 static HRESULT WINAPI IDirectSoundBufferImpl_Lock(
1446 LPDIRECTSOUNDBUFFER iface,DWORD writecursor,DWORD writebytes,LPVOID lplpaudioptr1,LPDWORD audiobytes1,LPVOID lplpaudioptr2,LPDWORD audiobytes2,DWORD flags
1447 ) {
1448 ICOM_THIS(IDirectSoundBufferImpl,iface);
1449 DWORD capf;
1450
1451 TRACE("(%p,%ld,%ld,%p,%p,%p,%p,0x%08lx)\n",
1452 This,
1453 writecursor,
1454 writebytes,
1455 lplpaudioptr1,
1456 audiobytes1,
1457 lplpaudioptr2,
1458 audiobytes2,
1459 flags
1460 );
1461
1462 if (flags & DSBLOCK_FROMWRITECURSOR) {
1463 DWORD writepos;
1464 /* GetCurrentPosition does too much magic to duplicate here */
1465 IDirectSoundBufferImpl_GetCurrentPosition(iface, NULL, &writepos);
1466 writecursor += writepos;
1467 }
1468 if (flags & DSBLOCK_ENTIREBUFFER)
1469 writebytes = This->buflen;
1470 if (writebytes > This->buflen)
1471 writebytes = This->buflen;
1472
1473 assert(audiobytes1!=audiobytes2);
1474 assert(lplpaudioptr1!=lplpaudioptr2);
1475
1476 if (This->dsbd.dwFlags & DSBCAPS_PRIMARYBUFFER)
1477 capf = DSDDESC_DONTNEEDPRIMARYLOCK;
1478 else
1479 capf = DSDDESC_DONTNEEDSECONDARYLOCK;
1480 if (!(This->dsound->drvdesc.dwFlags & capf) && This->hwbuf) {
1481 IDsDriverBuffer_Lock(This->hwbuf,
1482 lplpaudioptr1, audiobytes1,
1483 lplpaudioptr2, audiobytes2,
1484 writecursor, writebytes,
1485 0);
1486 } else
1487 if (writecursor+writebytes <= This->buflen) {
1488 *(LPBYTE*)lplpaudioptr1 = This->buffer+writecursor;
1489 *audiobytes1 = writebytes;
1490 if (lplpaudioptr2)
1491 *(LPBYTE*)lplpaudioptr2 = NULL;
1492 if (audiobytes2)
1493 *audiobytes2 = 0;
1494 TRACE("->%ld.0\n",writebytes);
1495 } else {
1496 *(LPBYTE*)lplpaudioptr1 = This->buffer+writecursor;
1497 *audiobytes1 = This->buflen-writecursor;
1498 if (lplpaudioptr2)
1499 *(LPBYTE*)lplpaudioptr2 = This->buffer;
1500 if (audiobytes2)
1501 *audiobytes2 = writebytes-(This->buflen-writecursor);
1502 TRACE("->%ld.%ld\n",*audiobytes1,audiobytes2?*audiobytes2:0);
1503 }
1504 return DS_OK;
1505 }
1506
1507 static HRESULT WINAPI IDirectSoundBufferImpl_SetCurrentPosition(
1508 LPDIRECTSOUNDBUFFER iface,DWORD newpos
1509 ) {
1510 ICOM_THIS(IDirectSoundBufferImpl,iface);
1511 TRACE("(%p,%ld)\n",This,newpos);
1512
1513 /* **** */
1514 EnterCriticalSection(&(This->lock));
1515
1516 This->mixpos = newpos;
1517 if (This->hwbuf)
1518 IDsDriverBuffer_SetPosition(This->hwbuf, This->mixpos);
1519
1520 LeaveCriticalSection(&(This->lock));
1521 /* **** */
1522
1523 return DS_OK;
1524 }
1525
1526 static HRESULT WINAPI IDirectSoundBufferImpl_SetPan(
1527 LPDIRECTSOUNDBUFFER iface,LONG pan
1528 ) {
1529 ICOM_THIS(IDirectSoundBufferImpl,iface);
1530
1531 TRACE("(%p,%ld)\n",This,pan);
1532
1533 if ((pan > DSBPAN_RIGHT) || (pan < DSBPAN_LEFT))
1534 return DSERR_INVALIDPARAM;
1535
1536 /* You cannot set the pan of the primary buffer */
1537 /* and you cannot use both pan and 3D controls */
1538 if (!(This->dsbd.dwFlags & DSBCAPS_CTRLPAN) ||
1539 (This->dsbd.dwFlags & DSBCAPS_CTRL3D) ||
1540 (This->dsbd.dwFlags & DSBCAPS_PRIMARYBUFFER))
1541 return DSERR_CONTROLUNAVAIL;
1542
1543 /* **** */
1544 EnterCriticalSection(&(This->lock));
1545
1546 This->volpan.lPan = pan;
1547
1548 DSOUND_RecalcVolPan(&(This->volpan));
1549
1550 if (This->hwbuf) {
1551 IDsDriverBuffer_SetVolumePan(This->hwbuf, &(This->volpan));
1552 }
1553
1554 LeaveCriticalSection(&(This->lock));
1555 /* **** */
1556
1557 return DS_OK;
1558 }
1559
1560 static HRESULT WINAPI IDirectSoundBufferImpl_GetPan(
1561 LPDIRECTSOUNDBUFFER iface,LPLONG pan
1562 ) {
1563 ICOM_THIS(IDirectSoundBufferImpl,iface);
1564 TRACE("(%p,%p)\n",This,pan);
1565
1566 if (pan == NULL)
1567 return DSERR_INVALIDPARAM;
1568
1569 *pan = This->volpan.lPan;
1570
1571 return DS_OK;
1572 }
1573
1574 static HRESULT WINAPI IDirectSoundBufferImpl_Unlock(
1575 LPDIRECTSOUNDBUFFER iface,LPVOID p1,DWORD x1,LPVOID p2,DWORD x2
1576 ) {
1577 ICOM_THIS(IDirectSoundBufferImpl,iface);
1578 DWORD capf;
1579
1580 TRACE("(%p,%p,%ld,%p,%ld):stub\n", This,p1,x1,p2,x2);
1581
1582 #if 0
1583 /* Preprocess 3D buffers... */
1584
1585 /* This is highly experimental and liable to break things */
1586 if (This->dsbd.dwFlags & DSBCAPS_CTRL3D)
1587 DSOUND_Create3DBuffer(This);
1588 #endif
1589
1590 if (This->dsbd.dwFlags & DSBCAPS_PRIMARYBUFFER)
1591 capf = DSDDESC_DONTNEEDPRIMARYLOCK;
1592 else
1593 capf = DSDDESC_DONTNEEDSECONDARYLOCK;
1594 if (!(This->dsound->drvdesc.dwFlags & capf) && This->hwbuf) {
1595 IDsDriverBuffer_Unlock(This->hwbuf, p1, x1, p2, x2);
1596 }
1597
1598 return DS_OK;
1599 }
1600
1601 static HRESULT WINAPI IDirectSoundBufferImpl_GetFrequency(
1602 LPDIRECTSOUNDBUFFER iface,LPDWORD freq
1603 ) {
1604 ICOM_THIS(IDirectSoundBufferImpl,iface);
1605 TRACE("(%p,%p)\n",This,freq);
1606
1607 if (freq == NULL)
1608 return DSERR_INVALIDPARAM;
1609
1610 *freq = This->freq;
1611 TRACE("-> %ld\n", *freq);
1612
1613 return DS_OK;
1614 }
1615
1616 static HRESULT WINAPI IDirectSoundBufferImpl_Initialize(
1617 LPDIRECTSOUNDBUFFER iface,LPDIRECTSOUND dsound,LPDSBUFFERDESC dbsd
1618 ) {
1619 ICOM_THIS(IDirectSoundBufferImpl,iface);
1620 FIXME("(%p,%p,%p):stub\n",This,dsound,dbsd);
1621 DPRINTF("Re-Init!!!\n");
1622 return DSERR_ALREADYINITIALIZED;
1623 }
1624
1625 static HRESULT WINAPI IDirectSoundBufferImpl_GetCaps(
1626 LPDIRECTSOUNDBUFFER iface,LPDSBCAPS caps
1627 ) {
1628 ICOM_THIS(IDirectSoundBufferImpl,iface);
1629 TRACE("(%p)->(%p)\n",This,caps);
1630
1631 if (caps == NULL)
1632 return DSERR_INVALIDPARAM;
1633
1634 /* I think we should check this value, not set it. See */
1635 /* Inside DirectX, p215. That should apply here, too. */
1636 caps->dwSize = sizeof(*caps);
1637
1638 caps->dwFlags = This->dsbd.dwFlags;
1639 if (This->hwbuf) caps->dwFlags |= DSBCAPS_LOCHARDWARE;
1640 else caps->dwFlags |= DSBCAPS_LOCSOFTWARE;
1641
1642 caps->dwBufferBytes = This->dsbd.dwBufferBytes;
1643
1644 /* This value represents the speed of the "unlock" command.
1645 As unlock is quite fast (it does not do anything), I put
1646 4096 ko/s = 4 Mo / s */
1647 /* FIXME: hwbuf speed */
1648 caps->dwUnlockTransferRate = 4096;
1649 caps->dwPlayCpuOverhead = 0;
1650
1651 return DS_OK;
1652 }
1653
1654 static HRESULT WINAPI IDirectSoundBufferImpl_QueryInterface(
1655 LPDIRECTSOUNDBUFFER iface,REFIID riid,LPVOID *ppobj
1656 ) {
1657 ICOM_THIS(IDirectSoundBufferImpl,iface);
1658
1659 TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
1660
1661 if ( IsEqualGUID( &IID_IDirectSoundNotify, riid ) ) {
1662 IDirectSoundNotifyImpl *dsn;
1663
1664 dsn = (IDirectSoundNotifyImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(*dsn));
1665 dsn->ref = 1;
1666 dsn->dsb = This;
1667 IDirectSoundBuffer_AddRef(iface);
1668 ICOM_VTBL(dsn) = &dsnvt;
1669 *ppobj = (LPVOID)dsn;
1670 return S_OK;
1671 }
1672
1673 #if USE_DSOUND3D
1674 if ( IsEqualGUID( &IID_IDirectSound3DBuffer, riid ) ) {
1675 IDirectSound3DBufferImpl *ds3db;
1676
1677 *ppobj = This->ds3db;
1678 if (*ppobj) {
1679 IDirectSound3DBuffer_AddRef((LPDIRECTSOUND3DBUFFER)This->ds3db);
1680 return S_OK;
1681 }
1682
1683 ds3db = (IDirectSound3DBufferImpl*)HeapAlloc(GetProcessHeap(),
1684 0,sizeof(*ds3db));
1685 ds3db->ref = 1;
1686 ds3db->dsb = (*ippdsb);
1687 ICOM_VTBL(ds3db) = &ds3dbvt;
1688 InitializeCriticalSection(&ds3db->lock);
1689
1690 ds3db->ds3db = This;
1691 IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER)This);
1692
1693 ds3db->ds3db.dwSize = sizeof(DS3DBUFFER);
1694 ds3db->ds3db.vPosition.x.x = 0.0;
1695 ds3db->ds3db.vPosition.y.y = 0.0;
1696 ds3db->ds3db.vPosition.z.z = 0.0;
1697 ds3db->ds3db.vVelocity.x.x = 0.0;
1698 ds3db->ds3db.vVelocity.y.y = 0.0;
1699 ds3db->ds3db.vVelocity.z.z = 0.0;
1700 ds3db->ds3db.dwInsideConeAngle = DS3D_DEFAULTCONEANGLE;
1701 ds3db->ds3db.dwOutsideConeAngle = DS3D_DEFAULTCONEANGLE;
1702 ds3db->ds3db.vConeOrientation.x.x = 0.0;
1703 ds3db->ds3db.vConeOrientation.y.y = 0.0;
1704 ds3db->ds3db.vConeOrientation.z.z = 0.0;
1705 ds3db->ds3db.lConeOutsideVolume = DS3D_DEFAULTCONEOUTSIDEVOLUME; ds3db->ds3db.flMinDistance = DS3D_DEFAULTMINDISTANCE;
1706 ds3db->ds3db.flMaxDistance = DS3D_DEFAULTMAXDISTANCE;
1707 ds3db->ds3db.dwMode = DS3DMODE_NORMAL;
1708 ds3db->buflen = ((*ippdsb)->buflen * primarybuf->wfx.nBlockAlign) /
1709 (*ippdsb)->wfx.nBlockAlign;
1710 ds3db->buffer = HeapAlloc(GetProcessHeap(), 0, ds3db->buflen);
1711 if (ds3db->buffer == NULL) {
1712 ds3db->buflen = 0;
1713 ds3db->ds3db.dwMode = DS3DMODE_DISABLE;
1714 }
1715
1716 return S_OK;
1717 }
1718 #endif
1719
1720 if ( IsEqualGUID( &IID_IDirectSound3DListener, riid ) ) {
1721 IDirectSound3DListenerImpl* dsl;
1722
1723 if (This->dsound->listener) {
1724 *ppobj = This->dsound->listener;
1725 IDirectSound3DListener_AddRef((LPDIRECTSOUND3DLISTENER)This->dsound->listener);
1726 return DS_OK;
1727 }
1728
1729 dsl = (IDirectSound3DListenerImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(*dsl));
1730 dsl->ref = 1;
1731 ICOM_VTBL(dsl) = &ds3dlvt;
1732 *ppobj = (LPVOID)dsl;
1733
1734 dsl->ds3dl.dwSize = sizeof(DS3DLISTENER);
1735 dsl->ds3dl.vPosition.u1.x = 0.0;
1736 dsl->ds3dl.vPosition.u2.y = 0.0;
1737 dsl->ds3dl.vPosition.u3.z = 0.0;
1738 dsl->ds3dl.vVelocity.u1.x = 0.0;
1739 dsl->ds3dl.vVelocity.u2.y = 0.0;
1740 dsl->ds3dl.vVelocity.u3.z = 0.0;
1741 dsl->ds3dl.vOrientFront.u1.x = 0.0;
1742 dsl->ds3dl.vOrientFront.u2.y = 0.0;
1743 dsl->ds3dl.vOrientFront.u3.z = 1.0;
1744 dsl->ds3dl.vOrientTop.u1.x = 0.0;
1745 dsl->ds3dl.vOrientTop.u2.y = 1.0;
1746 dsl->ds3dl.vOrientTop.u3.z = 0.0;
1747 dsl->ds3dl.flDistanceFactor = DS3D_DEFAULTDISTANCEFACTOR;
1748 dsl->ds3dl.flRolloffFactor = DS3D_DEFAULTROLLOFFFACTOR;
1749
1750 InitializeCriticalSection(&dsl->lock);
1751
1752 dsl->dsb = This;
1753 IDirectSoundBuffer_AddRef(iface);
1754
1755 This->dsound->listener = dsl;
1756 IDirectSound3DListener_AddRef((LPDIRECTSOUND3DLISTENER)dsl);
1757
1758 return S_OK;
1759 }
1760
1761 FIXME( "Unknown GUID %s\n", debugstr_guid( riid ) );
1762
1763 *ppobj = NULL;
1764
1765 return E_FAIL;
1766 }
1767
1768 static ICOM_VTABLE(IDirectSoundBuffer) dsbvt =
1769 {
1770 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1771 IDirectSoundBufferImpl_QueryInterface,
1772 IDirectSoundBufferImpl_AddRef,
1773 IDirectSoundBufferImpl_Release,
1774 IDirectSoundBufferImpl_GetCaps,
1775 IDirectSoundBufferImpl_GetCurrentPosition,
1776 IDirectSoundBufferImpl_GetFormat,
1777 IDirectSoundBufferImpl_GetVolume,
1778 IDirectSoundBufferImpl_GetPan,
1779 IDirectSoundBufferImpl_GetFrequency,
1780 IDirectSoundBufferImpl_GetStatus,
1781 IDirectSoundBufferImpl_Initialize,
1782 IDirectSoundBufferImpl_Lock,
1783 IDirectSoundBufferImpl_Play,
1784 IDirectSoundBufferImpl_SetCurrentPosition,
1785 IDirectSoundBufferImpl_SetFormat,
1786 IDirectSoundBufferImpl_SetVolume,
1787 IDirectSoundBufferImpl_SetPan,
1788 IDirectSoundBufferImpl_SetFrequency,
1789 IDirectSoundBufferImpl_Stop,
1790 IDirectSoundBufferImpl_Unlock
1791 };
1792
1793 /*******************************************************************************
1794 * IDirectSound
1795 */
1796
1797 static HRESULT WINAPI IDirectSoundImpl_SetCooperativeLevel(
1798 LPDIRECTSOUND iface,HWND hwnd,DWORD level
1799 ) {
1800 ICOM_THIS(IDirectSoundImpl,iface);
1801
1802 FIXME("(%p,%08lx,%ld):stub\n",This,(DWORD)hwnd,level);
1803
1804 This->priolevel = level;
1805
1806 return DS_OK;
1807 }
1808
1809 static HRESULT WINAPI IDirectSoundImpl_CreateSoundBuffer(
1810 LPDIRECTSOUND iface,LPDSBUFFERDESC dsbd,LPLPDIRECTSOUNDBUFFER ppdsb,LPUNKNOWN lpunk
1811 ) {
1812 ICOM_THIS(IDirectSoundImpl,iface);
1813 IDirectSoundBufferImpl** ippdsb=(IDirectSoundBufferImpl**)ppdsb;
1814 LPWAVEFORMATEX wfex;
1815 HRESULT err = DS_OK;
1816
1817 TRACE("(%p,%p,%p,%p)\n",This,dsbd,ippdsb,lpunk);
1818
1819 if ((This == NULL) || (dsbd == NULL) || (ippdsb == NULL))
1820 return DSERR_INVALIDPARAM;
1821
1822 if (TRACE_ON(dsound)) {
1823 TRACE("(structsize=%ld)\n",dsbd->dwSize);
1824 TRACE("(flags=0x%08lx:\n",dsbd->dwFlags);
1825 _dump_DSBCAPS(dsbd->dwFlags);
1826 DPRINTF(")\n");
1827 TRACE("(bufferbytes=%ld)\n",dsbd->dwBufferBytes);
1828 TRACE("(lpwfxFormat=%p)\n",dsbd->lpwfxFormat);
1829 }
1830
1831 wfex = dsbd->lpwfxFormat;
1832
1833 if (wfex)
1834 TRACE("(formattag=0x%04x,chans=%d,samplerate=%ld,"
1835 "bytespersec=%ld,blockalign=%d,bitspersamp=%d,cbSize=%d)\n",
1836 wfex->wFormatTag, wfex->nChannels, wfex->nSamplesPerSec,
1837 wfex->nAvgBytesPerSec, wfex->nBlockAlign,
1838 wfex->wBitsPerSample, wfex->cbSize);
1839
1840 if (dsbd->dwFlags & DSBCAPS_PRIMARYBUFFER) {
1841 if (primarybuf) {
1842 IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER)primarybuf);
1843 *ippdsb = primarybuf;
1844 primarybuf->dsbd.dwFlags = dsbd->dwFlags;
1845 return DS_OK;
1846 } /* Else create primary buffer */
1847 }
1848
1849 *ippdsb = (IDirectSoundBufferImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectSoundBufferImpl));
1850 if (*ippdsb == NULL)
1851 return DSERR_OUTOFMEMORY;
1852 ICOM_VTBL(*ippdsb) = &dsbvt;
1853 (*ippdsb)->ref = 1;
1854 (*ippdsb)->dsound = This;
1855 (*ippdsb)->parent = NULL;
1856 (*ippdsb)->buffer = NULL;
1857
1858 memcpy(&((*ippdsb)->dsbd),dsbd,sizeof(*dsbd));
1859 if (dsbd->lpwfxFormat)
1860 memcpy(&((*ippdsb)->wfx), dsbd->lpwfxFormat, sizeof((*ippdsb)->wfx));
1861
1862 TRACE("Created buffer at %p\n", *ippdsb);
1863
1864 if (dsbd->dwFlags & DSBCAPS_PRIMARYBUFFER) {
1865 (*ippdsb)->buflen = dsound->wfx.nAvgBytesPerSec;
1866 (*ippdsb)->freq = dsound->wfx.nSamplesPerSec;
1867
1868 /* FIXME: verify that hardware capabilities (DSCAPS_PRIMARY flags) match */
1869
1870 if (This->driver) {
1871 err = IDsDriver_CreateSoundBuffer(This->driver,wfex,dsbd->dwFlags,0,
1872 &((*ippdsb)->buflen),&((*ippdsb)->buffer),
1873 (LPVOID*)&((*ippdsb)->hwbuf));
1874 }
1875 if (err == DS_OK)
1876 err = DSOUND_PrimaryOpen(*ippdsb);
1877 } else {
1878 DWORD capf = 0;
1879 int use_hw;
1880
1881 (*ippdsb)->buflen = dsbd->dwBufferBytes;
1882 (*ippdsb)->freq = dsbd->lpwfxFormat->nSamplesPerSec;
1883
1884 /* Check necessary hardware mixing capabilities */
1885 if (wfex->nChannels==2) capf |= DSCAPS_SECONDARYSTEREO;
1886 else capf |= DSCAPS_SECONDARYMONO;
1887 if (wfex->wBitsPerSample==16) capf |= DSCAPS_SECONDARY16BIT;
1888 else capf |= DSCAPS_SECONDARY8BIT;
1889 use_hw = (This->drvcaps.dwFlags & capf) == capf;
1890
1891 /* FIXME: check hardware sample rate mixing capabilities */
1892 /* FIXME: check app hints for software/hardware buffer (STATIC, LOCHARDWARE, etc) */
1893 /* FIXME: check whether any hardware buffers are left */
1894 /* FIXME: handle DSDHEAP_CREATEHEAP for hardware buffers */
1895
1896 /* Allocate system memory if applicable */
1897 if ((This->drvdesc.dwFlags & DSDDESC_USESYSTEMMEMORY) || !use_hw) {
1898 (*ippdsb)->buffer = (LPBYTE)HeapAlloc(GetProcessHeap(),0,(*ippdsb)->buflen);
1899 if ((*ippdsb)->buffer == NULL)
1900 err = DSERR_OUTOFMEMORY;
1901 }
1902
1903 /* Allocate the hardware buffer */
1904 if (use_hw && (err == DS_OK)) {
1905 err = IDsDriver_CreateSoundBuffer(This->driver,wfex,dsbd->dwFlags,0,
1906 &((*ippdsb)->buflen),&((*ippdsb)->buffer),
1907 (LPVOID*)&((*ippdsb)->hwbuf));
1908 }
1909 }
1910
1911 if (err != DS_OK) {
1912 if ((*ippdsb)->buffer)
1913 HeapFree(GetProcessHeap(),0,(*ippdsb)->buffer);
1914 HeapFree(GetProcessHeap(),0,(*ippdsb));
1915 *ippdsb = NULL;
1916 return err;
1917 }
1918 /* calculate fragment size and write lead */
1919 DSOUND_RecalcFormat(*ippdsb);
1920
1921 /* It's not necessary to initialize values to zero since */
1922 /* we allocated this structure with HEAP_ZERO_MEMORY... */
1923 (*ippdsb)->playpos = 0;
1924 (*ippdsb)->mixpos = 0;
1925 (*ippdsb)->state = STATE_STOPPED;
1926 DSOUND_RecalcVolPan(&((*ippdsb)->volpan));
1927
1928 if (!(dsbd->dwFlags & DSBCAPS_PRIMARYBUFFER)) {
1929 (*ippdsb)->freqAdjust = ((*ippdsb)->freq << DSOUND_FREQSHIFT) /
1930 primarybuf->wfx.nSamplesPerSec;
1931 (*ippdsb)->nAvgBytesPerSec = (*ippdsb)->freq *
1932 dsbd->lpwfxFormat->nBlockAlign;
1933 }
1934
1935 EnterCriticalSection(&(This->lock));
1936 /* register buffer */
1937 if (!(dsbd->dwFlags & DSBCAPS_PRIMARYBUFFER)) {
1938 IDirectSoundBufferImpl **newbuffers = (IDirectSoundBufferImpl**)HeapReAlloc(GetProcessHeap(),0,This->buffers,sizeof(IDirectSoundBufferImpl*)*(This->nrofbuffers+1));
1939 if (newbuffers) {
1940 This->buffers = newbuffers;
1941 This->buffers[This->nrofbuffers] = *ippdsb;
1942 This->nrofbuffers++;
1943 TRACE("buffer count is now %d\n", This->nrofbuffers);
1944 } else {
1945 ERR("out of memory for buffer list! Current buffer count is %d\n", This->nrofbuffers);
1946 err = DSERR_OUTOFMEMORY;
1947 }
1948 }
1949 LeaveCriticalSection(&(This->lock));
1950
1951 IDirectSound_AddRef(iface);
1952
1953 InitializeCriticalSection(&((*ippdsb)->lock));
1954
1955 if (err != DS_OK) {
1956 /* oops... */
1957 IDirectSoundBuffer_Release(*ppdsb);
1958 *ippdsb = NULL;
1959 return err;
1960 }
1961
1962 #if USE_DSOUND3D
1963 if (dsbd->dwFlags & DSBCAPS_CTRL3D) {
1964 IDirectSound3DBufferImpl *ds3db;
1965
1966 ds3db = (IDirectSound3DBufferImpl*)HeapAlloc(GetProcessHeap(),
1967 0,sizeof(*ds3db));
1968 ICOM_VTBL(ds3db) = &ds3dbvt;
1969 ds3db->ref = 1;
1970 (*ippdsb)->ds3db = ds3db;
1971
1972 ds3db->dsb = (*ippdsb);
1973 IDirectSoundBufferImpl_AddRef((LPDIRECTSOUNDBUFFER)ippdsb);
1974
1975 InitializeCriticalSection(&ds3db->lock);
1976
1977 ds3db->ds3db.dwSize = sizeof(DS3DBUFFER);
1978 ds3db->ds3db.vPosition.x.x = 0.0;
1979 ds3db->ds3db.vPosition.y.y = 0.0;
1980 ds3db->ds3db.vPosition.z.z = 0.0;
1981 ds3db->ds3db.vVelocity.x.x = 0.0;
1982 ds3db->ds3db.vVelocity.y.y = 0.0;
1983 ds3db->ds3db.vVelocity.z.z = 0.0;
1984 ds3db->ds3db.dwInsideConeAngle = DS3D_DEFAULTCONEANGLE;
1985 ds3db->ds3db.dwOutsideConeAngle = DS3D_DEFAULTCONEANGLE;
1986 ds3db->ds3db.vConeOrientation.x.x = 0.0;
1987 ds3db->ds3db.vConeOrientation.y.y = 0.0;
1988 ds3db->ds3db.vConeOrientation.z.z = 0.0;
1989 ds3db->ds3db.lConeOutsideVolume = DS3D_DEFAULTCONEOUTSIDEVOLUME;
1990 ds3db->ds3db.flMinDistance = DS3D_DEFAULTMINDISTANCE;
1991 ds3db->ds3db.flMaxDistance = DS3D_DEFAULTMAXDISTANCE;
1992 ds3db->ds3db.dwMode = DS3DMODE_NORMAL;
1993 ds3db->buflen = ((*ippdsb)->buflen * primarybuf->wfx.nBlockAlign) /
1994 (*ippdsb)->wfx.nBlockAlign;
1995 ds3db->buffer = HeapAlloc(GetProcessHeap(), 0, ds3db->buflen);
1996 if (ds3db->buffer == NULL) {
1997 ds3db->buflen = 0;
1998 ds3db->ds3db.dwMode = DS3DMODE_DISABLE;
1999 }
2000 }
2001 #endif
2002 return DS_OK;
2003 }
2004
2005 static HRESULT WINAPI IDirectSoundImpl_DuplicateSoundBuffer(
2006 LPDIRECTSOUND iface,LPDIRECTSOUNDBUFFER pdsb,LPLPDIRECTSOUNDBUFFER ppdsb
2007 ) {
2008 ICOM_THIS(IDirectSoundImpl,iface);
2009 IDirectSoundBufferImpl* ipdsb=(IDirectSoundBufferImpl*)pdsb;
2010 IDirectSoundBufferImpl** ippdsb=(IDirectSoundBufferImpl**)ppdsb;
2011 TRACE("(%p,%p,%p)\n",This,ipdsb,ippdsb);
2012
2013 if (ipdsb->hwbuf) {
2014 FIXME("need to duplicate hardware buffer\n");
2015 }
2016
2017 *ippdsb = (IDirectSoundBufferImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectSoundBufferImpl));
2018
2019 IDirectSoundBuffer_AddRef(pdsb);
2020 memcpy(*ippdsb, ipdsb, sizeof(IDirectSoundBufferImpl));
2021 (*ippdsb)->ref = 1;
2022 (*ippdsb)->playpos = 0;
2023 (*ippdsb)->mixpos = 0;
2024 (*ippdsb)->dsound = This;
2025 (*ippdsb)->parent = ipdsb;
2026 memcpy(&((*ippdsb)->wfx), &(ipdsb->wfx), sizeof((*ippdsb)->wfx));
2027 InitializeCriticalSection(&(*ippdsb)->lock);
2028 /* register buffer */
2029 EnterCriticalSection(&(This->lock));
2030 {
2031 IDirectSoundBufferImpl **newbuffers = (IDirectSoundBufferImpl**)HeapReAlloc(GetProcessHeap(),0,This->buffers,sizeof(IDirectSoundBufferImpl**)*(This->nrofbuffers+1));
2032 if (newbuffers) {
2033 This->buffers = newbuffers;
2034 This->buffers[This->nrofbuffers] = *ippdsb;
2035 This->nrofbuffers++;
2036 TRACE("buffer count is now %d\n", This->nrofbuffers);
2037 } else {
2038 ERR("out of memory for buffer list! Current buffer count is %d\n", This->nrofbuffers);
2039 /* FIXME: release buffer */
2040 }
2041 }
2042 LeaveCriticalSection(&(This->lock));
2043 IDirectSound_AddRef(iface);
2044 return DS_OK;
2045 }
2046
2047
2048 static HRESULT WINAPI IDirectSoundImpl_GetCaps(LPDIRECTSOUND iface,LPDSCAPS caps) {
2049 ICOM_THIS(IDirectSoundImpl,iface);
2050 TRACE("(%p,%p)\n",This,caps);
2051 TRACE("(flags=0x%08lx)\n",caps->dwFlags);
2052
2053 if (caps == NULL)
2054 return DSERR_INVALIDPARAM;
2055
2056 /* We should check this value, not set it. See Inside DirectX, p215. */
2057 caps->dwSize = sizeof(*caps);
2058
2059 caps->dwFlags = This->drvcaps.dwFlags;
2060
2061 /* FIXME: copy caps from This->drvcaps */
2062 caps->dwMinSecondarySampleRate = DSBFREQUENCY_MIN;
2063 caps->dwMaxSecondarySampleRate = DSBFREQUENCY_MAX;
2064
2065 caps->dwPrimaryBuffers = 1;
2066
2067 caps->dwMaxHwMixingAllBuffers = 0;
2068 caps->dwMaxHwMixingStaticBuffers = 0;
2069 caps->dwMaxHwMixingStreamingBuffers = 0;
2070
2071 caps->dwFreeHwMixingAllBuffers = 0;
2072 caps->dwFreeHwMixingStaticBuffers = 0;
2073 caps->dwFreeHwMixingStreamingBuffers = 0;
2074
2075 caps->dwMaxHw3DAllBuffers = 0;
2076 caps->dwMaxHw3DStaticBuffers = 0;
2077 caps->dwMaxHw3DStreamingBuffers = 0;
2078
2079 caps->dwFreeHw3DAllBuffers = 0;
2080 caps->dwFreeHw3DStaticBuffers = 0;
2081 caps->dwFreeHw3DStreamingBuffers = 0;
2082
2083 caps->dwTotalHwMemBytes = 0;
2084
2085 caps->dwFreeHwMemBytes = 0;
2086
2087 caps->dwMaxContigFreeHwMemBytes = 0;
2088
2089 caps->dwUnlockTransferRateHwBuffers = 4096; /* But we have none... */
2090
2091 caps->dwPlayCpuOverheadSwBuffers = 1; /* 1% */
2092
2093 return DS_OK;
2094 }
2095
2096 static ULONG WINAPI IDirectSoundImpl_AddRef(LPDIRECTSOUND iface) {
2097 ICOM_THIS(IDirectSoundImpl,iface);
2098 return ++(This->ref);
2099 }
2100
2101 static ULONG WINAPI IDirectSoundImpl_Release(LPDIRECTSOUND iface) {
2102 ICOM_THIS(IDirectSoundImpl,iface);
2103 TRACE("(%p), ref was %ld\n",This,This->ref);
2104 if (!--(This->ref)) {
2105 UINT i;
2106
2107 timeKillEvent(This->timerID);
2108 timeEndPeriod(DS_TIME_RES);
2109
2110 if (primarybuf)
2111 IDirectSoundBuffer_Release((LPDIRECTSOUNDBUFFER)primarybuf);
2112
2113 if (This->buffers) {
2114 for( i=0;i<This->nrofbuffers;i++)
2115 IDirectSoundBuffer_Release((LPDIRECTSOUNDBUFFER)This->buffers[i]);
2116 }
2117
2118 if (This->primary)
2119 IDirectSoundBuffer_Release((LPDIRECTSOUNDBUFFER)This->primary);
2120
2121 DeleteCriticalSection(&This->lock);
2122 if (This->driver) {
2123 IDsDriver_Close(This->driver);
2124 } else {
2125 unsigned c;
2126 for (c=0; c<DS_HEL_FRAGS; c++)
2127 HeapFree(GetProcessHeap(),0,This->pwave[c]);
2128 }
2129 if (This->drvdesc.dwFlags & DSDDESC_DOMMSYSTEMOPEN) {
2130 waveOutClose(This->hwo);
2131 }
2132 if (This->driver)
2133 IDsDriver_Release(This->driver);
2134
2135 HeapFree(GetProcessHeap(),0,This);
2136 dsound = NULL;
2137 return 0;
2138 }
2139 return This->ref;
2140 }
2141
2142 static HRESULT WINAPI IDirectSoundImpl_SetSpeakerConfig(
2143 LPDIRECTSOUND iface,DWORD config
2144 ) {
2145 ICOM_THIS(IDirectSoundImpl,iface);
2146 FIXME("(%p,0x%08lx):stub\n",This,config);
2147 return DS_OK;
2148 }
2149
2150 static HRESULT WINAPI IDirectSoundImpl_QueryInterface(
2151 LPDIRECTSOUND iface,REFIID riid,LPVOID *ppobj
2152 ) {
2153 ICOM_THIS(IDirectSoundImpl,iface);
2154
2155 if ( IsEqualGUID( &IID_IDirectSound3DListener, riid ) ) {
2156
2157 if (This->listener) {
2158 *ppobj = This->listener;
2159 IDirectSound3DListener_AddRef((LPDIRECTSOUND3DLISTENER)This->listener);
2160 return DS_OK;
2161 }
2162
2163 This->listener = (IDirectSound3DListenerImpl*)HeapAlloc(
2164 GetProcessHeap(), 0, sizeof(*(This->listener)));
2165 This->listener->ref = 1;
2166 ICOM_VTBL(This->listener) = &ds3dlvt;
2167 *ppobj = (LPVOID)This->listener;
2168 IDirectSound3DListener_AddRef((LPDIRECTSOUND3DLISTENER)*ppobj);
2169
2170 This->listener->dsb = NULL;
2171
2172 This->listener->ds3dl.dwSize = sizeof(DS3DLISTENER);
2173 This->listener->ds3dl.vPosition.u1.x = 0.0;
2174 This->listener->ds3dl.vPosition.u2.y = 0.0;
2175 This->listener->ds3dl.vPosition.u3.z = 0.0;
2176 This->listener->ds3dl.vVelocity.u1.x = 0.0;
2177 This->listener->ds3dl.vVelocity.u2.y = 0.0;
2178 This->listener->ds3dl.vVelocity.u3.z = 0.0;
2179 This->listener->ds3dl.vOrientFront.u1.x = 0.0;
2180 This->listener->ds3dl.vOrientFront.u2.y = 0.0;
2181 This->listener->ds3dl.vOrientFront.u3.z = 1.0;
2182 This->listener->ds3dl.vOrientTop.u1.x = 0.0;
2183 This->listener->ds3dl.vOrientTop.u2.y = 1.0;
2184 This->listener->ds3dl.vOrientTop.u3.z = 0.0;
2185 This->listener->ds3dl.flDistanceFactor = DS3D_DEFAULTDISTANCEFACTOR;
2186 This->listener->ds3dl.flRolloffFactor = DS3D_DEFAULTROLLOFFFACTOR;
2187 This->listener->ds3dl.flDopplerFactor = DS3D_DEFAULTDOPPLERFACTOR;
2188
2189 InitializeCriticalSection(&This->listener->lock);
2190
2191 return DS_OK;
2192 }
2193
2194 FIXME("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
2195 return E_FAIL;
2196 }
2197
2198 static HRESULT WINAPI IDirectSoundImpl_Compact(
2199 LPDIRECTSOUND iface)
2200 {
2201 ICOM_THIS(IDirectSoundImpl,iface);
2202 TRACE("(%p)\n", This);
2203 return DS_OK;
2204 }
2205
2206 static HRESULT WINAPI IDirectSoundImpl_GetSpeakerConfig(
2207 LPDIRECTSOUND iface,
2208 LPDWORD lpdwSpeakerConfig)
2209 {
2210 ICOM_THIS(IDirectSoundImpl,iface);
2211 TRACE("(%p, %p)\n", This, lpdwSpeakerConfig);
2212 *lpdwSpeakerConfig = DSSPEAKER_STEREO | (DSSPEAKER_GEOMETRY_NARROW << 16);
2213 return DS_OK;
2214 }
2215
2216 static HRESULT WINAPI IDirectSoundImpl_Initialize(
2217 LPDIRECTSOUND iface,
2218 LPCGUID lpcGuid)
2219 {
2220 ICOM_THIS(IDirectSoundImpl,iface);
2221 TRACE("(%p, %p)\n", This, lpcGuid);
2222 return DS_OK;
2223 }
2224
2225 static ICOM_VTABLE(IDirectSound) dsvt =
2226 {
2227 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
2228 IDirectSoundImpl_QueryInterface,
2229 IDirectSoundImpl_AddRef,
2230 IDirectSoundImpl_Release,
2231 IDirectSoundImpl_CreateSoundBuffer,
2232 IDirectSoundImpl_GetCaps,
2233 IDirectSoundImpl_DuplicateSoundBuffer,
2234 IDirectSoundImpl_SetCooperativeLevel,
2235 IDirectSoundImpl_Compact,
2236 IDirectSoundImpl_GetSpeakerConfig,
2237 IDirectSoundImpl_SetSpeakerConfig,
2238 IDirectSoundImpl_Initialize
2239 };
2240
2241
2242 static void DSOUND_CheckEvent(IDirectSoundBufferImpl *dsb, int len)
2243 {
2244 int i;
2245 DWORD offset;
2246 LPDSBPOSITIONNOTIFY event;
2247
2248 if (dsb->nrofnotifies == 0)
2249 return;
2250
2251 TRACE("(%p) buflen = %ld, playpos = %ld, len = %d\n",
2252 dsb, dsb->buflen, dsb->playpos, len);
2253 for (i = 0; i < dsb->nrofnotifies ; i++) {
2254 event = dsb->notifies + i;
2255 offset = event->dwOffset;
2256 TRACE("checking %d, position %ld, event = %d\n",
2257 i, offset, event->hEventNotify);
2258 /* DSBPN_OFFSETSTOP has to be the last element. So this is */
2259 /* OK. [Inside DirectX, p274] */
2260 /* */
2261 /* This also means we can't sort the entries by offset, */
2262 /* because DSBPN_OFFSETSTOP == -1 */
2263 if (offset == DSBPN_OFFSETSTOP) {
2264 if (dsb->state == STATE_STOPPED) {
2265 SetEvent(event->hEventNotify);
2266 TRACE("signalled event %d (%d)\n", event->hEventNotify, i);
2267 return;
2268 } else
2269 return;
2270 }
2271 if ((dsb->playpos + len) >= dsb->buflen) {
2272 if ((offset < ((dsb->playpos + len) % dsb->buflen)) ||
2273 (offset >= dsb->playpos)) {
2274 TRACE("signalled event %d (%d)\n", event->hEventNotify, i);
2275 SetEvent(event->hEventNotify);
2276 }
2277 } else {
2278 if ((offset >= dsb->playpos) && (offset < (dsb->playpos + len))) {
2279 TRACE("signalled event %d (%d)\n", event->hEventNotify, i);
2280 SetEvent(event->hEventNotify);
2281 }
2282 }
2283 }
2284 }
2285
2286 /* WAV format info can be found at: */
2287 /* */
2288 /* http://www.cwi.nl/ftp/audio/AudioFormats.part2 */
2289 /* ftp://ftp.cwi.nl/pub/audio/RIFF-format */
2290 /* */
2291 /* Import points to remember: */
2292 /* */
2293 /* 8-bit WAV is unsigned */
2294 /* 16-bit WAV is signed */
2295
2296 static inline INT16 cvtU8toS16(BYTE byte)
2297 {
2298 INT16 s = (byte - 128) << 8;
2299
2300 return s;
2301 }
2302
2303 static inline BYTE cvtS16toU8(INT16 word)
2304 {
2305 BYTE b = (word + 32768) >> 8;
2306
2307 return b;
2308 }
2309
2310
2311 /* We should be able to optimize these two inline functions */
2312 /* so that we aren't doing 8->16->8 conversions when it is */
2313 /* not necessary. But this is still a WIP. Optimize later. */
2314 static inline void get_fields(const IDirectSoundBufferImpl *dsb, BYTE *buf, INT *fl, INT *fr)
2315 {
2316 INT16 *bufs = (INT16 *) buf;
2317
2318 /* TRACE("(%p)", buf); */
2319 if ((dsb->wfx.wBitsPerSample == 8) && dsb->wfx.nChannels == 2) {
2320 *fl = cvtU8toS16(*buf);
2321 *fr = cvtU8toS16(*(buf + 1));
2322 return;
2323 }
2324
2325 if ((dsb->wfx.wBitsPerSample == 16) && dsb->wfx.nChannels == 2) {
2326 *fl = *bufs;
2327 *fr = *(bufs + 1);
2328 return;
2329 }
2330
2331 if ((dsb->wfx.wBitsPerSample == 8) && dsb->wfx.nChannels == 1) {
2332 *fl = cvtU8toS16(*buf);
2333 *fr = *fl;
2334 return;
2335 }
2336
2337 if ((dsb->wfx.wBitsPerSample == 16) && dsb->wfx.nChannels == 1) {
2338 *fl = *bufs;
2339 *fr = *bufs;
2340 return;
2341 }
2342
2343 FIXME("get_fields found an unsupported configuration\n");
2344 return;
2345 }
2346
2347 static inline void set_fields(BYTE *buf, INT fl, INT fr)
2348 {
2349 INT16 *bufs = (INT16 *) buf;
2350
2351 if ((primarybuf->wfx.wBitsPerSample == 8) && (primarybuf->wfx.nChannels == 2)) {
2352 *buf = cvtS16toU8(fl);
2353 *(buf + 1) = cvtS16toU8(fr);
2354 return;
2355 }
2356
2357 if ((primarybuf->wfx.wBitsPerSample == 16) && (primarybuf->wfx.nChannels == 2)) {
2358 *bufs = fl;
2359 *(bufs + 1) = fr;
2360 return;
2361 }
2362
2363 if ((primarybuf->wfx.wBitsPerSample == 8) && (primarybuf->wfx.nChannels == 1)) {
2364 *buf = cvtS16toU8((fl + fr) >> 1);
2365 return;
2366 }
2367
2368 if ((primarybuf->wfx.wBitsPerSample == 16) && (primarybuf->wfx.nChannels == 1)) {
2369 *bufs = (fl + fr) >> 1;
2370 return;
2371 }
2372 FIXME("set_fields found an unsupported configuration\n");
2373 return;
2374 }
2375
2376 /* Now with PerfectPitch (tm) technology */
2377 static INT DSOUND_MixerNorm(IDirectSoundBufferImpl *dsb, BYTE *buf, INT len)
2378 {
2379 INT i, size, ipos, ilen, fieldL, fieldR;
2380 BYTE *ibp, *obp;
2381 INT iAdvance = dsb->wfx.nBlockAlign;
2382 INT oAdvance = primarybuf->wfx.nBlockAlign;
2383
2384 ibp = dsb->buffer + dsb->mixpos;
2385 obp = buf;
2386
2387 TRACE("(%p, %p, %p), mixpos=%ld\n", dsb, ibp, obp, dsb->mixpos);
2388 /* Check for the best case */
2389 if ((dsb->freq == primarybuf->wfx.nSamplesPerSec) &&
2390 (dsb->wfx.wBitsPerSample == primarybuf->wfx.wBitsPerSample) &&
2391 (dsb->wfx.nChannels == primarybuf->wfx.nChannels)) {
2392 DWORD bytesleft = dsb->buflen - dsb->mixpos;
2393 TRACE("(%p) Best case\n", dsb);
2394 if (len <= bytesleft )
2395 memcpy(obp, ibp, len);
2396 else { /* wrap */
2397 memcpy(obp, ibp, bytesleft );
2398 memcpy(obp + bytesleft, dsb->buffer, len - bytesleft);
2399 }
2400 return len;
2401 }
2402
2403 /* Check for same sample rate */
2404 if (dsb->freq == primarybuf->wfx.nSamplesPerSec) {
2405 TRACE("(%p) Same sample rate %ld = primary %ld\n", dsb,
2406 dsb->freq, primarybuf->wfx.nSamplesPerSec);
2407 ilen = 0;
2408 for (i = 0; i < len; i += oAdvance) {
2409 get_fields(dsb, ibp, &fieldL, &fieldR);
2410 ibp += iAdvance;
2411 ilen += iAdvance;
2412 set_fields(obp, fieldL, fieldR);
2413 obp += oAdvance;
2414 if (ibp >= (BYTE *)(dsb->buffer + dsb->buflen))
2415 ibp = dsb->buffer; /* wrap */
2416 }
2417 return (ilen);
2418 }
2419
2420 /* Mix in different sample rates */
2421 /* */
2422 /* New PerfectPitch(tm) Technology (c) 1998 Rob Riggs */
2423 /* Patent Pending :-] */
2424
2425 TRACE("(%p) Adjusting frequency: %ld -> %ld\n",
2426 dsb, dsb->freq, primarybuf->wfx.nSamplesPerSec);
2427
2428 size = len / oAdvance;
2429 ilen = ((size * dsb->freqAdjust) >> DSOUND_FREQSHIFT) * iAdvance;
2430 for (i = 0; i < size; i++) {
2431
2432 ipos = (((i * dsb->freqAdjust) >> DSOUND_FREQSHIFT) * iAdvance) + dsb->mixpos;
2433
2434 if (ipos >= dsb->buflen)
2435 ipos %= dsb->buflen; /* wrap */
2436
2437 get_fields(dsb, (dsb->buffer + ipos), &fieldL, &fieldR);
2438 set_fields(obp, fieldL, fieldR);
2439 obp += oAdvance;
2440 }
2441 return ilen;
2442 }
2443
2444 static void DSOUND_MixerVol(IDirectSoundBufferImpl *dsb, BYTE *buf, INT len)
2445 {
2446 INT i, inc = primarybuf->wfx.wBitsPerSample >> 3;
2447 BYTE *bpc = buf;
2448 INT16 *bps = (INT16 *) buf;
2449
2450 TRACE("(%p) left = %lx, right = %lx\n", dsb,
2451 dsb->volpan.dwTotalLeftAmpFactor, dsb->volpan.dwTotalRightAmpFactor);
2452 if ((!(dsb->dsbd.dwFlags & DSBCAPS_CTRLPAN) || (dsb->volpan.lPan == 0)) &&
2453 (!(dsb->dsbd.dwFlags & DSBCAPS_CTRLVOLUME) || (dsb->volpan.lVolume == 0)) &&
2454 !(dsb->dsbd.dwFlags & DSBCAPS_CTRL3D))
2455 return; /* Nothing to do */
2456
2457 /* If we end up with some bozo coder using panning or 3D sound */
2458 /* with a mono primary buffer, it could sound very weird using */
2459 /* this method. Oh well, tough patooties. */
2460
2461 for (i = 0; i < len; i += inc) {
2462 INT val;
2463
2464 switch (inc) {
2465
2466 case 1:
2467 /* 8-bit WAV is unsigned, but we need to operate */
2468 /* on signed data for this to work properly */
2469 val = *bpc - 128;
2470 val = ((val * (i & inc ? dsb->volpan.dwTotalRightAmpFactor : dsb->volpan.dwTotalLeftAmpFactor)) >> 16);
2471 *bpc = val + 128;
2472 bpc++;
2473 break;
2474 case 2:
2475 /* 16-bit WAV is signed -- much better */
2476 val = *bps;
2477 val = ((val * ((i & inc) ? dsb->volpan.dwTotalRightAmpFactor : dsb->volpan.dwTotalLeftAmpFactor)) >> 16);
2478 *bps = val;
2479 bps++;
2480 break;
2481 default:
2482 /* Very ugly! */
2483 FIXME("MixerVol had a nasty error\n");
2484 }
2485 }
2486 }
2487
2488 #ifdef USE_DSOUND3D
2489 static void DSOUND_Mixer3D(IDirectSoundBufferImpl *dsb, BYTE *buf, INT len)
2490 {
2491 BYTE *ibp, *obp;
2492 DWORD buflen, mixpos;
2493
2494 buflen = dsb->ds3db->buflen;
2495 mixpos = (dsb->mixpos * primarybuf->wfx.nBlockAlign) / dsb->wfx.nBlockAlign;
2496 ibp = dsb->ds3db->buffer + mixpos;
2497 obp = buf;
2498
2499 if (mixpos > buflen) {
2500 FIXME("Major breakage");
2501 return;
2502 }
2503
2504 if (len <= (mixpos + buflen))
2505 memcpy(obp, ibp, len);
2506 else { /* wrap */
2507 memcpy(obp, ibp, buflen - mixpos);
2508 memcpy(obp + (buflen - mixpos),
2509 dsb->buffer,
2510 len - (buflen - mixpos));
2511 }
2512 return;
2513 }
2514 #endif
2515
2516 static void *tmp_buffer;
2517 static size_t tmp_buffer_len = 0;
2518
2519 static void *DSOUND_tmpbuffer(size_t len)
2520 {
2521 if (len>tmp_buffer_len) {
2522 void *new_buffer = realloc(tmp_buffer, len);
2523 if (new_buffer) {
2524 tmp_buffer = new_buffer;
2525 tmp_buffer_len = len;
2526 }
2527 return new_buffer;
2528 }
2529 return tmp_buffer;
2530 }
2531
2532 static DWORD DSOUND_MixInBuffer(IDirectSoundBufferImpl *dsb, DWORD writepos, DWORD fraglen)
2533 {
2534 INT i, len, ilen, temp, field;
2535 INT advance = primarybuf->wfx.wBitsPerSample >> 3;
2536 BYTE *buf, *ibuf, *obuf;
2537 INT16 *ibufs, *obufs;
2538
2539 len = fraglen;
2540 if (!(dsb->playflags & DSBPLAY_LOOPING)) {
2541 temp = MulDiv(primarybuf->wfx.nAvgBytesPerSec, dsb->buflen,
2542 dsb->nAvgBytesPerSec) -
2543 MulDiv(primarybuf->wfx.nAvgBytesPerSec, dsb->mixpos,
2544 dsb->nAvgBytesPerSec);
2545 len = (len > temp) ? temp : len;
2546 }
2547 len &= ~3; /* 4 byte alignment */
2548
2549 if (len == 0) {
2550 /* This should only happen if we aren't looping and temp < 4 */
2551
2552 /* We skip the remainder, so check for possible events */
2553 DSOUND_CheckEvent(dsb, dsb->buflen - dsb->mixpos);
2554 /* Stop */
2555 dsb->state = STATE_STOPPED;
2556 dsb->playpos = 0;
2557 dsb->mixpos = 0;
2558 dsb->leadin = FALSE;
2559 /* Check for DSBPN_OFFSETSTOP */
2560 DSOUND_CheckEvent(dsb, 0);
2561 return 0;
2562 }
2563
2564 /* Been seeing segfaults in malloc() for some reason... */
2565 TRACE("allocating buffer (size = %d)\n", len);
2566 if ((buf = ibuf = (BYTE *) DSOUND_tmpbuffer(len)) == NULL)
2567 return 0;
2568
2569 TRACE("MixInBuffer (%p) len = %d, dest = %ld\n", dsb, len, writepos);
2570
2571 ilen = DSOUND_MixerNorm(dsb, ibuf, len);
2572 if ((dsb->dsbd.dwFlags & DSBCAPS_CTRLPAN) ||
2573 (dsb->dsbd.dwFlags & DSBCAPS_CTRLVOLUME))
2574 DSOUND_MixerVol(dsb, ibuf, len);
2575
2576 obuf = primarybuf->buffer + writepos;
2577 for (i = 0; i < len; i += advance) {
2578 obufs = (INT16 *) obuf;
2579 ibufs = (INT16 *) ibuf;
2580 if (primarybuf->wfx.wBitsPerSample == 8) {
2581 /* 8-bit WAV is unsigned */
2582 field = (*ibuf - 128);
2583 field += (*obuf - 128);
2584 field = field > 127 ? 127 : field;
2585 field = field < -128 ? -128 : field;
2586 *obuf = field + 128;
2587 } else {
2588 /* 16-bit WAV is signed */
2589 field = *ibufs;
2590 field += *obufs;
2591 field = field > 32767 ? 32767 : field;
2592 field = field < -32768 ? -32768 : field;
2593 *obufs = field;
2594 }
2595 ibuf += advance;
2596 obuf += advance;
2597 if (obuf >= (BYTE *)(primarybuf->buffer + primarybuf->buflen))
2598 obuf = primarybuf->buffer;
2599 }
2600 /* free(buf); */
2601
2602 if (dsb->dsbd.dwFlags & DSBCAPS_CTRLPOSITIONNOTIFY)
2603 DSOUND_CheckEvent(dsb, ilen);
2604
2605 if (dsb->leadin && (dsb->startpos > dsb->mixpos) && (dsb->startpos <= dsb->mixpos + ilen)) {
2606 /* HACK... leadin should be reset when the PLAY position reaches the startpos,
2607 * not the MIX position... but if the sound buffer is bigger than our prebuffering
2608 * (which must be the case for the streaming buffers that need this hack anyway)
2609 * plus DS_HEL_MARGIN or equivalent, then this ought to work anyway. */
2610 dsb->leadin = FALSE;
2611 }
2612
2613 dsb->mixpos += ilen;
2614
2615 if (dsb->mixpos >= dsb->buflen) {
2616 if (!(dsb->playflags & DSBPLAY_LOOPING)) {
2617 dsb->state = STATE_STOPPED;
2618 dsb->playpos = 0;
2619 dsb->mixpos = 0;
2620 dsb->leadin = FALSE;
2621 DSOUND_CheckEvent(dsb, 0); /* For DSBPN_OFFSETSTOP */
2622 } else {
2623 /* wrap */
2624 while (dsb->mixpos >= dsb->buflen)
2625 dsb->mixpos -= dsb->buflen;
2626 if (dsb->leadin && (dsb->startpos <= dsb->mixpos))
2627 dsb->leadin = FALSE; /* HACK: see above */
2628 }
2629 }
2630
2631 return len;
2632 }
2633
2634 static DWORD WINAPI DSOUND_MixPrimary(DWORD writepos, DWORD fraglen, BOOL starting)
2635 {
2636 INT i, len, maxlen = 0;
2637 IDirectSoundBufferImpl *dsb;
2638
2639 TRACE("(%ld,%ld,%d)\n", writepos, fraglen, starting);
2640 for (i = dsound->nrofbuffers - 1; i >= 0; i--) {
2641 dsb = dsound->buffers[i];
2642
2643 if (!dsb || !(ICOM_VTBL(dsb)))
2644 continue;
2645 if (dsb->buflen && dsb->state && !(starting && (dsb->state != STATE_STARTING))) {
2646 TRACE("Checking %p\n", dsb);
2647 EnterCriticalSection(&(dsb->lock));
2648 if (dsb->state == STATE_STOPPING) {
2649 /* FIXME: perhaps attempt to remove the buffer from the prebuffer */
2650 dsb->state = STATE_STOPPED;
2651 } else {
2652 len = DSOUND_MixInBuffer(dsb, writepos, fraglen);
2653 maxlen = len > maxlen ? len : maxlen;
2654 }
2655 LeaveCriticalSection(&(dsb->lock));
2656 }
2657 }
2658
2659 return maxlen;
2660 }
2661
2662 static void WINAPI DSOUND_MarkPlaying(void)
2663 {
2664 INT i;
2665 IDirectSoundBufferImpl *dsb;
2666
2667 for (i = dsound->nrofbuffers - 1; i >= 0; i--) {
2668 dsb = dsound->buffers[i];
2669
2670 if (!dsb || !(ICOM_VTBL(dsb)))
2671 continue;
2672 if (dsb->buflen && (dsb->state == STATE_STARTING))
2673 dsb->state = STATE_PLAYING;
2674 }
2675 }
2676
2677 static void CALLBACK DSOUND_timer(UINT timerID, UINT msg, DWORD dwUser, DWORD dw1, DWORD dw2)
2678 {
2679 DWORD len;
2680 int nfiller;
2681 BOOL forced;
2682
2683 if (!dsound || !primarybuf) {
2684 ERR("dsound died without killing us?\n");
2685 timeKillEvent(timerID);
2686 timeEndPeriod(DS_TIME_RES);
2687 return;
2688 }
2689
2690 EnterCriticalSection(&(dsound->lock));
2691
2692 if (!primarybuf || !primarybuf->ref) {
2693 /* seems the primary buffer is currently being released */
2694 LeaveCriticalSection(&(dsound->lock));
2695 return;
2696 }
2697
2698 /* the sound of silence */
2699 nfiller = primarybuf->wfx.wBitsPerSample == 8 ? 128 : 0;
2700
2701 /* whether the primary is forced to play even without secondary buffers */
2702 forced = ((primarybuf->state == STATE_PLAYING) || (primarybuf->state == STATE_STARTING));
2703
2704 if (primarybuf->hwbuf) {
2705 if (dsound->priolevel != DSSCL_WRITEPRIMARY) {
2706 BOOL paused = ((primarybuf->state == STATE_STOPPED) || (primarybuf->state == STATE_STARTING));
2707 DWORD playpos, writepos, inq, maxq, mixq, frag;
2708 IDsDriverBuffer_GetPosition(primarybuf->hwbuf, &playpos, &writepos);
2709 /* Well, we *could* do Just-In-Time mixing using the writepos,
2710 * but that's a little bit ambitious and unnecessary... */
2711 /* rather add our safety margin to the writepos, if we're playing */
2712 if (!paused) {
2713 writepos += primarybuf->writelead;
2714 while (writepos >= primarybuf->buflen)
2715 writepos -= primarybuf->buflen;
2716 } else writepos = playpos;
2717 TRACE("primary playpos=%ld, writepos=%ld, clrpos=%ld, mixpos=%ld\n",
2718 playpos,writepos,primarybuf->playpos,primarybuf->mixpos);
2719 /* wipe out just-played sound data */
2720 if (playpos < primarybuf->playpos) {
2721 memset(primarybuf->buffer + primarybuf->playpos, nfiller, primarybuf->buflen - primarybuf->playpos);
2722 memset(primarybuf->buffer, nfiller, playpos);
2723 } else {
2724 memset(primarybuf->buffer + primarybuf->playpos, nfiller, playpos - primarybuf->playpos);
2725 }
2726 primarybuf->playpos = playpos;
2727
2728 /* check how much prebuffering is left */
2729 inq = primarybuf->mixpos;
2730 if (inq < writepos)
2731 inq += primarybuf->buflen;
2732 inq -= writepos;
2733
2734 /* find the maximum we can prebuffer */
2735 if (!paused) {
2736 maxq = playpos;
2737 if (maxq < writepos)
2738 maxq += primarybuf->buflen;
2739 maxq -= writepos;
2740 } else maxq = primarybuf->buflen;
2741
2742 /* clip maxq to DS_HAL_QUEUE */
2743 frag = DS_HAL_QUEUE * dsound->fraglen;
2744 if (maxq > frag) maxq = frag;
2745
2746 EnterCriticalSection(&(primarybuf->lock));
2747
2748 /* check for consistency */
2749 if (inq > maxq) {
2750 /* the playback position must have passed our last
2751 * mixed position, i.e. it's an underrun, or we have
2752 * nothing more to play */
2753 inq = 0;
2754 /* stop the playback now, to allow buffers to refill */
2755 IDsDriverBuffer_Stop(primarybuf->hwbuf);
2756 if (primarybuf->state == STATE_PLAYING) {
2757 primarybuf->state = STATE_STARTING;
2758 }
2759 else if (primarybuf->state == STATE_STOPPING) {
2760 primarybuf->state = STATE_STOPPED;
2761 }
2762 else {
2763 /* how can we have an underrun if we aren't playing? */
2764 ERR("unexpected primary state (%ld)\n", primarybuf->state);
2765 }
2766 /* the Stop is supposed to reset play position to beginning of buffer */
2767 /* unfortunately, OSS is not able to do so, so get current pointer */
2768 IDsDriverBuffer_GetPosition(primarybuf->hwbuf, &playpos, NULL);
2769 writepos = playpos;
2770 primarybuf->playpos = playpos;
2771 primarybuf->mixpos = playpos;
2772 inq = 0;
2773 maxq = primarybuf->buflen;
2774 if (maxq > frag) maxq = frag;
2775 memset(primarybuf->buffer, nfiller, primarybuf->buflen);
2776 paused = TRUE;
2777 }
2778
2779 /* see if some new buffers have been started that we want to merge into our prebuffer;
2780 * this should minimize latency even when we have a large prebuffer */
2781 if (!paused) {
2782 if (primarybuf->mixpos < writepos) {
2783 /* mix to end of buffer */
2784 len = DSOUND_MixPrimary(writepos, primarybuf->buflen - writepos, TRUE);
2785 if ((len + writepos) < primarybuf->buflen)
2786 goto addmix_complete;
2787 /* mix from beginning of buffer */
2788 if (primarybuf->mixpos)
2789 len = DSOUND_MixPrimary(0, primarybuf->mixpos, TRUE);
2790 } else {
2791 /* mix middle of buffer */
2792 len = DSOUND_MixPrimary(writepos, primarybuf->mixpos - writepos, TRUE);
2793 }
2794 }
2795 addmix_complete:
2796 DSOUND_MarkPlaying();
2797
2798 mixq = maxq - inq;
2799 TRACE("queued %ld, max %ld, mixing %ld, paused %d\n", inq, maxq, mixq, paused);
2800 /* it's too inefficient to mix less than a fragment at a time */
2801 if (mixq >= dsound->fraglen) {
2802
2803 #define FRAG_MIXER \
2804 if (frag > mixq) frag = mixq; \
2805 len = DSOUND_MixPrimary(primarybuf->mixpos, frag, FALSE); \
2806 if (forced) len = frag; \
2807 primarybuf->mixpos += len; \
2808 mixq -= len; inq += len
2809
2810 if ((playpos < writepos) || (paused && (playpos == writepos))) {
2811 if (primarybuf->mixpos) {
2812 /* mix to end of buffer */
2813 frag = primarybuf->buflen - primarybuf->mixpos;
2814 FRAG_MIXER;
2815 if (primarybuf->mixpos < primarybuf->buflen)
2816 goto mix_complete;
2817 primarybuf->mixpos = 0;
2818 }
2819 if (mixq >= dsound->fraglen) {
2820 /* mix from beginning of buffer */
2821 frag = playpos;
2822 if ((!frag) && paused) frag = primarybuf->buflen;
2823 FRAG_MIXER;
2824 }
2825 }
2826 else if (playpos > writepos) {
2827 /* mix middle of buffer */
2828 frag = playpos - primarybuf->mixpos;
2829 FRAG_MIXER;
2830 }
2831 else {
2832 /* this should preferably not happen... */
2833 ERR("mixer malfunction (ambiguous writepos)!\n");
2834 }
2835 #undef FRAG_MIXER
2836 }
2837 mix_complete:
2838 if (inq) {
2839 /* buffers have been filled, restart playback */
2840 if (primarybuf->state == STATE_STARTING) {
2841 IDsDriverBuffer_Play(primarybuf->hwbuf, 0, 0, DSBPLAY_LOOPING);
2842 primarybuf->state = STATE_PLAYING;
2843 }
2844 else if (primarybuf->state == STATE_STOPPED) {
2845 /* the primarybuf is supposed to play if there's something to play
2846 * even if it is reported as stopped, so don't let this confuse you */
2847 IDsDriverBuffer_Play(primarybuf->hwbuf, 0, 0, DSBPLAY_LOOPING);
2848 primarybuf->state = STATE_STOPPING;
2849 }
2850 }
2851 LeaveCriticalSection(&(primarybuf->lock));
2852 } else {
2853 /* in the DSSCL_WRITEPRIMARY mode, the app is totally in charge... */
2854 if (primarybuf->state == STATE_STARTING) {
2855 IDsDriverBuffer_Play(primarybuf->hwbuf, 0, 0, DSBPLAY_LOOPING);
2856 primarybuf->state = STATE_PLAYING;
2857 }
2858 else if (primarybuf->state == STATE_STOPPING) {
2859 IDsDriverBuffer_Stop(primarybuf->hwbuf);
2860 primarybuf->state = STATE_STOPPED;
2861 }
2862 }
2863 } else {
2864 /* using waveOut stuff */
2865 /* if no buffers are playing, we should be in pause mode now */
2866 DWORD writepos;
2867 /* clean out completed fragments */
2868 while (dsound->pwqueue && (dsound->pwave[dsound->pwplay]->dwFlags & WHDR_DONE)) {
2869 if (dsound->priolevel != DSSCL_WRITEPRIMARY) {
2870 DWORD pos = dsound->pwplay * dsound->fraglen;
2871 TRACE("done playing primary pos=%ld\n",pos);
2872 memset(primarybuf->buffer + pos, nfiller, dsound->fraglen);
2873 }
2874 dsound->pwplay++;
2875 if (dsound->pwplay >= DS_HEL_FRAGS) dsound->pwplay = 0;
2876 dsound->pwqueue--;
2877 }
2878 primarybuf->playpos = dsound->pwplay * dsound->fraglen;
2879 TRACE("primary playpos=%ld, mixpos=%ld\n",primarybuf->playpos,primarybuf->mixpos);
2880 EnterCriticalSection(&(primarybuf->lock));
2881 if (!dsound->pwqueue) {
2882 /* this is either an underrun or we have nothing more to play...
2883 * since playback has already stopped now, we can enter pause mode,
2884 * in order to allow buffers to refill */
2885 if (primarybuf->state == STATE_PLAYING) {
2886 waveOutPause(dsound->hwo);
2887 primarybuf->state = STATE_STARTING;
2888 }
2889 else if (primarybuf->state == STATE_STOPPING) {
2890 waveOutPause(dsound->hwo);
2891 primarybuf->state = STATE_STOPPED;
2892 }
2893 }
2894
2895 /* find next write position, plus some extra margin */
2896 writepos = primarybuf->playpos + DS_HEL_MARGIN * dsound->fraglen;
2897 while (writepos >= primarybuf->buflen) writepos -= primarybuf->buflen;
2898
2899 /* see if some new buffers have been started that we want to merge into our prebuffer;
2900 * this should minimize latency even when we have a large prebuffer */
2901 if (dsound->priolevel != DSSCL_WRITEPRIMARY) {
2902 if ((primarybuf->state == STATE_PLAYING) || (primarybuf->state == STATE_STOPPING)) {
2903 while (writepos != primarybuf->mixpos) {
2904 len = DSOUND_MixPrimary(writepos, dsound->fraglen, TRUE);
2905 if (!len) break;
2906 writepos += dsound->fraglen;
2907 if (writepos >= primarybuf->buflen)
2908 writepos -= primarybuf->buflen;
2909 }
2910 }
2911 DSOUND_MarkPlaying();
2912 }
2913
2914 /* we want at least DS_HEL_QUEUE fragments in the prebuffer outqueue;
2915 * mix a bunch of fragments now as necessary */
2916 while (dsound->pwqueue < DS_HEL_QUEUE) {
2917 if (dsound->priolevel != DSSCL_WRITEPRIMARY) {
2918 len = DSOUND_MixPrimary(primarybuf->mixpos, dsound->fraglen, FALSE);
2919 } else len=0;
2920 if (forced) len = dsound->fraglen;
2921 /* if we have nothing to play, don't bother to */
2922 if (!len) break;
2923 if (len < dsound->fraglen) {
2924 TRACE("len=%ld is less than fraglen=%ld\n",len,dsound->fraglen);
2925 }
2926 /* ok, we have something to play */
2927 /* advance mix positions */
2928 primarybuf->mixpos += dsound->fraglen;
2929 if (primarybuf->mixpos >= primarybuf->buflen)
2930 primarybuf->mixpos -= primarybuf->buflen;
2931 /* output it */
2932 waveOutWrite(dsound->hwo, dsound->pwave[dsound->pwwrite], sizeof(WAVEHDR));
2933 dsound->pwwrite++;
2934 if (dsound->pwwrite >= DS_HEL_FRAGS) dsound->pwwrite = 0;
2935 dsound->pwqueue++;
2936 }
2937 if (dsound->pwqueue) {
2938 /* buffers have been filled, restart playback */
2939 if (primarybuf->state == STATE_STARTING) {
2940 waveOutRestart(dsound->hwo);
2941 primarybuf->state = STATE_PLAYING;
2942 }
2943 else if (primarybuf->state == STATE_STOPPED) {
2944 /* the primarybuf is supposed to play if there's something to play
2945 * even if it is reported as stopped, so don't let this confuse you */
2946 waveOutRestart(dsound->hwo);
2947 primarybuf->state = STATE_STOPPING;
2948 }
2949 }
2950 LeaveCriticalSection(&(primarybuf->lock));
2951 }
2952 LeaveCriticalSection(&(dsound->lock));
2953 }
2954
2955 /*******************************************************************************
2956 * DirectSoundCreate
2957 */
2958 HRESULT WINAPI DirectSoundCreate(REFGUID lpGUID,LPDIRECTSOUND *ppDS,IUnknown *pUnkOuter )
2959 {
2960 IDirectSoundImpl** ippDS=(IDirectSoundImpl**)ppDS;
2961 PIDSDRIVER drv = NULL;
2962 WAVEOUTCAPSA wcaps;
2963 unsigned wod, wodn;
2964 HRESULT err = DS_OK;
2965
2966 if (lpGUID)
2967 TRACE("(%p,%p,%p)\n",lpGUID,ippDS,pUnkOuter);
2968 else
2969 TRACE("DirectSoundCreate (%p)\n", ippDS);
2970
2971 if (ippDS == NULL)
2972 return DSERR_INVALIDPARAM;
2973
2974 if (primarybuf) {
2975 IDirectSound_AddRef((LPDIRECTSOUND)dsound);
2976 *ippDS = dsound;
2977 return DS_OK;
2978 }
2979
2980 /* Enumerate WINMM audio devices and find the one we want */
2981 wodn = waveOutGetNumDevs();
2982 if (!wodn) return DSERR_NODRIVER;
2983
2984 /* FIXME: How do we find the GUID of an audio device? */
2985 /* Well, just use the first available device for now... */
2986 wod = 0;
2987 /* Get output device caps */
2988 waveOutGetDevCapsA(wod, &wcaps, sizeof(wcaps));
2989 /* 0x810 is a "Wine extension" to get the DSound interface */
2990 waveOutMessage(wod, 0x810, (DWORD)&drv, 0);
2991
2992 /* Allocate memory */
2993 *ippDS = (IDirectSoundImpl*)HeapAlloc(GetProcessHeap(),0,sizeof(IDirectSoundImpl));
2994 if (*ippDS == NULL)
2995 return DSERR_OUTOFMEMORY;
2996
2997 ICOM_VTBL(*ippDS) = &dsvt;
2998 (*ippDS)->ref = 1;
2999
3000 (*ippDS)->driver = drv;
3001 (*ippDS)->fraglen = 0;
3002 (*ippDS)->priolevel = DSSCL_NORMAL;
3003 (*ippDS)->nrofbuffers = 0;
3004 (*ippDS)->buffers = NULL;
3005 (*ippDS)->primary = NULL;
3006 (*ippDS)->listener = NULL;
3007
3008 /* Get driver description */
3009 if (drv) {
3010 IDsDriver_GetDriverDesc(drv,&((*ippDS)->drvdesc));
3011 } else {
3012 /* if no DirectSound interface available, use WINMM API instead */
3013 (*ippDS)->drvdesc.dwFlags = DSDDESC_DOMMSYSTEMOPEN | DSDDESC_DOMMSYSTEMSETFORMAT;
3014 (*ippDS)->drvdesc.dnDevNode = wod; /* FIXME? */
3015 }
3016
3017 /* Set default wave format (may need it for waveOutOpen) */
3018 (*ippDS)->wfx.wFormatTag = WAVE_FORMAT_PCM;
3019 (*ippDS)->wfx.nChannels = 2;
3020 (*ippDS)->wfx.nSamplesPerSec = 22050;
3021 (*ippDS)->wfx.nAvgBytesPerSec = 44100;
3022 (*ippDS)->wfx.nBlockAlign = 2;
3023 (*ippDS)->wfx.wBitsPerSample = 8;
3024
3025 /* If the driver requests being opened through MMSYSTEM
3026 * (which is recommended by the DDK), it is supposed to happen
3027 * before the DirectSound interface is opened */
3028 if ((*ippDS)->drvdesc.dwFlags & DSDDESC_DOMMSYSTEMOPEN) {
3029 /* FIXME: is this right? */
3030 err = mmErr(waveOutOpen(&((*ippDS)->hwo), (*ippDS)->drvdesc.dnDevNode, &((*ippDS)->wfx),
3031 0, 0, CALLBACK_NULL | WAVE_DIRECTSOUND));
3032 }
3033
3034 if (drv && (err == DS_OK))
3035 err = IDsDriver_Open(drv);
3036
3037 /* FIXME: do we want to handle a temporarily busy device? */
3038 if (err != DS_OK) {
3039 HeapFree(GetProcessHeap(),0,*ippDS);
3040 *ippDS = NULL;
3041 return err;
3042 }
3043
3044 /* the driver is now open, so it's now allowed to call GetCaps */
3045 if (drv) {
3046 IDsDriver_GetCaps(drv,&((*ippDS)->drvcaps));
3047 } else {
3048 unsigned c;
3049
3050 /* FIXME: look at wcaps */
3051 (*ippDS)->drvcaps.dwFlags = DSCAPS_EMULDRIVER |
3052 DSCAPS_PRIMARY16BIT | DSCAPS_PRIMARYSTEREO;
3053
3054 /* Allocate memory for HEL buffer headers */
3055 for (c=0; c<DS_HEL_FRAGS; c++) {
3056 (*ippDS)->pwave[c] = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(WAVEHDR));
3057 if (!(*ippDS)->pwave[c]) {
3058 /* Argh, out of memory */
3059 while (c--) {
3060 HeapFree(GetProcessHeap(),0,(*ippDS)->pwave[c]);
3061 waveOutClose((*ippDS)->hwo);
3062 HeapFree(GetProcessHeap(),0,*ippDS);
3063 *ippDS = NULL;
3064 return DSERR_OUTOFMEMORY;
3065 }
3066 }
3067 }
3068 }
3069
3070 InitializeCriticalSection(&((*ippDS)->lock));
3071
3072 if (!dsound) {
3073 dsound = (*ippDS);
3074 if (primarybuf == NULL) {
3075 DSBUFFERDESC dsbd;
3076 HRESULT hr;
3077
3078 dsbd.dwSize = sizeof(DSBUFFERDESC);
3079 dsbd.dwFlags = DSBCAPS_PRIMARYBUFFER | DSBCAPS_GETCURRENTPOSITION2;
3080 dsbd.dwBufferBytes = 0;
3081 dsbd.lpwfxFormat = &(dsound->wfx);
3082 hr = IDirectSound_CreateSoundBuffer(*ppDS, &dsbd, (LPDIRECTSOUNDBUFFER*)&primarybuf, NULL);
3083 if (hr != DS_OK)
3084 return hr;
3085
3086 /* dsound->primary is NULL - don't need to Release */
3087 dsound->primary = primarybuf;
3088 IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER)primarybuf);
3089 }
3090 timeBeginPeriod(DS_TIME_RES);
3091 dsound->timerID = timeSetEvent(DS_TIME_DEL, DS_TIME_RES, DSOUND_timer,
3092 (DWORD)dsound, TIME_PERIODIC | TIME_CALLBACK_FUNCTION);
3093 }
3094 return DS_OK;
3095 }
3096
3097 /***************************************************************************
3098 * DirectSoundCaptureCreate [DSOUND.6]
3099 *
3100 * Create and initialize a DirectSoundCapture interface
3101 *
3102 * RETURNS
3103 * Success: DS_OK
3104 * Failure: DSERR_NOAGGREGATION, DSERR_ALLOCATED, DSERR_INVALIDPARAM,
3105 * DSERR_OUTOFMEMORY
3106 */
3107 HRESULT WINAPI DirectSoundCaptureCreate(
3108 LPCGUID lpcGUID,
3109 LPDIRECTSOUNDCAPTURE* lplpDSC,
3110 LPUNKNOWN pUnkOuter )
3111 {
3112 TRACE("(%s,%p,%p)\n", debugstr_guid(lpcGUID), lplpDSC, pUnkOuter);
3113
3114 if( pUnkOuter ) {
3115 return DSERR_NOAGGREGATION;
3116 }
3117
3118 /* Default device? */
3119 if ( !lpcGUID ) {
3120 return DSOUND_CreateDirectSoundCapture( (LPVOID*)lplpDSC );
3121 }
3122
3123 FIXME( "Unknown GUID %s\n", debugstr_guid(lpcGUID) );
3124 *lplpDSC = NULL;
3125
3126 return DSERR_OUTOFMEMORY;
3127 }
3128
3129 /***************************************************************************
3130 * DirectSoundCaptureEnumerateA [DSOUND.7]
3131 *
3132 * Enumerate all DirectSound drivers installed in the system
3133 *
3134 * RETURNS
3135 * Success: DS_OK
3136 * Failure: DSERR_INVALIDPARAM
3137 */
3138 HRESULT WINAPI DirectSoundCaptureEnumerateA(
3139 LPDSENUMCALLBACKA lpDSEnumCallback,
3140 LPVOID lpContext)
3141 {
3142 TRACE("(%p,%p)\n", lpDSEnumCallback, lpContext );
3143
3144 if ( lpDSEnumCallback )
3145 lpDSEnumCallback(NULL,"WINE Primary Sound Capture Driver",
3146 "SoundCap",lpContext);
3147
3148
3149 return DS_OK;
3150 }
3151
3152 /***************************************************************************
3153 * DirectSoundCaptureEnumerateW [DSOUND.8]
3154 *
3155 * Enumerate all DirectSound drivers installed in the system
3156 *
3157 * RETURNS
3158 * Success: DS_OK
3159 * Failure: DSERR_INVALIDPARAM
3160 */
3161 HRESULT WINAPI DirectSoundCaptureEnumerateW(
3162 LPDSENUMCALLBACKW lpDSEnumCallback,
3163 LPVOID lpContext)
3164 {
3165 FIXME("(%p,%p):stub\n", lpDSEnumCallback, lpContext );
3166 return DS_OK;
3167 }
3168
3169 static HRESULT
3170 DSOUND_CreateDirectSoundCapture( LPVOID* ppobj )
3171 {
3172 *ppobj = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof( IDirectSoundCaptureImpl ) );
3173
3174 if ( *ppobj == NULL ) {
3175 return DSERR_OUTOFMEMORY;
3176 }
3177
3178 {
3179 ICOM_THIS(IDirectSoundCaptureImpl,*ppobj);
3180
3181 This->ref = 1;
3182 ICOM_VTBL(This) = &dscvt;
3183
3184 InitializeCriticalSection( &This->lock );
3185 }
3186
3187 return S_OK;
3188 }
3189
3190 static HRESULT WINAPI
3191 IDirectSoundCaptureImpl_QueryInterface(
3192 LPDIRECTSOUNDCAPTURE iface,
3193 REFIID riid,
3194 LPVOID* ppobj )
3195 {
3196 ICOM_THIS(IDirectSoundCaptureImpl,iface);
3197
3198 FIXME( "(%p)->(%s,%p): stub\n", This, debugstr_guid(riid), ppobj );
3199
3200 return E_FAIL;
3201 }
3202
3203 static ULONG WINAPI
3204 IDirectSoundCaptureImpl_AddRef( LPDIRECTSOUNDCAPTURE iface )
3205 {
3206 ULONG uRef;
3207 ICOM_THIS(IDirectSoundCaptureImpl,iface);
3208
3209 EnterCriticalSection( &This->lock );
3210
3211 TRACE( "(%p) was 0x%08lx\n", This, This->ref );
3212 uRef = ++(This->ref);
3213
3214 LeaveCriticalSection( &This->lock );
3215
3216 return uRef;
3217 }
3218
3219 static ULONG WINAPI
3220 IDirectSoundCaptureImpl_Release( LPDIRECTSOUNDCAPTURE iface )
3221 {
3222 ULONG uRef;
3223 ICOM_THIS(IDirectSoundCaptureImpl,iface);
3224
3225 EnterCriticalSection( &This->lock );
3226
3227 TRACE( "(%p) was 0x%08lx\n", This, This->ref );
3228 uRef = --(This->ref);
3229
3230 LeaveCriticalSection( &This->lock );
3231
3232 if ( uRef == 0 ) {
3233 DeleteCriticalSection( &This->lock );
3234 HeapFree( GetProcessHeap(), 0, This );
3235 }
3236
3237 return uRef;
3238 }
3239
3240 static HRESULT WINAPI
3241 IDirectSoundCaptureImpl_CreateCaptureBuffer(
3242 LPDIRECTSOUNDCAPTURE iface,
3243 LPCDSCBUFFERDESC lpcDSCBufferDesc,
3244 LPDIRECTSOUNDCAPTUREBUFFER* lplpDSCaptureBuffer,
3245 LPUNKNOWN pUnk )
3246 {
3247 HRESULT hr;
3248 ICOM_THIS(IDirectSoundCaptureImpl,iface);
3249
3250 TRACE( "(%p)->(%p,%p,%p)\n", This, lpcDSCBufferDesc, lplpDSCaptureBuffer, pUnk );
3251
3252 if ( pUnk ) {
3253 return DSERR_INVALIDPARAM;
3254 }
3255
3256 hr = DSOUND_CreateDirectSoundCaptureBuffer( lpcDSCBufferDesc, (LPVOID*)lplpDSCaptureBuffer );
3257
3258 return hr;
3259 }
3260
3261 static HRESULT WINAPI
3262 IDirectSoundCaptureImpl_GetCaps(
3263 LPDIRECTSOUNDCAPTURE iface,
3264 LPDSCCAPS lpDSCCaps )
3265 {
3266 ICOM_THIS(IDirectSoundCaptureImpl,iface);
3267
3268 FIXME( "(%p)->(%p): stub\n", This, lpDSCCaps );
3269
3270 return DS_OK;
3271 }
3272
3273 static HRESULT WINAPI
3274 IDirectSoundCaptureImpl_Initialize(
3275 LPDIRECTSOUNDCAPTURE iface,
3276 LPCGUID lpcGUID )
3277 {
3278 ICOM_THIS(IDirectSoundCaptureImpl,iface);
3279
3280 FIXME( "(%p)->(%p): stub\n", This, lpcGUID );
3281
3282 return DS_OK;
3283 }
3284
3285
3286 static ICOM_VTABLE(IDirectSoundCapture) dscvt =
3287 {
3288 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
3289 /* IUnknown methods */
3290 IDirectSoundCaptureImpl_QueryInterface,
3291 IDirectSoundCaptureImpl_AddRef,
3292 IDirectSoundCaptureImpl_Release,
3293
3294 /* IDirectSoundCapture methods */
3295 IDirectSoundCaptureImpl_CreateCaptureBuffer,
3296 IDirectSoundCaptureImpl_GetCaps,
3297 IDirectSoundCaptureImpl_Initialize
3298 };
3299
3300 static HRESULT
3301 DSOUND_CreateDirectSoundCaptureBuffer( LPCDSCBUFFERDESC lpcDSCBufferDesc, LPVOID* ppobj )
3302 {
3303
3304 FIXME( "(%p,%p): ignoring lpcDSCBufferDesc\n", lpcDSCBufferDesc, ppobj );
3305
3306 *ppobj = HeapAlloc( GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof( IDirectSoundCaptureBufferImpl ) );
3307
3308 if ( *ppobj == NULL ) {
3309 return DSERR_OUTOFMEMORY;
3310 }
3311
3312 {
3313 ICOM_THIS(IDirectSoundCaptureBufferImpl,*ppobj);
3314
3315 This->ref = 1;
3316 ICOM_VTBL(This) = &dscbvt;
3317
3318 InitializeCriticalSection( &This->lock );
3319 }
3320
3321 return S_OK;
3322 }
3323
3324
3325 static HRESULT WINAPI
3326 IDirectSoundCaptureBufferImpl_QueryInterface(
3327 LPDIRECTSOUNDCAPTUREBUFFER iface,
3328 REFIID riid,
3329 LPVOID* ppobj )
3330 {
3331 ICOM_THIS(IDirectSoundCaptureBufferImpl,iface);
3332
3333 FIXME( "(%p)->(%s,%p): stub\n", This, debugstr_guid(riid), ppobj );
3334
3335 return E_FAIL;
3336 }
3337
3338 static ULONG WINAPI
3339 IDirectSoundCaptureBufferImpl_AddRef( LPDIRECTSOUNDCAPTUREBUFFER iface )
3340 {
3341 ULONG uRef;
3342 ICOM_THIS(IDirectSoundCaptureBufferImpl,iface);
3343
3344 EnterCriticalSection( &This->lock );
3345
3346 TRACE( "(%p) was 0x%08lx\n", This, This->ref );
3347 uRef = ++(This->ref);
3348
3349 LeaveCriticalSection( &This->lock );
3350
3351 return uRef;
3352 }
3353
3354 static ULONG WINAPI
3355 IDirectSoundCaptureBufferImpl_Release( LPDIRECTSOUNDCAPTUREBUFFER iface )
3356 {
3357 ULONG uRef;
3358 ICOM_THIS(IDirectSoundCaptureBufferImpl,iface);
3359
3360 EnterCriticalSection( &This->lock );
3361
3362 TRACE( "(%p) was 0x%08lx\n", This, This->ref );
3363 uRef = --(This->ref);
3364
3365 LeaveCriticalSection( &This->lock );
3366
3367 if ( uRef == 0 ) {
3368 DeleteCriticalSection( &This->lock );
3369 HeapFree( GetProcessHeap(), 0, This );
3370 }
3371
3372 return uRef;
3373 }
3374
3375 static HRESULT WINAPI
3376 IDirectSoundCaptureBufferImpl_GetCaps(
3377 LPDIRECTSOUNDCAPTUREBUFFER iface,
3378 LPDSCBCAPS lpDSCBCaps )
3379 {
3380 ICOM_THIS(IDirectSoundCaptureBufferImpl,iface);
3381
3382 FIXME( "(%p)->(%p): stub\n", This, lpDSCBCaps );
3383
3384 return DS_OK;
3385 }
3386
3387 static HRESULT WINAPI
3388 IDirectSoundCaptureBufferImpl_GetCurrentPosition(
3389 LPDIRECTSOUNDCAPTUREBUFFER iface,
3390 LPDWORD lpdwCapturePosition,
3391 LPDWORD lpdwReadPosition )
3392 {
3393 ICOM_THIS(IDirectSoundCaptureBufferImpl,iface);
3394
3395 FIXME( "(%p)->(%p,%p): stub\n", This, lpdwCapturePosition, lpdwReadPosition );
3396
3397 return DS_OK;
3398 }
3399
3400 static HRESULT WINAPI
3401 IDirectSoundCaptureBufferImpl_GetFormat(
3402 LPDIRECTSOUNDCAPTUREBUFFER iface,
3403 LPWAVEFORMATEX lpwfxFormat,
3404 DWORD dwSizeAllocated,
3405 LPDWORD lpdwSizeWritten )
3406 {
3407 ICOM_THIS(IDirectSoundCaptureBufferImpl,iface);
3408
3409 FIXME( "(%p)->(%p,0x%08lx,%p): stub\n", This, lpwfxFormat, dwSizeAllocated, lpdwSizeWritten );
3410
3411 return DS_OK;
3412 }
3413
3414 static HRESULT WINAPI
3415 IDirectSoundCaptureBufferImpl_GetStatus(
3416 LPDIRECTSOUNDCAPTUREBUFFER iface,
3417 LPDWORD lpdwStatus )
3418 {
3419 ICOM_THIS(IDirectSoundCaptureBufferImpl,iface);
3420
3421 FIXME( "(%p)->(%p): stub\n", This, lpdwStatus );
3422
3423 return DS_OK;
3424 }
3425
3426 static HRESULT WINAPI
3427 IDirectSoundCaptureBufferImpl_Initialize(
3428 LPDIRECTSOUNDCAPTUREBUFFER iface,
3429 LPDIRECTSOUNDCAPTURE lpDSC,
3430 LPCDSCBUFFERDESC lpcDSCBDesc )
3431 {
3432 ICOM_THIS(IDirectSoundCaptureBufferImpl,iface);
3433
3434 FIXME( "(%p)->(%p,%p): stub\n", This, lpDSC, lpcDSCBDesc );
3435
3436 return DS_OK;
3437 }
3438
3439 static HRESULT WINAPI
3440 IDirectSoundCaptureBufferImpl_Lock(
3441 LPDIRECTSOUNDCAPTUREBUFFER iface,
3442 DWORD dwReadCusor,
3443 DWORD dwReadBytes,
3444 LPVOID* lplpvAudioPtr1,
3445 LPDWORD lpdwAudioBytes1,
3446 LPVOID* lplpvAudioPtr2,
3447 LPDWORD lpdwAudioBytes2,
3448 DWORD dwFlags )
3449 {
3450 ICOM_THIS(IDirectSoundCaptureBufferImpl,iface);
3451
3452 FIXME( "(%p)->(%08lu,%08lu,%p,%p,%p,%p,0x%08lx): stub\n", This, dwReadCusor, dwReadBytes, lplpvAudioPtr1, lpdwAudioBytes1, lplpvAudioPtr2, lpdwAudioBytes2, dwFlags );
3453
3454 return DS_OK;
3455 }
3456
3457 static HRESULT WINAPI
3458 IDirectSoundCaptureBufferImpl_Start(
3459 LPDIRECTSOUNDCAPTUREBUFFER iface,
3460 DWORD dwFlags )
3461 {
3462 ICOM_THIS(IDirectSoundCaptureBufferImpl,iface);
3463
3464 FIXME( "(%p)->(0x%08lx): stub\n", This, dwFlags );
3465
3466 return DS_OK;
3467 }
3468
3469 static HRESULT WINAPI
3470 IDirectSoundCaptureBufferImpl_Stop( LPDIRECTSOUNDCAPTUREBUFFER iface )
3471 {
3472 ICOM_THIS(IDirectSoundCaptureBufferImpl,iface);
3473
3474 FIXME( "(%p): stub\n", This );
3475
3476 return DS_OK;
3477 }
3478
3479 static HRESULT WINAPI
3480 IDirectSoundCaptureBufferImpl_Unlock(
3481 LPDIRECTSOUNDCAPTUREBUFFER iface,
3482 LPVOID lpvAudioPtr1,
3483 DWORD dwAudioBytes1,
3484 LPVOID lpvAudioPtr2,
3485 DWORD dwAudioBytes2 )
3486 {
3487 ICOM_THIS(IDirectSoundCaptureBufferImpl,iface);
3488
3489 FIXME( "(%p)->(%p,%08lu,%p,%08lu): stub\n", This, lpvAudioPtr1, dwAudioBytes1, lpvAudioPtr2, dwAudioBytes2 );
3490
3491 return DS_OK;
3492 }
3493
3494
3495 static ICOM_VTABLE(IDirectSoundCaptureBuffer) dscbvt =
3496 {
3497 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
3498 /* IUnknown methods */
3499 IDirectSoundCaptureBufferImpl_QueryInterface,
3500 IDirectSoundCaptureBufferImpl_AddRef,
3501 IDirectSoundCaptureBufferImpl_Release,
3502
3503 /* IDirectSoundCaptureBuffer methods */
3504 IDirectSoundCaptureBufferImpl_GetCaps,
3505 IDirectSoundCaptureBufferImpl_GetCurrentPosition,
3506 IDirectSoundCaptureBufferImpl_GetFormat,
3507 IDirectSoundCaptureBufferImpl_GetStatus,
3508 IDirectSoundCaptureBufferImpl_Initialize,
3509 IDirectSoundCaptureBufferImpl_Lock,
3510 IDirectSoundCaptureBufferImpl_Start,
3511 IDirectSoundCaptureBufferImpl_Stop,
3512 IDirectSoundCaptureBufferImpl_Unlock
3513 };
3514
3515 /*******************************************************************************
3516 * DirectSound ClassFactory
3517 */
3518 typedef struct
3519 {
3520 /* IUnknown fields */
3521 ICOM_VFIELD(IClassFactory);
3522 DWORD ref;
3523 } IClassFactoryImpl;
3524
3525 static HRESULT WINAPI
3526 DSCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
3527 ICOM_THIS(IClassFactoryImpl,iface);
3528
3529 FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
3530 return E_NOINTERFACE;
3531 }
3532
3533 static ULONG WINAPI
3534 DSCF_AddRef(LPCLASSFACTORY iface) {
3535 ICOM_THIS(IClassFactoryImpl,iface);
3536 return ++(This->ref);
3537 }
3538
3539 static ULONG WINAPI DSCF_Release(LPCLASSFACTORY iface) {
3540 ICOM_THIS(IClassFactoryImpl,iface);
3541 /* static class, won't be freed */
3542 return --(This->ref);
3543 }
3544
3545 static HRESULT WINAPI DSCF_CreateInstance(
3546 LPCLASSFACTORY iface,LPUNKNOWN pOuter,REFIID riid,LPVOID *ppobj
3547 ) {
3548 ICOM_THIS(IClassFactoryImpl,iface);
3549
3550 TRACE("(%p)->(%p,%s,%p)\n",This,pOuter,debugstr_guid(riid),ppobj);
3551 if ( IsEqualGUID( &IID_IDirectSound, riid ) ) {
3552 /* FIXME: reuse already created dsound if present? */
3553 return DirectSoundCreate(riid,(LPDIRECTSOUND*)ppobj,pOuter);
3554 }
3555 return E_NOINTERFACE;
3556 }
3557
3558 static HRESULT WINAPI DSCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
3559 ICOM_THIS(IClassFactoryImpl,iface);
3560 FIXME("(%p)->(%d),stub!\n",This,dolock);
3561 return S_OK;
3562 }
3563
3564 static ICOM_VTABLE(IClassFactory) DSCF_Vtbl = {
3565 ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
3566 DSCF_QueryInterface,
3567 DSCF_AddRef,
3568 DSCF_Release,
3569 DSCF_CreateInstance,
3570 DSCF_LockServer
3571 };
3572 static IClassFactoryImpl DSOUND_CF = {&DSCF_Vtbl, 1 };
3573
3574 /*******************************************************************************
3575 * DllGetClassObject [DSOUND.4]
3576 * Retrieves class object from a DLL object
3577 *
3578 * NOTES
3579 * Docs say returns STDAPI
3580 *
3581 * PARAMS
3582 * rclsid [I] CLSID for the class object
3583 * riid [I] Reference to identifier of interface for class object
3584 * ppv [O] Address of variable to receive interface pointer for riid
3585 *
3586 * RETURNS
3587 * Success: S_OK
3588 * Failure: CLASS_E_CLASSNOTAVAILABLE, E_OUTOFMEMORY, E_INVALIDARG,
3589 * E_UNEXPECTED
3590 */
3591 DWORD WINAPI DSOUND_DllGetClassObject(REFCLSID rclsid,REFIID riid,LPVOID *ppv)
3592 {
3593 TRACE("(%p,%p,%p)\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
3594 if ( IsEqualCLSID( &IID_IClassFactory, riid ) ) {
3595 *ppv = (LPVOID)&DSOUND_CF;
3596 IClassFactory_AddRef((IClassFactory*)*ppv);
3597 return S_OK;
3598 }
3599
3600 FIXME("(%p,%p,%p): no interface found.\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
3601 return CLASS_E_CLASSNOTAVAILABLE;
3602 }
3603
3604
3605 /*******************************************************************************
3606 * DllCanUnloadNow [DSOUND.3] Determines whether the DLL is in use.
3607 *
3608 * RETURNS
3609 * Success: S_OK
3610 * Failure: S_FALSE
3611 */
3612 DWORD WINAPI DSOUND_DllCanUnloadNow(void)
3613 {
3614 FIXME("(void): stub\n");
3615 return S_FALSE;
3616 }
widl and rpcrt4 development