?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Desktop window queue handling adapted.
[wine/multimedia.git] / multimedia / dsound.c
blob36245fd0803a7a024e1f0256f4eb69d5f0af63c4
1 /* DirectSound
2 *
3 * Copyright 1998 Marcus Meissner
4 * Copyright 1998 Rob Riggs
5 */
6 /*
7 * Note: This file requires multithread ability. It is not possible to
8 * implement the stuff in a single thread anyway. And most DirectX apps
9 * require threading themselves.
10 *
11 * FIXME: This file is full of race conditions and unlocked variable access
12 * from two threads. But we usually don't need to bother.
13 *
14 * Tested with a Soundblaster clone and a Gravis UltraSound Classic.
15 *
16 * Status:
17 * - Wing Commander 4/W95:
18 * The intromovie plays without problems. Nearly lipsynchron.
19 * - DiscWorld 2
20 * The sound works, but noticeable chunks are left out (from the sound and
21 * the animation). Don't know why yet.
22 * - Diablo:
23 * Sound works, but slows down the movieplayer.
24 * - XvT:
25 * Doesn't sound yet.
26 * - Monkey Island 3:
27 * The background sound of the startscreen works ;)
28 * - WingCommander Prophecy Demo:
29 * Sound works for the intromovie.
30 */
31
32 #include "config.h"
33 #include <assert.h>
34 #include <errno.h>
35 #include <sys/types.h>
36 #include <sys/time.h>
37 #include <sys/fcntl.h>
38 #include <unistd.h>
39 #include <stdlib.h>
40 #include <string.h>
41 #include <math.h> /* Insomnia - pow() function */
42 #include "windows.h"
43 #include "winerror.h"
44 #include "interfaces.h"
45 #include "multimedia.h"
46 #include "dsound.h"
47 #include "thread.h"
48 #include "debug.h"
49 #include "xmalloc.h"
50
51 #ifdef HAVE_OSS
52
53 #include <sys/ioctl.h>
54
55 /* #define USE_DSOUND3D 1 */
56
57 #define DSOUND_FRAGLEN (primarybuf->wfx.nAvgBytesPerSec >> 4)
58 #define DSOUND_FREQSHIFT (14)
59
60 static int audiofd = -1;
61 static int audioOK = 0;
62
63 static LPDIRECTSOUND dsound = NULL;
64
65 static LPDIRECTSOUNDBUFFER primarybuf = NULL;
66
67 static int DSOUND_setformat(LPWAVEFORMATEX wfex);
68 static void DSOUND_CheckEvent(IDirectSoundBuffer *dsb, int len);
69 static void DSOUND_CloseAudio(void);
70
71 #endif
72
73 HRESULT WINAPI DirectSoundEnumerate32A(LPDSENUMCALLBACK32A enumcb,LPVOID context) {
74 #ifdef HAVE_OSS
75 enumcb(NULL,"WINE DirectSound using Open Sound System","sound",context);
76 #endif
77 return 0;
78 }
79
80 #ifdef HAVE_OSS
81 static void _dump_DSBCAPS(DWORD xmask) {
82 struct {
83 DWORD mask;
84 char *name;
85 } flags[] = {
86 #define FE(x) { x, #x },
87 FE(DSBCAPS_PRIMARYBUFFER)
88 FE(DSBCAPS_STATIC)
89 FE(DSBCAPS_LOCHARDWARE)
90 FE(DSBCAPS_LOCSOFTWARE)
91 FE(DSBCAPS_CTRLFREQUENCY)
92 FE(DSBCAPS_CTRLPAN)
93 FE(DSBCAPS_CTRLVOLUME)
94 FE(DSBCAPS_CTRLDEFAULT)
95 FE(DSBCAPS_CTRLALL)
96 FE(DSBCAPS_STICKYFOCUS)
97 FE(DSBCAPS_GETCURRENTPOSITION2)
98 };
99 int i;
100
101 for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
102 if (flags[i].mask & xmask)
103 fprintf(stderr,"%s ",flags[i].name);
104 }
105
106 /*******************************************************************************
107 * IDirectSound3DBuffer
108 */
109
110 // IUnknown methods
111 static HRESULT WINAPI IDirectSound3DBuffer_QueryInterface(
112 LPDIRECTSOUND3DBUFFER this, REFIID riid, LPVOID *ppobj)
113 {
114 char xbuf[50];
115
116 WINE_StringFromCLSID(riid,xbuf);
117 TRACE(dsound,"(%p,%s,%p)\n",this,xbuf,ppobj);
118 return E_FAIL;
119 }
120
121 static ULONG WINAPI IDirectSound3DBuffer_AddRef(LPDIRECTSOUND3DBUFFER this)
122 {
123 this->ref++;
124 return this->ref;
125 }
126
127 static ULONG WINAPI IDirectSound3DBuffer_Release(LPDIRECTSOUND3DBUFFER this)
128 {
129 if(--this->ref)
130 return this->ref;
131
132 HeapFree(GetProcessHeap(),0,this->buffer);
133 HeapFree(GetProcessHeap(),0,this);
134
135 return 0;
136 }
137
138 // IDirectSound3DBuffer methods
139 static HRESULT WINAPI IDirectSound3DBuffer_GetAllParameters(
140 LPDIRECTSOUND3DBUFFER this,
141 LPDS3DBUFFER lpDs3dBuffer)
142 {
143 FIXME(dsound,"stub\n");
144 return DS_OK;
145 }
146
147 static HRESULT WINAPI IDirectSound3DBuffer_GetConeAngles(
148 LPDIRECTSOUND3DBUFFER this,
149 LPDWORD lpdwInsideConeAngle,
150 LPDWORD lpdwOutsideConeAngle)
151 {
152 FIXME(dsound,"stub\n");
153 return DS_OK;
154 }
155
156 static HRESULT WINAPI IDirectSound3DBuffer_GetConeOrientation(
157 LPDIRECTSOUND3DBUFFER this,
158 LPD3DVECTOR lpvConeOrientation)
159 {
160 FIXME(dsound,"stub\n");
161 return DS_OK;
162 }
163
164 static HRESULT WINAPI IDirectSound3DBuffer_GetConeOutsideVolume(
165 LPDIRECTSOUND3DBUFFER this,
166 LPLONG lplConeOutsideVolume)
167 {
168 FIXME(dsound,"stub\n");
169 return DS_OK;
170 }
171
172 static HRESULT WINAPI IDirectSound3DBuffer_GetMaxDistance(
173 LPDIRECTSOUND3DBUFFER this,
174 LPD3DVALUE lpfMaxDistance)
175 {
176 FIXME(dsound,"stub\n");
177 return DS_OK;
178 }
179
180 static HRESULT WINAPI IDirectSound3DBuffer_GetMinDistance(
181 LPDIRECTSOUND3DBUFFER this,
182 LPD3DVALUE lpfMinDistance)
183 {
184 FIXME(dsound,"stub\n");
185 return DS_OK;
186 }
187
188 static HRESULT WINAPI IDirectSound3DBuffer_GetMode(
189 LPDIRECTSOUND3DBUFFER this,
190 LPDWORD lpdwMode)
191 {
192 FIXME(dsound,"stub\n");
193 return DS_OK;
194 }
195
196 static HRESULT WINAPI IDirectSound3DBuffer_GetPosition(
197 LPDIRECTSOUND3DBUFFER this,
198 LPD3DVECTOR lpvPosition)
199 {
200 FIXME(dsound,"stub\n");
201 return DS_OK;
202 }
203
204 static HRESULT WINAPI IDirectSound3DBuffer_GetVelocity(
205 LPDIRECTSOUND3DBUFFER this,
206 LPD3DVECTOR lpvVelocity)
207 {
208 FIXME(dsound,"stub\n");
209 return DS_OK;
210 }
211
212 static HRESULT WINAPI IDirectSound3DBuffer_SetAllParameters(
213 LPDIRECTSOUND3DBUFFER this,
214 LPCDS3DBUFFER lpcDs3dBuffer,
215 DWORD dwApply)
216 {
217 FIXME(dsound,"stub\n");
218 return DS_OK;
219 }
220
221 static HRESULT WINAPI IDirectSound3DBuffer_SetConeAngles(
222 LPDIRECTSOUND3DBUFFER this,
223 DWORD dwInsideConeAngle,
224 DWORD dwOutsideConeAngle,
225 DWORD dwApply)
226 {
227 FIXME(dsound,"stub\n");
228 return DS_OK;
229 }
230
231 static HRESULT WINAPI IDirectSound3DBuffer_SetConeOrientation(
232 LPDIRECTSOUND3DBUFFER this,
233 D3DVALUE x, D3DVALUE y, D3DVALUE z,
234 DWORD dwApply)
235 {
236 FIXME(dsound,"stub\n");
237 return DS_OK;
238 }
239
240 static HRESULT WINAPI IDirectSound3DBuffer_SetConeOutsideVolume(
241 LPDIRECTSOUND3DBUFFER this,
242 LONG lConeOutsideVolume,
243 DWORD dwApply)
244 {
245 FIXME(dsound,"stub\n");
246 return DS_OK;
247 }
248
249 static HRESULT WINAPI IDirectSound3DBuffer_SetMaxDistance(
250 LPDIRECTSOUND3DBUFFER this,
251 D3DVALUE fMaxDistance,
252 DWORD dwApply)
253 {
254 FIXME(dsound,"stub\n");
255 return DS_OK;
256 }
257
258 static HRESULT WINAPI IDirectSound3DBuffer_SetMinDistance(
259 LPDIRECTSOUND3DBUFFER this,
260 D3DVALUE fMinDistance,
261 DWORD dwApply)
262 {
263 FIXME(dsound,"stub\n");
264 return DS_OK;
265 }
266
267 static HRESULT WINAPI IDirectSound3DBuffer_SetMode(
268 LPDIRECTSOUND3DBUFFER this,
269 DWORD dwMode,
270 DWORD dwApply)
271 {
272 TRACE(dsound, "mode = %lx\n", dwMode);
273 this->ds3db.dwMode = dwMode;
274 return DS_OK;
275 }
276
277 static HRESULT WINAPI IDirectSound3DBuffer_SetPosition(
278 LPDIRECTSOUND3DBUFFER this,
279 D3DVALUE x, D3DVALUE y, D3DVALUE z,
280 DWORD dwApply)
281 {
282 FIXME(dsound,"stub\n");
283 return DS_OK;
284 }
285
286 static HRESULT WINAPI IDirectSound3DBuffer_SetVelocity(
287 LPDIRECTSOUND3DBUFFER this,
288 D3DVALUE x, D3DVALUE y, D3DVALUE z,
289 DWORD dwApply)
290 {
291 FIXME(dsound,"stub\n");
292 return DS_OK;
293 }
294
295 IDirectSound3DBuffer_VTable ds3dbvt = {
296 // IUnknown methods
297 IDirectSound3DBuffer_QueryInterface,
298 IDirectSound3DBuffer_AddRef,
299 IDirectSound3DBuffer_Release,
300 // IDirectSound3DBuffer methods
301 IDirectSound3DBuffer_GetAllParameters,
302 IDirectSound3DBuffer_GetConeAngles,
303 IDirectSound3DBuffer_GetConeOrientation,
304 IDirectSound3DBuffer_GetConeOutsideVolume,
305 IDirectSound3DBuffer_GetMaxDistance,
306 IDirectSound3DBuffer_GetMinDistance,
307 IDirectSound3DBuffer_GetMode,
308 IDirectSound3DBuffer_GetPosition,
309 IDirectSound3DBuffer_GetVelocity,
310 IDirectSound3DBuffer_SetAllParameters,
311 IDirectSound3DBuffer_SetConeAngles,
312 IDirectSound3DBuffer_SetConeOrientation,
313 IDirectSound3DBuffer_SetConeOutsideVolume,
314 IDirectSound3DBuffer_SetMaxDistance,
315 IDirectSound3DBuffer_SetMinDistance,
316 IDirectSound3DBuffer_SetMode,
317 IDirectSound3DBuffer_SetPosition,
318 IDirectSound3DBuffer_SetVelocity,
319 };
320
321 #ifdef USE_DSOUND3D
322 static int DSOUND_Create3DBuffer(LPDIRECTSOUNDBUFFER dsb)
323 {
324 DWORD i, temp, iSize, oSize, offset;
325 LPBYTE bIbuf, bObuf, bTbuf = NULL;
326 LPWORD wIbuf, wObuf, wTbuf = NULL;
327
328 // Inside DirectX says it's stupid but allowed
329 if (dsb->wfx.nChannels == 2) {
330 // Convert to mono
331 if (dsb->wfx.wBitsPerSample == 16) {
332 iSize = dsb->buflen / 4;
333 wTbuf = malloc(dsb->buflen / 2);
334 if (wTbuf == NULL)
335 return DSERR_OUTOFMEMORY;
336 for (i = 0; i < iSize; i++)
337 wTbuf[i] = (dsb->buffer[i] + dsb->buffer[(i * 2) + 1]) / 2;
338 wIbuf = wTbuf;
339 } else {
340 iSize = dsb->buflen / 2;
341 bTbuf = malloc(dsb->buflen / 2);
342 if (bTbuf == NULL)
343 return DSERR_OUTOFMEMORY;
344 for (i = 0; i < iSize; i++)
345 bTbuf[i] = (dsb->buffer[i] + dsb->buffer[(i * 2) + 1]) / 2;
346 bIbuf = bTbuf;
347 }
348 } else {
349 if (dsb->wfx.wBitsPerSample == 16) {
350 iSize = dsb->buflen / 2;
351 wIbuf = (LPWORD) dsb->buffer;
352 } else {
353 bIbuf = (LPBYTE) dsb->buffer;
354 iSize = dsb->buflen;
355 }
356 }
357
358 if (primarybuf->wfx.wBitsPerSample == 16) {
359 wObuf = (LPWORD) dsb->ds3db->buffer;
360 oSize = dsb->ds3db->buflen / 2;
361 } else {
362 bObuf = (LPBYTE) dsb->ds3db->buffer;
363 oSize = dsb->ds3db->buflen;
364 }
365
366 offset = primarybuf->wfx.nSamplesPerSec / 100; // 10ms
367 if (primarybuf->wfx.wBitsPerSample == 16 && dsb->wfx.wBitsPerSample == 16)
368 for (i = 0; i < iSize; i++) {
369 temp = wIbuf[i];
370 if (i >= offset)
371 temp += wIbuf[i - offset] >> 9;
372 else
373 temp += wIbuf[i + iSize - offset] >> 9;
374 wObuf[i * 2] = temp;
375 wObuf[(i * 2) + 1] = temp;
376 }
377 else if (primarybuf->wfx.wBitsPerSample == 8 && dsb->wfx.wBitsPerSample == 8)
378 for (i = 0; i < iSize; i++) {
379 temp = bIbuf[i];
380 if (i >= offset)
381 temp += bIbuf[i - offset] >> 5;
382 else
383 temp += bIbuf[i + iSize - offset] >> 5;
384 bObuf[i * 2] = temp;
385 bObuf[(i * 2) + 1] = temp;
386 }
387
388 if (wTbuf)
389 free(wTbuf);
390 if (bTbuf)
391 free(bTbuf);
392
393 return DS_OK;
394 }
395 #endif
396 /*******************************************************************************
397 * IDirectSound3DListener
398 */
399
400 // IUnknown methods
401 static HRESULT WINAPI IDirectSound3DListener_QueryInterface(
402 LPDIRECTSOUND3DLISTENER this, REFIID riid, LPVOID *ppobj)
403 {
404 char xbuf[50];
405
406 WINE_StringFromCLSID(riid,xbuf);
407 TRACE(dsound,"(%p,%s,%p)\n",this,xbuf,ppobj);
408 return E_FAIL;
409 }
410
411 static ULONG WINAPI IDirectSound3DListener_AddRef(LPDIRECTSOUND3DLISTENER this)
412 {
413 this->ref++;
414 return this->ref;
415 }
416
417 static ULONG WINAPI IDirectSound3DListener_Release(LPDIRECTSOUND3DLISTENER this)
418 {
419 this->ref--;
420 return this->ref;
421 }
422
423 // IDirectSound3DListener methods
424 static HRESULT WINAPI IDirectSound3DListener_GetAllParameter(
425 LPDIRECTSOUND3DLISTENER this,
426 LPDS3DLISTENER lpDS3DL)
427 {
428 FIXME(dsound,"stub\n");
429 return DS_OK;
430 }
431
432 static HRESULT WINAPI IDirectSound3DListener_GetDistanceFactor(
433 LPDIRECTSOUND3DLISTENER this,
434 LPD3DVALUE lpfDistanceFactor)
435 {
436 FIXME(dsound,"stub\n");
437 return DS_OK;
438 }
439
440 static HRESULT WINAPI IDirectSound3DListener_GetDopplerFactor(
441 LPDIRECTSOUND3DLISTENER this,
442 LPD3DVALUE lpfDopplerFactor)
443 {
444 FIXME(dsound,"stub\n");
445 return DS_OK;
446 }
447
448 static HRESULT WINAPI IDirectSound3DListener_GetOrientation(
449 LPDIRECTSOUND3DLISTENER this,
450 LPD3DVECTOR lpvOrientFront,
451 LPD3DVECTOR lpvOrientTop)
452 {
453 FIXME(dsound,"stub\n");
454 return DS_OK;
455 }
456
457 static HRESULT WINAPI IDirectSound3DListener_GetPosition(
458 LPDIRECTSOUND3DLISTENER this,
459 LPD3DVECTOR lpvPosition)
460 {
461 FIXME(dsound,"stub\n");
462 return DS_OK;
463 }
464
465 static HRESULT WINAPI IDirectSound3DListener_GetRolloffFactor(
466 LPDIRECTSOUND3DLISTENER this,
467 LPD3DVALUE lpfRolloffFactor)
468 {
469 FIXME(dsound,"stub\n");
470 return DS_OK;
471 }
472
473 static HRESULT WINAPI IDirectSound3DListener_GetVelocity(
474 LPDIRECTSOUND3DLISTENER this,
475 LPD3DVECTOR lpvVelocity)
476 {
477 FIXME(dsound,"stub\n");
478 return DS_OK;
479 }
480
481 static HRESULT WINAPI IDirectSound3DListener_SetAllParameters(
482 LPDIRECTSOUND3DLISTENER this,
483 LPCDS3DLISTENER lpcDS3DL,
484 DWORD dwApply)
485 {
486 FIXME(dsound,"stub\n");
487 return DS_OK;
488 }
489
490 static HRESULT WINAPI IDirectSound3DListener_SetDistanceFactor(
491 LPDIRECTSOUND3DLISTENER this,
492 D3DVALUE fDistanceFactor,
493 DWORD dwApply)
494 {
495 FIXME(dsound,"stub\n");
496 return DS_OK;
497 }
498
499 static HRESULT WINAPI IDirectSound3DListener_SetDopplerFactor(
500 LPDIRECTSOUND3DLISTENER this,
501 D3DVALUE fDopplerFactor,
502 DWORD dwApply)
503 {
504 FIXME(dsound,"stub\n");
505 return DS_OK;
506 }
507
508 static HRESULT WINAPI IDirectSound3DListener_SetOrientation(
509 LPDIRECTSOUND3DLISTENER this,
510 D3DVALUE xFront, D3DVALUE yFront, D3DVALUE zFront,
511 D3DVALUE xTop, D3DVALUE yTop, D3DVALUE zTop,
512 DWORD dwApply)
513 {
514 FIXME(dsound,"stub\n");
515 return DS_OK;
516 }
517
518 static HRESULT WINAPI IDirectSound3DListener_SetPosition(
519 LPDIRECTSOUND3DLISTENER this,
520 D3DVALUE x, D3DVALUE y, D3DVALUE z,
521 DWORD dwApply)
522 {
523 FIXME(dsound,"stub\n");
524 return DS_OK;
525 }
526
527 static HRESULT WINAPI IDirectSound3DListener_SetRolloffFactor(
528 LPDIRECTSOUND3DLISTENER this,
529 D3DVALUE fRolloffFactor,
530 DWORD dwApply)
531 {
532 FIXME(dsound,"stub\n");
533 return DS_OK;
534 }
535
536 static HRESULT WINAPI IDirectSound3DListener_SetVelocity(
537 LPDIRECTSOUND3DLISTENER this,
538 D3DVALUE x, D3DVALUE y, D3DVALUE z,
539 DWORD dwApply)
540 {
541 FIXME(dsound,"stub\n");
542 return DS_OK;
543 }
544
545 static HRESULT WINAPI IDirectSound3DListener_CommitDeferredSettings(
546 LPDIRECTSOUND3DLISTENER this)
547
548 {
549 FIXME(dsound,"stub\n");
550 return DS_OK;
551 }
552
553 IDirectSound3DListener_VTable ds3dlvt = {
554 // IUnknown methods
555 IDirectSound3DListener_QueryInterface,
556 IDirectSound3DListener_AddRef,
557 IDirectSound3DListener_Release,
558 // IDirectSound3DListener methods
559 IDirectSound3DListener_GetAllParameter,
560 IDirectSound3DListener_GetDistanceFactor,
561 IDirectSound3DListener_GetDopplerFactor,
562 IDirectSound3DListener_GetOrientation,
563 IDirectSound3DListener_GetPosition,
564 IDirectSound3DListener_GetRolloffFactor,
565 IDirectSound3DListener_GetVelocity,
566 IDirectSound3DListener_SetAllParameters,
567 IDirectSound3DListener_SetDistanceFactor,
568 IDirectSound3DListener_SetDopplerFactor,
569 IDirectSound3DListener_SetOrientation,
570 IDirectSound3DListener_SetPosition,
571 IDirectSound3DListener_SetRolloffFactor,
572 IDirectSound3DListener_SetVelocity,
573 IDirectSound3DListener_CommitDeferredSettings,
574 };
575
576 /*******************************************************************************
577 * IDirectSoundNotify
578 */
579 static HRESULT WINAPI IDirectSoundNotify_QueryInterface(
580 LPDIRECTSOUNDNOTIFY this,REFIID riid,LPVOID *ppobj
581 ) {
582 char xbuf[50];
583
584 WINE_StringFromCLSID(riid,xbuf);
585 TRACE(dsound,"(%p,%s,%p)\n",this,xbuf,ppobj);
586 return E_FAIL;
587 }
588
589 static ULONG WINAPI IDirectSoundNotify_AddRef(LPDIRECTSOUNDNOTIFY this) {
590 return ++(this->ref);
591 }
592
593 static ULONG WINAPI IDirectSoundNotify_Release(LPDIRECTSOUNDNOTIFY this) {
594 this->ref--;
595 if (!this->ref) {
596 this->dsb->lpvtbl->fnRelease(this->dsb);
597 HeapFree(GetProcessHeap(),0,this);
598 return 0;
599 }
600 return this->ref;
601 }
602
603 static HRESULT WINAPI IDirectSoundNotify_SetNotificationPositions(
604 LPDIRECTSOUNDNOTIFY this,DWORD howmuch,LPCDSBPOSITIONNOTIFY notify
605 ) {
606 int i;
607
608 if (TRACE_ON(dsound)) {
609 TRACE(dsound,"(%p,0x%08lx,%p)\n",this,howmuch,notify);
610 for (i=0;i<howmuch;i++)
611 TRACE(dsound,"notify at %ld to 0x%08lx\n",
612 notify[i].dwOffset,(DWORD)notify[i].hEventNotify);
613 }
614 this->dsb->notifies = HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,this->dsb->notifies,(this->dsb->nrofnotifies+howmuch)*sizeof(DSBPOSITIONNOTIFY));
615 memcpy( this->dsb->notifies+this->dsb->nrofnotifies,
616 notify,
617 howmuch*sizeof(DSBPOSITIONNOTIFY)
618 );
619 this->dsb->nrofnotifies+=howmuch;
620
621 return 0;
622 }
623
624 IDirectSoundNotify_VTable dsnvt = {
625 IDirectSoundNotify_QueryInterface,
626 IDirectSoundNotify_AddRef,
627 IDirectSoundNotify_Release,
628 IDirectSoundNotify_SetNotificationPositions,
629 };
630
631 /*******************************************************************************
632 * IDirectSoundBuffer
633 */
634
635 // This sets this format for the <em>Primary Buffer Only</em>
636 // See file:///cdrom/sdk52/docs/worddoc/dsound.doc page 120
637 static HRESULT WINAPI IDirectSoundBuffer_SetFormat(
638 LPDIRECTSOUNDBUFFER this,LPWAVEFORMATEX wfex
639 ) {
640 LPDIRECTSOUNDBUFFER *dsb;
641 int i;
642
643 // Let's be pedantic!
644 if ((wfex == NULL) ||
645 (wfex->wFormatTag != WAVE_FORMAT_PCM) ||
646 (wfex->nChannels < 1) || (wfex->nChannels > 2) ||
647 (wfex->nSamplesPerSec < 1) ||
648 (wfex->nBlockAlign < 1) || (wfex->nChannels > 4) ||
649 ((wfex->wBitsPerSample != 8) && (wfex->wBitsPerSample != 16))) {
650 TRACE(dsound, "failed pedantic check!\n");
651 return DSERR_INVALIDPARAM;
652 }
653
654 // ****
655 EnterCriticalSection(&(primarybuf->lock));
656
657 if (primarybuf->wfx.nSamplesPerSec != wfex->nSamplesPerSec) {
658 dsb = dsound->buffers;
659 for (i = 0; i < dsound->nrofbuffers; i++, dsb++) {
660 // ****
661 EnterCriticalSection(&((*dsb)->lock));
662
663 (*dsb)->freqAdjust = ((*dsb)->freq << DSOUND_FREQSHIFT) /
664 wfex->nSamplesPerSec;
665
666 LeaveCriticalSection(&((*dsb)->lock));
667 // ****
668 }
669 }
670
671 memcpy(&(primarybuf->wfx), wfex, sizeof(primarybuf->wfx));
672
673 TRACE(dsound,"(formattag=0x%04x,chans=%d,samplerate=%ld"
674 "bytespersec=%ld,blockalign=%d,bitspersamp=%d,cbSize=%d)\n",
675 wfex->wFormatTag, wfex->nChannels, wfex->nSamplesPerSec,
676 wfex->nAvgBytesPerSec, wfex->nBlockAlign,
677 wfex->wBitsPerSample, wfex->cbSize);
678
679 primarybuf->wfx.nAvgBytesPerSec =
680 this->wfx.nSamplesPerSec * this->wfx.nBlockAlign;
681
682 DSOUND_CloseAudio();
683
684 LeaveCriticalSection(&(primarybuf->lock));
685 // ****
686
687 return DS_OK;
688 }
689
690 static HRESULT WINAPI IDirectSoundBuffer_SetVolume(
691 LPDIRECTSOUNDBUFFER this,LONG vol
692 ) {
693 double temp;
694
695 TRACE(dsound,"(%p,%ld)\n",this,vol);
696
697 // I'm not sure if we need this for primary buffer
698 if (!(this->dsbd.dwFlags & DSBCAPS_CTRLVOLUME))
699 return DSERR_CONTROLUNAVAIL;
700
701 if ((vol > DSBVOLUME_MAX) || (vol < DSBVOLUME_MIN))
702 return DSERR_INVALIDPARAM;
703
704 // This needs to adjust the soundcard volume when
705 // called for the primary buffer
706 if (this->dsbd.dwFlags & DSBCAPS_PRIMARYBUFFER) {
707 FIXME(dsound, "Volume control of primary unimplemented.\n");
708 this->volume = vol;
709 return DS_OK;
710 }
711
712 // ****
713 EnterCriticalSection(&(this->lock));
714
715 this->volume = vol;
716
717 temp = (double) (this->volume - (this->pan > 0 ? this->pan : 0));
718 this->lVolAdjust = (ULONG) (pow(2.0, temp / 600.0) * 32768.0);
719 temp = (double) (this->volume + (this->pan < 0 ? this->pan : 0));
720 this->rVolAdjust = (ULONG) (pow(2.0, temp / 600.0) * 32768.0);
721
722 LeaveCriticalSection(&(this->lock));
723 // ****
724
725 TRACE(dsound, "left = %lx, right = %lx\n", this->lVolAdjust, this->rVolAdjust);
726
727 return DS_OK;
728 }
729
730 static HRESULT WINAPI IDirectSoundBuffer_GetVolume(
731 LPDIRECTSOUNDBUFFER this,LPLONG vol
732 ) {
733 TRACE(dsound,"(%p,%p)\n",this,vol);
734
735 if (vol == NULL)
736 return DSERR_INVALIDPARAM;
737
738 *vol = this->volume;
739 return DS_OK;
740 }
741
742 static HRESULT WINAPI IDirectSoundBuffer_SetFrequency(
743 LPDIRECTSOUNDBUFFER this,DWORD freq
744 ) {
745 TRACE(dsound,"(%p,%ld)\n",this,freq);
746
747 // You cannot set the frequency of the primary buffer
748 if (!(this->dsbd.dwFlags & DSBCAPS_CTRLFREQUENCY) ||
749 (this->dsbd.dwFlags & DSBCAPS_PRIMARYBUFFER))
750 return DSERR_CONTROLUNAVAIL;
751
752 if ((freq < DSBFREQUENCY_MIN) || (freq > DSBFREQUENCY_MAX))
753 return DSERR_INVALIDPARAM;
754
755 // ****
756 EnterCriticalSection(&(this->lock));
757
758 this->freq = freq;
759 this->freqAdjust = (freq << DSOUND_FREQSHIFT) / primarybuf->wfx.nSamplesPerSec;
760 this->nAvgBytesPerSec = freq * this->wfx.nBlockAlign;
761
762 LeaveCriticalSection(&(this->lock));
763 // ****
764
765 return DS_OK;
766 }
767
768 static HRESULT WINAPI IDirectSoundBuffer_Play(
769 LPDIRECTSOUNDBUFFER this,DWORD reserved1,DWORD reserved2,DWORD flags
770 ) {
771 TRACE(dsound,"(%p,%08lx,%08lx,%08lx)\n",
772 this,reserved1,reserved2,flags
773 );
774 this->playflags = flags;
775 this->playing = 1;
776 return DS_OK;
777 }
778
779 static HRESULT WINAPI IDirectSoundBuffer_Stop(LPDIRECTSOUNDBUFFER this)
780 {
781 TRACE(dsound,"(%p)\n",this);
782
783 // ****
784 EnterCriticalSection(&(this->lock));
785
786 this->playing = 0;
787 DSOUND_CheckEvent(this, 0);
788
789 LeaveCriticalSection(&(this->lock));
790 // ****
791
792 return DS_OK;
793 }
794
795 static DWORD WINAPI IDirectSoundBuffer_AddRef(LPDIRECTSOUNDBUFFER this) {
796 // TRACE(dsound,"(%p) ref was %ld\n",this, this->ref);
797
798 return ++(this->ref);
799 }
800 static DWORD WINAPI IDirectSoundBuffer_Release(LPDIRECTSOUNDBUFFER this) {
801 int i;
802
803 // TRACE(dsound,"(%p) ref was %ld\n",this, this->ref);
804
805 if (--this->ref)
806 return this->ref;
807
808 for (i=0;i<this->dsound->nrofbuffers;i++)
809 if (this->dsound->buffers[i] == this)
810 break;
811 if (i < this->dsound->nrofbuffers) {
812 /* Put the last buffer of the list in the (now empty) position */
813 this->dsound->buffers[i] = this->dsound->buffers[this->dsound->nrofbuffers - 1];
814 this->dsound->buffers = HeapReAlloc(GetProcessHeap(),0,this->dsound->buffers,sizeof(LPDIRECTSOUNDBUFFER)*this->dsound->nrofbuffers);
815 this->dsound->nrofbuffers--;
816 this->dsound->lpvtbl->fnRelease(this->dsound);
817 }
818
819 DeleteCriticalSection(&(this->lock));
820
821 if (this->ds3db && this->ds3db->lpvtbl)
822 this->ds3db->lpvtbl->fnRelease(this->ds3db);
823
824 HeapFree(GetProcessHeap(),0,this->buffer);
825 HeapFree(GetProcessHeap(),0,this);
826
827 if (this == primarybuf)
828 primarybuf = NULL;
829
830 return DS_OK;
831 }
832
833 static HRESULT WINAPI IDirectSoundBuffer_GetCurrentPosition(
834 LPDIRECTSOUNDBUFFER this,LPDWORD playpos,LPDWORD writepos
835 ) {
836 TRACE(dsound,"(%p,%p,%p)\n",this,playpos,writepos);
837 if (playpos) *playpos = this->playpos;
838 if (writepos) *writepos = this->writepos;
839 return DS_OK;
840 }
841
842 static HRESULT WINAPI IDirectSoundBuffer_GetStatus(
843 LPDIRECTSOUNDBUFFER this,LPDWORD status
844 ) {
845 TRACE(dsound,"(%p,%p)\n",this,status);
846
847 if (status == NULL)
848 return DSERR_INVALIDPARAM;
849
850 *status = 0;
851 if (this->playing)
852 *status |= DSBSTATUS_PLAYING;
853 if (this->playflags & DSBPLAY_LOOPING)
854 *status |= DSBSTATUS_LOOPING;
855
856 return DS_OK;
857 }
858
859
860 static HRESULT WINAPI IDirectSoundBuffer_GetFormat(
861 LPDIRECTSOUNDBUFFER this,LPWAVEFORMATEX lpwf,DWORD wfsize,LPDWORD wfwritten
862 ) {
863 TRACE(dsound,"(%p,%p,%ld,%p)\n",this,lpwf,wfsize,wfwritten);
864
865 if (wfsize>sizeof(this->wfx))
866 wfsize = sizeof(this->wfx);
867 if (lpwf) { // NULL is valid
868 memcpy(lpwf,&(this->wfx),wfsize);
869 if (wfwritten)
870 *wfwritten = wfsize;
871 } else
872 if (wfwritten)
873 *wfwritten = sizeof(this->wfx);
874 else
875 return DSERR_INVALIDPARAM;
876
877 return DS_OK;
878 }
879
880 static HRESULT WINAPI IDirectSoundBuffer_Lock(
881 LPDIRECTSOUNDBUFFER this,DWORD writecursor,DWORD writebytes,LPVOID lplpaudioptr1,LPDWORD audiobytes1,LPVOID lplpaudioptr2,LPDWORD audiobytes2,DWORD flags
882 ) {
883
884 TRACE(dsound,"(%p,%ld,%ld,%p,%p,%p,%p,0x%08lx)\n",
885 this,
886 writecursor,
887 writebytes,
888 lplpaudioptr1,
889 audiobytes1,
890 lplpaudioptr2,
891 audiobytes2,
892 flags
893 );
894 if (flags & DSBLOCK_FROMWRITECURSOR)
895 writecursor += this->writepos;
896 if (flags & DSBLOCK_ENTIREBUFFER)
897 writebytes = this->buflen;
898 if (writebytes > this->buflen)
899 writebytes = this->buflen;
900
901 assert(audiobytes1!=audiobytes2);
902 assert(lplpaudioptr1!=lplpaudioptr2);
903 if (writecursor+writebytes <= this->buflen) {
904 *(LPBYTE*)lplpaudioptr1 = this->buffer+writecursor;
905 *audiobytes1 = writebytes;
906 if (lplpaudioptr2)
907 *(LPBYTE*)lplpaudioptr2 = NULL;
908 if (audiobytes2)
909 *audiobytes2 = 0;
910 TRACE(dsound,"->%ld.0\n",writebytes);
911 } else {
912 *(LPBYTE*)lplpaudioptr1 = this->buffer+writecursor;
913 *audiobytes1 = this->buflen-writecursor;
914 if (lplpaudioptr2)
915 *(LPBYTE*)lplpaudioptr2 = this->buffer;
916 if (audiobytes2)
917 *audiobytes2 = writebytes-(this->buflen-writecursor);
918 TRACE(dsound,"->%ld.%ld\n",*audiobytes1,audiobytes2?*audiobytes2:0);
919 }
920 // No. See file:///cdrom/sdk52/docs/worddoc/dsound.doc page 21
921 // this->writepos=(writecursor+writebytes)%this->buflen;
922 return DS_OK;
923 }
924
925 static HRESULT WINAPI IDirectSoundBuffer_SetCurrentPosition(
926 LPDIRECTSOUNDBUFFER this,DWORD newpos
927 ) {
928 TRACE(dsound,"(%p,%ld)\n",this,newpos);
929
930 // ****
931 EnterCriticalSection(&(this->lock));
932
933 this->playpos = newpos;
934
935 LeaveCriticalSection(&(this->lock));
936 // ****
937
938 return 0;
939 }
940
941 static HRESULT WINAPI IDirectSoundBuffer_SetPan(
942 LPDIRECTSOUNDBUFFER this,LONG pan
943 ) {
944 double temp;
945
946 TRACE(dsound,"(%p,%ld)\n",this,pan);
947
948 if ((pan > DSBPAN_RIGHT) || (pan < DSBPAN_LEFT))
949 return DSERR_INVALIDPARAM;
950
951 // You cannot set the pan of the primary buffer
952 // and you cannot use both pan and 3D controls
953 if (!(this->dsbd.dwFlags & DSBCAPS_CTRLPAN) ||
954 (this->dsbd.dwFlags & DSBCAPS_CTRL3D) ||
955 (this->dsbd.dwFlags & DSBCAPS_PRIMARYBUFFER))
956 return DSERR_CONTROLUNAVAIL;
957
958 // ****
959 EnterCriticalSection(&(this->lock));
960
961 this->pan = pan;
962
963 temp = (double) (this->volume - (this->pan > 0 ? this->pan : 0));
964 this->lVolAdjust = (ULONG) (pow(2.0, temp / 600.0) * 32768.0);
965 temp = (double) (this->volume + (this->pan < 0 ? this->pan : 0));
966 this->rVolAdjust = (ULONG) (pow(2.0, temp / 600.0) * 32768.0);
967
968 LeaveCriticalSection(&(this->lock));
969 // ****
970
971 return DS_OK;
972 }
973
974 static HRESULT WINAPI IDirectSoundBuffer_GetPan(
975 LPDIRECTSOUNDBUFFER this,LPLONG pan
976 ) {
977 TRACE(dsound,"(%p,%p)\n",this,pan);
978
979 if (pan == NULL)
980 return DSERR_INVALIDPARAM;
981
982 *pan = this->pan;
983
984 return DS_OK;
985 }
986
987 static HRESULT WINAPI IDirectSoundBuffer_Unlock(
988 LPDIRECTSOUNDBUFFER this,LPVOID p1,DWORD x1,LPVOID p2,DWORD x2
989 ) {
990 TRACE(dsound,"(%p,%p,%ld,%p,%ld):stub\n", this,p1,x1,p2,x2);
991
992 // There is really nothing to do here. Should someone
993 // choose to implement static buffers in hardware (by
994 // using a wave table synth, for example) this is where
995 // you'd want to do the loading. For software buffers,
996 // which is what we currently use, we need do nothing.
997
998 #if 0
999 // It's also the place to pre-process 3D buffers...
1000
1001 // This is highly experimental and liable to break things
1002 if (this->dsbd.dwFlags & DSBCAPS_CTRL3D)
1003 DSOUND_Create3DBuffer(this);
1004 #endif
1005
1006 return DS_OK;
1007 }
1008
1009 static HRESULT WINAPI IDirectSoundBuffer_GetFrequency(
1010 LPDIRECTSOUNDBUFFER this,LPDWORD freq
1011 ) {
1012 TRACE(dsound,"(%p,%p)\n",this,freq);
1013
1014 if (freq == NULL)
1015 return DSERR_INVALIDPARAM;
1016
1017 *freq = this->freq;
1018
1019 return DS_OK;
1020 }
1021
1022 static HRESULT WINAPI IDirectSoundBuffer_Initialize(
1023 LPDIRECTSOUNDBUFFER this,LPDIRECTSOUND dsound,LPDSBUFFERDESC dbsd
1024 ) {
1025 FIXME(dsound,"(%p,%p,%p):stub\n",this,dsound,dbsd);
1026 printf("Re-Init!!!\n");
1027 return DSERR_ALREADYINITIALIZED;
1028 }
1029
1030 static HRESULT WINAPI IDirectSoundBuffer_GetCaps(
1031 LPDIRECTSOUNDBUFFER this,LPDSBCAPS caps
1032 ) {
1033 TRACE(dsound,"(%p)->(%p)\n",this,caps);
1034
1035 if (caps == NULL)
1036 return DSERR_INVALIDPARAM;
1037
1038 // I think we should check this value, not set it. See
1039 // Inside DirectX, p215. That should apply here, too.
1040 caps->dwSize = sizeof(*caps);
1041
1042 caps->dwFlags = this->dsbd.dwFlags | DSBCAPS_LOCSOFTWARE;
1043 caps->dwBufferBytes = this->dsbd.dwBufferBytes;
1044 /* This value represents the speed of the "unlock" command.
1045 As unlock is quite fast (it does not do anything), I put
1046 4096 ko/s = 4 Mo / s */
1047 caps->dwUnlockTransferRate = 4096;
1048 caps->dwPlayCpuOverhead = 0;
1049
1050 return DS_OK;
1051 }
1052
1053 static HRESULT WINAPI IDirectSoundBuffer_QueryInterface(
1054 LPDIRECTSOUNDBUFFER this,REFIID riid,LPVOID *ppobj
1055 ) {
1056 char xbuf[50];
1057
1058 WINE_StringFromCLSID(riid,xbuf);
1059 TRACE(dsound,"(%p,%s,%p)\n",this,xbuf,ppobj);
1060
1061 if (!memcmp(&IID_IDirectSoundNotify,riid,sizeof(*riid))) {
1062 IDirectSoundNotify *dsn;
1063
1064 dsn = (LPDIRECTSOUNDNOTIFY)HeapAlloc(GetProcessHeap(),0,sizeof(*dsn));
1065 dsn->ref = 1;
1066 dsn->dsb = this;
1067 this->lpvtbl->fnAddRef(this);
1068 dsn->lpvtbl = &dsnvt;
1069 *ppobj = (LPVOID)dsn;
1070 return 0;
1071 }
1072
1073 if (!memcmp(&IID_IDirectSound3DBuffer,riid,sizeof(*riid))) {
1074 *ppobj = this->ds3db;
1075 if (*ppobj)
1076 return DS_OK;
1077 }
1078
1079 return E_FAIL;
1080 }
1081
1082 static struct tagLPDIRECTSOUNDBUFFER_VTABLE dsbvt = {
1083 IDirectSoundBuffer_QueryInterface,
1084 IDirectSoundBuffer_AddRef,
1085 IDirectSoundBuffer_Release,
1086 IDirectSoundBuffer_GetCaps,
1087 IDirectSoundBuffer_GetCurrentPosition,
1088 IDirectSoundBuffer_GetFormat,
1089 IDirectSoundBuffer_GetVolume,
1090 IDirectSoundBuffer_GetPan,
1091 IDirectSoundBuffer_GetFrequency,
1092 IDirectSoundBuffer_GetStatus,
1093 IDirectSoundBuffer_Initialize,
1094 IDirectSoundBuffer_Lock,
1095 IDirectSoundBuffer_Play,
1096 IDirectSoundBuffer_SetCurrentPosition,
1097 IDirectSoundBuffer_SetFormat,
1098 IDirectSoundBuffer_SetVolume,
1099 IDirectSoundBuffer_SetPan,
1100 IDirectSoundBuffer_SetFrequency,
1101 IDirectSoundBuffer_Stop,
1102 IDirectSoundBuffer_Unlock
1103 };
1104
1105 /*******************************************************************************
1106 * IDirectSound
1107 */
1108
1109 static HRESULT WINAPI IDirectSound_SetCooperativeLevel(
1110 LPDIRECTSOUND this,HWND32 hwnd,DWORD level
1111 ) {
1112 FIXME(dsound,"(%p,%08lx,%ld):stub\n",this,(DWORD)hwnd,level);
1113 return 0;
1114 }
1115
1116 static HRESULT WINAPI IDirectSound_CreateSoundBuffer(
1117 LPDIRECTSOUND this,LPDSBUFFERDESC dsbd,LPLPDIRECTSOUNDBUFFER ppdsb,LPUNKNOWN lpunk
1118 ) {
1119 LPWAVEFORMATEX wfex;
1120
1121 TRACE(dsound,"(%p,%p,%p,%p)\n",this,dsbd,ppdsb,lpunk);
1122
1123 if ((this == NULL) || (dsbd == NULL) || (ppdsb == NULL))
1124 return DSERR_INVALIDPARAM;
1125
1126 if (TRACE_ON(dsound)) {
1127 TRACE(dsound,"(size=%ld)\n",dsbd->dwSize);
1128 TRACE(dsound,"(flags=0x%08lx\n",dsbd->dwFlags);
1129 _dump_DSBCAPS(dsbd->dwFlags);
1130 TRACE(dsound,"(bufferbytes=%ld)\n",dsbd->dwBufferBytes);
1131 TRACE(dsound,"(lpwfxFormat=%p)\n",dsbd->lpwfxFormat);
1132 }
1133
1134 wfex = dsbd->lpwfxFormat;
1135
1136 if (wfex)
1137 TRACE(dsound,"(formattag=0x%04x,chans=%d,samplerate=%ld"
1138 "bytespersec=%ld,blockalign=%d,bitspersamp=%d,cbSize=%d)\n",
1139 wfex->wFormatTag, wfex->nChannels, wfex->nSamplesPerSec,
1140 wfex->nAvgBytesPerSec, wfex->nBlockAlign,
1141 wfex->wBitsPerSample, wfex->cbSize);
1142
1143 if (dsbd->dwFlags & DSBCAPS_PRIMARYBUFFER) {
1144 if (primarybuf) {
1145 primarybuf->lpvtbl->fnAddRef(primarybuf);
1146 *ppdsb = primarybuf;
1147 return DS_OK;
1148 } // Else create primarybuf
1149 }
1150
1151 *ppdsb = (LPDIRECTSOUNDBUFFER)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectSoundBuffer));
1152 if (*ppdsb == NULL)
1153 return DSERR_OUTOFMEMORY;
1154 (*ppdsb)->ref = 1;
1155
1156 TRACE(dsound, "Created buffer at %p\n", *ppdsb);
1157
1158 if (dsbd->dwFlags & DSBCAPS_PRIMARYBUFFER) {
1159 (*ppdsb)->buflen = dsound->wfx.nAvgBytesPerSec;
1160 (*ppdsb)->freq = dsound->wfx.nSamplesPerSec;
1161 } else {
1162 (*ppdsb)->buflen = dsbd->dwBufferBytes;
1163 (*ppdsb)->freq = dsbd->lpwfxFormat->nSamplesPerSec;
1164 }
1165 (*ppdsb)->buffer = (LPBYTE)HeapAlloc(GetProcessHeap(),0,(*ppdsb)->buflen);
1166 if ((*ppdsb)->buffer == NULL) {
1167 HeapFree(GetProcessHeap(),0,(*ppdsb));
1168 *ppdsb = NULL;
1169 return DSERR_OUTOFMEMORY;
1170 }
1171 // It's not necessary to initialize values to zero since
1172 // we allocated this structure with HEAP_ZERO_MEMORY...
1173 (*ppdsb)->playpos = 0;
1174 (*ppdsb)->writepos = 0;
1175 (*ppdsb)->lpvtbl = &dsbvt;
1176 (*ppdsb)->dsound = this;
1177 (*ppdsb)->playing = 0;
1178 (*ppdsb)->lVolAdjust = (1 << 15);
1179 (*ppdsb)->rVolAdjust = (1 << 15);
1180
1181 if (!(dsbd->dwFlags & DSBCAPS_PRIMARYBUFFER)) {
1182 (*ppdsb)->freqAdjust = ((*ppdsb)->freq << DSOUND_FREQSHIFT) /
1183 primarybuf->wfx.nSamplesPerSec;
1184 (*ppdsb)->nAvgBytesPerSec = (*ppdsb)->freq *
1185 dsbd->lpwfxFormat->nBlockAlign;
1186 }
1187
1188 memcpy(&((*ppdsb)->dsbd),dsbd,sizeof(*dsbd));
1189
1190 /* register buffer */
1191 if (!(dsbd->dwFlags & DSBCAPS_PRIMARYBUFFER)) {
1192 this->buffers = (LPDIRECTSOUNDBUFFER*)HeapReAlloc(GetProcessHeap(),0,this->buffers,sizeof(LPDIRECTSOUNDBUFFER)*(this->nrofbuffers+1));
1193 this->buffers[this->nrofbuffers] = *ppdsb;
1194 this->nrofbuffers++;
1195 }
1196 this->lpvtbl->fnAddRef(this);
1197
1198 if (dsbd->lpwfxFormat)
1199 memcpy(&((*ppdsb)->wfx), dsbd->lpwfxFormat, sizeof((*ppdsb)->wfx));
1200
1201 InitializeCriticalSection(&((*ppdsb)->lock));
1202
1203 #if 0
1204 if (dsbd->dwFlags & DSBCAPS_CTRL3D) {
1205 IDirectSound3DBuffer *ds3db;
1206
1207 ds3db = (LPDIRECTSOUND3DBUFFER)HeapAlloc(GetProcessHeap(),
1208 0,sizeof(*ds3db));
1209 ds3db->ref = 1;
1210 ds3db->dsb = (*ppdsb);
1211 ds3db->lpvtbl = &ds3dbvt;
1212 (*ppdsb)->ds3db = ds3db;
1213 ds3db->ds3db.dwSize = sizeof(DS3DBUFFER);
1214 ds3db->ds3db.vPosition.x = 0.0;
1215 ds3db->ds3db.vPosition.y = 0.0;
1216 ds3db->ds3db.vPosition.z = 0.0;
1217 ds3db->ds3db.vVelocity.x = 0.0;
1218 ds3db->ds3db.vVelocity.y = 0.0;
1219 ds3db->ds3db.vVelocity.z = 0.0;
1220 ds3db->ds3db.dwInsideConeAngle = DS3D_DEFAULTCONEANGLE;
1221 ds3db->ds3db.dwOutsideConeAngle = DS3D_DEFAULTCONEANGLE;
1222 ds3db->ds3db.vConeOrientation.x = 0.0;
1223 ds3db->ds3db.vConeOrientation.y = 0.0;
1224 ds3db->ds3db.vConeOrientation.z = 0.0;
1225 ds3db->ds3db.lConeOutsideVolume = DS3D_DEFAULTCONEOUTSIDEVOLUME;
1226 ds3db->ds3db.flMinDistance = DS3D_DEFAULTMINDISTANCE;
1227 ds3db->ds3db.flMaxDistance = DS3D_DEFAULTMAXDISTANCE;
1228 ds3db->ds3db.dwMode = DS3DMODE_NORMAL;
1229 ds3db->buflen = ((*ppdsb)->buflen * primarybuf->wfx.nBlockAlign) /
1230 (*ppdsb)->wfx.nBlockAlign;
1231 ds3db->buffer = HeapAlloc(GetProcessHeap(), 0, ds3db->buflen);
1232 if (ds3db->buffer == NULL) {
1233 ds3db->buflen = 0;
1234 ds3db->ds3db.dwMode = DS3DMODE_DISABLE;
1235 }
1236 }
1237 #endif
1238 return DS_OK;
1239 }
1240
1241 static HRESULT WINAPI IDirectSound_DuplicateSoundBuffer(
1242 LPDIRECTSOUND this,LPDIRECTSOUNDBUFFER pdsb,LPLPDIRECTSOUNDBUFFER ppdsb
1243 ) {
1244 TRACE(dsound,"(%p,%p,%p)\n",this,pdsb,ppdsb);
1245
1246 *ppdsb = (LPDIRECTSOUNDBUFFER)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectSoundBuffer));
1247
1248 (*ppdsb)->ref =1;
1249 (*ppdsb)->buffer = (LPBYTE)HeapAlloc(GetProcessHeap(),0,pdsb->buflen);
1250 memcpy((*ppdsb)->buffer,pdsb->buffer,pdsb->buflen);
1251 (*ppdsb)->buflen = pdsb->buflen;
1252 (*ppdsb)->playpos = 0;
1253 (*ppdsb)->writepos = 0;
1254 (*ppdsb)->lpvtbl = &dsbvt;
1255 (*ppdsb)->dsound = this;
1256 memcpy(&((*ppdsb)->wfx), &(pdsb->wfx), sizeof((*ppdsb)->wfx));
1257 /* register buffer */
1258 this->buffers = (LPDIRECTSOUNDBUFFER*)HeapReAlloc(GetProcessHeap(),0,this->buffers,sizeof(LPDIRECTSOUNDBUFFER)*(this->nrofbuffers+1));
1259 this->buffers[this->nrofbuffers] = *ppdsb;
1260 this->nrofbuffers++;
1261 this->lpvtbl->fnAddRef(this);
1262 return 0;
1263 }
1264
1265
1266 static HRESULT WINAPI IDirectSound_GetCaps(LPDIRECTSOUND this,LPDSCAPS caps) {
1267 TRACE(dsound,"(%p,%p)\n",this,caps);
1268 TRACE(dsound,"(flags=0x%08lx)\n",caps->dwFlags);
1269
1270 if (caps == NULL)
1271 return DSERR_INVALIDPARAM;
1272
1273 // We should check this value, not set it. See Inside DirectX, p215.
1274 caps->dwSize = sizeof(*caps);
1275
1276 caps->dwFlags =
1277 DSCAPS_PRIMARYSTEREO |
1278 DSCAPS_PRIMARY16BIT |
1279 DSCAPS_SECONDARYSTEREO |
1280 DSCAPS_SECONDARY16BIT |
1281 DSCAPS_CONTINUOUSRATE;
1282 /* FIXME: query OSS */
1283 caps->dwMinSecondarySampleRate = DSBFREQUENCY_MIN;
1284 caps->dwMaxSecondarySampleRate = DSBFREQUENCY_MAX;
1285
1286 caps->dwPrimaryBuffers = 1;
1287
1288 caps->dwMaxHwMixingAllBuffers = 0;
1289 caps->dwMaxHwMixingStaticBuffers = 0;
1290 caps->dwMaxHwMixingStreamingBuffers = 0;
1291
1292 caps->dwFreeHwMixingAllBuffers = 0;
1293 caps->dwFreeHwMixingStaticBuffers = 0;
1294 caps->dwFreeHwMixingStreamingBuffers = 0;
1295
1296 caps->dwMaxHw3DAllBuffers = 0;
1297 caps->dwMaxHw3DStaticBuffers = 0;
1298 caps->dwMaxHw3DStreamingBuffers = 0;
1299
1300 caps->dwFreeHw3DAllBuffers = 0;
1301 caps->dwFreeHw3DStaticBuffers = 0;
1302 caps->dwFreeHw3DStreamingBuffers = 0;
1303
1304 caps->dwTotalHwMemBytes = 0;
1305
1306 caps->dwFreeHwMemBytes = 0;
1307
1308 caps->dwMaxContigFreeHwMemBytes = 0;
1309
1310 caps->dwUnlockTransferRateHwBuffers = 4096; // But we have none...
1311
1312 caps->dwPlayCpuOverheadSwBuffers = 1; // 1%
1313
1314 return 0;
1315 }
1316
1317 static ULONG WINAPI IDirectSound_AddRef(LPDIRECTSOUND this) {
1318 return ++(this->ref);
1319 }
1320
1321 static ULONG WINAPI IDirectSound_Release(LPDIRECTSOUND this) {
1322 TRACE(dsound,"(%p), ref was %ld\n",this,this->ref);
1323 if (!--(this->ref)) {
1324 DSOUND_CloseAudio();
1325 while(IDirectSoundBuffer_Release(primarybuf)); // Deallocate
1326 FIXME(dsound, "need to release all buffers!\n");
1327 HeapFree(GetProcessHeap(),0,this);
1328 dsound = NULL;
1329 return 0;
1330 }
1331 return this->ref;
1332 }
1333
1334 static HRESULT WINAPI IDirectSound_SetSpeakerConfig(
1335 LPDIRECTSOUND this,DWORD config
1336 ) {
1337 FIXME(dsound,"(%p,0x%08lx):stub\n",this,config);
1338 return 0;
1339 }
1340
1341 static HRESULT WINAPI IDirectSound_QueryInterface(
1342 LPDIRECTSOUND this,REFIID riid,LPVOID *ppobj
1343 ) {
1344 char xbuf[50];
1345
1346 if (!memcmp(&IID_IDirectSound3DListener,riid,sizeof(*riid))) {
1347
1348 if (this->listener) {
1349 *ppobj = this->listener;
1350 return DS_OK;
1351 }
1352 this->listener = (LPDIRECTSOUND3DLISTENER)HeapAlloc(
1353 GetProcessHeap(), 0, sizeof(*(this->listener)));
1354 this->listener->ref = 1;
1355 this->listener->lpvtbl = &ds3dlvt;
1356 this->lpvtbl->fnAddRef(this);
1357 this->listener->ds3dl.dwSize = sizeof(DS3DLISTENER);
1358 this->listener->ds3dl.vPosition.x = 0.0;
1359 this->listener->ds3dl.vPosition.y = 0.0;
1360 this->listener->ds3dl.vPosition.z = 0.0;
1361 this->listener->ds3dl.vVelocity.x = 0.0;
1362 this->listener->ds3dl.vVelocity.y = 0.0;
1363 this->listener->ds3dl.vVelocity.z = 0.0;
1364 this->listener->ds3dl.vOrientFront.x = 0.0;
1365 this->listener->ds3dl.vOrientFront.y = 0.0;
1366 this->listener->ds3dl.vOrientFront.z = 1.0;
1367 this->listener->ds3dl.vOrientTop.x = 0.0;
1368 this->listener->ds3dl.vOrientTop.y = 1.0;
1369 this->listener->ds3dl.vOrientTop.z = 0.0;
1370 this->listener->ds3dl.flDistanceFactor = DS3D_DEFAULTDISTANCEFACTOR;
1371 this->listener->ds3dl.flRolloffFactor = DS3D_DEFAULTROLLOFFFACTOR;
1372 this->listener->ds3dl.flDopplerFactor = DS3D_DEFAULTDOPPLERFACTOR;
1373 *ppobj = (LPVOID)this->listener;
1374 return DS_OK;
1375 }
1376
1377 WINE_StringFromCLSID(riid,xbuf);
1378 TRACE(dsound,"(%p,%s,%p)\n",this,xbuf,ppobj);
1379 return E_FAIL;
1380 }
1381
1382 static HRESULT WINAPI IDirectSound_Compact(
1383 LPDIRECTSOUND this)
1384 {
1385 TRACE(dsound, "(%p)\n", this);
1386 return DS_OK;
1387 }
1388
1389 static HRESULT WINAPI IDirectSound_GetSpeakerConfig(
1390 LPDIRECTSOUND this,
1391 LPDWORD lpdwSpeakerConfig)
1392 {
1393 TRACE(dsound, "(%p, %p)\n", this, lpdwSpeakerConfig);
1394 *lpdwSpeakerConfig = DSSPEAKER_STEREO | (DSSPEAKER_GEOMETRY_NARROW << 16);
1395 return DS_OK;
1396 }
1397
1398 static HRESULT WINAPI IDirectSound_Initialize(
1399 LPDIRECTSOUND this,
1400 LPGUID lpGuid)
1401 {
1402 TRACE(dsound, "(%p, %p)\n", this, lpGuid);
1403 return DS_OK;
1404 }
1405
1406 static struct tagLPDIRECTSOUND_VTABLE dsvt = {
1407 IDirectSound_QueryInterface,
1408 IDirectSound_AddRef,
1409 IDirectSound_Release,
1410 IDirectSound_CreateSoundBuffer,
1411 IDirectSound_GetCaps,
1412 IDirectSound_DuplicateSoundBuffer,
1413 IDirectSound_SetCooperativeLevel,
1414 IDirectSound_Compact,
1415 IDirectSound_GetSpeakerConfig,
1416 IDirectSound_SetSpeakerConfig,
1417 IDirectSound_Initialize
1418 };
1419
1420 static int
1421 DSOUND_setformat(LPWAVEFORMATEX wfex) {
1422 int xx,channels,speed,format,nformat;
1423
1424 if (!audioOK) {
1425 TRACE(dsound, "(%p) deferred\n", wfex);
1426 return 0;
1427 }
1428 switch (wfex->wFormatTag) {
1429 default:
1430 WARN(dsound,"unknown WAVE_FORMAT tag %d\n",wfex->wFormatTag);
1431 return DSERR_BADFORMAT;
1432 case WAVE_FORMAT_PCM:
1433 break;
1434 }
1435 if (wfex->wBitsPerSample==8)
1436 format = AFMT_U8;
1437 else
1438 format = AFMT_S16_LE;
1439
1440 if (-1==ioctl(audiofd,SNDCTL_DSP_GETFMTS,&xx)) {
1441 perror("ioctl SNDCTL_DSP_GETFMTS");
1442 return -1;
1443 }
1444 if ((xx&format)!=format) {/* format unsupported */
1445 FIXME(dsound,"SNDCTL_DSP_GETFMTS: format not supported\n");
1446 return -1;
1447 }
1448 nformat = format;
1449 if (-1==ioctl(audiofd,SNDCTL_DSP_SETFMT,&nformat)) {
1450 perror("ioctl SNDCTL_DSP_SETFMT");
1451 return -1;
1452 }
1453 if (nformat!=format) {/* didn't work */
1454 FIXME(dsound,"SNDCTL_DSP_GETFMTS: format not set\n");
1455 return -1;
1456 }
1457
1458 channels = wfex->nChannels-1;
1459 if (-1==ioctl(audiofd,SNDCTL_DSP_STEREO,&channels)) {
1460 perror("ioctl SNDCTL_DSP_STEREO");
1461 return -1;
1462 }
1463 speed = wfex->nSamplesPerSec;
1464 if (-1==ioctl(audiofd,SNDCTL_DSP_SPEED,&speed)) {
1465 perror("ioctl SNDCTL_DSP_SPEED");
1466 return -1;
1467 }
1468 TRACE(dsound,"(freq=%ld,channels=%d,bits=%d)\n",
1469 wfex->nSamplesPerSec,wfex->nChannels,wfex->wBitsPerSample
1470 );
1471 return 0;
1472 }
1473
1474 static void DSOUND_CheckEvent(IDirectSoundBuffer *dsb, int len)
1475 {
1476 int i;
1477 DWORD offset;
1478 LPDSBPOSITIONNOTIFY event;
1479
1480 if (dsb->nrofnotifies == 0)
1481 return;
1482
1483 TRACE(dsound,"(%p) buflen = %ld, playpos = %ld, len = %d\n",
1484 dsb, dsb->buflen, dsb->playpos, len);
1485 for (i = 0; i < dsb->nrofnotifies ; i++) {
1486 event = dsb->notifies + i;
1487 offset = event->dwOffset;
1488 TRACE(dsound, "checking %d, position %ld, event = %d\n",
1489 i, offset, event->hEventNotify);
1490 // DSBPN_OFFSETSTOP has to be the last element. So this is
1491 // OK. [Inside DirectX, p274]
1492 //
1493 // This also means we can't sort the entries by offset,
1494 // because DSBPN_OFFSETSTOP == -1
1495 if (offset == DSBPN_OFFSETSTOP) {
1496 if (dsb->playing == 0) {
1497 SetEvent(event->hEventNotify);
1498 TRACE(dsound,"signalled event %d (%d)\n", event->hEventNotify, i);
1499 return;
1500 } else
1501 return;
1502 }
1503 if ((dsb->playpos + len) >= dsb->buflen) {
1504 if ((offset < ((dsb->playpos + len) % dsb->buflen)) ||
1505 (offset >= dsb->playpos)) {
1506 TRACE(dsound,"signalled event %d (%d)\n", event->hEventNotify, i);
1507 SetEvent(event->hEventNotify);
1508 }
1509 } else {
1510 if ((offset >= dsb->playpos) && (offset < (dsb->playpos + len))) {
1511 TRACE(dsound,"signalled event %d (%d)\n", event->hEventNotify, i);
1512 SetEvent(event->hEventNotify);
1513 }
1514 }
1515 }
1516 }
1517
1518 // WAV format info can be found at:
1519 //
1520 // http://www.cwi.nl/ftp/audio/AudioFormats.part2
1521 // ftp://ftp.cwi.nl/pub/audio/RIFF-format
1522 //
1523 // Import points to remember:
1524 //
1525 // 8-bit WAV is unsigned
1526 // 16-bit WAV is signed
1527
1528 static inline INT16 cvtU8toS16(BYTE byte)
1529 {
1530 INT16 s = (byte - 128) << 8;
1531
1532 return s;
1533 }
1534
1535 static inline BYTE cvtS16toU8(INT16 word)
1536 {
1537 BYTE b = (word + 32768) >> 8;
1538
1539 return b;
1540 }
1541
1542
1543 // We should be able to optimize these two inline functions
1544 // so that we aren't doing 8->16->8 conversions when it is
1545 // not necessary. But this is still a WIP. Optimize later.
1546 static inline void get_fields(const IDirectSoundBuffer *dsb, BYTE *buf, INT32 *fl, INT32 *fr)
1547 {
1548 INT16 *bufs = (INT16 *) buf;
1549
1550 // TRACE(dsound, "(%p)", buf);
1551 if ((dsb->wfx.wBitsPerSample == 8) && dsb->wfx.nChannels == 2) {
1552 *fl = cvtU8toS16(*buf);
1553 *fr = cvtU8toS16(*(buf + 1));
1554 return;
1555 }
1556
1557 if ((dsb->wfx.wBitsPerSample == 16) && dsb->wfx.nChannels == 2) {
1558 *fl = *bufs;
1559 *fr = *(bufs + 1);
1560 return;
1561 }
1562
1563 if ((dsb->wfx.wBitsPerSample == 8) && dsb->wfx.nChannels == 1) {
1564 *fl = cvtU8toS16(*buf);
1565 *fr = *fl;
1566 return;
1567 }
1568
1569 if ((dsb->wfx.wBitsPerSample == 16) && dsb->wfx.nChannels == 1) {
1570 *fl = *bufs;
1571 *fr = *bufs;
1572 return;
1573 }
1574
1575 FIXME(dsound, "get_fields found an unsupported configuration\n");
1576 return;
1577 }
1578
1579 static inline void set_fields(BYTE *buf, INT32 fl, INT32 fr)
1580 {
1581 INT16 *bufs = (INT16 *) buf;
1582
1583 if ((primarybuf->wfx.wBitsPerSample == 8) && (primarybuf->wfx.nChannels == 2)) {
1584 *buf = cvtS16toU8(fl);
1585 *(buf + 1) = cvtS16toU8(fr);
1586 return;
1587 }
1588
1589 if ((primarybuf->wfx.wBitsPerSample == 16) && (primarybuf->wfx.nChannels == 2)) {
1590 *bufs = fl;
1591 *(bufs + 1) = fr;
1592 return;
1593 }
1594
1595 if ((primarybuf->wfx.wBitsPerSample == 8) && (primarybuf->wfx.nChannels == 1)) {
1596 *buf = cvtS16toU8((fl + fr) >> 1);
1597 return;
1598 }
1599
1600 if ((primarybuf->wfx.wBitsPerSample == 16) && (primarybuf->wfx.nChannels == 1)) {
1601 *bufs = (fl + fr) >> 1;
1602 return;
1603 }
1604 FIXME(dsound, "set_fields found an unsupported configuration\n");
1605 return;
1606 }
1607
1608 // Now with PerfectPitch (tm) technology
1609 static INT32 DSOUND_MixerNorm(IDirectSoundBuffer *dsb, BYTE *buf, INT32 len)
1610 {
1611 INT32 i, size, ipos, ilen, fieldL, fieldR;
1612 BYTE *ibp, *obp;
1613 INT32 iAdvance = dsb->wfx.nBlockAlign;
1614 INT32 oAdvance = primarybuf->wfx.nBlockAlign;
1615
1616 ibp = dsb->buffer + dsb->playpos;
1617 obp = buf;
1618
1619 TRACE(dsound, "(%p, %p, %p), playpos=%8.8lx\n", dsb, ibp, obp, dsb->playpos);
1620 // Check for the best case
1621 if ((dsb->freq == primarybuf->wfx.nSamplesPerSec) &&
1622 (dsb->wfx.wBitsPerSample == primarybuf->wfx.wBitsPerSample) &&
1623 (dsb->wfx.nChannels == primarybuf->wfx.nChannels)) {
1624 TRACE(dsound, "(%p) Best case\n", dsb);
1625 if ((ibp + len) < (BYTE *)(dsb->buffer + dsb->buflen))
1626 memcpy(obp, ibp, len);
1627 else { // wrap
1628 memcpy(obp, ibp, dsb->buflen - dsb->playpos);
1629 memcpy(obp + (dsb->buflen - dsb->playpos),
1630 dsb->buffer,
1631 len - (dsb->buflen - dsb->playpos));
1632 }
1633 return len;
1634 }
1635
1636 // Check for same sample rate
1637 if (dsb->freq == primarybuf->wfx.nSamplesPerSec) {
1638 TRACE(dsound, "(%p) Same sample rate %ld = primary %ld\n", dsb,
1639 dsb->freq, primarybuf->wfx.nSamplesPerSec);
1640 ilen = 0;
1641 for (i = 0; i < len; i += oAdvance) {
1642 get_fields(dsb, ibp, &fieldL, &fieldR);
1643 ibp += iAdvance;
1644 ilen += iAdvance;
1645 set_fields(obp, fieldL, fieldR);
1646 obp += oAdvance;
1647 if (ibp >= (BYTE *)(dsb->buffer + dsb->buflen))
1648 ibp = dsb->buffer; // wrap
1649 }
1650 return (ilen);
1651 }
1652
1653 // Mix in different sample rates
1654 //
1655 // New PerfectPitch(tm) Technology (c) 1998 Rob Riggs
1656 // Patent Pending :-]
1657
1658 TRACE(dsound, "(%p) Adjusting frequency: %ld -> %ld\n",
1659 dsb, dsb->freq, primarybuf->wfx.nSamplesPerSec);
1660
1661 size = len / oAdvance;
1662 ilen = ((size * dsb->freqAdjust) >> DSOUND_FREQSHIFT) * iAdvance;
1663 for (i = 0; i < size; i++) {
1664
1665 ipos = (((i * dsb->freqAdjust) >> DSOUND_FREQSHIFT) * iAdvance) + dsb->playpos;
1666
1667 if (ipos >= dsb->buflen)
1668 ipos %= dsb->buflen; // wrap
1669
1670 get_fields(dsb, (dsb->buffer + ipos), &fieldL, &fieldR);
1671 set_fields(obp, fieldL, fieldR);
1672 obp += oAdvance;
1673 }
1674 return ilen;
1675 }
1676
1677 static void DSOUND_MixerVol(IDirectSoundBuffer *dsb, BYTE *buf, INT32 len)
1678 {
1679 INT32 i, inc = primarybuf->wfx.wBitsPerSample >> 3;
1680 BYTE *bpc = buf;
1681 INT16 *bps = (INT16 *) buf;
1682
1683 TRACE(dsound, "(%p) left = %lx, right = %lx\n", dsb,
1684 dsb->lVolAdjust, dsb->rVolAdjust);
1685 if ((!(dsb->dsbd.dwFlags & DSBCAPS_CTRLPAN) || (dsb->pan == 0)) &&
1686 (!(dsb->dsbd.dwFlags & DSBCAPS_CTRLVOLUME) || (dsb->volume == 0)) &&
1687 !(dsb->dsbd.dwFlags & DSBCAPS_CTRL3D))
1688 return; // Nothing to do
1689
1690 // If we end up with some bozo coder using panning or 3D sound
1691 // with a mono primary buffer, it could sound very weird using
1692 // this method. Oh well, tough patooties.
1693
1694 for (i = 0; i < len; i += inc) {
1695 INT32 val;
1696
1697 switch (inc) {
1698
1699 case 1:
1700 // 8-bit WAV is unsigned, but we need to operate
1701 // on signed data for this to work properly
1702 val = *bpc - 128;
1703 val = ((val * (i & inc ? dsb->rVolAdjust : dsb->lVolAdjust)) >> 15);
1704 *bpc = val + 128;
1705 bpc++;
1706 break;
1707 case 2:
1708 // 16-bit WAV is signed -- much better
1709 val = *bps;
1710 val = ((val * ((i & inc) ? dsb->rVolAdjust : dsb->lVolAdjust)) >> 15);
1711 *bps = val;
1712 bps++;
1713 break;
1714 default:
1715 // Very ugly!
1716 FIXME(dsound, "MixerVol had a nasty error\n");
1717 }
1718 }
1719 }
1720
1721 #ifdef USE_DSOUND3D
1722 static void DSOUND_Mixer3D(IDirectSoundBuffer *dsb, BYTE *buf, INT32 len)
1723 {
1724 BYTE *ibp, *obp;
1725 DWORD buflen, playpos;
1726
1727 buflen = dsb->ds3db->buflen;
1728 playpos = (dsb->playpos * primarybuf->wfx.nBlockAlign) / dsb->wfx.nBlockAlign;
1729 ibp = dsb->ds3db->buffer + playpos;
1730 obp = buf;
1731
1732 if (playpos > buflen) {
1733 FIXME(dsound, "Major breakage");
1734 return;
1735 }
1736
1737 if (len <= (playpos + buflen))
1738 memcpy(obp, ibp, len);
1739 else { // wrap
1740 memcpy(obp, ibp, buflen - playpos);
1741 memcpy(obp + (buflen - playpos),
1742 dsb->buffer,
1743 len - (buflen - playpos));
1744 }
1745 return;
1746 }
1747 #endif
1748
1749 static DWORD DSOUND_MixInBuffer(IDirectSoundBuffer *dsb)
1750 {
1751 INT32 i, len, ilen, temp, field;
1752 INT32 advance = primarybuf->wfx.wBitsPerSample >> 3;
1753 BYTE *buf, *ibuf, *obuf;
1754 INT16 *ibufs, *obufs;
1755
1756 len = DSOUND_FRAGLEN; // The most we will use
1757 if (!(dsb->playflags & DSBPLAY_LOOPING)) {
1758 temp = ((primarybuf->wfx.nAvgBytesPerSec * dsb->buflen) /
1759 dsb->nAvgBytesPerSec) -
1760 ((primarybuf->wfx.nAvgBytesPerSec * dsb->playpos) /
1761 dsb->nAvgBytesPerSec);
1762 len = (len > temp) ? temp : len;
1763 }
1764 len &= ~3; // 4 byte alignment
1765
1766 if (len == 0) {
1767 // This should only happen if we aren't looping and temp < 4
1768
1769 // We skip the remainder, so check for possible events
1770 DSOUND_CheckEvent(dsb, dsb->buflen - dsb->playpos);
1771 // Stop
1772 dsb->playing = 0;
1773 dsb->writepos = 0;
1774 dsb->playpos = 0;
1775 // Check for DSBPN_OFFSETSTOP
1776 DSOUND_CheckEvent(dsb, 0);
1777 return 0;
1778 }
1779
1780 // Been seeing segfaults in malloc() for some reason...
1781 TRACE(dsound, "allocating buffer (size = %d)\n", len);
1782 if ((buf = ibuf = (BYTE *) malloc(len)) == NULL)
1783 return 0;
1784
1785 TRACE(dsound, "MixInBuffer (%p) len = %d\n", dsb, len);
1786
1787 ilen = DSOUND_MixerNorm(dsb, ibuf, len);
1788 if ((dsb->dsbd.dwFlags & DSBCAPS_CTRLPAN) ||
1789 (dsb->dsbd.dwFlags & DSBCAPS_CTRLVOLUME))
1790 DSOUND_MixerVol(dsb, ibuf, len);
1791
1792 obuf = primarybuf->buffer + primarybuf->playpos;
1793 for (i = 0; i < len; i += advance) {
1794 obufs = (INT16 *) obuf;
1795 ibufs = (INT16 *) ibuf;
1796 if (primarybuf->wfx.wBitsPerSample == 8) {
1797 // 8-bit WAV is unsigned
1798 field = (*ibuf - 128);
1799 field += (*obuf - 128);
1800 field = field > 127 ? 127 : field;
1801 field = field < -128 ? -128 : field;
1802 *obuf = field + 128;
1803 } else {
1804 // 16-bit WAV is signed
1805 field = *ibufs;
1806 field += *obufs;
1807 field = field > 32767 ? 32767 : field;
1808 field = field < -32768 ? -32768 : field;
1809 *obufs = field;
1810 }
1811 ibuf += advance;
1812 obuf += advance;
1813 if (obuf >= (BYTE *)(primarybuf->buffer + primarybuf->buflen))
1814 obuf = primarybuf->buffer;
1815 }
1816 free(buf);
1817
1818 if (dsb->dsbd.dwFlags & DSBCAPS_CTRLPOSITIONNOTIFY)
1819 DSOUND_CheckEvent(dsb, ilen);
1820
1821 dsb->playpos += ilen;
1822 dsb->writepos = dsb->playpos + ilen;
1823
1824 if (dsb->playpos >= dsb->buflen) {
1825 if (!(dsb->playflags & DSBPLAY_LOOPING)) {
1826 dsb->playing = 0;
1827 dsb->writepos = 0;
1828 dsb->playpos = 0;
1829 DSOUND_CheckEvent(dsb, 0); // For DSBPN_OFFSETSTOP
1830 } else
1831 dsb->playpos %= dsb->buflen; // wrap
1832 }
1833
1834 if (dsb->writepos >= dsb->buflen)
1835 dsb->writepos %= dsb->buflen;
1836
1837 return len;
1838 }
1839
1840 static DWORD WINAPI DSOUND_MixPrimary(void)
1841 {
1842 INT32 i, len, maxlen = 0;
1843 IDirectSoundBuffer *dsb;
1844
1845 for (i = dsound->nrofbuffers - 1; i >= 0; i--) {
1846 dsb = dsound->buffers[i];
1847
1848 if (!dsb || !(dsb->lpvtbl))
1849 continue;
1850 dsb->lpvtbl->fnAddRef(dsb);
1851 if (dsb->buflen && dsb->playing) {
1852 EnterCriticalSection(&(dsb->lock));
1853 len = DSOUND_MixInBuffer(dsb);
1854 maxlen = len > maxlen ? len : maxlen;
1855 LeaveCriticalSection(&(dsb->lock));
1856 }
1857 dsb->lpvtbl->fnRelease(dsb);
1858 }
1859
1860 return maxlen;
1861 }
1862
1863 static int DSOUND_OpenAudio(void)
1864 {
1865 int audioFragment;
1866
1867 if (primarybuf == NULL)
1868 return DSERR_OUTOFMEMORY;
1869
1870 while (audiofd != -1)
1871 sleep(5);
1872 audiofd = open("/dev/audio",O_WRONLY);
1873 if (audiofd==-1) {
1874 // Don't worry if sound is busy at the moment
1875 if (errno != EBUSY)
1876 perror("open /dev/audio");
1877 return audiofd; // -1
1878 }
1879
1880 // We should probably do something here if SETFRAGMENT fails...
1881 audioFragment=0x0002000c;
1882 if (-1==ioctl(audiofd,SNDCTL_DSP_SETFRAGMENT,&audioFragment))
1883 perror("ioctl SETFRAGMENT");
1884
1885 audioOK = 1;
1886 DSOUND_setformat(&(primarybuf->wfx));
1887
1888 return 0;
1889 }
1890
1891 static void DSOUND_CloseAudio(void)
1892 {
1893 int neutral;
1894
1895 neutral = primarybuf->wfx.wBitsPerSample == 8 ? 128 : 0;
1896 audioOK = 0; // race condition
1897 Sleep(5);
1898 // It's possible we've been called with audio closed
1899 // from SetFormat()... this is just to force a call
1900 // to OpenAudio() to reset the hardware properly
1901 if (audiofd != -1)
1902 close(audiofd);
1903 primarybuf->playpos = 0;
1904 primarybuf->writepos = DSOUND_FRAGLEN;
1905 memset(primarybuf->buffer, neutral, primarybuf->buflen);
1906 audiofd = -1;
1907 TRACE(dsound, "Audio stopped\n");
1908 }
1909
1910 static int DSOUND_WriteAudio(char *buf, int len)
1911 {
1912 int result, left = 0;
1913
1914 while (left < len) {
1915 result = write(audiofd, buf + left, len - left);
1916 if (result == -1)
1917 if (errno == EINTR)
1918 continue;
1919 else
1920 return result;
1921 left += result;
1922 }
1923 return 0;
1924 }
1925
1926 static void DSOUND_OutputPrimary(int len)
1927 {
1928 int neutral, flen1, flen2;
1929 char *frag1, *frag2;
1930
1931 // This is a bad place for this. We need to clear the
1932 // buffer with a neutral value, for unsigned 8-bit WAVE
1933 // that's 128, for signed 16-bit it's 0
1934 neutral = primarybuf->wfx.wBitsPerSample == 8 ? 128 : 0;
1935
1936 // ****
1937 EnterCriticalSection(&(primarybuf->lock));
1938
1939 // Write out the
1940 if ((audioOK == 1) || (DSOUND_OpenAudio() == 0)) {
1941 if (primarybuf->playpos + len >= primarybuf->buflen) {
1942 frag1 = primarybuf->buffer + primarybuf->playpos;
1943 flen1 = primarybuf->buflen - primarybuf->playpos;
1944 frag2 = primarybuf->buffer;
1945 flen2 = len - (primarybuf->buflen - primarybuf->playpos);
1946 if (DSOUND_WriteAudio(frag1, flen1) != 0) {
1947 perror("DSOUND_WriteAudio");
1948 LeaveCriticalSection(&(primarybuf->lock));
1949 ExitThread(0);
1950 }
1951 memset(frag1, neutral, flen1);
1952 if (DSOUND_WriteAudio(frag2, flen2) != 0) {
1953 perror("DSOUND_WriteAudio");
1954 LeaveCriticalSection(&(primarybuf->lock));
1955 ExitThread(0);
1956 }
1957 memset(frag2, neutral, flen2);
1958 } else {
1959 frag1 = primarybuf->buffer + primarybuf->playpos;
1960 flen1 = len;
1961 if (DSOUND_WriteAudio(frag1, flen1) != 0) {
1962 perror("DSOUND_WriteAudio");
1963 LeaveCriticalSection(&(primarybuf->lock));
1964 ExitThread(0);
1965 }
1966 memset(frag1, neutral, flen1);
1967 }
1968 } else {
1969 // Can't play audio at the moment -- we need to sleep
1970 // to make up for the time we'd be blocked in write()
1971 // to /dev/audio
1972 Sleep(60);
1973 }
1974 primarybuf->playpos += len;
1975 if (primarybuf->playpos >= primarybuf->buflen)
1976 primarybuf->playpos %= primarybuf->buflen;
1977 primarybuf->writepos = primarybuf->playpos + DSOUND_FRAGLEN;
1978 if (primarybuf->writepos >= primarybuf->buflen)
1979 primarybuf->writepos %= primarybuf->buflen;
1980
1981 LeaveCriticalSection(&(primarybuf->lock));
1982 // ****
1983 }
1984
1985 static DWORD WINAPI DSOUND_thread(LPVOID arg)
1986 {
1987 int len;
1988
1989 TRACE(dsound,"dsound is at pid %d\n",getpid());
1990 while (1) {
1991 if (!dsound) {
1992 WARN(dsound,"DSOUND thread giving up.\n");
1993 ExitThread(0);
1994 }
1995 if (getppid()==1) {
1996 WARN(dsound,"DSOUND father died? Giving up.\n");
1997 ExitThread(0);
1998 }
1999 /* RACE: dsound could be deleted */
2000 dsound->lpvtbl->fnAddRef(dsound);
2001 if (primarybuf == NULL) {
2002 // Should never happen
2003 WARN(dsound, "Lost the primary buffer!\n");
2004 dsound->lpvtbl->fnRelease(dsound);
2005 ExitThread(0);
2006 }
2007
2008 // ****
2009 EnterCriticalSection(&(primarybuf->lock));
2010 len = DSOUND_MixPrimary();
2011 LeaveCriticalSection(&(primarybuf->lock));
2012 // ****
2013
2014 if (primarybuf->playing)
2015 len = DSOUND_FRAGLEN > len ? DSOUND_FRAGLEN : len;
2016 if (len) {
2017 // This does all the work
2018 DSOUND_OutputPrimary(len);
2019 } else {
2020 // no buffers playing -- close and wait
2021 if (audioOK)
2022 DSOUND_CloseAudio();
2023 Sleep(100);
2024 }
2025 dsound->lpvtbl->fnRelease(dsound);
2026 }
2027 ExitThread(0);
2028 }
2029
2030 #endif /* HAVE_OSS */
2031
2032 HRESULT WINAPI DirectSoundCreate(LPGUID lpGUID,LPDIRECTSOUND *ppDS,IUnknown *pUnkOuter )
2033 {
2034 if (lpGUID)
2035 TRACE(dsound,"(%p,%p,%p)\n",lpGUID,ppDS,pUnkOuter);
2036 else
2037 TRACE(dsound,"DirectSoundCreate (%p)\n", ppDS);
2038
2039 #ifdef HAVE_OSS
2040
2041 if (ppDS == NULL)
2042 return DSERR_INVALIDPARAM;
2043
2044 if (primarybuf) {
2045 dsound->lpvtbl->fnAddRef(dsound);
2046 *ppDS = dsound;
2047 return DS_OK;
2048 }
2049
2050 // Check that we actually have audio capabilities
2051 // If we do, whether it's busy or not, we continue
2052 // otherwise we return with DSERR_NODRIVER
2053
2054 audiofd = open("/dev/audio",O_WRONLY);
2055 if (audiofd == -1) {
2056 if (errno == ENODEV) {
2057 TRACE(dsound, "No sound hardware\n");
2058 return DSERR_NODRIVER;
2059 } else if (errno == EBUSY) {
2060 TRACE(dsound, "Sound device busy, will keep trying\n");
2061 } else {
2062 TRACE(dsound, "Unexpected error while checking for sound support\n");
2063 return DSERR_GENERIC;
2064 }
2065 } else {
2066 close(audiofd);
2067 audiofd = -1;
2068 }
2069
2070 *ppDS = (LPDIRECTSOUND)HeapAlloc(GetProcessHeap(),0,sizeof(IDirectSound));
2071 if (*ppDS == NULL)
2072 return DSERR_OUTOFMEMORY;
2073
2074 (*ppDS)->ref = 1;
2075 (*ppDS)->lpvtbl = &dsvt;
2076 (*ppDS)->buffers = NULL;
2077 (*ppDS)->nrofbuffers = 0;
2078
2079 (*ppDS)->wfx.wFormatTag = 1;
2080 (*ppDS)->wfx.nChannels = 2;
2081 (*ppDS)->wfx.nSamplesPerSec = 22050;
2082 (*ppDS)->wfx.nAvgBytesPerSec = 44100;
2083 (*ppDS)->wfx.nBlockAlign = 2;
2084 (*ppDS)->wfx.wBitsPerSample = 8;
2085
2086 if (!dsound) {
2087 HANDLE32 hnd;
2088 DWORD xid;
2089
2090 dsound = (*ppDS);
2091 if (primarybuf == NULL) {
2092 DSBUFFERDESC dsbd;
2093 HRESULT hr;
2094
2095 dsbd.dwSize = sizeof(DSBUFFERDESC);
2096 dsbd.dwFlags = DSBCAPS_PRIMARYBUFFER;
2097 dsbd.dwBufferBytes = 0;
2098 dsbd.lpwfxFormat = &(dsound->wfx);
2099 hr = IDirectSound_CreateSoundBuffer(*ppDS, &dsbd, &primarybuf, NULL);
2100 if (hr != DS_OK)
2101 return hr;
2102 dsound->primary = primarybuf;
2103 }
2104 memset(primarybuf->buffer, 128, primarybuf->buflen);
2105 hnd = CreateThread(NULL,0,DSOUND_thread,0,0,&xid);
2106 }
2107 return DS_OK;
2108 #else
2109 MessageBox32A(0,"DirectSound needs the Open Sound System Driver, which has not been found by ./configure.","WINE DirectSound",MB_OK|MB_ICONSTOP);
2110 return DSERR_NODRIVER;
2111 #endif
2112 }
2113
2114 /*******************************************************************************
2115 * DirectSound ClassFactory
2116 */
2117 static HRESULT WINAPI
2118 DSCF_QueryInterface(LPCLASSFACTORY this,REFIID riid,LPVOID *ppobj) {
2119 char buf[80];
2120
2121 if (HIWORD(riid))
2122 WINE_StringFromCLSID(riid,buf);
2123 else
2124 sprintf(buf,"<guid-0x%04x>",LOWORD(riid));
2125 FIXME(dsound,"(%p)->(%s,%p),stub!\n",this,buf,ppobj);
2126 return E_NOINTERFACE;
2127 }
2128
2129 static ULONG WINAPI
2130 DSCF_AddRef(LPCLASSFACTORY this) {
2131 return ++(this->ref);
2132 }
2133
2134 static ULONG WINAPI DSCF_Release(LPCLASSFACTORY this) {
2135 /* static class, won't be freed */
2136 return --(this->ref);
2137 }
2138
2139 static HRESULT WINAPI DSCF_CreateInstance(
2140 LPCLASSFACTORY this,LPUNKNOWN pOuter,REFIID riid,LPVOID *ppobj
2141 ) {
2142 char buf[80];
2143
2144 WINE_StringFromCLSID(riid,buf);
2145 TRACE(dsound,"(%p)->(%p,%s,%p)\n",this,pOuter,buf,ppobj);
2146 if (!memcmp(riid,&IID_IDirectSound,sizeof(IID_IDirectSound))) {
2147 /* FIXME: reuse already created dsound if present? */
2148 return DirectSoundCreate(riid,(LPDIRECTSOUND*)ppobj,pOuter);
2149 }
2150 return E_NOINTERFACE;
2151 }
2152
2153 static HRESULT WINAPI DSCF_LockServer(LPCLASSFACTORY this,BOOL32 dolock) {
2154 FIXME(dsound,"(%p)->(%d),stub!\n",this,dolock);
2155 return S_OK;
2156 }
2157
2158 static IClassFactory_VTable DSCF_VTable = {
2159 DSCF_QueryInterface,
2160 DSCF_AddRef,
2161 DSCF_Release,
2162 DSCF_CreateInstance,
2163 DSCF_LockServer
2164 };
2165 static IClassFactory DSOUND_CF = {&DSCF_VTable, 1 };
2166
2167 /*******************************************************************************
2168 * DllGetClassObject [DSOUND.4]
2169 * Retrieves class object from a DLL object
2170 *
2171 * NOTES
2172 * Docs say returns STDAPI
2173 *
2174 * PARAMS
2175 * rclsid [I] CLSID for the class object
2176 * riid [I] Reference to identifier of interface for class object
2177 * ppv [O] Address of variable to receive interface pointer for riid
2178 *
2179 * RETURNS
2180 * Success: S_OK
2181 * Failure: CLASS_E_CLASSNOTAVAILABLE, E_OUTOFMEMORY, E_INVALIDARG,
2182 * E_UNEXPECTED
2183 */
2184 DWORD WINAPI DSOUND_DllGetClassObject(REFCLSID rclsid,REFIID riid,LPVOID *ppv)
2185 {
2186 char buf[80],xbuf[80];
2187
2188 if (HIWORD(rclsid))
2189 WINE_StringFromCLSID(rclsid,xbuf);
2190 else
2191 sprintf(xbuf,"<guid-0x%04x>",LOWORD(rclsid));
2192 if (HIWORD(riid))
2193 WINE_StringFromCLSID(riid,buf);
2194 else
2195 sprintf(buf,"<guid-0x%04x>",LOWORD(riid));
2196 WINE_StringFromCLSID(riid,xbuf);
2197 TRACE(dsound, "(%p,%p,%p)\n", xbuf, buf, ppv);
2198 if (!memcmp(riid,&IID_IClassFactory,sizeof(IID_IClassFactory))) {
2199 *ppv = (LPVOID)&DSOUND_CF;
2200 DSOUND_CF.lpvtbl->fnAddRef(&DSOUND_CF);
2201 return S_OK;
2202 }
2203 FIXME(dsound, "(%p,%p,%p): no interface found.\n", xbuf, buf, ppv);
2204 return E_NOINTERFACE;
2205 }
2206
2207
2208 /*******************************************************************************
2209 * DllCanUnloadNow [DSOUND.3] Determines whether the DLL is in use.
2210 *
2211 * RETURNS
2212 * Success: S_OK
2213 * Failure: S_FALSE
2214 */
2215 DWORD WINAPI DSOUND_DllCanUnloadNow(void)
2216 {
2217 FIXME(dsound, "(void): stub\n");
2218 return S_FALSE;
2219 }
Maarten's multimedia branch