?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Improve a couple traces
[dsound-openal.git] / buffer.c
blob65d377d23eb47397038b7346d07c5baf34698eb4
1 /* DirectSound COM interface
2 *
3 * Copyright 2009 Maarten Lankhorst
4 *
5 * Some code taken from the original dsound-openal implementation
6 * Copyright 2007-2009 Chris Robinson
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Lesser General Public
10 * License as published by the Free Software Foundation; either
11 * version 2.1 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Lesser General Public License for more details.
17 *
18 * You should have received a copy of the GNU Lesser General Public
19 * License along with this library; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 */
22
23 #include <stdarg.h>
24
25 #ifdef __WINESRC__
26
27 #define COBJMACROS
28 #define NONAMELESSSTRUCT
29 #define NONAMELESSUNION
30 #include "windef.h"
31 #include "winbase.h"
32 #include "winuser.h"
33 #include "winnls.h"
34 #include "winreg.h"
35 #include "vfwmsgs.h"
36 #include "mmsystem.h"
37 #include "winternl.h"
38 #include "mmddk.h"
39 #include "wine/debug.h"
40 #include "dsound.h"
41
42 #include "dsound_private.h"
43
44 #include "ks.h"
45 #include "ksmedia.h"
46
47 WINE_DEFAULT_DEBUG_CHANNEL(dsound);
48
49 #else
50
51 #define WINVER 0x0600
52 #define INITGUID
53 #include <windows.h>
54 #include <dsound.h>
55
56 #include "dsound_private.h"
57
58 DEFINE_GUID(CLSID_DirectSoundPrivate,0x11ab3ec0,0x25ec,0x11d1,0xa4,0xd8,0x00,0xc0,0x4f,0xc2,0x8a,0xca);
59
60 DEFINE_GUID(DSPROPSETID_DirectSoundDevice,0x84624f82,0x25ec,0x11d1,0xa4,0xd8,0x00,0xc0,0x4f,0xc2,0x8a,0xca);
61
62 DEFINE_GUID(KSDATAFORMAT_SUBTYPE_PCM, 0x00000001, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
63 DEFINE_GUID(KSDATAFORMAT_SUBTYPE_IEEE_FLOAT, 0x00000003, 0x0000, 0x0010, 0x80, 0x00, 0x00, 0xaa, 0x00, 0x38, 0x9b, 0x71);
64
65 #ifndef E_PROP_ID_UNSUPPORTED
66 #define E_PROP_ID_UNSUPPORTED ((HRESULT)0x80070490)
67 #endif
68
69 #endif
70
71 #ifndef WAVE_FORMAT_IEEE_FLOAT
72 #define WAVE_FORMAT_IEEE_FLOAT 3
73 #endif
74
75 /* TODO: when bufferlost is set, return from all calls except initialize with
76 * DSERR_BUFFERLOST
77 */
78 static const IDirectSoundBuffer8Vtbl DS8Buffer_Vtbl;
79 static const IDirectSound3DBufferVtbl DS8Buffer3d_Vtbl;
80 static const IDirectSoundNotifyVtbl DS8BufferNot_Vtbl;
81 static const IKsPropertySetVtbl DS8BufferProp_Vtbl;
82
83 /* Amount of buffers that have to be queued when
84 * bufferdatastatic and buffersubdata are not available */
85 #define QBUFFERS 3
86
87 struct DS8Data
88 {
89 LONG ref;
90
91 /* Lock was called and unlock isn't? */
92 BOOL locked;
93
94 WAVEFORMATEXTENSIBLE format;
95
96 ALuint buf_size;
97 ALenum buf_format;
98 ALenum in_type, in_chans;
99 DWORD dsbflags;
100 BYTE *data;
101 ALuint *buffers;
102 ALuint numsegs;
103 ALuint segsize;
104 ALuint lastsegsize;
105 };
106
107 static void trigger_notifies(DS8Buffer *buf, DWORD lastpos, DWORD curpos, BOOL stopping)
108 {
109 DWORD i;
110 if (lastpos == curpos && !stopping)
111 return;
112 for (i = 0; i < buf->nnotify; ++i)
113 {
114 DSBPOSITIONNOTIFY *not = &buf->notify[i];
115 HANDLE event = not->hEventNotify;
116 DWORD ofs = not->dwOffset;
117
118 if (ofs == (DWORD)DSBPN_OFFSETSTOP)
119 {
120 if (stopping)
121 SetEvent(event);
122 continue;
123 }
124
125 /* Wraparound case */
126 if (curpos < lastpos)
127 {
128 if (ofs < curpos || ofs >= lastpos)
129 SetEvent(event);
130 continue;
131 }
132
133 /* Normal case */
134 if (ofs >= lastpos && ofs < curpos)
135 SetEvent(event);
136 }
137 }
138
139 static void CALLBACK DS8Buffer_timer(UINT timerID, UINT msg, DWORD_PTR dwUser,
140 DWORD_PTR dw1, DWORD_PTR dw2)
141 {
142 DS8Primary *prim = (DS8Primary*)dwUser;
143 DWORD i;
144 (void)timerID;
145 (void)msg;
146 (void)dw1;
147 (void)dw2;
148
149 EnterCriticalSection(&prim->crst);
150 setALContext(prim->ctx);
151
152 /* OpenAL doesn't support our lovely buffer extensions
153 * so just make sure enough buffers are queued
154 */
155 if(!prim->ExtAL.BufferSamplesSOFT && !prim->ExtAL.BufferSubData &&
156 !prim->ExtAL.BufferDataStatic)
157 {
158 /* FIXME: Should probably use this logic to also
159 * call trigger_notifies
160 */
161 for (i = 0; i < prim->nbuffers; ++i)
162 {
163 DS8Buffer *buf = prim->buffers[i];
164 ALint done = 0, queued = QBUFFERS, state = AL_PLAYING;
165 ALuint which, ofs;
166
167 if (buf->buffer->numsegs == 1 || !buf->isplaying)
168 continue;
169
170 alGetSourcei(buf->source, AL_SOURCE_STATE, &state);
171 alGetSourcei(buf->source, AL_BUFFERS_QUEUED, &queued);
172 alGetSourcei(buf->source, AL_BUFFERS_PROCESSED, &done);
173
174 queued -= done;
175 while (done--)
176 alSourceUnqueueBuffers(buf->source, 1, &which);
177 while (queued < QBUFFERS)
178 {
179 which = buf->buffer->buffers[buf->curidx];
180 ofs = buf->curidx*buf->buffer->segsize;
181 if(buf->curidx < buf->buffer->numsegs-1)
182 alBufferData(which, buf->buffer->buf_format,
183 buf->buffer->data + ofs, buf->buffer->segsize,
184 buf->buffer->format.Format.nSamplesPerSec);
185 else
186 alBufferData(which, buf->buffer->buf_format,
187 buf->buffer->data + ofs, buf->buffer->lastsegsize,
188 buf->buffer->format.Format.nSamplesPerSec);
189
190 alSourceQueueBuffers(buf->source, 1, &which);
191 buf->curidx = (buf->curidx+1)%buf->buffer->numsegs;
192 queued++;
193
194 if (!buf->curidx && !buf->islooping)
195 {
196 buf->isplaying = FALSE;
197 break;
198 }
199 }
200 if (state != AL_PLAYING)
201 {
202 if (!queued)
203 {
204 IDirectSoundBuffer8_Stop(&buf->IDirectSoundBuffer8_iface);
205 continue;
206 }
207 alSourcePlay(buf->source);
208 }
209 getALError();
210 }
211 }
212
213 for (i = 0; i < prim->nnotifies ; )
214 {
215 DS8Buffer *buf = prim->notifies[i];
216 IDirectSoundBuffer8 *dsb = &buf->IDirectSoundBuffer8_iface;
217 DWORD status, curpos;
218 HRESULT hr;
219
220 hr = IDirectSoundBuffer8_GetStatus(dsb, &status);
221 if (SUCCEEDED(hr))
222 {
223 if (!(status & DSBSTATUS_PLAYING))
224 {
225 /* Stop will remove this buffer from list,
226 * and put another at the current position
227 * don't increment i
228 */
229 IDirectSoundBuffer8_Stop(dsb);
230 continue;
231 }
232 hr = IDirectSoundBuffer8_GetCurrentPosition(dsb, &curpos, NULL);
233 if (SUCCEEDED(hr))
234 {
235 trigger_notifies(buf, buf->lastpos, curpos, FALSE);
236 buf->lastpos = curpos;
237 }
238 }
239 i++;
240 }
241 popALContext();
242 LeaveCriticalSection(&prim->crst);
243 }
244
245 static void DS8Buffer_starttimer(DS8Primary *prim)
246 {
247 TIMECAPS time;
248 ALint refresh = FAKE_REFRESH_COUNT;
249 DWORD triggertime, res = DS_TIME_RES;
250
251 if(prim->timer_id)
252 return;
253
254 timeGetDevCaps(&time, sizeof(TIMECAPS));
255
256 alcGetIntegerv(prim->parent->device, ALC_REFRESH, 1, &refresh);
257 getALCError(prim->parent->device);
258
259 triggertime = 1000 / refresh;
260 if(triggertime < time.wPeriodMin)
261 triggertime = time.wPeriodMin;
262 TRACE("Calling timer every %u ms for %i refreshes per second\n", triggertime, refresh);
263
264 if (res < time.wPeriodMin)
265 res = time.wPeriodMin;
266 if (timeBeginPeriod(res) == TIMERR_NOCANDO)
267 WARN("Could not set minimum resolution, don't expect sound\n");
268
269 prim->timer_res = res;
270 prim->timer_id = timeSetEvent(triggertime, res, DS8Buffer_timer, (DWORD_PTR)prim, TIME_PERIODIC | TIME_KILL_SYNCHRONOUS);
271 }
272
273 /* Should be called with critsect held and context set.. */
274 static void DS8Buffer_addnotify(DS8Buffer *buf)
275 {
276 DS8Buffer **list;
277 DWORD i;
278
279 list = buf->primary->notifies;
280 for(i = 0; i < buf->primary->nnotifies; ++i)
281 {
282 if(buf == list[i])
283 {
284 ERR("Buffer %p already in notification list\n", buf);
285 return;
286 }
287 }
288 if(buf->primary->nnotifies == buf->primary->sizenotifies)
289 {
290 list = HeapReAlloc(GetProcessHeap(), 0, list, (buf->primary->nnotifies + 1) * sizeof(*list));
291 if(!list)
292 return;
293 buf->primary->sizenotifies++;
294 }
295 list[buf->primary->nnotifies++] = buf;
296 buf->primary->notifies = list;
297 }
298
299 static void DS8Buffer_removenotify(DS8Buffer *buf)
300 {
301 DWORD i;
302 for(i = 0; i < buf->primary->nnotifies; ++i)
303 {
304 if(buf == buf->primary->notifies[i])
305 {
306 buf->primary->notifies[i] =
307 buf->primary->notifies[--buf->primary->nnotifies];
308 return;
309 }
310 }
311 }
312
313 static const char *get_fmtstr_PCM(const DS8Primary *prim, const WAVEFORMATEX *format, WAVEFORMATEXTENSIBLE *out, ALenum *in_chans, ALenum *in_type)
314 {
315 out->Format = *format;
316 out->Format.cbSize = 0;
317
318 if(format->wBitsPerSample == 8)
319 {
320 *in_type = AL_UNSIGNED_BYTE;
321 switch(format->nChannels)
322 {
323 case 1: *in_chans = AL_MONO;
324 return "AL_FORMAT_MONO8";
325 case 2: *in_chans = AL_STEREO;
326 return "AL_FORMAT_STEREO8";
327 case 4: *in_chans = AL_QUAD;
328 return "AL_FORMAT_QUAD8";
329 case 6: *in_chans = AL_5POINT1;
330 return "AL_FORMAT_51CHN8";
331 case 7: *in_chans = AL_6POINT1;
332 return "AL_FORMAT_61CHN8";
333 case 8: *in_chans = AL_7POINT1;
334 return "AL_FORMAT_71CHN8";
335 default: break;
336 }
337 }
338 else if(format->wBitsPerSample == 16)
339 {
340 *in_type = AL_SHORT;
341 switch(format->nChannels)
342 {
343 case 1: *in_chans = AL_MONO;
344 return "AL_FORMAT_MONO16";
345 case 2: *in_chans = AL_STEREO;
346 return "AL_FORMAT_STEREO16";
347 case 4: *in_chans = AL_QUAD;
348 return "AL_FORMAT_QUAD16";
349 case 6: *in_chans = AL_5POINT1;
350 return "AL_FORMAT_51CHN16";
351 case 7: *in_chans = AL_6POINT1;
352 return "AL_FORMAT_61CHN16";
353 case 8: *in_chans = AL_7POINT1;
354 return "AL_FORMAT_71CHN16";
355 default: break;
356 }
357 }
358 #if 0 /* Will cause incorrect byte offsets */
359 else if(format->wBitsPerSample == 24 && prim->SupportedExt[SOFT_BUFFER_SAMPLES])
360 {
361 *in_type = AL_BYTE3;
362 switch(format->nChannels)
363 {
364 case 1: *in_chans = AL_MONO;
365 return "AL_MONO32F";
366 case 2: *in_chans = AL_STEREO;
367 return "AL_STEREO32F";
368 case 4: *in_chans = AL_QUAD;
369 return "AL_QUAD32F";
370 case 6: *in_chans = AL_5POINT1;
371 return "AL_5POINT1_32F";
372 case 7: *in_chans = AL_6POINT1;
373 return "AL_6POINT1_32F";
374 case 8: *in_chans = AL_7POINT1;
375 return "AL_7POINT1_32F";
376 default: break;
377 }
378 }
379 #endif
380 else if(format->wBitsPerSample == 32 && prim->SupportedExt[SOFT_BUFFER_SAMPLES])
381 {
382 *in_type = AL_INT;
383 switch(format->nChannels)
384 {
385 case 1: *in_chans = AL_MONO;
386 return "AL_MONO32F";
387 case 2: *in_chans = AL_STEREO;
388 return "AL_STEREO32F";
389 case 4: *in_chans = AL_QUAD;
390 return "AL_QUAD32F";
391 case 6: *in_chans = AL_5POINT1;
392 return "AL_5POINT1_32F";
393 case 7: *in_chans = AL_6POINT1;
394 return "AL_6POINT1_32F";
395 case 8: *in_chans = AL_7POINT1;
396 return "AL_7POINT1_32F";
397 default: break;
398 }
399 }
400
401 FIXME("Could not get OpenAL format (%d-bit, %d channels)\n",
402 format->wBitsPerSample, format->nChannels);
403 return NULL;
404 }
405
406 static const char *get_fmtstr_FLOAT(const DS8Primary *prim, const WAVEFORMATEX *format, WAVEFORMATEXTENSIBLE *out, ALenum *in_chans, ALenum *in_type)
407 {
408 out->Format = *format;
409 out->Format.cbSize = 0;
410
411 if(format->wBitsPerSample == 32 &&
412 (prim->SupportedExt[EXT_FLOAT32] || prim->SupportedExt[SOFT_BUFFER_SAMPLES]))
413 {
414 *in_type = AL_FLOAT;
415 switch(format->nChannels)
416 {
417 case 1: *in_chans = AL_MONO;
418 return "AL_FORMAT_MONO_FLOAT32";
419 case 2: *in_chans = AL_STEREO;
420 return "AL_FORMAT_STEREO_FLOAT32";
421 case 4: *in_chans = AL_QUAD;
422 return "AL_FORMAT_QUAD32";
423 case 6: *in_chans = AL_5POINT1;
424 return "AL_FORMAT_51CHN32";
425 case 7: *in_chans = AL_6POINT1;
426 return "AL_FORMAT_61CHN32";
427 case 8: *in_chans = AL_7POINT1;
428 return "AL_FORMAT_71CHN32";
429 default: break;
430 }
431 }
432 #if 0 /* Will cause incorrect byte offsets */
433 else if(format->wBitsPerSample == 64 && prim->SupportedExt[SOFT_BUFFER_SAMPLES])
434 {
435 *in_type = AL_DOUBLE;
436 switch(format->nChannels)
437 {
438 case 1: *in_chans = AL_MONO;
439 return "AL_MONO32F";
440 case 2: *in_chans = AL_STEREO;
441 return "AL_STEREO32F";
442 case 4: *in_chans = AL_QUAD;
443 return "AL_QUAD32F";
444 case 6: *in_chans = AL_5POINT1;
445 return "AL_5POINT1_32F";
446 case 7: *in_chans = AL_6POINT1;
447 return "AL_6POINT1_32F";
448 case 8: *in_chans = AL_7POINT1;
449 return "AL_7POINT1_32F";
450 default: break;
451 }
452 }
453 #endif
454
455 FIXME("Could not get OpenAL format (%d-bit, %d channels)\n",
456 format->wBitsPerSample, format->nChannels);
457 return NULL;
458 }
459
460 /* Speaker configs */
461 #define MONO SPEAKER_FRONT_CENTER
462 #define STEREO (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT)
463 #define REAR (SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT)
464 #define QUAD (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT)
465 #define X5DOT1 (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT)
466 #define X6DOT1 (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_CENTER|SPEAKER_SIDE_LEFT|SPEAKER_SIDE_RIGHT)
467 #define X7DOT1 (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT|SPEAKER_SIDE_LEFT|SPEAKER_SIDE_RIGHT)
468
469 static const char *get_fmtstr_EXT(const DS8Primary *prim, const WAVEFORMATEX *format, WAVEFORMATEXTENSIBLE *out, ALenum *in_chans, ALenum *in_type)
470 {
471 *out = *(const WAVEFORMATEXTENSIBLE*)format;
472 out->Format.cbSize = sizeof(*out) - sizeof(out->Format);
473
474 if(!out->Samples.wValidBitsPerSample)
475 out->Samples.wValidBitsPerSample = out->Format.wBitsPerSample;
476 else if(out->Samples.wValidBitsPerSample != out->Format.wBitsPerSample)
477 {
478 FIXME("Padded samples not supported (%u of %u)\n", out->Samples.wValidBitsPerSample, out->Format.wBitsPerSample);
479 return NULL;
480 }
481
482 if(out->dwChannelMask != MONO && out->dwChannelMask != STEREO &&
483 !prim->SupportedExt[EXT_MCFORMATS] && !prim->SupportedExt[SOFT_BUFFER_SAMPLES])
484 {
485 WARN("Multi-channel not available\n");
486 return NULL;
487 }
488
489 if(IsEqualGUID(&out->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM))
490 {
491 if(out->Samples.wValidBitsPerSample == 8)
492 {
493 *in_type = AL_UNSIGNED_BYTE;
494 switch(out->dwChannelMask)
495 {
496 case MONO: *in_chans = AL_MONO;
497 return "AL_FORMAT_MONO8";
498 case STEREO: *in_chans = AL_STEREO;
499 return "AL_FORMAT_STEREO8";
500 case REAR: *in_chans = AL_REAR;
501 return "AL_FORMAT_REAR8";
502 case QUAD: *in_chans = AL_QUAD;
503 return "AL_FORMAT_QUAD8";
504 case X5DOT1: *in_chans = AL_5POINT1;
505 return "AL_FORMAT_51CHN8";
506 case X6DOT1: *in_chans = AL_6POINT1;
507 return "AL_FORMAT_61CHN8";
508 case X7DOT1: *in_chans = AL_7POINT1;
509 return "AL_FORMAT_71CHN8";
510 default: break;
511 }
512 }
513 else if(out->Samples.wValidBitsPerSample == 16)
514 {
515 *in_type = AL_SHORT;
516 switch(out->dwChannelMask)
517 {
518 case MONO: *in_chans = AL_MONO;
519 return "AL_FORMAT_MONO16";
520 case STEREO: *in_chans = AL_STEREO;
521 return "AL_FORMAT_STEREO16";
522 case REAR: *in_chans = AL_REAR;
523 return "AL_FORMAT_REAR16";
524 case QUAD: *in_chans = AL_QUAD;
525 return "AL_FORMAT_QUAD16";
526 case X5DOT1: *in_chans = AL_5POINT1;
527 return "AL_FORMAT_51CHN16";
528 case X6DOT1: *in_chans = AL_6POINT1;
529 return "AL_FORMAT_61CHN16";
530 case X7DOT1: *in_chans = AL_7POINT1;
531 return "AL_FORMAT_71CHN16";
532 default: break;
533 }
534 }
535 #if 0
536 else if(out->Samples.wValidBitsPerSample == 24 &&
537 prim->SupportedExt[SOFT_BUFFER_SAMPLES])
538 {
539 *in_type = AL_BYTE3;
540 switch(out->dwChannelMask)
541 {
542 case MONO: *in_chans = AL_MONO;
543 return "AL_MONO32F";
544 case STEREO: *in_chans = AL_STEREO;
545 return "AL_STEREO32F";
546 case REAR: *in_chans = AL_REAR;
547 return "AL_REAR32F";
548 case QUAD: *in_chans = AL_QUAD;
549 return "AL_QUAD32F";
550 case X5DOT1: *in_chans = AL_5POINT1;
551 return "AL_5POINT1_32F";
552 case X6DOT1: *in_chans = AL_6POINT1;
553 return "AL_6POINT1_32F";
554 case X7DOT1: *in_chans = AL_7POINT1;
555 return "AL_7POINT1_32F";
556 default: break;
557 }
558 }
559 #endif
560 else if(out->Samples.wValidBitsPerSample == 32 &&
561 prim->SupportedExt[SOFT_BUFFER_SAMPLES])
562 {
563 *in_type = AL_INT;
564 switch(out->dwChannelMask)
565 {
566 case MONO: *in_chans = AL_MONO;
567 return "AL_MONO32F";
568 case STEREO: *in_chans = AL_STEREO;
569 return "AL_STEREO32F";
570 case REAR: *in_chans = AL_REAR;
571 return "AL_REAR32F";
572 case QUAD: *in_chans = AL_QUAD;
573 return "AL_QUAD32F";
574 case X5DOT1: *in_chans = AL_5POINT1;
575 return "AL_5POINT1_32F";
576 case X6DOT1: *in_chans = AL_6POINT1;
577 return "AL_6POINT1_32F";
578 case X7DOT1: *in_chans = AL_7POINT1;
579 return "AL_7POINT1_32F";
580 default: break;
581 }
582 }
583
584 FIXME("Could not get OpenAL PCM format (%d-bit, channelmask %#x)\n",
585 out->Samples.wValidBitsPerSample, out->dwChannelMask);
586 return NULL;
587 }
588 else if(IsEqualGUID(&out->SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT) &&
589 (prim->SupportedExt[EXT_FLOAT32] || prim->SupportedExt[SOFT_BUFFER_SAMPLES]))
590 {
591 if(out->Samples.wValidBitsPerSample == 32)
592 {
593 *in_type = AL_FLOAT;
594 switch(out->dwChannelMask)
595 {
596 case MONO: *in_chans = AL_MONO;
597 return "AL_FORMAT_MONO_FLOAT32";
598 case STEREO: *in_chans = AL_STEREO;
599 return "AL_FORMAT_STEREO_FLOAT32";
600 case REAR: *in_chans = AL_REAR;
601 return "AL_FORMAT_REAR32";
602 case QUAD: *in_chans = AL_QUAD;
603 return "AL_FORMAT_QUAD32";
604 case X5DOT1: *in_chans = AL_5POINT1;
605 return "AL_FORMAT_51CHN32";
606 case X6DOT1: *in_chans = AL_6POINT1;
607 return "AL_FORMAT_61CHN32";
608 case X7DOT1: *in_chans = AL_7POINT1;
609 return "AL_FORMAT_71CHN32";
610 default: break;
611 }
612 }
613 #if 0
614 else if(out->Samples.wValidBitsPerSample == 64 &&
615 prim->SupportedExt[SOFT_BUFFER_SAMPLES])
616 {
617 *in_type = AL_DOUBLE;
618 switch(out->dwChannelMask)
619 {
620 case MONO: *in_chans = AL_MONO;
621 return "AL_MONO32F";
622 case STEREO: *in_chans = AL_STEREO;
623 return "AL_STEREO32F";
624 case REAR: *in_chans = AL_REAR;
625 return "AL_REAR32F";
626 case QUAD: *in_chans = AL_QUAD;
627 return "AL_QUAD32F";
628 case X5DOT1: *in_chans = AL_5POINT1;
629 return "AL_5POINT1_32F";
630 case X6DOT1: *in_chans = AL_6POINT1;
631 return "AL_6POINT1_32F";
632 case X7DOT1: *in_chans = AL_7POINT1;
633 return "AL_7POINT1_32F";
634 default: break;
635 }
636 }
637 #endif
638 else
639 {
640 WARN("Invalid float bits: %u\n", out->Samples.wValidBitsPerSample);
641 return NULL;
642 }
643
644 FIXME("Could not get OpenAL float format (%d-bit, channelmask %#x)\n",
645 out->Samples.wValidBitsPerSample, out->dwChannelMask);
646 return NULL;
647 }
648 else if(!IsEqualGUID(&out->SubFormat, &GUID_NULL))
649 ERR("Unhandled extensible format: %s\n", debugstr_guid(&out->SubFormat));
650 return NULL;
651 }
652
653 static void DS8Data_Release(DS8Data *This);
654 static HRESULT DS8Data_Create(DS8Data **ppv, const DSBUFFERDESC *desc, DS8Primary *prim)
655 {
656 HRESULT hr = DSERR_INVALIDPARAM;
657 const WAVEFORMATEX *format;
658 const char *fmt_str = NULL;
659 DS8Data *pBuffer;
660
661 format = desc->lpwfxFormat;
662 TRACE("Requested buffer format:\n"
663 " FormatTag = 0x%04x\n"
664 " Channels = %d\n"
665 " SamplesPerSec = %u\n"
666 " AvgBytesPerSec = %u\n"
667 " BlockAlign = %d\n"
668 " BitsPerSample = %d\n",
669 format->wFormatTag, format->nChannels,
670 format->nSamplesPerSec, format->nAvgBytesPerSec,
671 format->nBlockAlign, format->wBitsPerSample);
672
673 if(format->nBlockAlign == 0)
674 {
675 WARN("Invalid BlockAlign specified\n");
676 return DSERR_INVALIDPARAM;
677 }
678
679 /* Generate a new buffer. Supporting the DSBCAPS_LOC* flags properly
680 * will need the EAX-RAM extension. Currently, we just tell the app it
681 * gets what it wanted. */
682 pBuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*pBuffer));
683 if(!pBuffer)
684 return E_OUTOFMEMORY;
685 pBuffer->ref = 1;
686
687 pBuffer->dsbflags = desc->dwFlags;
688 if((pBuffer->dsbflags&(DSBCAPS_LOCSOFTWARE|DSBCAPS_LOCHARDWARE)) == (DSBCAPS_LOCSOFTWARE|DSBCAPS_LOCHARDWARE))
689 {
690 WARN("Hardware and software location requested\n");
691 goto fail;
692 }
693 if(!(pBuffer->dsbflags&(DSBCAPS_LOCSOFTWARE|DSBCAPS_LOCHARDWARE|DSBCAPS_LOCDEFER)))
694 pBuffer->dsbflags |= DSBCAPS_LOCHARDWARE;
695
696 pBuffer->buf_size = desc->dwBufferBytes + format->nBlockAlign - 1;
697 pBuffer->buf_size -= pBuffer->buf_size%format->nBlockAlign;
698
699 hr = DSERR_BUFFERTOOSMALL;
700 if(pBuffer->buf_size < DSBSIZE_MIN)
701 goto fail;
702
703 hr = DSERR_INVALIDPARAM;
704 if(pBuffer->buf_size > DSBSIZE_MAX)
705 goto fail;
706
707 pBuffer->numsegs = 1;
708 pBuffer->segsize = pBuffer->buf_size;
709 pBuffer->lastsegsize = pBuffer->buf_size;
710
711 if(!(pBuffer->dsbflags&DSBCAPS_STATIC) && !prim->ExtAL.BufferSubData &&
712 !prim->ExtAL.BufferSamplesSOFT && !prim->ExtAL.BufferDataStatic)
713 {
714 ALCint refresh = FAKE_REFRESH_COUNT;
715 ALuint newSize;
716
717 alcGetIntegerv(prim->parent->device, ALC_REFRESH, 1, &refresh);
718 getALCError(prim->parent->device);
719
720 newSize = format->nAvgBytesPerSec/refresh + format->nBlockAlign - 1;
721 newSize -= newSize%format->nBlockAlign;
722
723 /* Make sure enough buffers are available */
724 if(newSize > pBuffer->buf_size/(QBUFFERS+2))
725 ERR("Buffer segments too large to stream (%u for %u)!\n",
726 newSize, pBuffer->buf_size);
727 else
728 {
729 pBuffer->numsegs = pBuffer->buf_size/newSize;
730 pBuffer->segsize = newSize;
731 pBuffer->lastsegsize = pBuffer->buf_size - (newSize*(pBuffer->numsegs-1));
732 TRACE("New streaming buffer (%u chunks, %u : %u sizes)\n",
733 pBuffer->numsegs, pBuffer->segsize, pBuffer->lastsegsize);
734 }
735 }
736
737 if(format->wFormatTag == WAVE_FORMAT_PCM)
738 fmt_str = get_fmtstr_PCM(prim, format, &pBuffer->format, &pBuffer->in_chans, &pBuffer->in_type);
739 else if(format->wFormatTag == WAVE_FORMAT_IEEE_FLOAT)
740 fmt_str = get_fmtstr_FLOAT(prim, format, &pBuffer->format, &pBuffer->in_chans, &pBuffer->in_type);
741 else if(format->wFormatTag == WAVE_FORMAT_EXTENSIBLE)
742 {
743 const WAVEFORMATEXTENSIBLE *wfe;
744
745 hr = DSERR_CONTROLUNAVAIL;
746 if(format->cbSize != sizeof(WAVEFORMATEXTENSIBLE)-sizeof(WAVEFORMATEX) &&
747 format->cbSize != sizeof(WAVEFORMATEXTENSIBLE))
748 goto fail;
749
750 wfe = (const WAVEFORMATEXTENSIBLE*)format;
751 TRACE("Extensible values:\n"
752 " Samples = %d\n"
753 " ChannelMask = %#x\n"
754 " SubFormat = %s\n",
755 wfe->Samples.wReserved, wfe->dwChannelMask,
756 debugstr_guid(&wfe->SubFormat));
757
758 hr = DSERR_INVALIDCALL;
759 fmt_str = get_fmtstr_EXT(prim, format, &pBuffer->format, &pBuffer->in_chans, &pBuffer->in_type);
760 }
761 else
762 ERR("Unhandled formattag 0x%04x\n", format->wFormatTag);
763
764 if(!fmt_str)
765 goto fail;
766
767 pBuffer->buf_format = alGetEnumValue(fmt_str);
768 if(alGetError() != AL_NO_ERROR || pBuffer->buf_format == 0 ||
769 pBuffer->buf_format == -1)
770 {
771 WARN("Could not get OpenAL format from %s\n", fmt_str);
772 goto fail;
773 }
774
775 hr = E_OUTOFMEMORY;
776 pBuffer->buffers = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*pBuffer->buffers)*pBuffer->numsegs);
777 pBuffer->data = HeapAlloc(GetProcessHeap(), 0, pBuffer->buf_size);
778 if(!pBuffer->buffers || !pBuffer->data)
779 goto fail;
780
781 alGenBuffers(pBuffer->numsegs, pBuffer->buffers);
782 getALError();
783
784 *ppv = pBuffer;
785 return S_OK;
786
787 fail:
788 DS8Data_Release(pBuffer);
789 return hr;
790 }
791
792 static void DS8Data_AddRef(DS8Data *data)
793 {
794 InterlockedIncrement(&data->ref);
795 }
796
797 /* This function is always called with the device lock held */
798 static void DS8Data_Release(DS8Data *This)
799 {
800 if(InterlockedDecrement(&This->ref)) return;
801
802 TRACE("Deleting %p\n", This);
803 if (This->buffers && This->buffers[0])
804 {
805 alDeleteBuffers(This->numsegs, This->buffers);
806 getALError();
807 }
808 HeapFree(GetProcessHeap(), 0, This->buffers);
809 HeapFree(GetProcessHeap(), 0, This->data);
810 HeapFree(GetProcessHeap(), 0, This);
811 }
812
813 HRESULT DS8Buffer_Create(DS8Buffer **ppv, DS8Primary *parent, DS8Buffer *orig)
814 {
815 HRESULT hr = DSERR_OUTOFMEMORY;
816 DS8Buffer *This;
817 DS8Buffer **bufs;
818
819 *ppv = NULL;
820 This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*This));
821 if(!This) return hr;
822
823 This->IDirectSoundBuffer8_iface.lpVtbl = (IDirectSoundBuffer8Vtbl*)&DS8Buffer_Vtbl;
824 This->IDirectSound3DBuffer_iface.lpVtbl = (IDirectSound3DBufferVtbl*)&DS8Buffer3d_Vtbl;
825 This->IDirectSoundNotify_iface.lpVtbl = (IDirectSoundNotifyVtbl*)&DS8BufferNot_Vtbl;
826 This->IKsPropertySet_iface.lpVtbl = (IKsPropertySetVtbl*)&DS8BufferProp_Vtbl;
827
828 This->primary = parent;
829 This->ctx = parent->ctx;
830 This->ExtAL = &parent->ExtAL;
831 This->crst = &parent->crst;
832 This->ref = This->all_ref = 1;
833
834 if(orig)
835 {
836 This->buffer = orig->buffer;
837 DS8Data_AddRef(This->buffer);
838 }
839
840 /* Append to buffer list */
841 bufs = parent->buffers;
842 if(parent->nbuffers == parent->sizebuffers)
843 {
844 bufs = HeapReAlloc(GetProcessHeap(), 0, bufs, sizeof(*bufs)*(1+parent->nbuffers));
845 if(!bufs) goto fail;
846 parent->sizebuffers++;
847 }
848 parent->buffers = bufs;
849 bufs[parent->nbuffers++] = This;
850
851 /* Disable until initialized.. */
852 This->ds3dmode = DS3DMODE_DISABLE;
853
854 *ppv = This;
855 return S_OK;
856
857 fail:
858 DS8Buffer_Destroy(This);
859 return hr;
860 }
861
862 void DS8Buffer_Destroy(DS8Buffer *This)
863 {
864 DWORD idx;
865 TRACE("Destroying %p\n", This);
866
867 DS8Buffer_removenotify(This);
868
869 /* Remove from list, if in list */
870 for(idx = 0;idx < This->primary->nbuffers;++idx)
871 {
872 if(This->primary->buffers[idx] == This)
873 {
874 This->primary->buffers[idx] = This->primary->buffers[This->primary->nbuffers-1];
875 This->primary->nbuffers--;
876 break;
877 }
878 }
879 setALContext(This->ctx);
880 if(This->source)
881 {
882 ALuint *sources;
883
884 alSourceStop(This->source);
885 alSourcei(This->source, AL_BUFFER, 0);
886 getALError();
887
888 sources = This->primary->sources;
889 if(This->primary->nsources == This->primary->sizesources)
890 {
891 sources = HeapReAlloc(GetProcessHeap(), 0, sources, sizeof(*sources)*(1+This->primary->nsources));
892 if(!sources)
893 alDeleteSources(1, &This->source);
894 else
895 This->primary->sizesources++;
896 }
897 if(sources)
898 {
899 sources[This->primary->nsources++] = This->source;
900 This->primary->sources = sources;
901 }
902 }
903 HeapFree(GetProcessHeap(), 0, This->notify);
904 This->source = 0;
905 if(This->buffer)
906 DS8Data_Release(This->buffer);
907 popALContext();
908 HeapFree(GetProcessHeap(), 0, This);
909 }
910
911 static inline DS8Buffer *impl_from_IDirectSoundBuffer8(IDirectSoundBuffer8 *iface)
912 {
913 return CONTAINING_RECORD(iface, DS8Buffer, IDirectSoundBuffer8_iface);
914 }
915
916 static HRESULT WINAPI DS8Buffer_QueryInterface(IDirectSoundBuffer8 *iface, REFIID riid, void **ppv)
917 {
918 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
919
920 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
921
922 *ppv = NULL;
923 if(IsEqualIID(riid, &IID_IUnknown) ||
924 IsEqualIID(riid, &IID_IDirectSoundBuffer))
925 *ppv = &This->IDirectSoundBuffer8_iface;
926 else if(IsEqualIID(riid, &IID_IDirectSoundBuffer8))
927 {
928 if(This->primary->parent->is_8)
929 *ppv = &This->IDirectSoundBuffer8_iface;
930 }
931 else if(IsEqualIID(riid, &IID_IDirectSound3DBuffer))
932 {
933 if((This->buffer->dsbflags&DSBCAPS_CTRL3D))
934 *ppv = &This->IDirectSound3DBuffer_iface;
935 }
936 else if(IsEqualIID(riid, &IID_IDirectSoundNotify))
937 {
938 if((This->buffer->dsbflags&DSBCAPS_CTRLPOSITIONNOTIFY))
939 *ppv = &This->IDirectSoundNotify_iface;
940 }
941 else if(IsEqualIID(riid, &IID_IKsPropertySet))
942 *ppv = &This->IKsPropertySet_iface;
943 else
944 FIXME("Unhandled GUID: %s\n", debugstr_guid(riid));
945
946 if(*ppv)
947 {
948 IUnknown_AddRef((IUnknown*)*ppv);
949 return S_OK;
950 }
951
952 return E_NOINTERFACE;
953 }
954
955 static ULONG WINAPI DS8Buffer_AddRef(IDirectSoundBuffer8 *iface)
956 {
957 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
958 LONG ret;
959
960 InterlockedIncrement(&This->all_ref);
961 ret = InterlockedIncrement(&This->ref);
962 TRACE("new refcount %d\n", ret);
963
964 return ret;
965 }
966
967 static ULONG WINAPI DS8Buffer_Release(IDirectSoundBuffer8 *iface)
968 {
969 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
970 LONG ret;
971
972 ret = InterlockedDecrement(&This->ref);
973 TRACE("new refcount %d\n", ret);
974 if(InterlockedDecrement(&This->all_ref) == 0)
975 DS8Buffer_Destroy(This);
976
977 return ret;
978 }
979
980 static HRESULT WINAPI DS8Buffer_GetCaps(IDirectSoundBuffer8 *iface, DSBCAPS *caps)
981 {
982 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
983
984 TRACE("(%p)->(%p)\n", iface, caps);
985
986 if(!caps || caps->dwSize < sizeof(*caps))
987 {
988 WARN("Invalid DSBCAPS (%p, %u)\n", caps, (caps ? caps->dwSize : 0));
989 return DSERR_INVALIDPARAM;
990 }
991
992 caps->dwFlags = This->buffer->dsbflags;
993 caps->dwBufferBytes = This->buffer->buf_size;
994 caps->dwUnlockTransferRate = 4096;
995 caps->dwPlayCpuOverhead = 0;
996 return S_OK;
997 }
998
999 static HRESULT WINAPI DS8Buffer_GetCurrentPosition(IDirectSoundBuffer8 *iface, DWORD *playpos, DWORD *curpos)
1000 {
1001 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1002 WAVEFORMATEX *format = &This->buffer->format.Format;
1003 UINT writecursor, pos;
1004
1005 TRACE("(%p)->(%p, %p)\n", iface, playpos, curpos);
1006
1007 EnterCriticalSection(This->crst);
1008 setALContext(This->ctx);
1009
1010 if(This->buffer->numsegs > 1)
1011 {
1012 ALint queued = QBUFFERS;
1013 alGetSourcei(This->source, AL_BUFFERS_QUEUED, &queued);
1014 getALError();
1015
1016 pos = (This->curidx+This->buffer->numsegs-queued)%This->buffer->numsegs;
1017 pos *= This->buffer->segsize;
1018 writecursor = This->curidx * This->buffer->segsize;
1019 }
1020 else if(This->ExtAL->BufferSubData || This->ExtAL->BufferSamplesSOFT)
1021 {
1022 ALint rwpos[2] = { 0, 0 };
1023
1024 alGetSourceiv(This->source, AL_BYTE_RW_OFFSETS_SOFT, rwpos);
1025 getALError();
1026
1027 pos = rwpos[0];
1028 writecursor = rwpos[1];
1029 }
1030 else
1031 {
1032 ALint status = 0;
1033 ALint ofs = 0;
1034
1035 alGetSourcei(This->source, AL_BYTE_OFFSET, &ofs);
1036 alGetSourcei(This->source, AL_SOURCE_STATE, &status);
1037 getALError();
1038
1039 pos = ofs;
1040 if(status == AL_PLAYING)
1041 {
1042 writecursor = format->nSamplesPerSec / 100;
1043 writecursor *= format->nBlockAlign;
1044 }
1045 else
1046 writecursor = 0;
1047 writecursor = (writecursor + pos) % This->buffer->buf_size;
1048 }
1049 TRACE("%p Play pos = %u, write pos = %u\n", This, pos, writecursor);
1050 if(pos >= This->buffer->buf_size)
1051 {
1052 ERR("playpos >= buf_size\n");
1053 pos %= This->buffer->buf_size;
1054 }
1055 if(writecursor >= This->buffer->buf_size)
1056 {
1057 ERR("writepos >= buf_size\n");
1058 writecursor %= This->buffer->buf_size;
1059 }
1060
1061 if(playpos) *playpos = pos;
1062 if(curpos) *curpos = writecursor;
1063
1064 popALContext();
1065 LeaveCriticalSection(This->crst);
1066
1067 return S_OK;
1068 }
1069
1070 static HRESULT WINAPI DS8Buffer_GetFormat(IDirectSoundBuffer8 *iface, WAVEFORMATEX *wfx, DWORD allocated, DWORD *written)
1071 {
1072 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1073 HRESULT hr = S_OK;
1074 UINT size;
1075
1076 TRACE("(%p)->(%p, %u, %p)\n", iface, wfx, allocated, written);
1077
1078 if(!wfx && !written)
1079 {
1080 WARN("Cannot report format or format size\n");
1081 return DSERR_INVALIDPARAM;
1082 }
1083
1084 EnterCriticalSection(This->crst);
1085 size = sizeof(This->buffer->format.Format) + This->buffer->format.Format.cbSize;
1086 if(wfx)
1087 {
1088 if(allocated < size)
1089 hr = DSERR_INVALIDPARAM;
1090 else
1091 memcpy(wfx, &This->buffer->format.Format, size);
1092 }
1093 if(written)
1094 *written = size;
1095 LeaveCriticalSection(This->crst);
1096
1097 return hr;
1098 }
1099
1100 static HRESULT WINAPI DS8Buffer_GetVolume(IDirectSoundBuffer8 *iface, LONG *vol)
1101 {
1102 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1103 HRESULT hr;
1104
1105 TRACE("(%p)->(%p)\n", iface, vol);
1106
1107 if(!vol)
1108 {
1109 WARN("Invalid pointer\n");
1110 return DSERR_INVALIDPARAM;
1111 }
1112
1113 EnterCriticalSection(This->crst);
1114
1115 hr = DSERR_CONTROLUNAVAIL;
1116 if(!(This->buffer->dsbflags&DSBCAPS_CTRLVOLUME))
1117 WARN("Volume control not set\n");
1118 else
1119 {
1120 ALfloat gain = 1.0f;
1121
1122 setALContext(This->ctx);
1123 alGetSourcef(This->source, AL_GAIN, &gain);
1124 getALError();
1125 popALContext();
1126
1127 *vol = gain_to_mB(gain);
1128 *vol = min(*vol, DSBVOLUME_MAX);
1129 *vol = max(*vol, DSBVOLUME_MIN);
1130
1131 hr = DS_OK;
1132 }
1133
1134 LeaveCriticalSection(This->crst);
1135 return hr;
1136 }
1137
1138 static HRESULT WINAPI DS8Buffer_GetPan(IDirectSoundBuffer8 *iface, LONG *pan)
1139 {
1140 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1141 HRESULT hr;
1142
1143 TRACE("(%p)->(%p)\n", iface, pan);
1144
1145 if(!pan)
1146 {
1147 WARN("Invalid pointer\n");
1148 return DSERR_INVALIDPARAM;
1149 }
1150
1151 EnterCriticalSection(This->crst);
1152
1153 hr = DSERR_CONTROLUNAVAIL;
1154 if(!(This->buffer->dsbflags&DSBCAPS_CTRLPAN))
1155 WARN("Panning control not set\n");
1156 else
1157 {
1158 ALfloat pos[3];
1159
1160 setALContext(This->ctx);
1161 alGetSourcefv(This->source, AL_POSITION, pos);
1162 getALError();
1163 popALContext();
1164
1165 *pan = (LONG)((pos[0]+1.0) * (DSBPAN_RIGHT-DSBPAN_LEFT) / 2.0 + 0.5) + DSBPAN_LEFT;
1166 *pan = min(*pan, DSBPAN_RIGHT);
1167 *pan = max(*pan, DSBPAN_LEFT);
1168
1169 hr = DS_OK;
1170 }
1171
1172 LeaveCriticalSection(This->crst);
1173 return hr;
1174 }
1175
1176 static HRESULT WINAPI DS8Buffer_GetFrequency(IDirectSoundBuffer8 *iface, DWORD *freq)
1177 {
1178 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1179 HRESULT hr;
1180
1181 TRACE("(%p)->(%p)\n", iface, freq);
1182
1183 if(!freq)
1184 {
1185 WARN("Invalid pointer\n");
1186 return DSERR_INVALIDPARAM;
1187 }
1188
1189 EnterCriticalSection(This->crst);
1190
1191 hr = DSERR_CONTROLUNAVAIL;
1192 if(!(This->buffer->dsbflags&DSBCAPS_CTRLFREQUENCY))
1193 WARN("Frequency control not set\n");
1194 else
1195 {
1196 ALfloat pitch = 1.0f;
1197
1198 setALContext(This->ctx);
1199 alGetSourcefv(This->source, AL_PITCH, &pitch);
1200 getALError();
1201 popALContext();
1202
1203 *freq = (DWORD)(This->buffer->format.Format.nSamplesPerSec * pitch);
1204
1205 hr = DS_OK;
1206 }
1207
1208 LeaveCriticalSection(This->crst);
1209 return hr;
1210 }
1211
1212 static HRESULT WINAPI DS8Buffer_GetStatus(IDirectSoundBuffer8 *iface, DWORD *status)
1213 {
1214 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1215 ALint state, looping;
1216
1217 TRACE("(%p)->(%p)\n", iface, status);
1218
1219 if(!status)
1220 {
1221 WARN("Invalid pointer\n");
1222 return DSERR_INVALIDPARAM;
1223 }
1224
1225 EnterCriticalSection(This->crst);
1226
1227 setALContext(This->ctx);
1228 alGetSourcei(This->source, AL_SOURCE_STATE, &state);
1229 looping = This->islooping;
1230 if(This->buffer->numsegs == 1)
1231 alGetSourcei(This->source, AL_LOOPING, &looping);
1232 else if(state != AL_PLAYING)
1233 state = This->isplaying ? AL_PLAYING : AL_PAUSED;
1234 getALError();
1235 popALContext();
1236
1237 *status = 0;
1238 if((This->buffer->dsbflags&DSBCAPS_LOCDEFER))
1239 {
1240 if((This->buffer->dsbflags&DSBCAPS_LOCSOFTWARE))
1241 *status |= DSBSTATUS_LOCSOFTWARE;
1242 else if((This->buffer->dsbflags&DSBCAPS_LOCHARDWARE))
1243 *status |= DSBSTATUS_LOCHARDWARE;
1244 }
1245 if(state == AL_PLAYING)
1246 *status |= DSBSTATUS_PLAYING | (looping ? DSBSTATUS_LOOPING : 0);
1247
1248 LeaveCriticalSection(This->crst);
1249
1250 return S_OK;
1251 }
1252
1253 static HRESULT WINAPI DS8Buffer_Initialize(IDirectSoundBuffer8 *iface, IDirectSound *ds, const DSBUFFERDESC *desc)
1254 {
1255 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1256 DS3DBUFFER *ds3dbuffer;
1257 HRESULT hr;
1258
1259 TRACE("(%p)->(%p, %p)\n", iface, ds, desc);
1260
1261 EnterCriticalSection(This->crst);
1262 setALContext(This->ctx);
1263
1264 hr = DSERR_ALREADYINITIALIZED;
1265 if(This->source)
1266 goto out;
1267
1268 if(!This->buffer)
1269 {
1270 hr = DSERR_INVALIDPARAM;
1271 if(!desc)
1272 {
1273 WARN("Missing DSound buffer description\n");
1274 goto out;
1275 }
1276 if(!desc->lpwfxFormat)
1277 {
1278 WARN("Missing buffer format (%p)\n", This);
1279 goto out;
1280 }
1281 if((desc->dwFlags&DSBCAPS_CTRL3D) && desc->lpwfxFormat->nChannels != 1)
1282 {
1283 if(This->primary->parent->is_8)
1284 {
1285 /* DirectSoundBuffer8 objects aren't allowed non-mono 3D
1286 * buffers */
1287 WARN("Can't create multi-channel 3D buffers\n");
1288 goto out;
1289 }
1290 ERR("Multi-channel 3D sounds are not spatialized\n");
1291 }
1292
1293 hr = DS8Data_Create(&This->buffer, desc, This->primary);
1294 if(FAILED(hr))
1295 goto out;
1296 else
1297 {
1298 DS8Data *buf = This->buffer;
1299
1300 if(buf->in_type == AL_UNSIGNED_BYTE)
1301 memset(buf->data, 0x80, buf->buf_size);
1302 else
1303 memset(buf->data, 0x00, buf->buf_size);
1304
1305 if(This->ExtAL->BufferDataStatic)
1306 This->ExtAL->BufferDataStatic(buf->buffers[0], buf->buf_format,
1307 buf->data, buf->buf_size,
1308 buf->format.Format.nSamplesPerSec);
1309 else if(This->ExtAL->BufferSamplesSOFT)
1310 This->ExtAL->BufferSamplesSOFT(buf->buffers[0],
1311 buf->format.Format.nSamplesPerSec, buf->buf_format,
1312 buf->buf_size/buf->format.Format.nBlockAlign,
1313 buf->in_chans, buf->in_type, buf->data);
1314 else if(This->ExtAL->BufferSubData)
1315 alBufferData(buf->buffers[0], buf->buf_format,
1316 buf->data, buf->buf_size,
1317 buf->format.Format.nSamplesPerSec);
1318 }
1319 getALError();
1320 }
1321
1322 hr = DSERR_GENERIC;
1323 if(This->primary->nsources)
1324 {
1325 This->source = This->primary->sources[--This->primary->nsources];
1326 alSourcef(This->source, AL_GAIN, 1.0f);
1327 alSourcef(This->source, AL_PITCH, 1.0f);
1328 getALError();
1329 }
1330 else
1331 {
1332 alGenSources(1, &This->source);
1333 if(alGetError() != AL_NO_ERROR)
1334 goto out;
1335 }
1336
1337 ds3dbuffer = &This->ds3dbuffer;
1338 ds3dbuffer->dwSize = sizeof(*ds3dbuffer);
1339 ds3dbuffer->vPosition.x = 0.0;
1340 ds3dbuffer->vPosition.y = 0.0;
1341 ds3dbuffer->vPosition.z = 0.0;
1342 ds3dbuffer->vVelocity.x = 0.0;
1343 ds3dbuffer->vVelocity.y = 0.0;
1344 ds3dbuffer->vVelocity.z = 0.0;
1345 ds3dbuffer->dwInsideConeAngle = DS3D_DEFAULTCONEANGLE;
1346 ds3dbuffer->dwOutsideConeAngle = DS3D_DEFAULTCONEANGLE;
1347 ds3dbuffer->vConeOrientation.x = 0.0;
1348 ds3dbuffer->vConeOrientation.y = 0.0;
1349 ds3dbuffer->vConeOrientation.z = 1.0;
1350 ds3dbuffer->lConeOutsideVolume = DS3D_DEFAULTCONEOUTSIDEVOLUME;
1351 ds3dbuffer->flMinDistance = DS3D_DEFAULTMINDISTANCE;
1352 ds3dbuffer->flMaxDistance = DS3D_DEFAULTMAXDISTANCE;
1353 ds3dbuffer->dwMode = DS3DMODE_NORMAL;
1354
1355 if((This->buffer->dsbflags&DSBCAPS_CTRL3D))
1356 {
1357 if(This->primary->auxslot != 0)
1358 {
1359 alSource3i(This->source, AL_AUXILIARY_SEND_FILTER, This->primary->auxslot, 0, AL_FILTER_NULL);
1360 getALError();
1361 }
1362
1363 hr = IDirectSound3DBuffer_SetAllParameters(&This->IDirectSound3DBuffer_iface, ds3dbuffer, DS3D_IMMEDIATE);
1364 if(FAILED(hr))
1365 {
1366 ERR("SetAllParameters failed\n");
1367 goto out;
1368 }
1369 }
1370 else
1371 {
1372 ALuint source = This->source;
1373
1374 if(This->primary->auxslot != 0)
1375 {
1376 /* Simple hack to make reverb affect non-3D sounds too */
1377 alSource3i(source, AL_AUXILIARY_SEND_FILTER, This->primary->auxslot, 0, AL_FILTER_NULL);
1378 /*alSource3i(source, AL_AUXILIARY_SEND_FILTER, 0, 0, AL_FILTER_NULL);*/
1379 }
1380
1381 /* Non-3D sources aren't distance attenuated */
1382 This->ds3dmode = DS3DMODE_DISABLE;
1383 alSource3f(source, AL_POSITION, 0.0f, 1.0f, 0.0f);
1384 alSource3f(source, AL_VELOCITY, 0.0f, 0.0f, 0.0f);
1385 alSource3f(source, AL_DIRECTION, 0.0f, 0.0f, 0.0f);
1386 alSourcef(source, AL_CONE_OUTER_GAIN, 1.0f);
1387 alSourcef(source, AL_REFERENCE_DISTANCE, 1.0f);
1388 alSourcef(source, AL_MAX_DISTANCE, 1000.0f);
1389 alSourcef(source, AL_ROLLOFF_FACTOR, 0.0f);
1390 alSourcei(source, AL_CONE_INNER_ANGLE, 360);
1391 alSourcei(source, AL_CONE_OUTER_ANGLE, 360);
1392 alSourcei(source, AL_SOURCE_RELATIVE, AL_TRUE);
1393 getALError();
1394 }
1395 hr = S_OK;
1396
1397 out:
1398 popALContext();
1399 LeaveCriticalSection(This->crst);
1400
1401 return hr;
1402 }
1403
1404 static HRESULT WINAPI DS8Buffer_Lock(IDirectSoundBuffer8 *iface, DWORD ofs, DWORD bytes, void **ptr1, DWORD *len1, void **ptr2, DWORD *len2, DWORD flags)
1405 {
1406 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1407 HRESULT hr;
1408 DWORD remain;
1409
1410 TRACE("(%p)->(%u, %u, %p, %p, %p, %p, 0x%x)\n", This, ofs, bytes, ptr1, len1, ptr2, len2, flags);
1411
1412 if(!ptr1 || !len1)
1413 {
1414 WARN("Invalid pointer/len %p %p\n", ptr1, len1);
1415 return DSERR_INVALIDPARAM;
1416 }
1417
1418 EnterCriticalSection(This->crst);
1419 setALContext(This->ctx);
1420
1421 *ptr1 = NULL;
1422 *len1 = 0;
1423 if(ptr2) *ptr2 = NULL;
1424 if(len2) *len2 = 0;
1425
1426 hr = DSERR_INVALIDPARAM;
1427 if((flags&DSBLOCK_FROMWRITECURSOR))
1428 DS8Buffer_GetCurrentPosition(iface, NULL, &ofs);
1429 else if(ofs >= This->buffer->buf_size)
1430 {
1431 WARN("Invalid ofs %u\n", ofs);
1432 goto out;
1433 }
1434 if((flags&DSBLOCK_ENTIREBUFFER))
1435 bytes = This->buffer->buf_size;
1436 else if(bytes > This->buffer->buf_size)
1437 {
1438 WARN("Invalid size %u\n", bytes);
1439 goto out;
1440 }
1441
1442 *ptr1 = This->buffer->data + ofs;
1443 if(ofs+bytes >= This->buffer->buf_size)
1444 {
1445 *len1 = This->buffer->buf_size - ofs;
1446 remain = bytes - *len1;
1447 }
1448 else
1449 {
1450 *len1 = bytes;
1451 remain = 0;
1452 }
1453
1454 This->buffer->locked = TRUE;
1455
1456 if(ptr2 && len2 && remain)
1457 {
1458 *ptr2 = This->buffer->data;
1459 *len2 = remain;
1460 }
1461 hr = S_OK;
1462
1463 out:
1464 popALContext();
1465 LeaveCriticalSection(This->crst);
1466 return hr;
1467 }
1468
1469 static HRESULT WINAPI DS8Buffer_Play(IDirectSoundBuffer8 *iface, DWORD res1, DWORD prio, DWORD flags)
1470 {
1471 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1472 ALint type, state = AL_STOPPED;
1473 HRESULT hr;
1474 (void)res1;
1475
1476 TRACE("%p\n", This);
1477
1478 EnterCriticalSection(This->crst);
1479 setALContext(This->ctx);
1480
1481 hr = DSERR_BUFFERLOST;
1482 if(This->bufferlost)
1483 {
1484 WARN("Buffer %p lost\n", This);
1485 goto out;
1486 }
1487
1488 if((This->buffer->dsbflags&DSBCAPS_LOCDEFER))
1489 {
1490 if(!(This->buffer->dsbflags&(DSBCAPS_LOCHARDWARE|DSBCAPS_LOCSOFTWARE)))
1491 {
1492 if(flags & DSBPLAY_LOCSOFTWARE)
1493 This->buffer->dsbflags |= DSBCAPS_LOCSOFTWARE;
1494 else
1495 This->buffer->dsbflags |= DSBCAPS_LOCHARDWARE;
1496 }
1497 }
1498 else if(prio)
1499 {
1500 ERR("Invalid priority set for non-deferred buffer %p, %u!\n", This->buffer, prio);
1501 hr = DSERR_INVALIDPARAM;
1502 goto out;
1503 }
1504
1505 alGetSourcei(This->source, AL_SOURCE_STATE, &state);
1506 if(This->buffer->numsegs > 1)
1507 {
1508 This->islooping = !!(flags&DSBPLAY_LOOPING);
1509 if(state != AL_PLAYING && This->isplaying)
1510 state = AL_PLAYING;
1511 }
1512 else
1513 {
1514 alGetSourcei(This->source, AL_SOURCE_TYPE, &type);
1515 alSourcei(This->source, AL_LOOPING, (flags&DSBPLAY_LOOPING) ? AL_TRUE : AL_FALSE);
1516 }
1517 getALError();
1518
1519 hr = S_OK;
1520 if(state == AL_PLAYING)
1521 goto out;
1522
1523 /* alSourceQueueBuffers will implicitly set type to streaming */
1524 if(This->buffer->numsegs == 1)
1525 {
1526 if(type != AL_STATIC)
1527 alSourcei(This->source, AL_BUFFER, This->buffer->buffers[0]);
1528 alSourcePlay(This->source);
1529 }
1530 if(alGetError() != AL_NO_ERROR)
1531 {
1532 ERR("Couldn't start source\n");
1533 This->curidx = (This->buffer->numsegs-1+This->curidx)%This->buffer->numsegs;
1534 alSourcei(This->source, AL_BUFFER, 0);
1535 getALError();
1536 hr = DSERR_GENERIC;
1537 goto out;
1538 }
1539 This->isplaying = TRUE;
1540
1541 if(This->nnotify)
1542 {
1543 DS8Buffer_addnotify(This);
1544 DS8Buffer_starttimer(This->primary);
1545 }
1546 else if(This->buffer->numsegs > 1)
1547 DS8Buffer_starttimer(This->primary);
1548
1549 out:
1550 popALContext();
1551 LeaveCriticalSection(This->crst);
1552 return hr;
1553 }
1554
1555 static HRESULT WINAPI DS8Buffer_SetCurrentPosition(IDirectSoundBuffer8 *iface, DWORD pos)
1556 {
1557 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1558 HRESULT hr;
1559 TRACE("%p\n", This);
1560
1561 EnterCriticalSection(This->crst);
1562 setALContext(This->ctx);
1563
1564 hr = DSERR_INVALIDPARAM;
1565 if(pos >= This->buffer->buf_size)
1566 goto out;
1567
1568 if(This->buffer->numsegs > 1)
1569 {
1570 DS8Data *buf = This->buffer;
1571 This->curidx = pos/buf->segsize;
1572 if(This->curidx >= buf->numsegs)
1573 This->curidx = buf->numsegs - 1;
1574 if(This->isplaying)
1575 {
1576 alSourceStop(This->source);
1577 alSourcei(This->source, AL_BUFFER, 0);
1578 getALError();
1579 }
1580 }
1581 else
1582 alSourcei(This->source, AL_BYTE_OFFSET, pos);
1583 This->lastpos = pos;
1584 hr = S_OK;
1585
1586 out:
1587 popALContext();
1588 LeaveCriticalSection(This->crst);
1589 return hr;
1590 }
1591
1592 static HRESULT WINAPI DS8Buffer_SetFormat(IDirectSoundBuffer8 *iface, const WAVEFORMATEX *wfx)
1593 {
1594 /* This call only works on primary buffers */
1595 WARN("(%p)->(%p)\n", iface, wfx);
1596 return DSERR_INVALIDCALL;
1597 }
1598
1599 static HRESULT WINAPI DS8Buffer_SetVolume(IDirectSoundBuffer8 *iface, LONG vol)
1600 {
1601 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1602 HRESULT hr = S_OK;
1603
1604 TRACE("(%p)->(%d)\n", iface, vol);
1605
1606 if(vol > DSBVOLUME_MAX || vol < DSBVOLUME_MIN)
1607 {
1608 WARN("Invalid volume (%d)\n", vol);
1609 return DSERR_INVALIDPARAM;
1610 }
1611
1612 EnterCriticalSection(This->crst);
1613 if(!(This->buffer->dsbflags&DSBCAPS_CTRLVOLUME))
1614 hr = DSERR_CONTROLUNAVAIL;
1615 if(SUCCEEDED(hr))
1616 {
1617 ALfloat fvol = mB_to_gain(vol);
1618 setALContext(This->ctx);
1619 alSourcef(This->source, AL_GAIN, fvol);
1620 popALContext();
1621 }
1622 LeaveCriticalSection(This->crst);
1623
1624 return hr;
1625 }
1626
1627 static HRESULT WINAPI DS8Buffer_SetPan(IDirectSoundBuffer8 *iface, LONG pan)
1628 {
1629 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1630 HRESULT hr = S_OK;
1631
1632 TRACE("(%p)->(%d)\n", iface, pan);
1633
1634 if(pan > DSBPAN_RIGHT || pan < DSBPAN_LEFT)
1635 {
1636 WARN("invalid parameter: pan = %d\n", pan);
1637 return DSERR_INVALIDPARAM;
1638 }
1639
1640 EnterCriticalSection(This->crst);
1641 if(!(This->buffer->dsbflags&DSBCAPS_CTRLPAN))
1642 hr = DSERR_CONTROLUNAVAIL;
1643 else
1644 {
1645 ALfloat pos[3];
1646 pos[0] = (pan-DSBPAN_LEFT) * 2.0 / (ALfloat)(DSBPAN_RIGHT-DSBPAN_LEFT) - 1.0;
1647 /* NOTE: Strict movement along the X plane can cause the sound to jump
1648 * between left and right sharply. Using a curved path helps smooth it
1649 * out */
1650 pos[1] = sqrt(1.0 - pos[0]*pos[0]);
1651 pos[2] = 0.0;
1652
1653 setALContext(This->ctx);
1654 alSourcefv(This->source, AL_POSITION, pos);
1655 getALError();
1656 popALContext();
1657
1658 if(pan != 0 && This->buffer->format.Format.nChannels > 1)
1659 FIXME("Panning for multi-channel buffers is not supported\n");
1660 }
1661 LeaveCriticalSection(This->crst);
1662
1663 return hr;
1664 }
1665
1666 static HRESULT WINAPI DS8Buffer_SetFrequency(IDirectSoundBuffer8 *iface, DWORD freq)
1667 {
1668 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1669 HRESULT hr = S_OK;
1670
1671 TRACE("(%p)->(%u)\n", iface, freq);
1672
1673 if(freq < DSBFREQUENCY_MIN || freq > DSBFREQUENCY_MAX)
1674 {
1675 WARN("invalid parameter: freq = %d\n", freq);
1676 return DSERR_INVALIDPARAM;
1677 }
1678
1679 EnterCriticalSection(This->crst);
1680 if(!(This->buffer->dsbflags&DSBCAPS_CTRLFREQUENCY))
1681 hr = DSERR_CONTROLUNAVAIL;
1682 else
1683 {
1684 ALfloat pitch = 1.0f;
1685 if(freq != DSBFREQUENCY_ORIGINAL)
1686 pitch = freq / (ALfloat)This->buffer->format.Format.nSamplesPerSec;
1687
1688 setALContext(This->ctx);
1689 alSourcef(This->source, AL_PITCH, pitch);
1690 getALError();
1691 popALContext();
1692 }
1693 LeaveCriticalSection(This->crst);
1694 return hr;
1695 }
1696
1697 static HRESULT WINAPI DS8Buffer_Stop(IDirectSoundBuffer8 *iface)
1698 {
1699 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1700 ALint state;
1701
1702 TRACE("(%p)->()\n", iface);
1703
1704 EnterCriticalSection(This->crst);
1705 setALContext(This->ctx);
1706
1707 alSourcePause(This->source);
1708 getALError();
1709 /* Mac OS X doesn't immediately report state change
1710 * if Play() is immediately called after Stop, this can be fatal,
1711 * the buffer would never be restarted
1712 */
1713 do {
1714 state = AL_PAUSED;
1715 alGetSourcei(This->source, AL_SOURCE_STATE, &state);
1716 if(state != AL_PLAYING)
1717 break;
1718 Sleep(1);
1719 } while(1);
1720
1721 /* Stopped, remove from notify list */
1722 if(This->nnotify)
1723 {
1724 HRESULT hr;
1725 DWORD pos = This->lastpos;
1726 hr = IDirectSoundBuffer8_GetCurrentPosition(iface, &pos, NULL);
1727 if(FAILED(hr))
1728 ERR("Own getcurrentposition failed!\n");
1729 trigger_notifies(This, This->lastpos, pos, TRUE);
1730 This->lastpos = pos;
1731 DS8Buffer_removenotify(This);
1732 }
1733
1734 This->isplaying = FALSE;
1735
1736 popALContext();
1737 LeaveCriticalSection(This->crst);
1738
1739 return S_OK;
1740 }
1741
1742 static HRESULT WINAPI DS8Buffer_Unlock(IDirectSoundBuffer8 *iface, void *ptr1, DWORD len1, void *ptr2, DWORD len2)
1743 {
1744 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1745 DS8Data *buf = This->buffer;
1746 DWORD bufsize = buf->buf_size;
1747 DWORD_PTR ofs1, ofs2;
1748 DWORD_PTR boundary = (DWORD_PTR)buf->data;
1749 HRESULT hr;
1750
1751 TRACE("(%p)->(%p, %u, %p, %u)\n", iface, ptr1, len1, ptr2, len2);
1752
1753 EnterCriticalSection(This->crst);
1754 setALContext(This->ctx);
1755
1756 This->buffer->locked = 0;
1757 hr = DSERR_INVALIDPARAM;
1758
1759 /* Make sure offset is between boundary and boundary + bufsize */
1760 ofs1 = (DWORD_PTR)ptr1;
1761 ofs2 = (DWORD_PTR)ptr2;
1762 if(ofs1 < boundary)
1763 goto out;
1764 if(ofs2 && ofs2 != boundary)
1765 goto out;
1766 ofs1 -= boundary;
1767 ofs2 = 0;
1768 if(bufsize-ofs1 < len1 || len2 > ofs1)
1769 goto out;
1770 if(!ptr2)
1771 len2 = 0;
1772
1773 hr = S_OK;
1774 if(!len1 && !len2)
1775 goto out;
1776
1777 if(This->ExtAL->BufferDataStatic)
1778 goto out;
1779
1780 if(This->ExtAL->BufferSubSamplesSOFT)
1781 {
1782 WAVEFORMATEX *format = &buf->format.Format;
1783
1784 ptr1 = (BYTE*)ptr1 - (ofs1%format->nBlockAlign);
1785 ofs1 /= format->nBlockAlign;
1786 len1 /= format->nBlockAlign;
1787 if(len1 > 0)
1788 This->ExtAL->BufferSubSamplesSOFT(buf->buffers[0], ofs1, len1,
1789 buf->in_chans, buf->in_type, ptr1);
1790 ptr2 = (BYTE*)ptr2 - (ofs2%format->nBlockAlign);
1791 ofs2 /= format->nBlockAlign;
1792 len2 /= format->nBlockAlign;
1793 if(len2 > 0)
1794 This->ExtAL->BufferSubSamplesSOFT(buf->buffers[0], ofs2, len2,
1795 buf->in_chans, buf->in_type, ptr2);
1796 getALError();
1797 }
1798 else if(This->ExtAL->BufferSubData)
1799 {
1800 WAVEFORMATEX *format = &buf->format.Format;
1801
1802 len1 -= len1%format->nBlockAlign;
1803 if(len1 > 0)
1804 This->ExtAL->BufferSubData(buf->buffers[0], buf->buf_format, ptr1,
1805 ofs1, len1);
1806 len2 -= len2%format->nBlockAlign;
1807 if(len2 > 0)
1808 This->ExtAL->BufferSubData(buf->buffers[0], buf->buf_format, ptr2,
1809 ofs2, len2);
1810 getALError();
1811 }
1812 else
1813 {
1814 alBufferData(buf->buffers[0], buf->buf_format,
1815 buf->data, buf->buf_size,
1816 buf->format.Format.nSamplesPerSec);
1817 getALError();
1818 }
1819
1820 out:
1821 if(hr != S_OK)
1822 WARN("Invalid parameters (0x%lx,%u) (%p,%u,%p,%u)\n", boundary, bufsize, ptr1, len1, ptr2, len2);
1823 popALContext();
1824 LeaveCriticalSection(This->crst);
1825 return hr;
1826 }
1827
1828 static HRESULT WINAPI DS8Buffer_Restore(IDirectSoundBuffer8 *iface)
1829 {
1830 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1831 HRESULT hr;
1832
1833 TRACE("(%p)->()\n", iface);
1834
1835 EnterCriticalSection(This->crst);
1836 if(This->primary->parent->prio_level < DSSCL_WRITEPRIMARY ||
1837 iface == This->primary->write_emu)
1838 {
1839 This->bufferlost = 0;
1840 hr = S_OK;
1841 }
1842 else
1843 hr = DSERR_BUFFERLOST;
1844 LeaveCriticalSection(This->crst);
1845
1846 return hr;
1847 }
1848
1849 static HRESULT WINAPI DS8Buffer_SetFX(IDirectSoundBuffer8 *iface, DWORD fxcount, DSEFFECTDESC *desc, DWORD *rescodes)
1850 {
1851 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1852 DWORD i;
1853
1854 TRACE("(%p)->(%u, %p, %p)\n", This, fxcount, desc, rescodes);
1855
1856 if(!(This->buffer->dsbflags&DSBCAPS_CTRLFX))
1857 {
1858 WARN("FX control not set\n");
1859 return DSERR_CONTROLUNAVAIL;
1860 }
1861
1862 if(fxcount == 0)
1863 {
1864 if(desc || rescodes)
1865 {
1866 WARN("Non-NULL desc and/or result pointer specified with no effects.\n");
1867 return DSERR_INVALIDPARAM;
1868 }
1869
1870 /* No effects; we can handle that */
1871 return DS_OK;
1872 }
1873
1874 if(!desc || !rescodes)
1875 {
1876 WARN("NULL desc and/or result pointer specified.\n");
1877 return DSERR_INVALIDPARAM;
1878 }
1879
1880 /* We don't (currently) handle DSound effects */
1881 for(i = 0;i < fxcount;++i)
1882 {
1883 FIXME("Cannot handle effect: %s\n", debugstr_guid(&desc[i].guidDSFXClass));
1884 rescodes[i] = DSFXR_FAILED;
1885 }
1886
1887 return DSERR_INVALIDPARAM;
1888 }
1889
1890 static HRESULT WINAPI DS8Buffer_AcquireResources(IDirectSoundBuffer8 *iface, DWORD flags, DWORD fxcount, DWORD *rescodes)
1891 {
1892 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1893
1894 TRACE("(%p)->(%u, %u, %p)\n", This, flags, fxcount, rescodes);
1895
1896 /* effects aren't supported at the moment.. */
1897 if(fxcount != 0 || rescodes)
1898 {
1899 WARN("Non-zero effect count and/or result pointer specified with no effects.\n");
1900 return DSERR_INVALIDPARAM;
1901 }
1902
1903 EnterCriticalSection(This->crst);
1904 if((This->buffer->dsbflags&DSBCAPS_LOCDEFER))
1905 {
1906 This->buffer->dsbflags &= ~(DSBCAPS_LOCSOFTWARE|DSBCAPS_LOCHARDWARE);
1907 if((flags&DSBPLAY_LOCSOFTWARE))
1908 This->buffer->dsbflags |= DSBCAPS_LOCSOFTWARE;
1909 else
1910 This->buffer->dsbflags |= DSBCAPS_LOCHARDWARE;
1911 }
1912 LeaveCriticalSection(This->crst);
1913
1914 return S_OK;
1915 }
1916
1917 static HRESULT WINAPI DS8Buffer_GetObjectInPath(IDirectSoundBuffer8 *iface, REFGUID guid, DWORD idx, REFGUID rguidiface, void **ppv)
1918 {
1919 FIXME("(%p)->(%s, %u, %s, %p) : stub!\n", iface, debugstr_guid(guid), idx, debugstr_guid(rguidiface), ppv);
1920 return E_NOTIMPL;
1921 }
1922
1923 static const IDirectSoundBuffer8Vtbl DS8Buffer_Vtbl =
1924 {
1925 DS8Buffer_QueryInterface,
1926 DS8Buffer_AddRef,
1927 DS8Buffer_Release,
1928 DS8Buffer_GetCaps,
1929 DS8Buffer_GetCurrentPosition,
1930 DS8Buffer_GetFormat,
1931 DS8Buffer_GetVolume,
1932 DS8Buffer_GetPan,
1933 DS8Buffer_GetFrequency,
1934 DS8Buffer_GetStatus,
1935 DS8Buffer_Initialize,
1936 DS8Buffer_Lock,
1937 DS8Buffer_Play,
1938 DS8Buffer_SetCurrentPosition,
1939 DS8Buffer_SetFormat,
1940 DS8Buffer_SetVolume,
1941 DS8Buffer_SetPan,
1942 DS8Buffer_SetFrequency,
1943 DS8Buffer_Stop,
1944 DS8Buffer_Unlock,
1945 DS8Buffer_Restore,
1946 DS8Buffer_SetFX,
1947 DS8Buffer_AcquireResources,
1948 DS8Buffer_GetObjectInPath
1949 };
1950
1951 static inline DS8Buffer *impl_from_IDirectSound3DBuffer(IDirectSound3DBuffer *iface)
1952 {
1953 return CONTAINING_RECORD(iface, DS8Buffer, IDirectSound3DBuffer_iface);
1954 }
1955
1956 static HRESULT WINAPI DS8Buffer3D_QueryInterface(IDirectSound3DBuffer *iface, REFIID riid, void **ppv)
1957 {
1958 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
1959 return IDirectSoundBuffer8_QueryInterface(&This->IDirectSoundBuffer8_iface, riid, ppv);
1960 }
1961
1962 static ULONG WINAPI DS8Buffer3D_AddRef(IDirectSound3DBuffer *iface)
1963 {
1964 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
1965 LONG ret;
1966
1967 InterlockedIncrement(&This->all_ref);
1968 ret = InterlockedIncrement(&This->ds3d_ref);
1969 TRACE("new refcount %d\n", ret);
1970
1971 return ret;
1972 }
1973
1974 static ULONG WINAPI DS8Buffer3D_Release(IDirectSound3DBuffer *iface)
1975 {
1976 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
1977 LONG ret;
1978
1979 ret = InterlockedDecrement(&This->ds3d_ref);
1980 TRACE("new refcount %d\n", ret);
1981 if(InterlockedDecrement(&This->all_ref) == 0)
1982 DS8Buffer_Destroy(This);
1983
1984 return ret;
1985 }
1986
1987 static HRESULT WINAPI DS8Buffer3D_GetAllParameters(IDirectSound3DBuffer *iface, DS3DBUFFER *ds3dbuffer)
1988 {
1989 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
1990 DS3DBUFFER ds3dbuf;
1991 HRESULT hr;
1992
1993 TRACE("%p\n", This);
1994
1995 if(!ds3dbuffer || ds3dbuffer->dwSize < sizeof(*ds3dbuffer))
1996 {
1997 WARN("Invalid parameters %p %u\n", ds3dbuffer, ds3dbuffer ? ds3dbuffer->dwSize : 0);
1998 return DSERR_INVALIDPARAM;
1999 }
2000 ds3dbuf.dwSize = sizeof(ds3dbuf);
2001
2002 EnterCriticalSection(This->crst);
2003 setALContext(This->ctx);
2004
2005 hr = IDirectSound3DBuffer_GetPosition(iface, &ds3dbuf.vPosition);
2006 if(SUCCEEDED(hr))
2007 hr = IDirectSound3DBuffer_GetVelocity(iface, &ds3dbuf.vVelocity);
2008 if(SUCCEEDED(hr))
2009 hr = IDirectSound3DBuffer_GetConeAngles(iface, &ds3dbuf.dwInsideConeAngle, &ds3dbuf.dwOutsideConeAngle);
2010 if(SUCCEEDED(hr))
2011 hr = IDirectSound3DBuffer_GetConeOrientation(iface, &ds3dbuf.vConeOrientation);
2012 if(SUCCEEDED(hr))
2013 hr = IDirectSound3DBuffer_GetConeOutsideVolume(iface, &ds3dbuf.lConeOutsideVolume);
2014 if(SUCCEEDED(hr))
2015 hr = IDirectSound3DBuffer_GetMinDistance(iface, &ds3dbuf.flMinDistance);
2016 if(SUCCEEDED(hr))
2017 hr = IDirectSound3DBuffer_GetMaxDistance(iface, &ds3dbuf.flMaxDistance);
2018 if(SUCCEEDED(hr))
2019 hr = IDirectSound3DBuffer_GetMode(iface, &ds3dbuf.dwMode);
2020 if(SUCCEEDED(hr))
2021 memcpy(ds3dbuffer, &ds3dbuf, sizeof(ds3dbuf));
2022
2023 popALContext();
2024 LeaveCriticalSection(This->crst);
2025
2026 return hr;
2027 }
2028
2029 static HRESULT WINAPI DS8Buffer3D_GetConeAngles(IDirectSound3DBuffer *iface, DWORD *pdwInsideConeAngle, DWORD *pdwOutsideConeAngle)
2030 {
2031 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2032 ALint inangle, outangle;
2033
2034 TRACE("(%p)->(%p, %p)\n", This, pdwInsideConeAngle, pdwOutsideConeAngle);
2035 if(!pdwInsideConeAngle || !pdwOutsideConeAngle)
2036 {
2037 WARN("Invalid pointers (%p, %p)\n", pdwInsideConeAngle, pdwOutsideConeAngle);
2038 return DSERR_INVALIDPARAM;
2039 }
2040
2041 EnterCriticalSection(This->crst);
2042 setALContext(This->ctx);
2043
2044 alGetSourcei(This->source, AL_CONE_INNER_ANGLE, &inangle);
2045 alGetSourcei(This->source, AL_CONE_OUTER_ANGLE, &outangle);
2046 getALError();
2047 *pdwInsideConeAngle = inangle;
2048 *pdwOutsideConeAngle = outangle;
2049
2050 popALContext();
2051 LeaveCriticalSection(This->crst);
2052
2053 return S_OK;
2054 }
2055
2056 static HRESULT WINAPI DS8Buffer3D_GetConeOrientation(IDirectSound3DBuffer *iface, D3DVECTOR *orient)
2057 {
2058 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2059 ALfloat dir[3];
2060
2061 TRACE("(%p)->(%p)\n", This, orient);
2062 if(!orient)
2063 {
2064 WARN("Invalid pointer\n");
2065 return DSERR_INVALIDPARAM;
2066 }
2067
2068 EnterCriticalSection(This->crst);
2069 setALContext(This->ctx);
2070
2071 alGetSourcefv(This->source, AL_DIRECTION, dir);
2072 getALError();
2073 orient->x = dir[0];
2074 orient->y = dir[1];
2075 orient->z = -dir[2];
2076
2077 popALContext();
2078 LeaveCriticalSection(This->crst);
2079
2080 return S_OK;
2081 }
2082
2083 static HRESULT WINAPI DS8Buffer3D_GetConeOutsideVolume(IDirectSound3DBuffer *iface, LONG *vol)
2084 {
2085 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2086 ALfloat gain;
2087
2088 TRACE("(%p)->(%p)\n", This, vol);
2089 if(!vol)
2090 {
2091 WARN("Invalid pointer\n");
2092 return DSERR_INVALIDPARAM;
2093 }
2094
2095 EnterCriticalSection(This->crst);
2096 setALContext(This->ctx);
2097
2098 alGetSourcef(This->source, AL_CONE_OUTER_GAIN, &gain);
2099 getALError();
2100 *vol = gain_to_mB(gain);
2101 *vol = max(*vol, DSBVOLUME_MIN);
2102 *vol = min(*vol, DSBVOLUME_MAX);
2103
2104 popALContext();
2105 LeaveCriticalSection(This->crst);
2106 return S_OK;
2107 }
2108
2109 static HRESULT WINAPI DS8Buffer3D_GetMaxDistance(IDirectSound3DBuffer *iface, D3DVALUE *maxdist)
2110 {
2111 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2112 ALfloat dist;
2113
2114 TRACE("(%p)->(%p)\n", This, maxdist);
2115 if(!maxdist)
2116 {
2117 WARN("Invalid pointer\n");
2118 return DSERR_INVALIDPARAM;
2119 }
2120
2121 EnterCriticalSection(This->crst);
2122 setALContext(This->ctx);
2123
2124 alGetSourcef(This->source, AL_MAX_DISTANCE, &dist);
2125 getALError();
2126 *maxdist = dist;
2127
2128 popALContext();
2129 LeaveCriticalSection(This->crst);
2130
2131 return S_OK;
2132 }
2133
2134 static HRESULT WINAPI DS8Buffer3D_GetMinDistance(IDirectSound3DBuffer *iface, D3DVALUE *mindist)
2135 {
2136 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2137 ALfloat dist;
2138
2139 TRACE("(%p)->(%p)\n", This, mindist);
2140 if(!mindist)
2141 {
2142 WARN("Invalid pointer\n");
2143 return DSERR_INVALIDPARAM;
2144 }
2145
2146 EnterCriticalSection(This->crst);
2147 setALContext(This->ctx);
2148
2149 alGetSourcef(This->source, AL_REFERENCE_DISTANCE, &dist);
2150 getALError();
2151 *mindist = dist;
2152
2153 popALContext();
2154 LeaveCriticalSection(This->crst);
2155
2156 return S_OK;
2157 }
2158
2159 static HRESULT WINAPI DS8Buffer3D_GetMode(IDirectSound3DBuffer *iface, DWORD *mode)
2160 {
2161 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2162
2163 TRACE("(%p)->(%p)\n", This, mode);
2164 if(!mode)
2165 {
2166 WARN("Invalid pointer\n");
2167 return DSERR_INVALIDPARAM;
2168 }
2169
2170 EnterCriticalSection(This->crst);
2171 *mode = This->ds3dmode;
2172 LeaveCriticalSection(This->crst);
2173
2174 return S_OK;
2175 }
2176
2177 static HRESULT WINAPI DS8Buffer3D_GetPosition(IDirectSound3DBuffer *iface, D3DVECTOR *pos)
2178 {
2179 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2180 ALfloat alpos[3];
2181
2182 TRACE("(%p)->(%p)\n", This, pos);
2183 if(!pos)
2184 {
2185 WARN("Invalid pointer\n");
2186 return DSERR_INVALIDPARAM;
2187 }
2188
2189 EnterCriticalSection(This->crst);
2190 setALContext(This->ctx);
2191
2192 alGetSourcefv(This->source, AL_POSITION, alpos);
2193 getALError();
2194 pos->x = alpos[0];
2195 pos->y = alpos[1];
2196 pos->z = -alpos[2];
2197
2198 popALContext();
2199 LeaveCriticalSection(This->crst);
2200
2201 return S_OK;
2202 }
2203
2204 static HRESULT WINAPI DS8Buffer3D_GetVelocity(IDirectSound3DBuffer *iface, D3DVECTOR *vel)
2205 {
2206 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2207 ALfloat alvel[3];
2208
2209 TRACE("(%p)->(%p)\n", This, vel);
2210 if(!vel)
2211 {
2212 WARN("Invalid pointer\n");
2213 return DSERR_INVALIDPARAM;
2214 }
2215
2216 EnterCriticalSection(This->crst);
2217 setALContext(This->ctx);
2218
2219 alGetSourcefv(This->source, AL_VELOCITY, alvel);
2220 getALError();
2221 vel->x = alvel[0];
2222 vel->y = alvel[1];
2223 vel->z = -alvel[2];
2224
2225 popALContext();
2226 LeaveCriticalSection(This->crst);
2227
2228 return S_OK;
2229 }
2230
2231 static HRESULT WINAPI DS8Buffer3D_SetAllParameters(IDirectSound3DBuffer *iface, const DS3DBUFFER *ds3dbuffer, DWORD apply)
2232 {
2233 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2234 TRACE("(%p)->(%p, %u)\n", This, ds3dbuffer, apply);
2235
2236 if(!ds3dbuffer || ds3dbuffer->dwSize < sizeof(*ds3dbuffer))
2237 {
2238 WARN("Invalid DS3DBUFFER (%p, %u)\n", ds3dbuffer, ds3dbuffer ? ds3dbuffer->dwSize : 0);
2239 return DSERR_INVALIDPARAM;
2240 }
2241
2242 if(ds3dbuffer->dwInsideConeAngle > DS3D_MAXCONEANGLE ||
2243 ds3dbuffer->dwOutsideConeAngle > DS3D_MAXCONEANGLE)
2244 {
2245 WARN("Invalid cone angles (%u, %u)\n", ds3dbuffer->dwInsideConeAngle,
2246 ds3dbuffer->dwOutsideConeAngle);
2247 return DSERR_INVALIDPARAM;
2248 }
2249
2250 if(ds3dbuffer->lConeOutsideVolume > DSBVOLUME_MAX ||
2251 ds3dbuffer->lConeOutsideVolume < DSBVOLUME_MIN)
2252 {
2253 WARN("Invalid cone outside volume (%d)\n", ds3dbuffer->lConeOutsideVolume);
2254 return DSERR_INVALIDPARAM;
2255 }
2256
2257 if(ds3dbuffer->flMaxDistance < 0.0f)
2258 {
2259 WARN("Invalid max distance (%f)\n", ds3dbuffer->flMaxDistance);
2260 return DSERR_INVALIDPARAM;
2261 }
2262
2263 if(ds3dbuffer->flMinDistance < 0.0f)
2264 {
2265 WARN("Invalid min distance (%f)\n", ds3dbuffer->flMinDistance);
2266 return DSERR_INVALIDPARAM;
2267 }
2268
2269 if(ds3dbuffer->dwMode != DS3DMODE_NORMAL &&
2270 ds3dbuffer->dwMode != DS3DMODE_HEADRELATIVE &&
2271 ds3dbuffer->dwMode != DS3DMODE_DISABLE)
2272 {
2273 WARN("Invalid mode (%u)\n", ds3dbuffer->dwMode);
2274 return DSERR_INVALIDPARAM;
2275 }
2276
2277 EnterCriticalSection(This->crst);
2278 setALContext(This->ctx);
2279 IDirectSound3DBuffer_SetPosition(iface, ds3dbuffer->vPosition.x, ds3dbuffer->vPosition.y, ds3dbuffer->vPosition.z, apply);
2280 IDirectSound3DBuffer_SetVelocity(iface, ds3dbuffer->vVelocity.x, ds3dbuffer->vVelocity.y, ds3dbuffer->vVelocity.z, apply);
2281 IDirectSound3DBuffer_SetConeAngles(iface, ds3dbuffer->dwInsideConeAngle, ds3dbuffer->dwOutsideConeAngle, apply);
2282 IDirectSound3DBuffer_SetConeOrientation(iface, ds3dbuffer->vConeOrientation.x, ds3dbuffer->vConeOrientation.y, ds3dbuffer->vConeOrientation.z, apply);
2283 IDirectSound3DBuffer_SetConeOutsideVolume(iface, ds3dbuffer->lConeOutsideVolume, apply);
2284 IDirectSound3DBuffer_SetMinDistance(iface, ds3dbuffer->flMinDistance, apply);
2285 IDirectSound3DBuffer_SetMaxDistance(iface, ds3dbuffer->flMaxDistance, apply);
2286 IDirectSound3DBuffer_SetMode(iface, ds3dbuffer->dwMode, apply);
2287 popALContext();
2288 LeaveCriticalSection(This->crst);
2289
2290 return S_OK;
2291 }
2292
2293 static HRESULT WINAPI DS8Buffer3D_SetConeAngles(IDirectSound3DBuffer *iface, DWORD dwInsideConeAngle, DWORD dwOutsideConeAngle, DWORD apply)
2294 {
2295 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2296
2297 TRACE("(%p)->(%u, %u, %u)\n", This, dwInsideConeAngle, dwOutsideConeAngle, apply);
2298 if(dwInsideConeAngle > DS3D_MAXCONEANGLE ||
2299 dwOutsideConeAngle > DS3D_MAXCONEANGLE)
2300 {
2301 WARN("Invalid cone angles (%u, %u)\n", dwInsideConeAngle, dwOutsideConeAngle);
2302 return DSERR_INVALIDPARAM;
2303 }
2304
2305 EnterCriticalSection(This->crst);
2306 if(apply == DS3D_DEFERRED)
2307 {
2308 This->ds3dbuffer.dwInsideConeAngle = dwInsideConeAngle;
2309 This->ds3dbuffer.dwOutsideConeAngle = dwOutsideConeAngle;
2310 This->dirty.bit.cone_angles = 1;
2311 }
2312 else
2313 {
2314 setALContext(This->ctx);
2315 alSourcei(This->source, AL_CONE_INNER_ANGLE, dwInsideConeAngle);
2316 alSourcei(This->source, AL_CONE_OUTER_ANGLE, dwOutsideConeAngle);
2317 getALError();
2318 popALContext();
2319 }
2320 LeaveCriticalSection(This->crst);
2321
2322 return S_OK;
2323 }
2324
2325 static HRESULT WINAPI DS8Buffer3D_SetConeOrientation(IDirectSound3DBuffer *iface, D3DVALUE x, D3DVALUE y, D3DVALUE z, DWORD apply)
2326 {
2327 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2328
2329 TRACE("(%p)->(%f, %f, %f, %u)\n", This, x, y, z, apply);
2330
2331 EnterCriticalSection(This->crst);
2332 if(apply == DS3D_DEFERRED)
2333 {
2334 This->ds3dbuffer.vConeOrientation.x = x;
2335 This->ds3dbuffer.vConeOrientation.y = y;
2336 This->ds3dbuffer.vConeOrientation.z = z;
2337 This->dirty.bit.cone_orient = 1;
2338 }
2339 else
2340 {
2341 setALContext(This->ctx);
2342 alSource3f(This->source, AL_DIRECTION, x, y, -z);
2343 getALError();
2344 popALContext();
2345 }
2346 LeaveCriticalSection(This->crst);
2347
2348 return S_OK;
2349 }
2350
2351 static HRESULT WINAPI DS8Buffer3D_SetConeOutsideVolume(IDirectSound3DBuffer *iface, LONG vol, DWORD apply)
2352 {
2353 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2354
2355 TRACE("(%p)->(%u, %u)\n", This, vol, apply);
2356 if(vol < DSBVOLUME_MIN || vol > DSBVOLUME_MAX)
2357 {
2358 WARN("Invalid volume (%u)\n", vol);
2359 return DSERR_INVALIDPARAM;
2360 }
2361
2362 EnterCriticalSection(This->crst);
2363 if(apply == DS3D_DEFERRED)
2364 {
2365 This->ds3dbuffer.lConeOutsideVolume = vol;
2366 This->dirty.bit.cone_outsidevolume = 1;
2367 }
2368 else
2369 {
2370 setALContext(This->ctx);
2371 alSourcef(This->source, AL_CONE_OUTER_GAIN, mB_to_gain(vol));
2372 getALError();
2373 popALContext();
2374 }
2375 LeaveCriticalSection(This->crst);
2376
2377 return S_OK;
2378 }
2379
2380 static HRESULT WINAPI DS8Buffer3D_SetMaxDistance(IDirectSound3DBuffer *iface, D3DVALUE maxdist, DWORD apply)
2381 {
2382 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2383
2384 TRACE("(%p)->(%f, %u)\n", This, maxdist, apply);
2385 if(maxdist < 0.0f)
2386 {
2387 WARN("Invalid max distance (%f)\n", maxdist);
2388 return DSERR_INVALIDPARAM;
2389 }
2390
2391 EnterCriticalSection(This->crst);
2392 if(apply == DS3D_DEFERRED)
2393 {
2394 This->ds3dbuffer.flMaxDistance = maxdist;
2395 This->dirty.bit.max_distance = 1;
2396 }
2397 else
2398 {
2399 setALContext(This->ctx);
2400 alSourcef(This->source, AL_MAX_DISTANCE, maxdist);
2401 getALError();
2402 popALContext();
2403 }
2404 LeaveCriticalSection(This->crst);
2405
2406 return S_OK;
2407 }
2408
2409 static HRESULT WINAPI DS8Buffer3D_SetMinDistance(IDirectSound3DBuffer *iface, D3DVALUE mindist, DWORD apply)
2410 {
2411 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2412
2413 TRACE("(%p)->(%f, %u)\n", This, mindist, apply);
2414 if(mindist < 0.0f)
2415 {
2416 WARN("Invalid min distance (%f)\n", mindist);
2417 return DSERR_INVALIDPARAM;
2418 }
2419
2420 EnterCriticalSection(This->crst);
2421 if(apply == DS3D_DEFERRED)
2422 {
2423 This->ds3dbuffer.flMinDistance = mindist;
2424 This->dirty.bit.min_distance = 1;
2425 }
2426 else
2427 {
2428 setALContext(This->ctx);
2429 alSourcef(This->source, AL_REFERENCE_DISTANCE, mindist);
2430 getALError();
2431 popALContext();
2432 }
2433 LeaveCriticalSection(This->crst);
2434
2435 return S_OK;
2436 }
2437
2438 static HRESULT WINAPI DS8Buffer3D_SetMode(IDirectSound3DBuffer *iface, DWORD mode, DWORD apply)
2439 {
2440 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2441
2442 TRACE("(%p)->(%u, %u)\n", This, mode, apply);
2443 if(mode != DS3DMODE_NORMAL && mode != DS3DMODE_HEADRELATIVE &&
2444 mode != DS3DMODE_DISABLE)
2445 {
2446 WARN("Invalid mode (%u)\n", mode);
2447 return DSERR_INVALIDPARAM;
2448 }
2449
2450 EnterCriticalSection(This->crst);
2451 if(apply == DS3D_DEFERRED)
2452 {
2453 This->ds3dbuffer.dwMode = mode;
2454 This->dirty.bit.mode = 1;
2455 }
2456 else
2457 {
2458 setALContext(This->ctx);
2459 alSourcei(This->source, AL_SOURCE_RELATIVE,
2460 (mode != DS3DMODE_NORMAL) ? AL_TRUE : AL_FALSE);
2461 alSourcef(This->source, AL_ROLLOFF_FACTOR,
2462 (mode == DS3DMODE_DISABLE) ? 0.0f : This->primary->rollofffactor);
2463 This->ds3dmode = mode;
2464 getALError();
2465 popALContext();
2466 }
2467 LeaveCriticalSection(This->crst);
2468
2469 return S_OK;
2470 }
2471
2472 static HRESULT WINAPI DS8Buffer3D_SetPosition(IDirectSound3DBuffer *iface, D3DVALUE x, D3DVALUE y, D3DVALUE z, DWORD apply)
2473 {
2474 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2475
2476 TRACE("(%p)->(%f, %f, %f, %u)\n", This, x, y, z, apply);
2477
2478 EnterCriticalSection(This->crst);
2479 if(apply == DS3D_DEFERRED)
2480 {
2481 This->ds3dbuffer.vPosition.x = x;
2482 This->ds3dbuffer.vPosition.y = y;
2483 This->ds3dbuffer.vPosition.z = z;
2484 This->dirty.bit.pos = 1;
2485 }
2486 else
2487 {
2488 setALContext(This->ctx);
2489 alSource3f(This->source, AL_POSITION, x, y, -z);
2490 getALError();
2491 popALContext();
2492 }
2493 LeaveCriticalSection(This->crst);
2494
2495 return S_OK;
2496 }
2497
2498 static HRESULT WINAPI DS8Buffer3D_SetVelocity(IDirectSound3DBuffer *iface, D3DVALUE x, D3DVALUE y, D3DVALUE z, DWORD apply)
2499 {
2500 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2501
2502 TRACE("(%p)->(%f, %f, %f, %u)\n", This, x, y, z, apply);
2503
2504 EnterCriticalSection(This->crst);
2505 if(apply == DS3D_DEFERRED)
2506 {
2507 This->ds3dbuffer.vVelocity.x = x;
2508 This->ds3dbuffer.vVelocity.y = y;
2509 This->ds3dbuffer.vVelocity.z = z;
2510 This->dirty.bit.vel = 1;
2511 }
2512 else
2513 {
2514 setALContext(This->ctx);
2515 alSource3f(This->source, AL_VELOCITY, x, y, -z);
2516 getALError();
2517 popALContext();
2518 }
2519 LeaveCriticalSection(This->crst);
2520
2521 return S_OK;
2522 }
2523
2524 static const IDirectSound3DBufferVtbl DS8Buffer3d_Vtbl =
2525 {
2526 DS8Buffer3D_QueryInterface,
2527 DS8Buffer3D_AddRef,
2528 DS8Buffer3D_Release,
2529 DS8Buffer3D_GetAllParameters,
2530 DS8Buffer3D_GetConeAngles,
2531 DS8Buffer3D_GetConeOrientation,
2532 DS8Buffer3D_GetConeOutsideVolume,
2533 DS8Buffer3D_GetMaxDistance,
2534 DS8Buffer3D_GetMinDistance,
2535 DS8Buffer3D_GetMode,
2536 DS8Buffer3D_GetPosition,
2537 DS8Buffer3D_GetVelocity,
2538 DS8Buffer3D_SetAllParameters,
2539 DS8Buffer3D_SetConeAngles,
2540 DS8Buffer3D_SetConeOrientation,
2541 DS8Buffer3D_SetConeOutsideVolume,
2542 DS8Buffer3D_SetMaxDistance,
2543 DS8Buffer3D_SetMinDistance,
2544 DS8Buffer3D_SetMode,
2545 DS8Buffer3D_SetPosition,
2546 DS8Buffer3D_SetVelocity
2547 };
2548
2549 static inline DS8Buffer *impl_from_IDirectSoundNotify(IDirectSoundNotify *iface)
2550 {
2551 return CONTAINING_RECORD(iface, DS8Buffer, IDirectSoundNotify_iface);
2552 }
2553
2554 static HRESULT WINAPI DS8BufferNot_QueryInterface(IDirectSoundNotify *iface, REFIID riid, void **ppv)
2555 {
2556 DS8Buffer *This = impl_from_IDirectSoundNotify(iface);
2557 return IDirectSoundBuffer8_QueryInterface(&This->IDirectSoundBuffer8_iface, riid, ppv);
2558 }
2559
2560 static ULONG WINAPI DS8BufferNot_AddRef(IDirectSoundNotify *iface)
2561 {
2562 DS8Buffer *This = impl_from_IDirectSoundNotify(iface);
2563 LONG ret;
2564
2565 InterlockedIncrement(&This->all_ref);
2566 ret = InterlockedIncrement(&This->not_ref);
2567 TRACE("new refcount %d\n", ret);
2568
2569 return ret;
2570 }
2571
2572 static ULONG WINAPI DS8BufferNot_Release(IDirectSoundNotify *iface)
2573 {
2574 DS8Buffer *This = impl_from_IDirectSoundNotify(iface);
2575 LONG ret;
2576
2577 ret = InterlockedDecrement(&This->not_ref);
2578 TRACE("new refcount %d\n", ret);
2579 if(InterlockedDecrement(&This->all_ref) == 0)
2580 DS8Buffer_Destroy(This);
2581
2582 return ret;
2583 }
2584
2585 static HRESULT WINAPI DS8BufferNot_SetNotificationPositions(IDirectSoundNotify *iface, DWORD count, const DSBPOSITIONNOTIFY *notifications)
2586 {
2587 DS8Buffer *This = impl_from_IDirectSoundNotify(iface);
2588 DSBPOSITIONNOTIFY *nots;
2589 DWORD state;
2590 HRESULT hr;
2591
2592 EnterCriticalSection(This->crst);
2593 hr = DSERR_INVALIDPARAM;
2594 if(count && !notifications)
2595 goto out;
2596
2597 hr = IDirectSoundBuffer8_GetStatus(&This->IDirectSoundBuffer8_iface, &state);
2598 if(FAILED(hr))
2599 goto out;
2600
2601 hr = DSERR_INVALIDCALL;
2602 if((state&DSBSTATUS_PLAYING))
2603 goto out;
2604
2605 if(!count)
2606 {
2607 HeapFree(GetProcessHeap(), 0, This->notify);
2608 This->notify = 0;
2609 This->nnotify = 0;
2610 hr = S_OK;
2611 }
2612 else
2613 {
2614 DWORD i;
2615
2616 hr = DSERR_INVALIDPARAM;
2617 for(i = 0;i < count;++i)
2618 {
2619 if(notifications[i].dwOffset >= This->buffer->buf_size &&
2620 notifications[i].dwOffset != (DWORD)DSBPN_OFFSETSTOP)
2621 goto out;
2622 }
2623
2624 hr = E_OUTOFMEMORY;
2625 nots = HeapAlloc(GetProcessHeap(), 0, count*sizeof(*nots));
2626 if(!nots)
2627 goto out;
2628 memcpy(nots, notifications, count*sizeof(*nots));
2629
2630 HeapFree(GetProcessHeap(), 0, This->notify);
2631 This->notify = nots;
2632 This->nnotify = count;
2633
2634 hr = S_OK;
2635 }
2636
2637 out:
2638 LeaveCriticalSection(This->crst);
2639 return hr;
2640 }
2641
2642 static const IDirectSoundNotifyVtbl DS8BufferNot_Vtbl =
2643 {
2644 DS8BufferNot_QueryInterface,
2645 DS8BufferNot_AddRef,
2646 DS8BufferNot_Release,
2647 DS8BufferNot_SetNotificationPositions
2648 };
2649
2650 /* NOTE: Due to some apparent quirks in DSound, the listener properties are
2651 handled through secondary buffers. */
2652 static inline DS8Buffer *impl_from_IKsPropertySet(IKsPropertySet *iface)
2653 {
2654 return CONTAINING_RECORD(iface, DS8Buffer, IKsPropertySet_iface);
2655 }
2656
2657 static HRESULT WINAPI DS8BufferProp_QueryInterface(IKsPropertySet *iface, REFIID riid, void **ppv)
2658 {
2659 DS8Buffer *This = impl_from_IKsPropertySet(iface);
2660 return IDirectSoundBuffer8_QueryInterface(&This->IDirectSoundBuffer8_iface, riid, ppv);
2661 }
2662
2663 static ULONG WINAPI DS8BufferProp_AddRef(IKsPropertySet *iface)
2664 {
2665 DS8Buffer *This = impl_from_IKsPropertySet(iface);
2666 LONG ret;
2667
2668 InterlockedIncrement(&This->all_ref);
2669 ret = InterlockedIncrement(&This->prop_ref);
2670 TRACE("new refcount %d\n", ret);
2671
2672 return ret;
2673 }
2674
2675 static ULONG WINAPI DS8BufferProp_Release(IKsPropertySet *iface)
2676 {
2677 DS8Buffer *This = impl_from_IKsPropertySet(iface);
2678 LONG ret;
2679
2680 ret = InterlockedDecrement(&This->prop_ref);
2681 TRACE("new refcount %d\n", ret);
2682 if(InterlockedDecrement(&This->all_ref) == 0)
2683 DS8Buffer_Destroy(This);
2684
2685 return ret;
2686 }
2687
2688 static HRESULT WINAPI DS8BufferProp_Get(IKsPropertySet *iface,
2689 REFGUID guidPropSet, ULONG dwPropID,
2690 LPVOID pInstanceData, ULONG cbInstanceData,
2691 LPVOID pPropData, ULONG cbPropData,
2692 PULONG pcbReturned)
2693 {
2694 DS8Buffer *This = impl_from_IKsPropertySet(iface);
2695 HRESULT hr = E_PROP_ID_UNSUPPORTED;
2696
2697 TRACE("(%p)->(%s, %u, %p, %u, %p, %u, %p)\n", iface, debugstr_guid(guidPropSet),
2698 dwPropID, pInstanceData, cbInstanceData, pPropData, cbPropData, pcbReturned);
2699
2700 if(!pcbReturned)
2701 return E_POINTER;
2702 *pcbReturned = 0;
2703
2704 #if 0
2705 if(IsEqualIID(guidPropSet, &DSPROPSETID_EAX20_BufferProperties))
2706 {
2707 }
2708 else
2709 #endif
2710 {
2711 /* Not a known buffer/source property. Pass it to the listener */
2712 hr = IKsPropertySet_Get(&This->primary->IKsPropertySet_iface, guidPropSet,
2713 dwPropID, pInstanceData, cbInstanceData, pPropData, cbPropData,
2714 pcbReturned);
2715 }
2716
2717 return hr;
2718 }
2719
2720 static HRESULT WINAPI DS8BufferProp_Set(IKsPropertySet *iface,
2721 REFGUID guidPropSet, ULONG dwPropID,
2722 LPVOID pInstanceData, ULONG cbInstanceData,
2723 LPVOID pPropData, ULONG cbPropData)
2724 {
2725 DS8Buffer *This = impl_from_IKsPropertySet(iface);
2726 HRESULT hr = E_PROP_ID_UNSUPPORTED;
2727
2728 TRACE("(%p)->(%s, %u, %p, %u, %p, %u)\n", iface, debugstr_guid(guidPropSet),
2729 dwPropID, pInstanceData, cbInstanceData, pPropData, cbPropData);
2730
2731 #if 0
2732 if(IsEqualIID(guidPropSet, &DSPROPSETID_EAX20_BufferProperties))
2733 {
2734 }
2735 else
2736 #endif
2737 {
2738 /* Not a known buffer/source property. Pass it to the listener */
2739 hr = IKsPropertySet_Set(&This->primary->IKsPropertySet_iface, guidPropSet,
2740 dwPropID, pInstanceData, cbInstanceData, pPropData,
2741 cbPropData);
2742 }
2743
2744 return hr;
2745 }
2746
2747 static HRESULT WINAPI DS8BufferProp_QuerySupport(IKsPropertySet *iface,
2748 REFGUID guidPropSet, ULONG dwPropID,
2749 PULONG pTypeSupport)
2750 {
2751 DS8Buffer *This = impl_from_IKsPropertySet(iface);
2752 HRESULT hr = E_PROP_ID_UNSUPPORTED;
2753
2754 TRACE("(%p)->(%s, %u, %p)\n", iface, debugstr_guid(guidPropSet), dwPropID, pTypeSupport);
2755
2756 if(!pTypeSupport)
2757 return E_POINTER;
2758 *pTypeSupport = 0;
2759
2760 #if 0
2761 if(IsEqualIID(guidPropSet, &DSPROPSETID_EAX20_BufferProperties))
2762 {
2763 }
2764 else
2765 #endif
2766 {
2767 /* Not a known buffer/source property. Pass it to the listener */
2768 hr = IKsPropertySet_QuerySupport(&This->primary->IKsPropertySet_iface,
2769 guidPropSet, dwPropID, pTypeSupport);
2770 }
2771
2772 return hr;
2773 }
2774
2775 static const IKsPropertySetVtbl DS8BufferProp_Vtbl =
2776 {
2777 DS8BufferProp_QueryInterface,
2778 DS8BufferProp_AddRef,
2779 DS8BufferProp_Release,
2780 DS8BufferProp_Get,
2781 DS8BufferProp_Set,
2782 DS8BufferProp_QuerySupport
2783 };
A DirectSound wrapper for OpenAL