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., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #include <stdarg.h>
23
24 #define NONAMELESSSTRUCT
25 #define NONAMELESSUNION
26 #include "windef.h"
27 #include "winbase.h"
28 #include "winuser.h"
29 #include "mmsystem.h"
30 #include "winternl.h"
31 #include "mmddk.h"
32 #include "wine/debug.h"
33 #include "dsound.h"
34 #include "dsdriver.h"
35 #include "dsound_private.h"
36
37 WINE_DEFAULT_DEBUG_CHANNEL(dsound);
38
39 /** Calculate how long a fragment length of about 10 ms should be in frames
40 *
41 * nSamplesPerSec: Frequency rate in samples per second
42 * nBlockAlign: Size of a single blockalign
43 *
44 * Returns:
45 * Size in bytes of a single fragment
46 */
47 DWORD DSOUND_fraglen(DWORD nSamplesPerSec, DWORD nBlockAlign)
48 {
49 DWORD fraglen = 256 * nBlockAlign;
50
51 /* Compensate for only being roughly accurate */
52 if (nSamplesPerSec <= 26000)
53 fraglen /= 2;
54
55 if (nSamplesPerSec <= 10000)
56 fraglen /= 2;
57
58 if (nSamplesPerSec >= 80000)
59 fraglen *= 2;
60
61 return fraglen;
62 }
63
64 static void DSOUND_RecalcPrimary(DirectSoundDevice *device)
65 {
66 TRACE("(%p)\n", device);
67
68 device->fraglen = DSOUND_fraglen(device->pwfx->nSamplesPerSec, device->pwfx->nBlockAlign);
69 device->helfrags = device->buflen / device->fraglen;
70 TRACE("fraglen=%d helfrags=%d\n", device->fraglen, device->helfrags);
71
72 if (device->hwbuf && device->drvdesc.dwFlags & DSDDESC_DONTNEEDWRITELEAD)
73 device->writelead = 0;
74 else
75 /* calculate the 10ms write lead */
76 device->writelead = (device->pwfx->nSamplesPerSec / 100) * device->pwfx->nBlockAlign;
77 }
78
79 HRESULT DSOUND_ReopenDevice(DirectSoundDevice *device, BOOL forcewave)
80 {
81 HRESULT hres = DS_OK;
82 TRACE("(%p, %d)\n", device, forcewave);
83
84 if (device->driver)
85 {
86 IDsDriver_Close(device->driver);
87 if (device->drvdesc.dwFlags & DSDDESC_DOMMSYSTEMOPEN)
88 waveOutClose(device->hwo);
89 IDsDriver_Release(device->driver);
90 device->driver = NULL;
91 device->buffer = NULL;
92 device->hwo = 0;
93 }
94 else if (device->drvdesc.dwFlags & DSDDESC_DOMMSYSTEMOPEN)
95 waveOutClose(device->hwo);
96
97 /* DRV_QUERYDSOUNDIFACE is a "Wine extension" to get the DSound interface */
98 if (ds_hw_accel != DS_HW_ACCEL_EMULATION && !forcewave)
99 waveOutMessage((HWAVEOUT)device->drvdesc.dnDevNode, DRV_QUERYDSOUNDIFACE, (DWORD_PTR)&device->driver, 0);
100
101 /* Get driver description */
102 if (device->driver) {
103 DWORD wod = device->drvdesc.dnDevNode;
104 hres = IDsDriver_GetDriverDesc(device->driver,&(device->drvdesc));
105 device->drvdesc.dnDevNode = wod;
106 if (FAILED(hres)) {
107 WARN("IDsDriver_GetDriverDesc failed: %08x\n", hres);
108 IDsDriver_Release(device->driver);
109 device->driver = NULL;
110 }
111 }
112
113 /* if no DirectSound interface available, use WINMM API instead */
114 if (!device->driver)
115 device->drvdesc.dwFlags = DSDDESC_DOMMSYSTEMOPEN | DSDDESC_DOMMSYSTEMSETFORMAT;
116
117 if (device->drvdesc.dwFlags & DSDDESC_DOMMSYSTEMOPEN)
118 {
119 DWORD flags = CALLBACK_FUNCTION;
120
121 if (device->driver)
122 flags |= WAVE_DIRECTSOUND;
123
124 hres = mmErr(waveOutOpen(&(device->hwo), device->drvdesc.dnDevNode, device->pwfx, (DWORD_PTR)DSOUND_callback, (DWORD)device, flags));
125 if (FAILED(hres)) {
126 WARN("waveOutOpen failed\n");
127 if (device->driver)
128 {
129 IDsDriver_Release(device->driver);
130 device->driver = NULL;
131 }
132 return hres;
133 }
134 }
135
136 if (device->driver)
137 hres = IDsDriver_Open(device->driver);
138
139 return hres;
140 }
141
142 static HRESULT DSOUND_PrimaryOpen(DirectSoundDevice *device)
143 {
144 DWORD buflen;
145 HRESULT err = DS_OK;
146 TRACE("(%p)\n", device);
147
148 /* on original windows, the buffer it set to a fixed size, no matter what the settings are.
149 on windows this size is always fixed (tested on win-xp) */
150 if (!device->buflen)
151 device->buflen = ds_hel_buflen;
152 buflen = device->buflen;
153 buflen -= buflen % device->pwfx->nBlockAlign;
154 device->buflen = buflen;
155
156 if (device->driver)
157 {
158 err = IDsDriver_CreateSoundBuffer(device->driver,device->pwfx,
159 DSBCAPS_PRIMARYBUFFER,0,
160 &(device->buflen),&(device->buffer),
161 (LPVOID*)&(device->hwbuf));
162
163 if (err != DS_OK) {
164 WARN("IDsDriver_CreateSoundBuffer failed (%08x), falling back to waveout\n", err);
165 err = DSOUND_ReopenDevice(device, TRUE);
166 if (FAILED(err))
167 {
168 WARN("Falling back to waveout failed too! Giving up\n");
169 return err;
170 }
171 }
172 DSOUND_RecalcPrimary(device);
173 device->prebuf = ds_snd_queue_max;
174 if (device->helfrags < ds_snd_queue_min)
175 {
176 WARN("Too little sound buffer to be effective (%d/%d) falling back to waveout\n", device->buflen, ds_snd_queue_min * device->fraglen);
177 device->buflen = buflen;
178 IDsDriverBuffer_Release(device->hwbuf);
179 device->hwbuf = NULL;
180 err = DSOUND_ReopenDevice(device, TRUE);
181 if (FAILED(err))
182 {
183 WARN("Falling back to waveout failed too! Giving up\n");
184 return err;
185 }
186 }
187 else if (device->helfrags < ds_snd_queue_max)
188 device->prebuf = device->helfrags;
189 }
190
191 device->mix_buffer_len = DSOUND_bufpos_to_mixpos(device, device->buflen);
192 device->mix_buffer = HeapAlloc(GetProcessHeap(), 0, device->mix_buffer_len);
193 if (!device->mix_buffer)
194 {
195 if (device->hwbuf)
196 IDsDriverBuffer_Release(device->hwbuf);
197 device->hwbuf = NULL;
198 return DSERR_OUTOFMEMORY;
199 }
200
201 if (device->state == STATE_PLAYING) device->state = STATE_STARTING;
202 else if (device->state == STATE_STOPPING) device->state = STATE_STOPPED;
203
204 /* are we using waveOut stuff? */
205 if (!device->driver) {
206 LPBYTE newbuf;
207 LPWAVEHDR headers = NULL;
208 DWORD overshot;
209 unsigned int c;
210
211 /* Start in pause mode, to allow buffers to get filled */
212 waveOutPause(device->hwo);
213
214 TRACE("desired buflen=%d, old buffer=%p\n", buflen, device->buffer);
215
216 /* reallocate emulated primary buffer */
217 if (device->buffer)
218 newbuf = HeapReAlloc(GetProcessHeap(),0,device->buffer, buflen);
219 else
220 newbuf = HeapAlloc(GetProcessHeap(),0, buflen);
221
222 if (!newbuf) {
223 ERR("failed to allocate primary buffer\n");
224 return DSERR_OUTOFMEMORY;
225 /* but the old buffer might still exist and must be re-prepared */
226 }
227
228 DSOUND_RecalcPrimary(device);
229 if (device->pwave)
230 headers = HeapReAlloc(GetProcessHeap(),0,device->pwave, device->helfrags * sizeof(WAVEHDR));
231 else
232 headers = HeapAlloc(GetProcessHeap(),0,device->helfrags * sizeof(WAVEHDR));
233
234 if (!headers) {
235 ERR("failed to allocate wave headers\n");
236 HeapFree(GetProcessHeap(), 0, newbuf);
237 DSOUND_RecalcPrimary(device);
238 return DSERR_OUTOFMEMORY;
239 }
240
241 device->buffer = newbuf;
242 device->pwave = headers;
243
244 /* prepare fragment headers */
245 for (c=0; c<device->helfrags; c++) {
246 device->pwave[c].lpData = (char*)device->buffer + c*device->fraglen;
247 device->pwave[c].dwBufferLength = device->fraglen;
248 device->pwave[c].dwUser = (DWORD)device;
249 device->pwave[c].dwFlags = 0;
250 device->pwave[c].dwLoops = 0;
251 err = mmErr(waveOutPrepareHeader(device->hwo,&device->pwave[c],sizeof(WAVEHDR)));
252 if (err != DS_OK) {
253 while (c--)
254 waveOutUnprepareHeader(device->hwo,&device->pwave[c],sizeof(WAVEHDR));
255 break;
256 }
257 }
258
259 overshot = device->buflen % device->fraglen;
260 /* sanity */
261 if(overshot)
262 {
263 overshot -= overshot % device->pwfx->nBlockAlign;
264 device->pwave[device->helfrags - 1].dwBufferLength += overshot;
265 }
266
267 TRACE("fraglen=%d, overshot=%d\n", device->fraglen, overshot);
268 }
269 device->mixfunction = mixfunctions[device->pwfx->wBitsPerSample/8 - 1];
270 device->normfunction = normfunctions[device->pwfx->wBitsPerSample/8 - 1];
271 FillMemory(device->buffer, device->buflen, (device->pwfx->wBitsPerSample == 8) ? 128 : 0);
272 FillMemory(device->mix_buffer, device->mix_buffer_len, 0);
273 device->pwplay = device->pwqueue = device->playpos = device->mixpos = 0;
274 return err;
275 }
276
277
278 static void DSOUND_PrimaryClose(DirectSoundDevice *device)
279 {
280 TRACE("(%p)\n", device);
281
282 /* are we using waveOut stuff? */
283 if (!device->hwbuf) {
284 unsigned c;
285
286 /* get out of CS when calling the wave system */
287 LeaveCriticalSection(&(device->mixlock));
288 /* **** */
289 device->pwqueue = (DWORD)-1; /* resetting queues */
290 waveOutReset(device->hwo);
291 for (c=0; c<device->helfrags; c++)
292 waveOutUnprepareHeader(device->hwo, &device->pwave[c], sizeof(WAVEHDR));
293 /* **** */
294 EnterCriticalSection(&(device->mixlock));
295
296 /* clear the queue */
297 device->pwqueue = 0;
298 } else {
299 ULONG ref = IDsDriverBuffer_Release(device->hwbuf);
300 if (!ref)
301 device->hwbuf = 0;
302 else
303 ERR("Still %d references on primary buffer, refcount leak?\n", ref);
304 }
305 }
306
307 HRESULT DSOUND_PrimaryCreate(DirectSoundDevice *device)
308 {
309 HRESULT err = DS_OK;
310 TRACE("(%p)\n", device);
311
312 device->buflen = ds_hel_buflen;
313 err = DSOUND_PrimaryOpen(device);
314
315 if (err != DS_OK) {
316 WARN("DSOUND_PrimaryOpen failed\n");
317 return err;
318 }
319
320 device->state = STATE_STOPPED;
321 return DS_OK;
322 }
323
324 HRESULT DSOUND_PrimaryDestroy(DirectSoundDevice *device)
325 {
326 TRACE("(%p)\n", device);
327
328 /* **** */
329 EnterCriticalSection(&(device->mixlock));
330
331 DSOUND_PrimaryClose(device);
332 if (device->driver) {
333 if (device->hwbuf) {
334 if (IDsDriverBuffer_Release(device->hwbuf) == 0)
335 device->hwbuf = 0;
336 }
337 } else
338 HeapFree(GetProcessHeap(),0,device->pwave);
339 HeapFree(GetProcessHeap(),0,device->pwfx);
340 device->pwfx=NULL;
341
342 LeaveCriticalSection(&(device->mixlock));
343 /* **** */
344
345 return DS_OK;
346 }
347
348 HRESULT DSOUND_PrimaryPlay(DirectSoundDevice *device)
349 {
350 HRESULT err = DS_OK;
351 TRACE("(%p)\n", device);
352
353 if (device->hwbuf) {
354 err = IDsDriverBuffer_Play(device->hwbuf, 0, 0, DSBPLAY_LOOPING);
355 if (err != DS_OK)
356 WARN("IDsDriverBuffer_Play failed\n");
357 } else {
358 err = mmErr(waveOutRestart(device->hwo));
359 if (err != DS_OK)
360 WARN("waveOutRestart failed\n");
361 }
362
363 return err;
364 }
365
366 HRESULT DSOUND_PrimaryStop(DirectSoundDevice *device)
367 {
368 HRESULT err = DS_OK;
369 TRACE("(%p)\n", device);
370
371 if (device->hwbuf) {
372 err = IDsDriverBuffer_Stop(device->hwbuf);
373 if (err == DSERR_BUFFERLOST) {
374 DSOUND_PrimaryClose(device);
375 err = DSOUND_ReopenDevice(device, FALSE);
376 if (FAILED(err))
377 ERR("DSOUND_ReopenDevice failed\n");
378 else
379 {
380 err = DSOUND_PrimaryOpen(device);
381 if (FAILED(err))
382 WARN("DSOUND_PrimaryOpen failed\n");
383 }
384 } else if (err != DS_OK) {
385 WARN("IDsDriverBuffer_Stop failed\n");
386 }
387 } else {
388
389 /* don't call the wave system with the lock set */
390 LeaveCriticalSection(&(device->mixlock));
391 /* **** */
392
393 err = mmErr(waveOutPause(device->hwo));
394
395 /* **** */
396 EnterCriticalSection(&(device->mixlock));
397
398 if (err != DS_OK)
399 WARN("waveOutPause failed\n");
400 }
401
402 return err;
403 }
404
405 HRESULT DSOUND_PrimaryGetPosition(DirectSoundDevice *device, LPDWORD playpos, LPDWORD writepos)
406 {
407 TRACE("(%p,%p,%p)\n", device, playpos, writepos);
408
409 if (device->hwbuf) {
410 HRESULT err=IDsDriverBuffer_GetPosition(device->hwbuf,playpos,writepos);
411 if (err) {
412 WARN("IDsDriverBuffer_GetPosition failed\n");
413 return err;
414 }
415 } else {
416 TRACE("pwplay=%i, pwqueue=%i\n", device->pwplay, device->pwqueue);
417
418 /* check if playpos was requested */
419 if (playpos)
420 /* use the cached play position */
421 *playpos = device->pwplay * device->fraglen;
422
423 /* check if writepos was requested */
424 if (writepos)
425 /* the writepos is the first non-queued position */
426 *writepos = ((device->pwplay + device->pwqueue) % device->helfrags) * device->fraglen;
427 }
428 TRACE("playpos = %d, writepos = %d (%p, time=%d)\n", playpos?*playpos:-1, writepos?*writepos:-1, device, GetTickCount());
429 return DS_OK;
430 }
431
432 HRESULT DSOUND_PrimarySetFormat(DirectSoundDevice *device, LPCWAVEFORMATEX wfex, BOOL forced)
433 {
434 HRESULT err = DSERR_BUFFERLOST;
435 int i, alloc_size, cp_size;
436 DWORD nSamplesPerSec, bpp, chans;
437 TRACE("(%p,%p)\n", device, wfex);
438
439 if (device->priolevel == DSSCL_NORMAL) {
440 WARN("failed priority check!\n");
441 return DSERR_PRIOLEVELNEEDED;
442 }
443
444 /* Let's be pedantic! */
445 if (wfex == NULL) {
446 WARN("invalid parameter: wfex==NULL!\n");
447 return DSERR_INVALIDPARAM;
448 }
449 TRACE("(formattag=0x%04x,chans=%d,samplerate=%d,"
450 "bytespersec=%d,blockalign=%d,bitspersamp=%d,cbSize=%d)\n",
451 wfex->wFormatTag, wfex->nChannels, wfex->nSamplesPerSec,
452 wfex->nAvgBytesPerSec, wfex->nBlockAlign,
453 wfex->wBitsPerSample, wfex->cbSize);
454
455 /* **** */
456 RtlAcquireResourceExclusive(&(device->buffer_list_lock), TRUE);
457 EnterCriticalSection(&(device->mixlock));
458
459 if (wfex->wFormatTag == WAVE_FORMAT_PCM) {
460 alloc_size = sizeof(WAVEFORMATEX);
461 cp_size = sizeof(PCMWAVEFORMAT);
462 } else
463 alloc_size = cp_size = sizeof(WAVEFORMATEX) + wfex->cbSize;
464
465 device->pwfx = HeapReAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,device->pwfx,alloc_size);
466
467 nSamplesPerSec = device->pwfx->nSamplesPerSec;
468 bpp = device->pwfx->wBitsPerSample;
469 chans = device->pwfx->nChannels;
470
471 CopyMemory(device->pwfx, wfex, cp_size);
472
473 if (!(device->drvdesc.dwFlags & DSDDESC_DOMMSYSTEMSETFORMAT) && device->hwbuf) {
474 err = IDsDriverBuffer_SetFormat(device->hwbuf, device->pwfx);
475
476 /* On bad format, try to re-create, big chance it will work then, only do this if we <HAVE> to */
477 if (forced && (device->pwfx->nSamplesPerSec/100 != wfex->nSamplesPerSec/100 || err == DSERR_BADFORMAT))
478 {
479 err = DSERR_BUFFERLOST;
480 CopyMemory(device->pwfx, wfex, cp_size);
481 }
482
483 if (err != DSERR_BUFFERLOST && FAILED(err)) {
484 WARN("IDsDriverBuffer_SetFormat failed\n");
485 if (!forced)
486 err = DS_OK;
487 goto done;
488 }
489
490 if (err == S_FALSE)
491 {
492 /* ALSA specific: S_FALSE tells that recreation was successful,
493 * but size and location may be changed, and buffer has to be restarted
494 * I put it here, so if frequency doesn't match the error will be changed to DSERR_BUFFERLOST
495 * and the entire re-initialization will occur anyway
496 */
497 IDsDriverBuffer_Lock(device->hwbuf, (LPVOID *)&device->buffer, &device->buflen, NULL, NULL, 0, 0, DSBLOCK_ENTIREBUFFER);
498 IDsDriverBuffer_Unlock(device->hwbuf, device->buffer, 0, NULL, 0);
499
500 if (device->state == STATE_PLAYING) device->state = STATE_STARTING;
501 else if (device->state == STATE_STOPPING) device->state = STATE_STOPPED;
502 device->pwplay = device->pwqueue = device->playpos = device->mixpos = 0;
503 err = DS_OK;
504 }
505 DSOUND_RecalcPrimary(device);
506 }
507
508 if (err == DSERR_BUFFERLOST)
509 {
510 DSOUND_PrimaryClose(device);
511
512 err = DSOUND_ReopenDevice(device, FALSE);
513 if (FAILED(err))
514 {
515 WARN("DSOUND_ReopenDevice failed: %08x\n", err);
516 goto done;
517 }
518 err = DSOUND_PrimaryOpen(device);
519 if (err != DS_OK) {
520 WARN("DSOUND_PrimaryOpen failed\n");
521 goto done;
522 }
523
524 if (wfex->nSamplesPerSec/100 != device->pwfx->nSamplesPerSec/100 && forced && device->buffer)
525 {
526 DSOUND_PrimaryClose(device);
527 device->pwfx->nSamplesPerSec = wfex->nSamplesPerSec;
528 err = DSOUND_ReopenDevice(device, TRUE);
529 if (FAILED(err))
530 WARN("DSOUND_ReopenDevice(2) failed: %08x\n", err);
531 else if (FAILED((err = DSOUND_PrimaryOpen(device))))
532 WARN("DSOUND_PrimaryOpen(2) failed: %08x\n", err);
533 }
534 }
535
536 device->mix_buffer_len = DSOUND_bufpos_to_mixpos(device, device->buflen);
537 device->mix_buffer = HeapReAlloc(GetProcessHeap(), 0, device->mix_buffer, device->mix_buffer_len);
538 FillMemory(device->mix_buffer, device->mix_buffer_len, 0);
539 device->mixfunction = mixfunctions[device->pwfx->wBitsPerSample/8 - 1];
540 device->normfunction = normfunctions[device->pwfx->wBitsPerSample/8 - 1];
541
542 if (nSamplesPerSec != device->pwfx->nSamplesPerSec || bpp != device->pwfx->wBitsPerSample || chans != device->pwfx->nChannels) {
543 IDirectSoundBufferImpl** dsb = device->buffers;
544 for (i = 0; i < device->nrofbuffers; i++, dsb++) {
545 /* **** */
546 RtlAcquireResourceExclusive(&(*dsb)->lock, TRUE);
547
548 (*dsb)->freqAdjust = ((DWORD64)(*dsb)->freq << DSOUND_FREQSHIFT) / device->pwfx->nSamplesPerSec;
549 DSOUND_RecalcFormat((*dsb));
550 DSOUND_MixToTemporary((*dsb), 0, (*dsb)->buflen, FALSE);
551 (*dsb)->primary_mixpos = 0;
552
553 RtlReleaseResource(&(*dsb)->lock);
554 /* **** */
555 }
556 }
557
558 done:
559 LeaveCriticalSection(&(device->mixlock));
560 RtlReleaseResource(&(device->buffer_list_lock));
561 /* **** */
562
563 return err;
564 }
565
566 /*******************************************************************************
567 * PrimaryBuffer
568 */
569 /* This sets this format for the <em>Primary Buffer Only</em> */
570 /* See file:///cdrom/sdk52/docs/worddoc/dsound.doc page 120 */
571 static HRESULT WINAPI PrimaryBufferImpl_SetFormat(
572 LPDIRECTSOUNDBUFFER iface,
573 LPCWAVEFORMATEX wfex)
574 {
575 DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
576 TRACE("(%p,%p)\n", iface, wfex);
577 return DSOUND_PrimarySetFormat(device, wfex, device->priolevel == DSSCL_WRITEPRIMARY);
578 }
579
580 static HRESULT WINAPI PrimaryBufferImpl_SetVolume(
581 LPDIRECTSOUNDBUFFER iface,LONG vol
582 ) {
583 DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
584 DWORD ampfactors;
585 DSVOLUMEPAN volpan;
586 HRESULT hres = DS_OK;
587 TRACE("(%p,%d)\n", iface, vol);
588
589 if (!(device->dsbd.dwFlags & DSBCAPS_CTRLVOLUME)) {
590 WARN("control unavailable\n");
591 return DSERR_CONTROLUNAVAIL;
592 }
593
594 if ((vol > DSBVOLUME_MAX) || (vol < DSBVOLUME_MIN)) {
595 WARN("invalid parameter: vol = %d\n", vol);
596 return DSERR_INVALIDPARAM;
597 }
598
599 /* **** */
600 EnterCriticalSection(&(device->mixlock));
601
602 waveOutGetVolume(device->hwo, &factors);
603 volpan.dwTotalLeftAmpFactor=ampfactors & 0xffff;
604 volpan.dwTotalRightAmpFactor=ampfactors >> 16;
605 DSOUND_AmpFactorToVolPan(&volpan);
606 if (vol != volpan.lVolume) {
607 volpan.lVolume=vol;
608 DSOUND_RecalcVolPan(&volpan);
609 if (device->hwbuf) {
610 hres = IDsDriverBuffer_SetVolumePan(device->hwbuf, &volpan);
611 if (hres != DS_OK)
612 WARN("IDsDriverBuffer_SetVolumePan failed\n");
613 } else {
614 ampfactors = (volpan.dwTotalLeftAmpFactor & 0xffff) | (volpan.dwTotalRightAmpFactor << 16);
615 waveOutSetVolume(device->hwo, ampfactors);
616 }
617 }
618
619 LeaveCriticalSection(&(device->mixlock));
620 /* **** */
621
622 return hres;
623 }
624
625 static HRESULT WINAPI PrimaryBufferImpl_GetVolume(
626 LPDIRECTSOUNDBUFFER iface,LPLONG vol
627 ) {
628 DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
629 DWORD ampfactors;
630 DSVOLUMEPAN volpan;
631 TRACE("(%p,%p)\n", iface, vol);
632
633 if (!(device->dsbd.dwFlags & DSBCAPS_CTRLVOLUME)) {
634 WARN("control unavailable\n");
635 return DSERR_CONTROLUNAVAIL;
636 }
637
638 if (vol == NULL) {
639 WARN("invalid parameter: vol = NULL\n");
640 return DSERR_INVALIDPARAM;
641 }
642
643 waveOutGetVolume(device->hwo, &factors);
644 volpan.dwTotalLeftAmpFactor=ampfactors & 0xffff;
645 volpan.dwTotalRightAmpFactor=ampfactors >> 16;
646 DSOUND_AmpFactorToVolPan(&volpan);
647 *vol = volpan.lVolume;
648 return DS_OK;
649 }
650
651 static HRESULT WINAPI PrimaryBufferImpl_SetFrequency(
652 LPDIRECTSOUNDBUFFER iface,DWORD freq
653 ) {
654 PrimaryBufferImpl *This = (PrimaryBufferImpl *)iface;
655 TRACE("(%p,%d)\n",This,freq);
656
657 /* You cannot set the frequency of the primary buffer */
658 WARN("control unavailable\n");
659 return DSERR_CONTROLUNAVAIL;
660 }
661
662 static HRESULT WINAPI PrimaryBufferImpl_Play(
663 LPDIRECTSOUNDBUFFER iface,DWORD reserved1,DWORD reserved2,DWORD flags
664 ) {
665 DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
666 TRACE("(%p,%08x,%08x,%08x)\n", iface, reserved1, reserved2, flags);
667
668 if (!(flags & DSBPLAY_LOOPING)) {
669 WARN("invalid parameter: flags = %08x\n", flags);
670 return DSERR_INVALIDPARAM;
671 }
672
673 /* **** */
674 EnterCriticalSection(&(device->mixlock));
675
676 if (device->state == STATE_STOPPED)
677 device->state = STATE_STARTING;
678 else if (device->state == STATE_STOPPING)
679 device->state = STATE_PLAYING;
680
681 LeaveCriticalSection(&(device->mixlock));
682 /* **** */
683
684 return DS_OK;
685 }
686
687 static HRESULT WINAPI PrimaryBufferImpl_Stop(LPDIRECTSOUNDBUFFER iface)
688 {
689 DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
690 TRACE("(%p)\n", iface);
691
692 /* **** */
693 EnterCriticalSection(&(device->mixlock));
694
695 if (device->state == STATE_PLAYING)
696 device->state = STATE_STOPPING;
697 else if (device->state == STATE_STARTING)
698 device->state = STATE_STOPPED;
699
700 LeaveCriticalSection(&(device->mixlock));
701 /* **** */
702
703 return DS_OK;
704 }
705
706 static ULONG WINAPI PrimaryBufferImpl_AddRef(LPDIRECTSOUNDBUFFER iface)
707 {
708 PrimaryBufferImpl *This = (PrimaryBufferImpl *)iface;
709 ULONG ref = InterlockedIncrement(&(This->ref));
710 TRACE("(%p) ref was %d\n", This, ref - 1);
711 return ref;
712 }
713
714 static ULONG WINAPI PrimaryBufferImpl_Release(LPDIRECTSOUNDBUFFER iface)
715 {
716 PrimaryBufferImpl *This = (PrimaryBufferImpl *)iface;
717 DWORD ref = InterlockedDecrement(&(This->ref));
718 TRACE("(%p) ref was %d\n", This, ref + 1);
719
720 if (!ref) {
721 This->device->primary = NULL;
722 HeapFree(GetProcessHeap(), 0, This);
723 TRACE("(%p) released\n", This);
724 }
725 return ref;
726 }
727
728 static HRESULT WINAPI PrimaryBufferImpl_GetCurrentPosition(
729 LPDIRECTSOUNDBUFFER iface,LPDWORD playpos,LPDWORD writepos
730 ) {
731 HRESULT hres;
732 DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
733 TRACE("(%p,%p,%p)\n", iface, playpos, writepos);
734
735 /* **** */
736 EnterCriticalSection(&(device->mixlock));
737
738 hres = DSOUND_PrimaryGetPosition(device, playpos, writepos);
739 if (hres != DS_OK) {
740 WARN("DSOUND_PrimaryGetPosition failed\n");
741 LeaveCriticalSection(&(device->mixlock));
742 return hres;
743 }
744 if (writepos) {
745 if (device->state != STATE_STOPPED)
746 /* apply the documented 10ms lead to writepos */
747 *writepos += device->writelead;
748 while (*writepos >= device->buflen) *writepos -= device->buflen;
749 }
750
751 LeaveCriticalSection(&(device->mixlock));
752 /* **** */
753
754 TRACE("playpos = %d, writepos = %d (%p, time=%d)\n", playpos?*playpos:0, writepos?*writepos:0, device, GetTickCount());
755 return DS_OK;
756 }
757
758 static HRESULT WINAPI PrimaryBufferImpl_GetStatus(
759 LPDIRECTSOUNDBUFFER iface,LPDWORD status
760 ) {
761 DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
762 TRACE("(%p,%p)\n", iface, status);
763
764 if (status == NULL) {
765 WARN("invalid parameter: status == NULL\n");
766 return DSERR_INVALIDPARAM;
767 }
768
769 *status = 0;
770 if ((device->state == STATE_STARTING) ||
771 (device->state == STATE_PLAYING))
772 *status |= DSBSTATUS_PLAYING | DSBSTATUS_LOOPING;
773
774 TRACE("status=%x\n", *status);
775 return DS_OK;
776 }
777
778
779 static HRESULT WINAPI PrimaryBufferImpl_GetFormat(
780 LPDIRECTSOUNDBUFFER iface,
781 LPWAVEFORMATEX lpwf,
782 DWORD wfsize,
783 LPDWORD wfwritten)
784 {
785 DWORD size;
786 DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
787 TRACE("(%p,%p,%d,%p)\n", iface, lpwf, wfsize, wfwritten);
788
789 size = sizeof(WAVEFORMATEX) + device->pwfx->cbSize;
790
791 if (lpwf) { /* NULL is valid */
792 if (wfsize >= size) {
793 CopyMemory(lpwf,device->pwfx,size);
794 if (wfwritten)
795 *wfwritten = size;
796 } else {
797 WARN("invalid parameter: wfsize too small\n");
798 if (wfwritten)
799 *wfwritten = 0;
800 return DSERR_INVALIDPARAM;
801 }
802 } else {
803 if (wfwritten)
804 *wfwritten = sizeof(WAVEFORMATEX) + device->pwfx->cbSize;
805 else {
806 WARN("invalid parameter: wfwritten == NULL\n");
807 return DSERR_INVALIDPARAM;
808 }
809 }
810
811 return DS_OK;
812 }
813
814 static HRESULT WINAPI PrimaryBufferImpl_Lock(
815 LPDIRECTSOUNDBUFFER iface,DWORD writecursor,DWORD writebytes,LPVOID *lplpaudioptr1,LPDWORD audiobytes1,LPVOID *lplpaudioptr2,LPDWORD audiobytes2,DWORD flags
816 ) {
817 HRESULT hres;
818 DirectSoundDevice *device = ((PrimaryBufferImpl *)iface)->device;
819 TRACE("(%p,%d,%d,%p,%p,%p,%p,0x%08x) at %d\n",
820 iface,
821 writecursor,
822 writebytes,
823 lplpaudioptr1,
824 audiobytes1,
825 lplpaudioptr2,
826 audiobytes2,
827 flags,
828 GetTickCount()
829 );
830
831 if (device->priolevel != DSSCL_WRITEPRIMARY) {
832 WARN("failed priority check!\n");
833 return DSERR_PRIOLEVELNEEDED;
834 }
835
836 /* when this flag is set, writecursor is meaningless and must be calculated */
837 if (flags & DSBLOCK_FROMWRITECURSOR) {
838 /* GetCurrentPosition does too much magic to duplicate here */
839 hres = IDirectSoundBuffer_GetCurrentPosition(iface, NULL, &writecursor);
840 if (hres !=