?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Cleanup messages in supportedFormat.
[wine/wine-gecko.git] / dlls / dsound / mixer.c
blob1e491fefb94e2de43fce793c3a42be1441ff6859
1 /* DirectSound
2 *
3 * Copyright 1998 Marcus Meissner
4 * Copyright 1998 Rob Riggs
5 * Copyright 2000-2002 TransGaming Technologies, Inc.
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 */
21
22 #include "config.h"
23 #include <assert.h>
24 #include <stdarg.h>
25 #include <stdio.h>
26 #include <sys/types.h>
27 #include <sys/fcntl.h>
28 #ifdef HAVE_UNISTD_H
29 # include <unistd.h>
30 #endif
31 #include <stdlib.h>
32 #include <string.h>
33 #include <math.h> /* Insomnia - pow() function */
34
35 #include "windef.h"
36 #include "winbase.h"
37 #include "wingdi.h"
38 #include "winuser.h"
39 #include "winerror.h"
40 #include "mmsystem.h"
41 #include "winreg.h"
42 #include "winternl.h"
43 #include "mmddk.h"
44 #include "wine/windef16.h"
45 #include "wine/debug.h"
46 #include "dsound.h"
47 #include "dsdriver.h"
48 #include "dsound_private.h"
49
50 WINE_DEFAULT_DEBUG_CHANNEL(dsound);
51
52 void DSOUND_RecalcVolPan(PDSVOLUMEPAN volpan)
53 {
54 double temp;
55 TRACE("(%p)\n",volpan);
56
57 TRACE("Vol=%ld Pan=%ld\n", volpan->lVolume, volpan->lPan);
58 /* the AmpFactors are expressed in 16.16 fixed point */
59 volpan->dwVolAmpFactor = (ULONG) (pow(2.0, volpan->lVolume / 600.0) * 0xffff);
60 /* FIXME: dwPan{Left|Right}AmpFactor */
61
62 /* FIXME: use calculated vol and pan ampfactors */
63 temp = (double) (volpan->lVolume - (volpan->lPan > 0 ? volpan->lPan : 0));
64 volpan->dwTotalLeftAmpFactor = (ULONG) (pow(2.0, temp / 600.0) * 0xffff);
65 temp = (double) (volpan->lVolume + (volpan->lPan < 0 ? volpan->lPan : 0));
66 volpan->dwTotalRightAmpFactor = (ULONG) (pow(2.0, temp / 600.0) * 0xffff);
67
68 TRACE("left = %lx, right = %lx\n", volpan->dwTotalLeftAmpFactor, volpan->dwTotalRightAmpFactor);
69 }
70
71 void DSOUND_AmpFactorToVolPan(PDSVOLUMEPAN volpan)
72 {
73 double left,right;
74 TRACE("(%p)\n",volpan);
75
76 TRACE("left=%lx, right=%lx\n",volpan->dwTotalLeftAmpFactor,volpan->dwTotalRightAmpFactor);
77 if (volpan->dwTotalLeftAmpFactor==0)
78 left=-10000;
79 else
80 left=600 * log(((double)volpan->dwTotalLeftAmpFactor) / 0xffff) / log(2);
81 if (volpan->dwTotalRightAmpFactor==0)
82 right=-10000;
83 else
84 right=600 * log(((double)volpan->dwTotalRightAmpFactor) / 0xffff) / log(2);
85 if (left<right)
86 {
87 volpan->lVolume=right;
88 volpan->dwVolAmpFactor=volpan->dwTotalRightAmpFactor;
89 }
90 else
91 {
92 volpan->lVolume=left;
93 volpan->dwVolAmpFactor=volpan->dwTotalLeftAmpFactor;
94 }
95 if (volpan->lVolume < -10000)
96 volpan->lVolume=-10000;
97 volpan->lPan=right-left;
98 if (volpan->lPan < -10000)
99 volpan->lPan=-10000;
100
101 TRACE("Vol=%ld Pan=%ld\n", volpan->lVolume, volpan->lPan);
102 }
103
104 void DSOUND_RecalcFormat(IDirectSoundBufferImpl *dsb)
105 {
106 DWORD sw;
107 TRACE("(%p)\n",dsb);
108
109 sw = dsb->pwfx->nChannels * (dsb->pwfx->wBitsPerSample / 8);
110 /* calculate the 10ms write lead */
111 dsb->writelead = (dsb->freq / 100) * sw;
112 }
113
114 void DSOUND_CheckEvent(IDirectSoundBufferImpl *dsb, int len)
115 {
116 int i;
117 DWORD offset;
118 LPDSBPOSITIONNOTIFY event;
119 TRACE("(%p,%d)\n",dsb,len);
120
121 if (dsb->nrofnotifies == 0)
122 return;
123
124 TRACE("(%p) buflen = %ld, playpos = %ld, len = %d\n",
125 dsb, dsb->buflen, dsb->playpos, len);
126 for (i = 0; i < dsb->nrofnotifies ; i++) {
127 event = dsb->notifies + i;
128 offset = event->dwOffset;
129 TRACE("checking %d, position %ld, event = %p\n",
130 i, offset, event->hEventNotify);
131 /* DSBPN_OFFSETSTOP has to be the last element. So this is */
132 /* OK. [Inside DirectX, p274] */
133 /* */
134 /* This also means we can't sort the entries by offset, */
135 /* because DSBPN_OFFSETSTOP == -1 */
136 if (offset == DSBPN_OFFSETSTOP) {
137 if (dsb->state == STATE_STOPPED) {
138 SetEvent(event->hEventNotify);
139 TRACE("signalled event %p (%d)\n", event->hEventNotify, i);
140 return;
141 } else
142 return;
143 }
144 if ((dsb->playpos + len) >= dsb->buflen) {
145 if ((offset < ((dsb->playpos + len) % dsb->buflen)) ||
146 (offset >= dsb->playpos)) {
147 TRACE("signalled event %p (%d)\n", event->hEventNotify, i);
148 SetEvent(event->hEventNotify);
149 }
150 } else {
151 if ((offset >= dsb->playpos) && (offset < (dsb->playpos + len))) {
152 TRACE("signalled event %p (%d)\n", event->hEventNotify, i);
153 SetEvent(event->hEventNotify);
154 }
155 }
156 }
157 }
158
159 /* WAV format info can be found at:
160 *
161 * http://www.cwi.nl/ftp/audio/AudioFormats.part2
162 * ftp://ftp.cwi.nl/pub/audio/RIFF-format
163 *
164 * Import points to remember:
165 * 8-bit WAV is unsigned
166 * 16-bit WAV is signed
167 */
168 /* Use the same formulas as pcmconverter.c */
169 static inline INT16 cvtU8toS16(BYTE b)
170 {
171 return (short)((b+(b << 8))-32768);
172 }
173
174 static inline BYTE cvtS16toU8(INT16 s)
175 {
176 return (s >> 8) ^ (unsigned char)0x80;
177 }
178
179 static inline void cp_fields(const IDirectSoundBufferImpl *dsb, BYTE *ibuf, BYTE *obuf )
180 {
181 INT fl,fr;
182
183 if (dsb->pwfx->wBitsPerSample == 8) {
184 if (dsb->dsound->pwfx->wBitsPerSample == 8 &&
185 dsb->dsound->pwfx->nChannels == dsb->pwfx->nChannels) {
186 /* avoid needless 8->16->8 conversion */
187 *obuf=*ibuf;
188 if (dsb->pwfx->nChannels==2)
189 *(obuf+1)=*(ibuf+1);
190 return;
191 }
192 fl = cvtU8toS16(*ibuf);
193 fr = (dsb->pwfx->nChannels==2 ? cvtU8toS16(*(ibuf + 1)) : fl);
194 } else {
195 fl = *((INT16 *)ibuf);
196 fr = (dsb->pwfx->nChannels==2 ? *(((INT16 *)ibuf) + 1) : fl);
197 }
198
199 if (dsb->dsound->pwfx->nChannels == 2) {
200 if (dsb->dsound->pwfx->wBitsPerSample == 8) {
201 *obuf = cvtS16toU8(fl);
202 *(obuf + 1) = cvtS16toU8(fr);
203 return;
204 }
205 if (dsb->dsound->pwfx->wBitsPerSample == 16) {
206 *((INT16 *)obuf) = fl;
207 *(((INT16 *)obuf) + 1) = fr;
208 return;
209 }
210 }
211 if (dsb->dsound->pwfx->nChannels == 1) {
212 fl = (fl + fr) >> 1;
213 if (dsb->dsound->pwfx->wBitsPerSample == 8) {
214 *obuf = cvtS16toU8(fl);
215 return;
216 }
217 if (dsb->dsound->pwfx->wBitsPerSample == 16) {
218 *((INT16 *)obuf) = fl;
219 return;
220 }
221 }
222 }
223
224 /* Now with PerfectPitch (tm) technology */
225 static INT DSOUND_MixerNorm(IDirectSoundBufferImpl *dsb, BYTE *buf, INT len)
226 {
227 INT i, size, ipos, ilen;
228 BYTE *ibp, *obp;
229 INT iAdvance = dsb->pwfx->nBlockAlign;
230 INT oAdvance = dsb->dsound->pwfx->nBlockAlign;
231
232 ibp = dsb->buffer->memory + dsb->buf_mixpos;
233 obp = buf;
234
235 TRACE("(%p, %p, %p), buf_mixpos=%ld\n", dsb, ibp, obp, dsb->buf_mixpos);
236 /* Check for the best case */
237 if ((dsb->freq == dsb->dsound->pwfx->nSamplesPerSec) &&
238 (dsb->pwfx->wBitsPerSample == dsb->dsound->pwfx->wBitsPerSample) &&
239 (dsb->pwfx->nChannels == dsb->dsound->pwfx->nChannels)) {
240 DWORD bytesleft = dsb->buflen - dsb->buf_mixpos;
241 TRACE("(%p) Best case\n", dsb);
242 if (len <= bytesleft )
243 memcpy(obp, ibp, len);
244 else { /* wrap */
245 memcpy(obp, ibp, bytesleft );
246 memcpy(obp + bytesleft, dsb->buffer->memory, len - bytesleft);
247 }
248 return len;
249 }
250
251 /* Check for same sample rate */
252 if (dsb->freq == dsb->dsound->pwfx->nSamplesPerSec) {
253 TRACE("(%p) Same sample rate %ld = primary %ld\n", dsb,
254 dsb->freq, dsb->dsound->pwfx->nSamplesPerSec);
255 ilen = 0;
256 for (i = 0; i < len; i += oAdvance) {
257 cp_fields(dsb, ibp, obp );
258 ibp += iAdvance;
259 ilen += iAdvance;
260 obp += oAdvance;
261 if (ibp >= (BYTE *)(dsb->buffer->memory + dsb->buflen))
262 ibp = dsb->buffer->memory; /* wrap */
263 }
264 return (ilen);
265 }
266
267 /* Mix in different sample rates */
268 /* */
269 /* New PerfectPitch(tm) Technology (c) 1998 Rob Riggs */
270 /* Patent Pending :-] */
271
272 /* Patent enhancements (c) 2000 Ove Kåven,
273 * TransGaming Technologies Inc. */
274
275 /* FIXME("(%p) Adjusting frequency: %ld -> %ld (need optimization)\n",
276 dsb, dsb->freq, dsb->dsound->pwfx->nSamplesPerSec); */
277
278 size = len / oAdvance;
279 ilen = 0;
280 ipos = dsb->buf_mixpos;
281 for (i = 0; i < size; i++) {
282 cp_fields(dsb, (dsb->buffer->memory + ipos), obp);
283 obp += oAdvance;
284 dsb->freqAcc += dsb->freqAdjust;
285 if (dsb->freqAcc >= (1<<DSOUND_FREQSHIFT)) {
286 ULONG adv = (dsb->freqAcc>>DSOUND_FREQSHIFT) * iAdvance;
287 dsb->freqAcc &= (1<<DSOUND_FREQSHIFT)-1;
288 ipos += adv; ilen += adv;
289 ipos %= dsb->buflen;
290 }
291 }
292 return ilen;
293 }
294
295 static void DSOUND_MixerVol(IDirectSoundBufferImpl *dsb, BYTE *buf, INT len)
296 {
297 INT i;
298 BYTE *bpc = buf;
299 INT16 *bps = (INT16 *) buf;
300
301 TRACE("(%p,%p,%d)\n",dsb,buf,len);
302 TRACE("left = %lx, right = %lx\n", dsb->cvolpan.dwTotalLeftAmpFactor,
303 dsb->cvolpan.dwTotalRightAmpFactor);
304
305 if ((!(dsb->dsbd.dwFlags & DSBCAPS_CTRLPAN) || (dsb->cvolpan.lPan == 0)) &&
306 (!(dsb->dsbd.dwFlags & DSBCAPS_CTRLVOLUME) || (dsb->cvolpan.lVolume == 0)) &&
307 !(dsb->dsbd.dwFlags & DSBCAPS_CTRL3D))
308 return; /* Nothing to do */
309
310 /* If we end up with some bozo coder using panning or 3D sound */
311 /* with a mono primary buffer, it could sound very weird using */
312 /* this method. Oh well, tough patooties. */
313
314 switch (dsb->dsound->pwfx->wBitsPerSample) {
315 case 8:
316 /* 8-bit WAV is unsigned, but we need to operate */
317 /* on signed data for this to work properly */
318 switch (dsb->dsound->pwfx->nChannels) {
319 case 1:
320 for (i = 0; i < len; i++) {
321 INT val = *bpc - 128;
322 val = (val * dsb->cvolpan.dwTotalLeftAmpFactor) >> 16;
323 *bpc = val + 128;
324 bpc++;
325 }
326 break;
327 case 2:
328 for (i = 0; i < len; i+=2) {
329 INT val = *bpc - 128;
330 val = (val * dsb->cvolpan.dwTotalLeftAmpFactor) >> 16;
331 *bpc++ = val + 128;
332 val = *bpc - 128;
333 val = (val * dsb->cvolpan.dwTotalRightAmpFactor) >> 16;
334 *bpc = val + 128;
335 bpc++;
336 }
337 break;
338 default:
339 FIXME("doesn't support %d channels\n", dsb->dsound->pwfx->nChannels);
340 break;
341 }
342 break;
343 case 16:
344 /* 16-bit WAV is signed -- much better */
345 switch (dsb->dsound->pwfx->nChannels) {
346 case 1:
347 for (i = 0; i < len; i += 2) {
348 *bps = (*bps * dsb->cvolpan.dwTotalLeftAmpFactor) >> 16;
349 bps++;
350 }
351 break;
352 case 2:
353 for (i = 0; i < len; i += 4) {
354 *bps = (*bps * dsb->cvolpan.dwTotalLeftAmpFactor) >> 16;
355 bps++;
356 *bps = (*bps * dsb->cvolpan.dwTotalRightAmpFactor) >> 16;
357 bps++;
358 }
359 break;
360 default:
361 FIXME("doesn't support %d channels\n", dsb->dsound->pwfx->nChannels);
362 break;
363 }
364 break;
365 default:
366 FIXME("doesn't support %d bit samples\n", dsb->dsound->pwfx->wBitsPerSample);
367 break;
368 }
369 }
370
371 static void *tmp_buffer;
372 static size_t tmp_buffer_len = 0;
373
374 static void *DSOUND_tmpbuffer(size_t len)
375 {
376 if (len>tmp_buffer_len) {
377 void *new_buffer = realloc(tmp_buffer, len);
378 if (new_buffer) {
379 tmp_buffer = new_buffer;
380 tmp_buffer_len = len;
381 }
382 return new_buffer;
383 }
384 return tmp_buffer;
385 }
386
387 static DWORD DSOUND_MixInBuffer(IDirectSoundBufferImpl *dsb, DWORD writepos, DWORD fraglen)
388 {
389 INT i, len, ilen, temp, field, nBlockAlign, todo;
390 BYTE *buf, *ibuf;
391
392 TRACE("(%p,%ld,%ld)\n",dsb,writepos,fraglen);
393
394 len = fraglen;
395 if (!(dsb->playflags & DSBPLAY_LOOPING)) {
396 temp = MulDiv(dsb->dsound->pwfx->nAvgBytesPerSec, dsb->buflen,
397 dsb->nAvgBytesPerSec) -
398 MulDiv(dsb->dsound->pwfx->nAvgBytesPerSec, dsb->buf_mixpos,
399 dsb->nAvgBytesPerSec);
400 len = (len > temp) ? temp : len;
401 }
402 nBlockAlign = dsb->dsound->pwfx->nBlockAlign;
403 len = len / nBlockAlign * nBlockAlign; /* data alignment */
404
405 if (len == 0) {
406 /* This should only happen if we aren't looping and temp < nBlockAlign */
407 return 0;
408 }
409
410 /* Been seeing segfaults in malloc() for some reason... */
411 TRACE("allocating buffer (size = %d)\n", len);
412 if ((buf = ibuf = (BYTE *) DSOUND_tmpbuffer(len)) == NULL)
413 return 0;
414
415 TRACE("MixInBuffer (%p) len = %d, dest = %ld\n", dsb, len, writepos);
416
417 ilen = DSOUND_MixerNorm(dsb, ibuf, len);
418 if ((dsb->dsbd.dwFlags & DSBCAPS_CTRLPAN) ||
419 (dsb->dsbd.dwFlags & DSBCAPS_CTRLVOLUME) ||
420 (dsb->dsbd.dwFlags & DSBCAPS_CTRL3D))
421 DSOUND_MixerVol(dsb, ibuf, len);
422
423 if (dsb->dsound->pwfx->wBitsPerSample == 8) {
424 BYTE *obuf = dsb->dsound->buffer + writepos;
425
426 if ((writepos + len) <= dsb->dsound->buflen)
427 todo = len;
428 else
429 todo = dsb->dsound->buflen - writepos;
430
431 for (i = 0; i < todo; i++) {
432 /* 8-bit WAV is unsigned */
433 field = (*ibuf++ - 128);
434 field += (*obuf - 128);
435 if (field > 127) field = 127;
436 else if (field < -128) field = -128;
437 *obuf++ = field + 128;
438 }
439
440 if (todo < len) {
441 todo = len - todo;
442 obuf = dsb->dsound->buffer;
443
444 for (i = 0; i < todo; i++) {
445 /* 8-bit WAV is unsigned */
446 field = (*ibuf++ - 128);
447 field += (*obuf - 128);
448 if (field > 127) field = 127;
449 else if (field < -128) field = -128;
450 *obuf++ = field + 128;
451 }
452 }
453 } else {
454 INT16 *ibufs, *obufs;
455
456 ibufs = (INT16 *) ibuf;
457 obufs = (INT16 *)(dsb->dsound->buffer + writepos);
458
459 if ((writepos + len) <= dsb->dsound->buflen)
460 todo = len / 2;
461 else
462 todo = (dsb->dsound->buflen - writepos) / 2;
463
464 for (i = 0; i < todo; i++) {
465 /* 16-bit WAV is signed */
466 field = *ibufs++;
467 field += *obufs;
468 if (field > 32767) field = 32767;
469 else if (field < -32768) field = -32768;
470 *obufs++ = field;
471 }
472
473 if (todo < (len / 2)) {
474 todo = (len / 2) - todo;
475 obufs = (INT16 *)dsb->dsound->buffer;
476
477 for (i = 0; i < todo; i++) {
478 /* 16-bit WAV is signed */
479 field = *ibufs++;
480 field += *obufs;
481 if (field > 32767) field = 32767;
482 else if (field < -32768) field = -32768;
483 *obufs++ = field;
484 }
485 }
486 }
487
488 if (dsb->leadin && (dsb->startpos > dsb->buf_mixpos) && (dsb->startpos <= dsb->buf_mixpos + ilen)) {
489 /* HACK... leadin should be reset when the PLAY position reaches the startpos,
490 * not the MIX position... but if the sound buffer is bigger than our prebuffering
491 * (which must be the case for the streaming buffers that need this hack anyway)
492 * plus DS_HEL_MARGIN or equivalent, then this ought to work anyway. */
493 dsb->leadin = FALSE;
494 }
495
496 dsb->buf_mixpos += ilen;
497
498 if (dsb->buf_mixpos >= dsb->buflen) {
499 if (dsb->playflags & DSBPLAY_LOOPING) {
500 /* wrap */
501 dsb->buf_mixpos %= dsb->buflen;
502 if (dsb->leadin && (dsb->startpos <= dsb->buf_mixpos))
503 dsb->leadin = FALSE; /* HACK: see above */
504 }
505 }
506
507 return len;
508 }
509
510 static void DSOUND_PhaseCancel(IDirectSoundBufferImpl *dsb, DWORD writepos, DWORD len)
511 {
512 INT i, ilen, field, nBlockAlign, todo;
513 BYTE *buf, *ibuf;
514
515 TRACE("(%p,%ld,%ld)\n",dsb,writepos,len);
516
517 nBlockAlign = dsb->dsound->pwfx->nBlockAlign;
518 len = len / nBlockAlign * nBlockAlign; /* data alignment */
519
520 TRACE("allocating buffer (size = %ld)\n", len);
521 if ((buf = ibuf = (BYTE *) DSOUND_tmpbuffer(len)) == NULL)
522 return;
523
524 TRACE("PhaseCancel (%p) len = %ld, dest = %ld\n", dsb, len, writepos);
525
526 ilen = DSOUND_MixerNorm(dsb, ibuf, len);
527 if ((dsb->dsbd.dwFlags & DSBCAPS_CTRLPAN) ||
528 (dsb->dsbd.dwFlags & DSBCAPS_CTRLVOLUME) ||
529 (dsb->dsbd.dwFlags & DSBCAPS_CTRL3D))
530 DSOUND_MixerVol(dsb, ibuf, len);
531
532 /* subtract instead of add, to phase out premixed data */
533 if (dsb->dsound->pwfx->wBitsPerSample == 8) {
534 BYTE *obuf = dsb->dsound->buffer + writepos;
535
536 if ((writepos + len) <= dsb->dsound->buflen)
537 todo = len;
538 else
539 todo = dsb->dsound->buflen - writepos;
540
541 for (i = 0; i < todo; i++) {
542 /* 8-bit WAV is unsigned */
543 field = (*ibuf++ - 128);
544 field -= (*obuf - 128);
545 if (field > 127) field = 127;
546 else if (field < -128) field = -128;
547 *obuf++ = field + 128;
548 }
549
550 if (todo < len) {
551 todo = len - todo;
552 obuf = dsb->dsound->buffer;
553
554 for (i = 0; i < todo; i++) {
555 /* 8-bit WAV is unsigned */
556 field = (*ibuf++ - 128);
557 field -= (*obuf - 128);
558 if (field > 127) field = 127;
559 else if (field < -128) field = -128;
560 *obuf++ = field + 128;
561 }
562 }
563 } else {
564 INT16 *ibufs, *obufs;
565
566 ibufs = (INT16 *) ibuf;
567 obufs = (INT16 *)(dsb->dsound->buffer + writepos);
568
569 if ((writepos + len) <= dsb->dsound->buflen)
570 todo = len / 2;
571 else
572 todo = (dsb->dsound->buflen - writepos) / 2;
573
574 for (i = 0; i < todo; i++) {
575 /* 16-bit WAV is signed */
576 field = *ibufs++;
577 field -= *obufs;
578 if (field > 32767) field = 32767;
579 else if (field < -32768) field = -32768;
580 *obufs++ = field;
581 }
582
583 if (todo < (len / 2)) {
584 todo = (len / 2) - todo;
585 obufs = (INT16 *)dsb->dsound->buffer;
586
587 for (i = 0; i < todo; i++) {
588 /* 16-bit WAV is signed */
589 field = *ibufs++;
590 field -= *obufs;
591 if (field > 32767) field = 32767;
592 else if (field < -32768) field = -32768;
593 *obufs++ = field;
594 }
595 }
596 }
597 }
598
599 static void DSOUND_MixCancel(IDirectSoundBufferImpl *dsb, DWORD writepos, BOOL cancel)
600 {
601 DWORD size, flen, len, npos, nlen;
602 INT iAdvance = dsb->pwfx->nBlockAlign;
603 INT oAdvance = dsb->dsound->pwfx->nBlockAlign;
604 /* determine amount of premixed data to cancel */
605 DWORD primary_done =
606 ((dsb->primary_mixpos < writepos) ? dsb->dsound->buflen : 0) +
607 dsb->primary_mixpos - writepos;
608
609 TRACE("(%p, %ld), buf_mixpos=%ld\n", dsb, writepos, dsb->buf_mixpos);
610
611 /* backtrack the mix position */
612 size = primary_done / oAdvance;
613 flen = size * dsb->freqAdjust;
614 len = (flen >> DSOUND_FREQSHIFT) * iAdvance;
615 flen &= (1<<DSOUND_FREQSHIFT)-1;
616 while (dsb->freqAcc < flen) {
617 len += iAdvance;
618 dsb->freqAcc += 1<<DSOUND_FREQSHIFT;
619 }
620 len %= dsb->buflen;
621 npos = ((dsb->buf_mixpos < len) ? dsb->buflen : 0) +
622 dsb->buf_mixpos - len;
623 if (dsb->leadin && (dsb->startpos > npos) && (dsb->startpos <= npos + len)) {
624 /* stop backtracking at startpos */
625 npos = dsb->startpos;
626 len = ((dsb->buf_mixpos < npos) ? dsb->buflen : 0) +
627 dsb->buf_mixpos - npos;
628 flen = dsb->freqAcc;
629 nlen = len / dsb->pwfx->nBlockAlign;
630 nlen = ((nlen << DSOUND_FREQSHIFT) + flen) / dsb->freqAdjust;
631 nlen *= dsb->dsound->pwfx->nBlockAlign;
632 writepos =
633 ((dsb->primary_mixpos < nlen) ? dsb->dsound->buflen : 0) +
634 dsb->primary_mixpos - nlen;
635 }
636
637 dsb->freqAcc -= flen;
638 dsb->buf_mixpos = npos;
639 dsb->primary_mixpos = writepos;
640
641 TRACE("new buf_mixpos=%ld, primary_mixpos=%ld (len=%ld)\n",
642 dsb->buf_mixpos, dsb->primary_mixpos, len);
643
644 if (cancel) DSOUND_PhaseCancel(dsb, writepos, len);
645 }
646
647 void DSOUND_MixCancelAt(IDirectSoundBufferImpl *dsb, DWORD buf_writepos)
648 {
649 #if 0
650 DWORD i, size, flen, len, npos, nlen;
651 INT iAdvance = dsb->pwfx->nBlockAlign;
652 INT oAdvance = dsb->dsound->pwfx->nBlockAlign;
653 /* determine amount of premixed data to cancel */
654 DWORD buf_done =
655 ((dsb->buf_mixpos < buf_writepos) ? dsb->buflen : 0) +
656 dsb->buf_mixpos - buf_writepos;
657 #endif
658
659 WARN("(%p, %ld), buf_mixpos=%ld\n", dsb, buf_writepos, dsb->buf_mixpos);
660 /* since this is not implemented yet, just cancel *ALL* prebuffering for now
661 * (which is faster anyway when there's only a single secondary buffer) */
662 dsb->dsound->need_remix = TRUE;
663 }
664
665 void DSOUND_ForceRemix(IDirectSoundBufferImpl *dsb)
666 {
667 TRACE("(%p)\n",dsb);
668 EnterCriticalSection(&dsb->lock);
669 if (dsb->state == STATE_PLAYING) {
670 #if 0 /* this may not be quite reliable yet */
671 dsb->need_remix = TRUE;
672 #else
673 dsb->dsound->need_remix = TRUE;
674 #endif
675 }
676 LeaveCriticalSection(&dsb->lock);
677 }
678
679 static DWORD DSOUND_MixOne(IDirectSoundBufferImpl *dsb, DWORD playpos, DWORD writepos, DWORD mixlen)
680 {
681 DWORD len, slen;
682 /* determine this buffer's write position */
683 DWORD buf_writepos = DSOUND_CalcPlayPosition(dsb, dsb->state & dsb->dsound->state, writepos,
684 writepos, dsb->primary_mixpos, dsb->buf_mixpos);
685 /* determine how much already-mixed data exists */
686 DWORD buf_done =
687 ((dsb->buf_mixpos < buf_writepos) ? dsb->buflen : 0) +
688 dsb->buf_mixpos - buf_writepos;
689 DWORD primary_done =
690 ((dsb->primary_mixpos < writepos) ? dsb->dsound->buflen : 0) +
691 dsb->primary_mixpos - writepos;
692 DWORD adv_done =
693 ((dsb->dsound->mixpos < writepos) ? dsb->dsound->buflen : 0) +
694 dsb->dsound->mixpos - writepos;
695 DWORD played =
696 ((buf_writepos < dsb->playpos) ? dsb->buflen : 0) +
697 buf_writepos - dsb->playpos;
698 DWORD buf_left = dsb->buflen - buf_writepos;
699 int still_behind;
700
701 TRACE("(%p,%ld,%ld,%ld)\n",dsb,playpos,writepos,mixlen);
702 TRACE("buf_writepos=%ld, primary_writepos=%ld\n", buf_writepos, writepos);
703 TRACE("buf_done=%ld, primary_done=%ld\n", buf_done, primary_done);
704 TRACE("buf_mixpos=%ld, primary_mixpos=%ld, mixlen=%ld\n", dsb->buf_mixpos, dsb->primary_mixpos,
705 mixlen);
706 TRACE("looping=%ld, startpos=%ld, leadin=%ld\n", dsb->playflags, dsb->startpos, dsb->leadin);
707
708 /* check for notification positions */
709 if (dsb->dsbd.dwFlags & DSBCAPS_CTRLPOSITIONNOTIFY &&
710 dsb->state != STATE_STARTING) {
711 DSOUND_CheckEvent(dsb, played);
712 }
713
714 /* save write position for non-GETCURRENTPOSITION2... */
715 dsb->playpos = buf_writepos;
716
717 /* check whether CalcPlayPosition detected a mixing underrun */
718 if ((buf_done == 0) && (dsb->primary_mixpos != writepos)) {
719 /* it did, but did we have more to play? */
720 if ((dsb->playflags & DSBPLAY_LOOPING) ||
721 (dsb->buf_mixpos < dsb->buflen)) {
722 /* yes, have to recover */
723 ERR("underrun on sound buffer %p\n", dsb);
724 TRACE("recovering from underrun: primary_mixpos=%ld\n", writepos);
725 }
726 dsb->primary_mixpos = writepos;
727 primary_done = 0;
728 }
729 /* determine how far ahead we should mix */
730 if (((dsb->playflags & DSBPLAY_LOOPING) ||
731 (dsb->leadin && (dsb->probably_valid_to != 0))) &&
732 !(dsb->dsbd.dwFlags & DSBCAPS_STATIC)) {
733 /* if this is a streaming buffer, it typically means that
734 * we should defer mixing past probably_valid_to as long
735 * as we can, to avoid unnecessary remixing */
736 /* the heavy-looking calculations shouldn't be that bad,
737 * as any game isn't likely to be have more than 1 or 2
738 * streaming buffers in use at any time anyway... */
739 DWORD probably_valid_left =
740 (dsb->probably_valid_to == (DWORD)-1) ? dsb->buflen :
741 ((dsb->probably_valid_to < buf_writepos) ? dsb->buflen : 0) +
742 dsb->probably_valid_to - buf_writepos;
743 /* check for leadin condition */
744 if ((probably_valid_left == 0) &&
745 (dsb->probably_valid_to == dsb->startpos) &&
746 dsb->leadin)
747 probably_valid_left = dsb->buflen;
748 TRACE("streaming buffer probably_valid_to=%ld, probably_valid_left=%ld\n",
749 dsb->probably_valid_to, probably_valid_left);
750 /* check whether the app's time is already up */
751 if (probably_valid_left < dsb->writelead) {
752 WARN("probably_valid_to now within writelead, possible streaming underrun\n");
753 /* once we pass the point of no return,
754 * no reason to hold back anymore */
755 dsb->probably_valid_to = (DWORD)-1;
756 /* we just have to go ahead and mix what we have,
757 * there's no telling what the app is thinking anyway */
758 } else {
759 /* adjust for our frequency and our sample size */
760 probably_valid_left = MulDiv(probably_valid_left,
761 1 << DSOUND_FREQSHIFT,
762 dsb->pwfx->nBlockAlign * dsb->freqAdjust) *
763 dsb->dsound->pwfx->nBlockAlign;
764 /* check whether to clip mix_len */
765 if (probably_valid_left < mixlen) {
766 TRACE("clipping to probably_valid_left=%ld\n", probably_valid_left);
767 mixlen = probably_valid_left;
768 }
769 }
770 }
771 /* cut mixlen with what's already been mixed */
772 if (mixlen < primary_done) {
773 /* huh? and still CalcPlayPosition didn't
774 * detect an underrun? */
775 FIXME("problem with underrun detection (mixlen=%ld < primary_done=%ld)\n", mixlen, primary_done);
776 return 0;
777 }
778 len = mixlen - primary_done;
779 TRACE("remaining mixlen=%ld\n", len);
780
781 if (len < dsb->dsound->fraglen) {
782 /* smaller than a fragment, wait until it gets larger
783 * before we take the mixing overhead */
784 TRACE("mixlen not worth it, deferring mixing\n");
785 still_behind = 1;
786 goto post_mix;
787 }
788
789 /* ok, we know how much to mix, let's go */
790 still_behind = (adv_done > primary_done);
791 while (len) {
792 slen = dsb->dsound->buflen - dsb->primary_mixpos;
793 if (slen > len) slen = len;
794 slen = DSOUND_MixInBuffer(dsb, dsb->primary_mixpos, slen);
795
796 if ((dsb->primary_mixpos < dsb->dsound->mixpos) &&
797 (dsb->primary_mixpos + slen >= dsb->dsound->mixpos))
798 still_behind = FALSE;
799
800 dsb->primary_mixpos += slen; len -= slen;
801 dsb->primary_mixpos %= dsb->dsound->buflen;
802
803 if ((dsb->state == STATE_STOPPED) || !slen) break;
804 }
805 TRACE("new primary_mixpos=%ld, primary_advbase=%ld\n", dsb->primary_mixpos, dsb->dsound->mixpos);
806 TRACE("mixed data len=%ld, still_behind=%d\n", mixlen-len, still_behind);
807
808 post_mix:
809 /* check if buffer should be considered complete */
810 if (buf_left < dsb->writelead &&
811 !(dsb->playflags & DSBPLAY_LOOPING)) {
812 dsb->state = STATE_STOPPED;
813 dsb->playpos = 0;
814 dsb->last_playpos = 0;
815 dsb->buf_mixpos = 0;
816 dsb->leadin = FALSE;
817 DSOUND_CheckEvent(dsb, buf_left);
818 }
819
820 /* return how far we think the primary buffer can
821 * advance its underrun detector...*/
822 if (still_behind) return 0;
823 if ((mixlen - len) < primary_done) return 0;
824 slen = ((dsb->primary_mixpos < dsb->dsound->mixpos) ?
825 dsb->dsound->buflen : 0) + dsb->primary_mixpos -
826 dsb->dsound->mixpos;
827 if (slen > mixlen) {
828 /* the primary_done and still_behind checks above should have worked */
829 FIXME("problem with advancement calculation (advlen=%ld > mixlen=%ld)\n", slen, mixlen);
830 slen = 0;
831 }
832 return slen;
833 }
834
835 static DWORD DSOUND_MixToPrimary(IDirectSoundImpl *dsound, DWORD playpos, DWORD writepos, DWORD mixlen, BOOL recover)
836 {
837 INT i, len, maxlen = 0;
838 IDirectSoundBufferImpl *dsb;
839
840 TRACE("(%ld,%ld,%ld,%d)\n", playpos, writepos, mixlen, recover);
841 for (i = dsound->nrofbuffers - 1; i >= 0; i--) {
842 dsb = dsound->buffers[i];
843
844 if (!dsb || !dsb->lpVtbl)
845 continue;
846 if (dsb->buflen && dsb->state && !dsb->hwbuf) {
847 TRACE("Checking %p, mixlen=%ld\n", dsb, mixlen);
848 EnterCriticalSection(&(dsb->lock));
849 if (dsb->state == STATE_STOPPING) {
850 DSOUND_MixCancel(dsb, writepos, TRUE);
851 dsb->state = STATE_STOPPED;
852 DSOUND_CheckEvent(dsb, 0);
853 } else {
854 if ((dsb->state == STATE_STARTING) || recover) {
855 dsb->primary_mixpos = writepos;
856 memcpy(&dsb->cvolpan, &dsb->volpan, sizeof(dsb->cvolpan));
857 dsb->need_remix = FALSE;
858 }
859 else if (dsb->need_remix) {
860 DSOUND_MixCancel(dsb, writepos, TRUE);
861 memcpy(&dsb->cvolpan, &dsb->volpan, sizeof(dsb->cvolpan));
862 dsb->need_remix = FALSE;
863 }
864 len = DSOUND_MixOne(dsb, playpos, writepos, mixlen);
865 if (dsb->state == STATE_STARTING)
866 dsb->state = STATE_PLAYING;
867 maxlen = (len > maxlen) ? len : maxlen;
868 }
869 LeaveCriticalSection(&(dsb->lock));
870 }
871 }
872
873 return maxlen;
874 }
875
876 static void DSOUND_MixReset(IDirectSoundImpl *dsound, DWORD writepos)
877 {
878 INT i;
879 IDirectSoundBufferImpl *dsb;
880 int nfiller;
881
882 TRACE("(%ld)\n", writepos);
883
884 /* the sound of silence */
885 nfiller = dsound->pwfx->wBitsPerSample == 8 ? 128 : 0;
886
887 /* reset all buffer mix positions */
888 for (i = dsound->nrofbuffers - 1; i >= 0; i--) {
889 dsb = dsound->buffers[i];
890
891 if (!dsb || !dsb->lpVtbl)
892 continue;
893 if (dsb->buflen && dsb->state && !dsb->hwbuf) {
894 TRACE("Resetting %p\n", dsb);
895 EnterCriticalSection(&(dsb->lock));
896 if (dsb->state == STATE_STOPPING) {
897 dsb->state = STATE_STOPPED;
898 }
899 else if (dsb->state == STATE_STARTING) {
900 /* nothing */
901 } else {
902 DSOUND_MixCancel(dsb, writepos, FALSE);
903 memcpy(&dsb->cvolpan, &dsb->volpan, sizeof(dsb->cvolpan));
904 dsb->need_remix = FALSE;
905 }
906 LeaveCriticalSection(&(dsb->lock));
907 }
908 }
909
910 /* wipe out premixed data */
911 if (dsound->mixpos < writepos) {
912 memset(dsound->buffer + writepos, nfiller, dsound->buflen - writepos);
913 memset(dsound->buffer, nfiller, dsound->mixpos);
914 } else {
915 memset(dsound->buffer + writepos, nfiller, dsound->mixpos - writepos);
916 }
917
918 /* reset primary mix position */
919 dsound->mixpos = writepos;
920 }
921
922 static void DSOUND_CheckReset(IDirectSoundImpl *dsound, DWORD writepos)
923 {
924 TRACE("(%p,%ld)\n",dsound,writepos);
925 if (dsound->need_remix) {
926 DSOUND_MixReset(dsound, writepos);
927 dsound->need_remix = FALSE;
928 /* maximize Half-Life performance */
929 dsound->prebuf = ds_snd_queue_min;
930 dsound->precount = 0;
931 } else {
932 dsound->precount++;
933 if (dsound->precount >= 4) {
934 if (dsound->prebuf < ds_snd_queue_max)
935 dsound->prebuf++;
936 dsound->precount = 0;
937 }
938 }
939 TRACE("premix adjust: %d\n", dsound->prebuf);
940 }
941
942 void DSOUND_WaveQueue(IDirectSoundImpl *dsound, DWORD mixq)
943 {
944 TRACE("(%p,%ld)\n",dsound,mixq);
945 if (mixq + dsound->pwqueue > ds_hel_queue) mixq = ds_hel_queue - dsound->pwqueue;
946 TRACE("queueing %ld buffers, starting at %d\n", mixq, dsound->pwwrite);
947 for (; mixq; mixq--) {
948 waveOutWrite(dsound->hwo, dsound->pwave[dsound->pwwrite], sizeof(WAVEHDR));
949 dsound->pwwrite++;
950 if (dsound->pwwrite >= DS_HEL_FRAGS) dsound->pwwrite = 0;
951 dsound->pwqueue++;
952 }
953 }
954
955 /* #define SYNC_CALLBACK */
956
957 void DSOUND_PerformMix(IDirectSoundImpl *dsound)
958 {
959 int nfiller;
960 BOOL forced;
961 HRESULT hres;
962
963 TRACE("()\n");
964
965 /* the sound of silence */
966 nfiller = dsound->pwfx->wBitsPerSample == 8 ? 128 : 0;
967
968 /* whether the primary is forced to play even without secondary buffers */
969 forced = ((dsound->state == STATE_PLAYING) || (dsound->state == STATE_STARTING));
970
971 if (dsound->priolevel != DSSCL_WRITEPRIMARY) {
972 BOOL paused = ((dsound->state == STATE_STOPPED) || (dsound->state == STATE_STARTING));
973 /* FIXME: document variables */
974 DWORD playpos, writepos, inq, maxq, frag;
975 if (dsound->hwbuf) {
976 hres = IDsDriverBuffer_GetPosition(dsound->hwbuf, &playpos, &writepos);
977 if (hres) {
978 WARN("IDsDriverBuffer_GetPosition failed\n");
979 return;
980 }
981 /* Well, we *could* do Just-In-Time mixing using the writepos,
982 * but that's a little bit ambitious and unnecessary... */
983 /* rather add our safety margin to the writepos, if we're playing */
984 if (!paused) {
985 writepos += dsound->writelead;
986 writepos %= dsound->buflen;
987 } else writepos = playpos;
988 } else {
989 playpos = dsound->pwplay * dsound->fraglen;
990 writepos = playpos;
991 if (!paused) {
992 writepos += ds_hel_margin * dsound->fraglen;
993 writepos %= dsound->buflen;
994 }
995 }
996 TRACE("primary playpos=%ld, writepos=%ld, clrpos=%ld, mixpos=%ld, buflen=%ld\n",
997 playpos,writepos,dsound->playpos,dsound->mixpos,dsound->buflen);
998 assert(dsound->playpos < dsound->buflen);
999 /* wipe out just-played sound data */
1000 if (playpos < dsound->playpos) {
1001 memset(dsound->buffer + dsound->playpos, nfiller, dsound->buflen - dsound->playpos);
1002 memset(dsound->buffer, nfiller, playpos);
1003 } else {
1004 memset(dsound->buffer + dsound->playpos, nfiller, playpos - dsound->playpos);
1005 }
1006 dsound->playpos = playpos;
1007
1008 EnterCriticalSection(&(dsound->mixlock));
1009
1010 /* reset mixing if necessary */
1011 DSOUND_CheckReset(dsound, writepos);
1012
1013 /* check how much prebuffering is left */
1014 inq = dsound->mixpos;
1015 if (inq < writepos)
1016 inq += dsound->buflen;
1017 inq -= writepos;
1018
1019 /* find the maximum we can prebuffer */
1020 if (!paused) {
1021 maxq = playpos;
1022 if (maxq < writepos)
1023 maxq += dsound->buflen;
1024 maxq -= writepos;
1025 } else maxq = dsound->buflen;
1026
1027 /* clip maxq to dsound->prebuf */
1028 frag = dsound->prebuf * dsound->fraglen;
1029 if (maxq > frag) maxq = frag;
1030
1031 /* check for consistency */
1032 if (inq > maxq) {
1033 /* the playback position must have passed our last
1034 * mixed position, i.e. it's an underrun, or we have
1035 * nothing more to play */
1036 TRACE("reached end of mixed data (inq=%ld, maxq=%ld)\n", inq, maxq);
1037 inq = 0;
1038 /* stop the playback now, to allow buffers to refill */
1039 if (dsound->state == STATE_PLAYING) {
1040 dsound->state = STATE_STARTING;
1041 }
1042 else if (dsound->state == STATE_STOPPING) {
1043 dsound->state = STATE_STOPPED;
1044 }
1045 else {
1046 /* how can we have an underrun if we aren't playing? */
1047 WARN("unexpected primary state (%ld)\n", dsound->state);
1048 }
1049 #ifdef SYNC_CALLBACK
1050 /* DSOUND_callback may need this lock */
1051 LeaveCriticalSection(&(dsound->mixlock));
1052 #endif
1053 if (DSOUND_PrimaryStop(dsound) != DS_OK)
1054 WARN("DSOUND_PrimaryStop failed\n");
1055 #ifdef SYNC_CALLBACK
1056 EnterCriticalSection(&(dsound->mixlock));
1057 #endif
1058 if (dsound->hwbuf) {
1059 /* the Stop is supposed to reset play position to beginning of buffer */
1060 /* unfortunately, OSS is not able to do so, so get current pointer */
1061 hres = IDsDriverBuffer_GetPosition(dsound->hwbuf, &playpos, NULL);
1062 if (hres) {
1063 LeaveCriticalSection(&(dsound->mixlock));
1064 WARN("IDsDriverBuffer_GetPosition failed\n");
1065 return;
1066 }
1067 } else {
1068 playpos = dsound->pwplay * dsound->fraglen;
1069 }
1070 writepos = playpos;
1071 dsound->playpos = playpos;
1072 dsound->mixpos = writepos;
1073 inq = 0;
1074 maxq = dsound->buflen;
1075 if (maxq > frag) maxq = frag;
1076 memset(dsound->buffer, nfiller, dsound->buflen);
1077 paused = TRUE;
1078 }
1079
1080 /* do the mixing */
1081 frag = DSOUND_MixToPrimary(dsound, playpos, writepos, maxq, paused);
1082 if (forced) frag = maxq - inq;
1083 dsound->mixpos += frag;
1084 dsound->mixpos %= dsound->buflen;
1085
1086 if (frag) {
1087 /* buffers have been filled, restart playback */
1088 if (dsound->state == STATE_STARTING) {
1089 dsound->state = STATE_PLAYING;
1090 }
1091 else if (dsound->state == STATE_STOPPED) {
1092 /* the dsound is supposed to play if there's something to play
1093 * even if it is reported as stopped, so don't let this confuse you */
1094 dsound->state = STATE_STOPPING;
1095 }
1096 LeaveCriticalSection(&(dsound->mixlock));
1097 if (paused) {
1098 if (DSOUND_PrimaryPlay(dsound) != DS_OK)
1099 WARN("DSOUND_PrimaryPlay failed\n");
1100 else
1101 TRACE("starting playback\n");
1102 }
1103 }
1104 else
1105 LeaveCriticalSection(&(dsound->mixlock));
1106 } else {
1107 /* in the DSSCL_WRITEPRIMARY mode, the app is totally in charge... */
1108 if (dsound->state == STATE_STARTING) {
1109 if (DSOUND_PrimaryPlay(dsound) != DS_OK)
1110 WARN("DSOUND_PrimaryPlay failed\n");
1111 else
1112 dsound->state = STATE_PLAYING;
1113 }
1114 else if (dsound->state == STATE_STOPPING) {
1115 if (DSOUND_PrimaryStop(dsound) != DS_OK)
1116 WARN("DSOUND_PrimaryStop failed\n");
1117 else
1118 dsound->state = STATE_STOPPED;
1119 }
1120 }
1121 }
1122
1123 void CALLBACK DSOUND_timer(UINT timerID, UINT msg, DWORD dwUser, DWORD dw1, DWORD dw2)
1124 {
1125 IDirectSoundImpl* This = (IDirectSoundImpl*)dwUser;
1126 TRACE("(%d,%d,0x%lx,0x%lx,0x%lx)\n",timerID,msg,dwUser,dw1,dw2);
1127 TRACE("entering at %ld\n", GetTickCount());
1128
1129 if (dsound != This) {
1130 ERR("dsound died without killing us?\n");
1131 timeKillEvent(timerID);
1132 timeEndPeriod(DS_TIME_RES);
1133 return;
1134 }
1135
1136 RtlAcquireResourceShared(&(This->lock), TRUE);
1137
1138 if (This->ref) {
1139 DSOUND_PerformMix(This);
1140 }
1141
1142 RtlReleaseResource(&(This->lock));
1143
1144 TRACE("completed processing at %ld\n", GetTickCount());
1145 }
1146
1147 void CALLBACK DSOUND_callback(HWAVEOUT hwo, UINT msg, DWORD dwUser, DWORD dw1, DWORD dw2)
1148 {
1149 IDirectSoundImpl* This = (IDirectSoundImpl*)dwUser;
1150 TRACE("(%p,%x,%lx,%lx,%lx)\n",hwo,msg,dwUser,dw1,dw2);
1151 TRACE("entering at %ld, msg=%08x(%s)\n", GetTickCount(), msg,
1152 msg==MM_WOM_DONE ? "MM_WOM_DONE" : msg==MM_WOM_CLOSE ? "MM_WOM_CLOSE" :
1153 msg==MM_WOM_OPEN ? "MM_WOM_OPEN" : "UNKNOWN");
1154 if (msg == MM_WOM_DONE) {
1155 DWORD inq, mixq, fraglen, buflen, pwplay, playpos, mixpos;
1156 if (This->pwqueue == (DWORD)-1) {
1157 TRACE("completed due to reset\n");
1158 return;
1159 }
1160 /* it could be a bad idea to enter critical section here... if there's lock contention,
1161 * the resulting scheduling delays might obstruct the winmm player thread */
1162 #ifdef SYNC_CALLBACK
1163 EnterCriticalSection(&(This->mixlock));
1164 #endif
1165 /* retrieve current values */
1166 fraglen = This->fraglen;
1167 buflen = This->buflen;
1168 pwplay = This->pwplay;
1169 playpos = pwplay * fraglen;
1170 mixpos = This->mixpos;
1171 /* check remaining mixed data */
1172 inq = ((mixpos < playpos) ? buflen : 0) + mixpos - playpos;
1173 mixq = inq / fraglen;
1174 if ((inq - (mixq * fraglen)) > 0) mixq++;
1175 /* complete the playing buffer */
1176 TRACE("done playing primary pos=%ld\n", playpos);
1177 pwplay++;
1178 if (pwplay >= DS_HEL_FRAGS) pwplay = 0;
1179 /* write new values */
1180 This->pwplay = pwplay;
1181 This->pwqueue--;
1182 /* queue new buffer if we have data for it */
1183 if (inq>1) DSOUND_WaveQueue(This, inq-1);
1184 #ifdef SYNC_CALLBACK
1185 LeaveCriticalSection(&(This->mixlock));
1186 #endif
1187 }
1188 TRACE("completed\n");
1189 }
Wine tree for Wine Gecko development