?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Release 981025.
[wine/multimedia.git] / multimedia / dsound.c
blobbfb24a7b50eb7dde50c6ddc42dda9ca88cb09ab8
1 /* DirectSound
2 *
3 * Copyright 1998 Marcus Meissner
4 */
5 /*
6 * Note: This file requires multithread ability. It is not possible to
7 * implement the stuff in a single thread anyway. And most DirectX apps
8 * require threading themselves.
9 *
10 * FIXME: This file is full of race conditions and unlocked variable access
11 * from two threads. But we usually don't need to bother.
12 *
13 * Tested with a Soundblaster clone and a Gravis UltraSound Classic.
14 *
15 * Status:
16 * - Wing Commander 4/W95:
17 * The intromovie plays without problems. Nearly lipsynchron.
18 * - DiscWorld 2
19 * The sound works, but noticeable chunks are left out (from the sound and
20 * the animation). Don't know why yet.
21 * - Diablo:
22 * Sound works, but slows down the movieplayer.
23 * - XvT:
24 * Doesn't sound yet.
25 * - Monkey Island 3:
26 * The background sound of the startscreen works ;)
27 * - WingCommander Prophecy Demo:
28 * Sound works for the intromovie.
29 */
30
31 #include "config.h"
32 #include <assert.h>
33 #include <errno.h>
34 #include <sys/types.h>
35 #include <sys/time.h>
36 #include <sys/fcntl.h>
37 #include <unistd.h>
38 #include <stdlib.h>
39 #include <string.h>
40 #include <math.h> /* Insomnia - pow() function */
41 #include "windows.h"
42 #include "winerror.h"
43 #include "interfaces.h"
44 #include "mmsystem.h"
45 #include "dsound.h"
46 #include "thread.h"
47 #include "debug.h"
48
49 #ifdef HAVE_OSS
50 # include <sys/ioctl.h>
51 # ifdef HAVE_MACHINE_SOUNDCARD_H
52 # include <machine/soundcard.h>
53 # endif
54 # ifdef HAVE_SYS_SOUNDCARD_H
55 # include <sys/soundcard.h>
56 # endif
57
58 static int audiofd = -1;
59 static LPDIRECTSOUND dsound = NULL;
60
61 static short playbuf[2048];
62
63 #endif
64
65 HRESULT WINAPI DirectSoundEnumerate32A(LPDSENUMCALLBACK32A enumcb,LPVOID context) {
66 #ifdef HAVE_OSS
67 enumcb(NULL,"WINE DirectSound using Open Sound System","sound",context);
68 #endif
69 return 0;
70 }
71
72 #ifdef HAVE_OSS
73 static void _dump_DSBCAPS(DWORD xmask) {
74 struct {
75 DWORD mask;
76 char *name;
77 } flags[] = {
78 #define FE(x) { x, #x },
79 FE(DSBCAPS_PRIMARYBUFFER)
80 FE(DSBCAPS_STATIC)
81 FE(DSBCAPS_LOCHARDWARE)
82 FE(DSBCAPS_LOCSOFTWARE)
83 FE(DSBCAPS_CTRLFREQUENCY)
84 FE(DSBCAPS_CTRLPAN)
85 FE(DSBCAPS_CTRLVOLUME)
86 FE(DSBCAPS_CTRLDEFAULT)
87 FE(DSBCAPS_CTRLALL)
88 FE(DSBCAPS_STICKYFOCUS)
89 FE(DSBCAPS_GETCURRENTPOSITION2)
90 };
91 int i;
92
93 for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
94 if (flags[i].mask & xmask)
95 fprintf(stderr,"%s ",flags[i].name);
96 }
97
98 /*******************************************************************************
99 * IDirectSoundNotify
100 */
101 static HRESULT WINAPI IDirectSoundNotify_QueryInterface(
102 LPDIRECTSOUNDNOTIFY this,REFIID riid,LPVOID *ppobj
103 ) {
104 char xbuf[50];
105
106 WINE_StringFromCLSID(riid,xbuf);
107 TRACE(dsound,"(%p,%s,%p)\n",this,xbuf,ppobj);
108 return E_FAIL;
109 }
110
111 static ULONG WINAPI IDirectSoundNotify_AddRef(LPDIRECTSOUNDNOTIFY this) {
112 return ++(this->ref);
113 }
114
115 static ULONG WINAPI IDirectSoundNotify_Release(LPDIRECTSOUNDNOTIFY this) {
116 this->ref--;
117 if (!this->ref) {
118 this->dsb->lpvtbl->fnRelease(this->dsb);
119 HeapFree(GetProcessHeap(),0,this);
120 return 0;
121 }
122 return this->ref;
123 }
124
125 static int _sort_notifies(const void *a,const void *b) {
126 LPDSBPOSITIONNOTIFY na = (LPDSBPOSITIONNOTIFY)a;
127 LPDSBPOSITIONNOTIFY nb = (LPDSBPOSITIONNOTIFY)b;
128
129 return na->dwOffset-nb->dwOffset;
130 }
131
132 static HRESULT WINAPI IDirectSoundNotify_SetNotificationPositions(
133 LPDIRECTSOUNDNOTIFY this,DWORD howmuch,LPCDSBPOSITIONNOTIFY notify
134 ) {
135 int i;
136
137 if (TRACE_ON(dsound)) {
138 TRACE(dsound,"(%p,0x%08lx,%p)\n",this,howmuch,notify);
139 for (i=0;i<howmuch;i++)
140 TRACE(dsound,"notify at %ld to 0x%08lx\n",
141 notify[i].dwOffset,(DWORD)notify[i].hEventNotify);
142 }
143 this->dsb->notifies = HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,this->dsb->notifies,(this->dsb->nrofnotifies+howmuch)*sizeof(DSBPOSITIONNOTIFY));
144 memcpy( this->dsb->notifies+this->dsb->nrofnotifies,
145 notify,
146 howmuch*sizeof(DSBPOSITIONNOTIFY)
147 );
148 this->dsb->nrofnotifies+=howmuch;
149 qsort(this->dsb->notifies,this->dsb->nrofnotifies,sizeof(DSBPOSITIONNOTIFY),_sort_notifies);
150 return 0;
151 }
152
153 IDirectSoundNotify_VTable dsnvt = {
154 IDirectSoundNotify_QueryInterface,
155 IDirectSoundNotify_AddRef,
156 IDirectSoundNotify_Release,
157 IDirectSoundNotify_SetNotificationPositions,
158 };
159
160 /*******************************************************************************
161 * IDirectSoundBuffer
162 */
163 static HRESULT WINAPI IDirectSoundBuffer_SetFormat(
164 LPDIRECTSOUNDBUFFER this,LPWAVEFORMATEX wfex
165 ) {
166
167 memcpy(&(this->wfx),wfex,sizeof(this->wfx));
168 TRACE(dsound,"(%p,%p)\n", this,wfex);
169 TRACE(dsound,"(formattag=0x%04x,chans=%d,samplerate=%ld"
170 "bytespersec=%ld,blockalign=%d,bitspersamp=%d,cbSize=%d)\n",
171 wfex->wFormatTag, wfex->nChannels, wfex->nSamplesPerSec,
172 wfex->nAvgBytesPerSec, wfex->nBlockAlign,
173 wfex->wBitsPerSample, wfex->cbSize);
174
175 return 0;
176 }
177
178 static HRESULT WINAPI IDirectSoundBuffer_SetVolume(
179 LPDIRECTSOUNDBUFFER this,LONG vol
180 ) {
181 TRACE(dsound,"(%p,%ld)\n",this,vol);
182 this->volume = vol;
183 this->volfac = ((double)vol+10000.0)/10000.0;
184
185 return 0;
186 }
187
188 static HRESULT WINAPI IDirectSoundBuffer_GetVolume(
189 LPDIRECTSOUNDBUFFER this,LPLONG vol
190 ) {
191 TRACE(dsound,"(%p,%p)\n",this,vol);
192 *vol = this->volume;
193 return 0;
194 }
195
196 static HRESULT WINAPI IDirectSoundBuffer_SetFrequency(
197 LPDIRECTSOUNDBUFFER this,DWORD freq
198 ) {
199 TRACE(dsound,"(%p,%ld)\n",this,freq);
200 this->wfx.nSamplesPerSec = freq;
201 this->wfx.nAvgBytesPerSec = freq*this->wfx.nChannels*(this->wfx.wBitsPerSample/8);
202 return 0;
203 }
204
205 static HRESULT WINAPI IDirectSoundBuffer_Play(
206 LPDIRECTSOUNDBUFFER this,DWORD reserved1,DWORD reserved2,DWORD flags
207 ) {
208 TRACE(dsound,"(%p,%08lx,%08lx,%08lx)\n",
209 this,reserved1,reserved2,flags
210 );
211 this->playpos = 0;
212 this->playflags = flags;
213 this->playing = 1;
214 return 0;
215 }
216
217 static HRESULT WINAPI IDirectSoundBuffer_Stop(LPDIRECTSOUNDBUFFER this) {
218 TRACE(dsound,"(%p)\n",this);
219 this->playing = 0;
220 this->writepos = 0; /* hmm */
221 return 0;
222 }
223
224 static DWORD WINAPI IDirectSoundBuffer_AddRef(LPDIRECTSOUNDBUFFER this) {
225 return ++(this->ref);
226 }
227 static DWORD WINAPI IDirectSoundBuffer_Release(LPDIRECTSOUNDBUFFER this) {
228 int i;
229
230 if (--this->ref)
231 return this->ref;
232 for (i=0;i<this->dsound->nrofbuffers;i++)
233 if (this->dsound->buffers[i] == this)
234 break;
235 if (i < this->dsound->nrofbuffers) {
236 memcpy(
237 this->dsound->buffers+i,
238 this->dsound->buffers+i+1,
239 sizeof(LPDIRECTSOUNDBUFFER)*(this->dsound->nrofbuffers-i-1)
240 );
241 this->dsound->buffers = HeapReAlloc(GetProcessHeap(),0,this->dsound->buffers,sizeof(LPDIRECTSOUNDBUFFER)*this->dsound->nrofbuffers);
242 this->dsound->nrofbuffers--;
243 this->dsound->lpvtbl->fnRelease(this->dsound);
244 }
245 HeapFree(GetProcessHeap(),0,this->buffer);
246 HeapFree(GetProcessHeap(),0,this);
247 return 0;
248 }
249
250 static HRESULT WINAPI IDirectSoundBuffer_GetCurrentPosition(
251 LPDIRECTSOUNDBUFFER this,LPDWORD playpos,LPDWORD writepos
252 ) {
253 TRACE(dsound,"(%p,%p,%p)\n",this,playpos,writepos);
254 if (playpos) *playpos = this->playpos;
255 if (writepos) *writepos = this->writepos;
256 return 0;
257 }
258
259 static HRESULT WINAPI IDirectSoundBuffer_GetStatus(
260 LPDIRECTSOUNDBUFFER this,LPDWORD status
261 ) {
262 TRACE(dsound,"(%p,%p)\n",this,status);
263 *status = 0;
264 if (this->playing)
265 *status |= DSBSTATUS_PLAYING;
266 if (this->playflags & DSBPLAY_LOOPING)
267 *status |= DSBSTATUS_LOOPING;
268 return 0;
269 }
270
271 static HRESULT WINAPI IDirectSoundBuffer_GetFormat(
272 LPDIRECTSOUNDBUFFER this,LPWAVEFORMATEX lpwf,DWORD wfsize,LPDWORD wfwritten
273 ) {
274 TRACE(dsound,"(%p,%p,%ld,%p)\n",this,lpwf,wfsize,wfwritten);
275 if (wfsize>sizeof(this->wfx)) wfsize = sizeof(this->wfx);
276 memcpy(lpwf,&(this->wfx),wfsize);
277 if (wfwritten) *wfwritten = wfsize;
278 return 0;
279 }
280
281 static HRESULT WINAPI IDirectSoundBuffer_Lock(
282 LPDIRECTSOUNDBUFFER this,DWORD writecursor,DWORD writebytes,LPVOID lplpaudioptr1,LPDWORD audiobytes1,LPVOID lplpaudioptr2,LPDWORD audiobytes2,DWORD flags
283 ) {
284
285 TRACE(dsound,"(%p,%ld,%ld,%p,%p,%p,%p,0x%08lx)\n",
286 this,
287 writecursor,
288 writebytes,
289 lplpaudioptr1,
290 audiobytes1,
291 lplpaudioptr2,
292 audiobytes2,
293 flags
294 );
295 if (flags & DSBLOCK_FROMWRITECURSOR)
296 writecursor = this->writepos;
297 assert(audiobytes1!=audiobytes2);
298 assert(lplpaudioptr1!=lplpaudioptr2);
299 if (writecursor+writebytes <= this->buflen) {
300 *(LPBYTE*)lplpaudioptr1 = this->buffer+writecursor;
301 *audiobytes1 = writebytes;
302 if (lplpaudioptr2)
303 *(LPBYTE*)lplpaudioptr2 = NULL;
304 if (audiobytes2)
305 *audiobytes2 = 0;
306 TRACE(dsound,"->%ld.0\n",writebytes);
307 } else {
308 *(LPBYTE*)lplpaudioptr1 = this->buffer+writecursor;
309 *audiobytes1 = this->buflen-writecursor;
310 if (lplpaudioptr2)
311 *(LPBYTE*)lplpaudioptr2 = this->buffer;
312 if (audiobytes2)
313 *audiobytes2 = writebytes-(this->buflen-writecursor);
314 TRACE(dsound,"->%ld.%ld\n",*audiobytes1,audiobytes2?*audiobytes2:0);
315 }
316 this->writepos=(writecursor+writebytes)%this->buflen;
317 return 0;
318 }
319
320 static HRESULT WINAPI IDirectSoundBuffer_SetCurrentPosition(
321 LPDIRECTSOUNDBUFFER this,DWORD newpos
322 ) {
323 TRACE(dsound,"(%p,%ld)\n",this,newpos);
324 this->playpos = newpos;
325 return 0;
326 }
327
328 static HRESULT WINAPI IDirectSoundBuffer_SetPan(
329 LPDIRECTSOUNDBUFFER this,LONG newpan
330 ) {
331 TRACE(dsound,"(%p,%ld)\n",this,newpan);
332 this->pan = newpan;
333 return 0;
334 }
335
336 static HRESULT WINAPI IDirectSoundBuffer_GetPan(
337 LPDIRECTSOUNDBUFFER this,LPLONG pan
338 ) {
339 TRACE(dsound,"(%p,%p)\n",this,pan);
340 *pan = this->pan;
341 return 0;
342 }
343
344 static HRESULT WINAPI IDirectSoundBuffer_Unlock(
345 LPDIRECTSOUNDBUFFER this,LPVOID p1,DWORD x1,LPVOID p2,DWORD x2
346 ) {
347 /* FIXME(dsound,"(%p,%p,%ld,%p,%ld):stub\n", this,p1,x1,p2,x2); */
348 return 0;
349 }
350
351 static HRESULT WINAPI IDirectSoundBuffer_GetFrequency(
352 LPDIRECTSOUNDBUFFER this,LPDWORD freq
353 ) {
354 TRACE(dsound,"(%p,%p)\n",this,freq);
355 *freq = this->wfx.nSamplesPerSec;
356 return 0;
357 }
358
359 static HRESULT WINAPI IDirectSoundBuffer_Initialize(
360 LPDIRECTSOUNDBUFFER this,LPDIRECTSOUND dsound,LPDSBUFFERDESC dbsd
361 ) {
362 FIXME(dsound,"(%p,%p,%p):stub\n",this,dsound,dbsd);
363 printf("Re-Init!!!\n");
364 return DSERR_ALREADYINITIALIZED;
365 }
366
367 static HRESULT WINAPI IDirectSoundBuffer_GetCaps(
368 LPDIRECTSOUNDBUFFER this,LPDSBCAPS caps
369 ) {
370 caps->dwSize = sizeof(*caps);
371 caps->dwFlags = DSBCAPS_PRIMARYBUFFER|DSBCAPS_STATIC|DSBCAPS_CTRLALL|DSBCAPS_LOCSOFTWARE;
372 caps->dwBufferBytes = 65536;
373 caps->dwUnlockTransferRate = 0;
374 caps->dwPlayCpuOverhead = 0;
375 return DS_OK;
376 }
377
378 static HRESULT WINAPI IDirectSoundBuffer_QueryInterface(
379 LPDIRECTSOUNDBUFFER this,REFIID riid,LPVOID *ppobj
380 ) {
381 char xbuf[50];
382
383 if (!memcmp(&IID_IDirectSoundNotify,riid,sizeof(*riid))) {
384 IDirectSoundNotify *dsn;
385
386 dsn = (LPDIRECTSOUNDNOTIFY)HeapAlloc(GetProcessHeap(),0,sizeof(*dsn));
387 dsn->ref = 1;
388 dsn->dsb = this;
389 this->lpvtbl->fnAddRef(this);
390 dsn->lpvtbl = &dsnvt;
391 *ppobj = (LPVOID)dsn;
392 return 0;
393 }
394 WINE_StringFromCLSID(riid,xbuf);
395 TRACE(dsound,"(%p,%s,%p)\n",this,xbuf,ppobj);
396 return E_FAIL;
397 }
398
399 static struct tagLPDIRECTSOUNDBUFFER_VTABLE dsbvt = {
400 IDirectSoundBuffer_QueryInterface,
401 IDirectSoundBuffer_AddRef,
402 IDirectSoundBuffer_Release,
403 IDirectSoundBuffer_GetCaps,
404 IDirectSoundBuffer_GetCurrentPosition,
405 IDirectSoundBuffer_GetFormat,
406 IDirectSoundBuffer_GetVolume,
407 IDirectSoundBuffer_GetPan,
408 IDirectSoundBuffer_GetFrequency,
409 IDirectSoundBuffer_GetStatus,
410 IDirectSoundBuffer_Initialize,
411 IDirectSoundBuffer_Lock,
412 IDirectSoundBuffer_Play,
413 IDirectSoundBuffer_SetCurrentPosition,
414 IDirectSoundBuffer_SetFormat,
415 IDirectSoundBuffer_SetVolume,
416 IDirectSoundBuffer_SetPan,
417 IDirectSoundBuffer_SetFrequency,
418 IDirectSoundBuffer_Stop,
419 IDirectSoundBuffer_Unlock
420 };
421
422 /*******************************************************************************
423 * IDirectSound
424 */
425
426 static HRESULT WINAPI IDirectSound_SetCooperativeLevel(
427 LPDIRECTSOUND this,HWND32 hwnd,DWORD level
428 ) {
429 FIXME(dsound,"(%p,%08lx,%ld):stub\n",this,(DWORD)hwnd,level);
430 return 0;
431 }
432
433
434 static HRESULT WINAPI IDirectSound_CreateSoundBuffer(
435 LPDIRECTSOUND this,LPDSBUFFERDESC dsbd,LPLPDIRECTSOUNDBUFFER ppdsb,LPUNKNOWN lpunk
436 ) {
437 if (TRACE_ON(dsound)) {
438 TRACE(dsound,"(%p,%p,%p,%p)\n",this,dsbd,ppdsb,lpunk);
439 TRACE(dsound,"(size=%ld)\n",dsbd->dwSize);
440 TRACE(dsound,"(flags=0x%08lx\n",dsbd->dwFlags);
441 _dump_DSBCAPS(dsbd->dwFlags);
442 TRACE(dsound,"(bufferbytes=%ld)\n",dsbd->dwBufferBytes);
443 TRACE(dsound,"(lpwfxFormat=%p)\n",dsbd->lpwfxFormat);
444 }
445 *ppdsb = (LPDIRECTSOUNDBUFFER)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectSoundBuffer));
446 (*ppdsb)->ref =1;
447 (*ppdsb)->buffer = (LPBYTE)HeapAlloc(GetProcessHeap(),0,dsbd->dwBufferBytes);
448 (*ppdsb)->buflen = dsbd->dwBufferBytes;
449 (*ppdsb)->playpos = 0;
450 (*ppdsb)->writepos = 0;
451 (*ppdsb)->lpvtbl = &dsbvt;
452 (*ppdsb)->dsound = this;
453 (*ppdsb)->playing = 0;
454 (*ppdsb)->volfac = 1.0;
455 memcpy(&((*ppdsb)->dsbd),dsbd,sizeof(*dsbd));
456
457 /* register buffer */
458 this->buffers = (LPDIRECTSOUNDBUFFER*)HeapReAlloc(GetProcessHeap(),0,this->buffers,sizeof(LPDIRECTSOUNDBUFFER)*(this->nrofbuffers+1));
459 this->buffers[this->nrofbuffers] = *ppdsb;
460 this->nrofbuffers++;
461 this->lpvtbl->fnAddRef(this);
462
463 if (dsbd->lpwfxFormat) dsbvt.fnSetFormat(*ppdsb,dsbd->lpwfxFormat);
464 return 0;
465 }
466
467 static HRESULT WINAPI IDirectSound_DuplicateSoundBuffer(
468 LPDIRECTSOUND this,LPDIRECTSOUNDBUFFER pdsb,LPLPDIRECTSOUNDBUFFER ppdsb
469 ) {
470 TRACE(dsound,"(%p,%p,%p)\n",this,pdsb,ppdsb);
471
472 *ppdsb = (LPDIRECTSOUNDBUFFER)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectSoundBuffer));
473 (*ppdsb)->ref =1;
474 (*ppdsb)->buffer = (LPBYTE)HeapAlloc(GetProcessHeap(),0,pdsb->buflen);
475 memcpy((*ppdsb)->buffer,pdsb->buffer,pdsb->buflen);
476 (*ppdsb)->buflen = pdsb->buflen;
477 (*ppdsb)->playpos = 0;
478 (*ppdsb)->writepos = 0;
479 (*ppdsb)->lpvtbl = &dsbvt;
480 (*ppdsb)->dsound = this;
481 dsbvt.fnSetFormat(*ppdsb,&(pdsb->wfx));
482 /* register buffer */
483 this->buffers = (LPDIRECTSOUNDBUFFER*)HeapReAlloc(GetProcessHeap(),0,this->buffers,sizeof(LPDIRECTSOUNDBUFFER)*(this->nrofbuffers+1));
484 this->buffers[this->nrofbuffers] = *ppdsb;
485 this->nrofbuffers++;
486 this->lpvtbl->fnAddRef(this);
487 return 0;
488 }
489
490
491 static HRESULT WINAPI IDirectSound_GetCaps(LPDIRECTSOUND this,LPDSCAPS caps) {
492 TRACE(dsound,"(%p,%p)\n",this,caps);
493 TRACE(dsound,"(flags=0x%08lx)\n",caps->dwFlags);
494
495 caps->dwSize = sizeof(*caps);
496 caps->dwFlags = DSCAPS_PRIMARYSTEREO|DSCAPS_PRIMARY16BIT|DSCAPS_SECONDARYSTEREO|DSCAPS_SECONDARY16BIT;
497 /* FIXME: query OSS */
498 caps->dwMinSecondarySampleRate = 22050;
499 caps->dwMaxSecondarySampleRate = 48000;
500 caps->dwPrimaryBuffers = 1;
501 /* FIXME: set the rest... hmm */
502 return 0;
503 }
504
505 static ULONG WINAPI IDirectSound_AddRef(LPDIRECTSOUND this) {
506 TRACE(dsound,"(%p), ref was %d\n",this,this->ref);
507 return ++(this->ref);
508 }
509
510 static ULONG WINAPI IDirectSound_Release(LPDIRECTSOUND this) {
511 TRACE(dsound,"(%p), ref was %d\n",this,this->ref);
512 if (!--(this->ref)) {
513 HeapFree(GetProcessHeap(),0,this);
514 dsound = NULL;
515 close(audiofd);audiofd = -1;
516 return 0;
517 }
518 return this->ref;
519 }
520
521 static HRESULT WINAPI IDirectSound_SetSpeakerConfig(
522 LPDIRECTSOUND this,DWORD config
523 ) {
524 FIXME(dsound,"(%p,0x%08lx):stub\n",this,config);
525 return 0;
526 }
527
528 static HRESULT WINAPI IDirectSound_QueryInterface(
529 LPDIRECTSOUND this,REFIID riid,LPVOID *ppobj
530 ) {
531 char xbuf[50];
532
533 WINE_StringFromCLSID(riid,xbuf);
534 TRACE(dsound,"(%p,%s,%p)\n",this,xbuf,ppobj);
535 return E_FAIL;
536 }
537
538 static struct tagLPDIRECTSOUND_VTABLE dsvt = {
539 IDirectSound_QueryInterface,
540 IDirectSound_AddRef,
541 IDirectSound_Release,
542 IDirectSound_CreateSoundBuffer,
543 IDirectSound_GetCaps,
544 IDirectSound_DuplicateSoundBuffer,
545 IDirectSound_SetCooperativeLevel,
546 (void *)8,
547 (void *)9,
548 IDirectSound_SetSpeakerConfig,
549 (void *)11
550 };
551
552 static int
553 DSOUND_setformat(LPWAVEFORMATEX wfex) {
554 int xx,channels,speed,format,nformat;
555
556
557 switch (wfex->wFormatTag) {
558 default:
559 WARN(dsound,"unknown WAVE_FORMAT tag %d\n",wfex->wFormatTag);
560 return DSERR_BADFORMAT;
561 case WAVE_FORMAT_PCM:
562 break;
563 }
564 if (wfex->wBitsPerSample==8)
565 format = AFMT_U8;
566 else
567 format = AFMT_S16_LE;
568
569 if (-1==ioctl(audiofd,SNDCTL_DSP_GETFMTS,&xx)) {
570 perror("ioctl SNDCTL_DSP_GETFMTS");
571 return -1;
572 }
573 if ((xx&format)!=format) {/* format unsupported */
574 WARN(dsound,"SNDCTL_DSP_GETFMTS: format not supported\n");
575 return -1;
576 }
577 nformat = format;
578 if (-1==ioctl(audiofd,SNDCTL_DSP_SETFMT,&nformat)) {
579 perror("ioctl SNDCTL_DSP_SETFMT");
580 return -1;
581 }
582 if (nformat!=format) {/* didn't work */
583 WARN(dsound,"SNDCTL_DSP_GETFMTS: format not set\n");
584 return -1;
585 }
586
587 channels = wfex->nChannels-1;
588 if (-1==ioctl(audiofd,SNDCTL_DSP_STEREO,&channels)) {
589 perror("ioctl SNDCTL_DSP_STEREO");
590 return -1;
591 }
592 speed = wfex->nSamplesPerSec;
593 if (-1==ioctl(audiofd,SNDCTL_DSP_SPEED,&speed)) {
594 perror("ioctl SNDCTL_DSP_SPEED");
595 return -1;
596 }
597 TRACE(dsound,"(freq=%ld,channels=%d,bits=%d)\n",
598 wfex->nSamplesPerSec,wfex->nChannels,wfex->wBitsPerSample
599 );
600 return 0;
601 }
602
603 static LPDSBPOSITIONNOTIFY
604 DSOUND_nextevent(IDirectSoundBuffer *dsb) {
605 int i;
606
607 if (dsb->nrofnotifies) {
608 for (i=0;i<dsb->nrofnotifies;i++) {
609 if (dsb->playpos<dsb->notifies[i].dwOffset)
610 break;
611 }
612 if (i==dsb->nrofnotifies)
613 i=0;
614 return dsb->notifies+i;
615 }
616 return NULL;
617 }
618
619 #define CHECK_EVENT \
620 if (nextevent && (dsb->playpos == nextevent->dwOffset)) { \
621 SetEvent(nextevent->hEventNotify); \
622 TRACE(dsound,"signalled event %d\n",nextevent->hEventNotify);\
623 nextevent = DSOUND_nextevent(dsb); \
624 }
625
626
627 static void
628 DSOUND_MixInBuffer(IDirectSoundBuffer *dsb) {
629 int j,buflen = dsb->buflen;
630 LPDSBPOSITIONNOTIFY nextevent;
631 int xdiff = dsb->wfx.nSamplesPerSec-dsound->wfx.nSamplesPerSec;
632
633 /* Insomnia - Going along with REAL author's style */
634 long Rvoldec, Lvoldec;
635 long pan = dsb->pan;
636 long samp; /* temporary sample workspace */
637
638 {
639 double tmpr=dsb->volume-500;
640 double tmpl=tmpr;
641 if(pan>0) tmpl -= (double)pan;
642 else tmpr += (double)pan;
643 tmpl /= 1000.0;
644 tmpr /= 1000.0;
645 tmpl = pow(2.0, tmpl);
646 tmpr = pow(2.0, tmpr);
647 tmpl *= 65536; /* Set to the correct multiple times */
648 tmpr *= 65536; /* 65536 to be convenient for bit shifting */
649 tmpl += 0.5; /* Add .5 for rounding accuracy */
650 tmpr += 0.5;
651 Lvoldec = (long)tmpl;
652 Rvoldec = (long)tmpr;
653 }
654 /* End Insomnia's mod */
655
656 if (xdiff<0) xdiff=-xdiff;
657 if (xdiff>1500) {
658 WARN(dsound,"mixing in buffer of different frequency (%ld vs %ld), argh!\n",
659 dsb->wfx.nSamplesPerSec,dsound->wfx.nSamplesPerSec);
660 }
661 nextevent = DSOUND_nextevent(dsb);
662 /* TRACE(dsound,"(%d.%d.%d.%d)\n",dsound->wfx.wBitsPerSample,dsb->wfx.wBitsPerSample,dsound->wfx.nChannels,dsb->wfx.nChannels);*/
663
664 if (dsound->wfx.wBitsPerSample == 8) {
665 char *playbuf8 = (char*)playbuf;
666
667 if (dsb->wfx.wBitsPerSample == 8) {
668 unsigned char *xbuf = (unsigned char*)(dsb->buffer);
669 if (dsb->wfx.nChannels == 1) {
670 for (j=0;j<sizeof(playbuf)/2;j++) {
671
672 dsb->playpos=(dsb->playpos+1)%buflen;
673 if (!dsb->playpos && !(dsb->playflags&DSBPLAY_LOOPING)) {
674 dsb->playing = 0;
675 dsb->playpos = buflen;
676 return;
677 }
678 /* Insomnia- volume, panning, and correcting against wrap */
679 /* Left Channel */
680 samp = xbuf[dsb->playpos>>1];
681 samp *= Lvoldec;
682 samp >>= 16;
683 samp += playbuf8[(j<<1)];
684 if(samp > 127L) samp = 127L;
685 else if(samp < -128L) samp = -128L;
686 playbuf8[(j<<1)] = (short)samp;
687
688 /* Right Channel */
689 samp = xbuf[dsb->playpos>>1];
690 samp *= Rvoldec;
691 samp >>= 16;
692 samp += playbuf8[(j<<1)+1];
693 if(samp > 127L) samp = 127L;
694 else if(samp < -128L) samp = -128L;
695 playbuf8[(j<<1)+1] = (short)samp;
696 /* End Insomnia's mod */
697
698 CHECK_EVENT
699 }
700 } else {
701 for (j=0;j<sizeof(playbuf);j++) {
702 dsb->playpos=(dsb->playpos+1)%buflen;
703 if (!dsb->playpos && !(dsb->playflags&DSBPLAY_LOOPING)) {
704 dsb->playing = 0;
705 dsb->playpos = buflen;
706 return;
707 }
708 /* Insomnia- volume, panning, and correcting against wrap */
709 samp = xbuf[dsb->playpos>>1];
710
711 /* Right Channel */
712 if(j&1) samp *= Rvoldec;
713 /* Left Channel */
714 else samp *= Lvoldec;
715
716 samp >>= 16;
717 samp += playbuf8[j];
718 if(samp > 127L) samp = 127L;
719 else if(samp < -128L) samp = -128L;
720 playbuf8[j] = (short)samp;
721 /* End Insomnia's mod */
722
723 CHECK_EVENT
724 }
725 }
726 } else { /* 16 */
727 short *xbuf = (short*)(dsb->buffer);
728 if (dsb->wfx.nChannels == 1) {
729 for (j=0;j<sizeof(playbuf)/2;j++) {
730 dsb->playpos=(dsb->playpos+2)%buflen;
731 if (!dsb->playpos && !(dsb->playflags&DSBPLAY_LOOPING)) {
732 dsb->playing = 0;
733 dsb->playpos = buflen;
734 return;
735 }
736 /* Insomnia- volume, panning, and correcting against wrap */
737 /* Left Channel */
738 samp = xbuf[dsb->playpos>>1];
739 samp *= Lvoldec;
740 samp >>= 24;
741 samp += playbuf8[(j<<1)];
742 if(samp > 127L) samp = 127L;
743 else if(samp < -128L) samp = -128L;
744 playbuf8[(j<<1)] = (short)samp;
745
746 /* Right Channel */
747 samp = xbuf[dsb->playpos>>1];
748 samp *= Rvoldec;
749 samp >>= 24;
750 samp += playbuf8[(j<<1)+1];
751 if(samp > 127L) samp = 127L;
752 else if(samp < -128L) samp = -128L;
753 playbuf8[(j<<1)+1] = (short)samp;
754 /* End Insomnia's mod */
755
756 CHECK_EVENT
757 }
758 } else {
759 for (j=0;j<sizeof(playbuf);j++) {
760 dsb->playpos=(dsb->playpos+2)%buflen;
761 if (!dsb->playpos && !(dsb->playflags&DSBPLAY_LOOPING)) {
762 dsb->playing = 0;
763 dsb->playpos = buflen;
764 return;
765 }
766 /* Insomnia- volume, panning, and correcting against wrap */
767 samp = xbuf[dsb->playpos>>1];
768
769 /* Right Channel */
770 if(j&1) samp *= Rvoldec;
771 /* Left Channel */
772 else samp *= Lvoldec;
773
774 samp >>= 24;
775 samp += playbuf8[j];
776 if(samp > 127L) samp = 127L;
777 else if(samp < -128L) samp = -128L;
778 playbuf8[j] = (short)samp;
779 /* End Insomnia's mod */
780
781 CHECK_EVENT
782 }
783 }
784 }
785 } else { /* 16 bit */
786 if (dsb->wfx.wBitsPerSample == 8) {
787 /* unsigned char *xbuf = (unsigned char*)(dsb->buffer); */
788 char *xbuf = dsb->buffer;
789 if (dsb->wfx.nChannels == 1) {
790 WARN(dsound,"Mixing 8-bit stereo into 16!!\n");
791 for (j=0;j<sizeof(playbuf)/sizeof(playbuf[0])/2;j++) {
792 dsb->playpos=(dsb->playpos+1)%buflen;
793 if (!dsb->playpos && !(dsb->playflags&DSBPLAY_LOOPING)) {
794 dsb->playing = 0;
795 dsb->playpos = buflen;
796 return;
797 }
798 /* Insomnia- volume, panning, and correcting against wrap */
799 /* Left Channel */
800 samp = xbuf[dsb->playpos>>1];
801 samp *= Lvoldec;
802 samp >>= 8;
803 samp += playbuf[(j<<1)];
804 if(samp > 32767L) samp = 32767L;
805 else if(samp < -32768L) samp = -32768L;
806 playbuf[(j<<1)] = (short)samp;
807
808 /* Right Channel */
809 samp = xbuf[dsb->playpos>>1];
810 samp *= Rvoldec;
811 samp >>= 8;
812 samp += playbuf[(j<<1)+1];
813 if(samp > 32767L) samp = 32767L;
814 else if(samp < -32768L) samp = -32768L;
815 playbuf[(j<<1)+1] = (short)samp;
816 /* End Insomnia's mod */
817
818 CHECK_EVENT
819 }
820 } else {
821 for (j=0;j<sizeof(playbuf)/sizeof(playbuf[0]);j++) {
822 dsb->playpos=(dsb->playpos+1)%buflen;
823 if (!dsb->playpos && !(dsb->playflags&DSBPLAY_LOOPING)) {
824 dsb->playing = 0;
825 dsb->playpos = buflen;
826 return;
827 }
828 /* Insomnia- volume, panning, and correcting against wrap */
829 samp = xbuf[dsb->playpos>>1];
830
831 /* Right Channel */
832 if(j&1) samp *= Rvoldec;
833 /* Left Channel */
834 else samp *= Lvoldec;
835
836 samp >>= 8;
837 samp += playbuf[j];
838 if(samp > 32767L) samp = 32767L;
839 else if(samp < -32768L) samp = -32768L;
840 playbuf[j] = (short)samp;
841 /* End Insomnia's mod */
842
843 CHECK_EVENT
844 }
845 }
846 } else { /* 16 */
847 short *xbuf = (short*)(dsb->buffer);
848 if (dsb->wfx.nChannels == 1) {
849 for (j=0;j<sizeof(playbuf)/sizeof(playbuf[0])/2;j++) {
850 dsb->playpos=(dsb->playpos+2)%buflen;
851 if (!dsb->playpos && !(dsb->playflags&DSBPLAY_LOOPING)) {
852 dsb->playing = 0;
853 dsb->playpos = buflen;
854 return;
855 }
856 /* Insomnia- volume, panning, and correcting against wrap */
857 /* Left Channel */
858 samp = xbuf[dsb->playpos>>1];
859 samp *= Lvoldec;
860 samp >>= 16;
861 samp += playbuf[(j<<1)];
862 if(samp > 32767L) samp = 32767L;
863 else if(samp < -32768L) samp = -32768L;
864 playbuf[(j<<1)] = (short)samp;
865
866 /* Right Channel */
867 samp = xbuf[dsb->playpos>>1];
868 samp *= Rvoldec;
869 samp >>= 16;
870 samp += playbuf[(j<<1)+1];
871 if(samp > 32767L) samp = 32767L;
872 else if(samp < -32768L) samp = -32768L;
873 playbuf[(j<<1)+1] = (short)samp;
874 /* End Insomnia's mod */
875
876 CHECK_EVENT
877 }
878 } else {
879 for (j=0;j<sizeof(playbuf)/sizeof(playbuf[0]);j++) {
880 dsb->playpos=(dsb->playpos+2)%buflen;
881 if (!dsb->playpos && !(dsb->playflags&DSBPLAY_LOOPING)) {
882 dsb->playing = 0;
883 dsb->playpos = buflen;
884 return;
885 }
886 /* Insomnia- volume, panning, and correcting against wrap */
887 samp = xbuf[dsb->playpos>>1];
888
889 /* Right Channel */
890 if(j&1) samp *= Rvoldec;
891 /* Left Channel */
892 else samp *= Lvoldec;
893
894 samp >>= 16;
895 samp += playbuf[j];
896 if(samp > 32767L) samp = 32767L;
897 else if(samp < -32768L) samp = -32768L;
898 playbuf[j] = (short)samp;
899 /* End Insomnia's mod */
900
901 CHECK_EVENT
902 }
903 }
904 }
905 }
906 }
907
908 static DWORD WINAPI
909 DSOUND_thread(LPVOID arg) {
910 int res,i,curleft,playing,haveprimary = 0;
911
912 TRACE(dsound,"dsound is at pid %d\n",getpid());
913 while (1) {
914 if (!dsound) {
915 WARN(dsound,"DSOUND thread giving up.\n");
916 ExitThread(0);
917 }
918 if (getppid()==1) {
919 WARN(dsound,"DSOUND father died? Giving up.\n");
920 ExitThread(0);
921 }
922 /* RACE: dsound could be deleted */
923 dsound->lpvtbl->fnAddRef(dsound);
924 if (!dsound->nrofbuffers) {
925 /* no soundbuffer yet... wait. */
926 Sleep(1000);
927 dsound->lpvtbl->fnRelease(dsound);
928 continue;
929 }
930 memset(playbuf,0,sizeof(playbuf));
931 playing = 0;
932 haveprimary = 0;
933 for (i=dsound->nrofbuffers;i--;) {
934 IDirectSoundBuffer *dsb = dsound->buffers[i];
935
936 if (!dsb || !dsb->lpvtbl)
937 continue;
938 dsb->lpvtbl->fnAddRef(dsb);
939 if (dsb->playing && dsb->buflen)
940 playing++;
941 if (dsb->dsbd.dwFlags & DSBCAPS_PRIMARYBUFFER) {
942 haveprimary = 1;
943 if (memcmp(&dsound->wfx,&(dsb->wfx),sizeof(dsound->wfx))) {
944 DSOUND_setformat(&(dsb->wfx));
945 memcpy(&dsound->wfx,&(dsb->wfx),sizeof(dsb->wfx));
946 }
947 }
948 dsb->lpvtbl->fnRelease(dsb);
949 }
950 /* We have just one playbuffer, so use its format */
951 if ((playing==1) && !haveprimary) {
952 for (i=dsound->nrofbuffers;i--;) {
953 IDirectSoundBuffer *dsb = dsound->buffers[i];
954
955 dsb->lpvtbl->fnAddRef(dsb);
956 if (dsb->playing && dsb->buflen) {
957 if (memcmp(&dsound->wfx,&(dsb->wfx),sizeof(dsound->wfx))) {
958 DSOUND_setformat(&(dsb->wfx));
959 memcpy(&dsound->wfx,&(dsb->wfx),sizeof(dsb->wfx));
960 }
961 }
962 dsb->lpvtbl->fnRelease(dsb);
963 }
964 }
965 for (i=dsound->nrofbuffers;i--;) {
966 IDirectSoundBuffer *dsb = dsound->buffers[i];
967
968 if (!dsb || !dsb->lpvtbl)
969 continue;
970 dsb->lpvtbl->fnAddRef(dsb);
971 if (dsb->buflen && dsb->playing) {
972 playing++;
973 DSOUND_MixInBuffer(dsb);
974 }
975 dsb->lpvtbl->fnRelease(dsb);
976 }
977 dsound->lpvtbl->fnRelease(dsound);
978
979 /*fputc('0'+playing,stderr);*/
980 curleft = 0;
981 while (curleft < sizeof(playbuf)) {
982 res = write(audiofd,(LPBYTE)playbuf+curleft,sizeof(playbuf)-curleft);
983 if (res==-1) {
984 if (errno==EINTR)
985 continue;
986 perror("write audiofd");
987 ExitThread(0);
988 break;
989 }
990 curleft+=res;
991 }
992 }
993 ExitThread(0);
994 }
995
996 #endif /* HAVE_OSS */
997
998 HRESULT WINAPI DirectSoundCreate(LPGUID lpGUID,LPDIRECTSOUND *ppDS,IUnknown *pUnkOuter ) {
999 int xx;
1000 if (lpGUID)
1001 TRACE(dsound,"(%p,%p,%p)\n",lpGUID,ppDS,pUnkOuter);
1002 #ifdef HAVE_OSS
1003 if (audiofd>=0)
1004 return DSERR_ALLOCATED;
1005 audiofd = open("/dev/audio",O_WRONLY);
1006 if (audiofd==-1) {
1007 perror("open /dev/audio");
1008 audiofd=0;
1009 return DSERR_NODRIVER;
1010 }
1011 xx=0x0002000c;
1012 if (-1==ioctl(audiofd,SNDCTL_DSP_SETFRAGMENT,&xx))
1013 perror("ioctl SETFRAGMENT");
1014 /*
1015 TRACE(dsound,"SETFRAGMENT. count is now %d, fragsize is %d\n",
1016 (xx>>16)+1,xx&0xffff
1017 );
1018 */
1019
1020 *ppDS = (LPDIRECTSOUND)HeapAlloc(GetProcessHeap(),0,sizeof(IDirectSound));
1021 (*ppDS)->ref = 1;
1022 (*ppDS)->lpvtbl = &dsvt;
1023 (*ppDS)->buffers = NULL;
1024 (*ppDS)->nrofbuffers = 0;
1025
1026 (*ppDS)->wfx.wFormatTag = 1;
1027 (*ppDS)->wfx.nChannels = 2;
1028 (*ppDS)->wfx.nSamplesPerSec = 22050;
1029 (*ppDS)->wfx.nAvgBytesPerSec = 44100;
1030 (*ppDS)->wfx.nBlockAlign = 2;
1031 (*ppDS)->wfx.wBitsPerSample = 8;
1032
1033 DSOUND_setformat(&((*ppDS)->wfx));
1034
1035 if (!dsound) {
1036 HANDLE32 hnd;
1037 DWORD xid;
1038
1039 dsound = (*ppDS);
1040 hnd = CreateThread(NULL,0,DSOUND_thread,0,0,&xid);
1041 }
1042 return 0;
1043 #else
1044 MessageBox32A(0,"DirectSound needs the Open Sound System Driver, which has not been found by ./configure.","WINE DirectSound",MB_OK|MB_ICONSTOP);
1045 return DSERR_NODRIVER;
1046 #endif
1047 }
1048
1049
1050 /*******************************************************************************
1051 * DllGetClassObject [DSOUND.4]
1052 * Retrieves class object from a DLL object
1053 *
1054 * NOTES
1055 * Docs say returns STDAPI
1056 *
1057 * PARAMS
1058 * rclsid [I] CLSID for the class object
1059 * riid [I] Reference to identifier of interface for class object
1060 * ppv [O] Address of variable to receive interface pointer for riid
1061 *
1062 * RETURNS
1063 * Success: S_OK
1064 * Failure: CLASS_E_CLASSNOTAVAILABLE, E_OUTOFMEMORY, E_INVALIDARG,
1065 * E_UNEXPECTED
1066 */
1067 DWORD WINAPI DllGetClassObject( REFCLSID rclsid, REFIID riid, LPVOID *ppv )
1068 {
1069 FIXME(dsound, "(%p,%p,%p): stub\n", rclsid, riid, ppv);
1070 return S_OK;
1071 }
1072
1073
1074 /*******************************************************************************
1075 * DllCanUnloadNow [DSOUND.3] Determines whether the DLL is in use.
1076 *
1077 * RETURNS
1078 * Success: S_OK
1079 * Failure: S_FALSE
1080 */
1081 DWORD WINAPI DllCanUnloadNow(void)
1082 {
1083 FIXME(dsound, "(void): stub\n");
1084 return S_FALSE;
1085 }
Maarten's multimedia branch