?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Fix some missing initializer warnings
[dsound-openal.git] / buffer.c
blob9a1d7194936267dcdf7489ba6c3a85ff1357c70c
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->primary = parent;
824 This->IDirectSoundBuffer8_iface.lpVtbl = &DS8Buffer_Vtbl;
825 This->IDirectSound3DBuffer_iface.lpVtbl = &DS8Buffer3d_Vtbl;
826 This->IDirectSoundNotify_iface.lpVtbl = &DS8BufferNot_Vtbl;
827 This->IKsPropertySet_iface.lpVtbl = &DS8BufferProp_Vtbl;
828 This->ctx = parent->ctx;
829 This->ExtAL = &parent->ExtAL;
830 This->crst = &parent->crst;
831 This->ref = This->all_ref = 1;
832
833 if(orig)
834 {
835 This->buffer = orig->buffer;
836 DS8Data_AddRef(This->buffer);
837 }
838
839 /* Append to buffer list */
840 bufs = parent->buffers;
841 if(parent->nbuffers == parent->sizebuffers)
842 {
843 bufs = HeapReAlloc(GetProcessHeap(), 0, bufs, sizeof(*bufs)*(1+parent->nbuffers));
844 if(!bufs) goto fail;
845 parent->sizebuffers++;
846 }
847 parent->buffers = bufs;
848 bufs[parent->nbuffers++] = This;
849
850 /* Disable until initialized.. */
851 This->ds3dmode = DS3DMODE_DISABLE;
852
853 *ppv = This;
854 return S_OK;
855
856 fail:
857 DS8Buffer_Destroy(This);
858 return hr;
859 }
860
861 void DS8Buffer_Destroy(DS8Buffer *This)
862 {
863 DWORD idx;
864 TRACE("Destroying %p\n", This);
865
866 DS8Buffer_removenotify(This);
867
868 /* Remove from list, if in list */
869 for(idx = 0;idx < This->primary->nbuffers;++idx)
870 {
871 if(This->primary->buffers[idx] == This)
872 {
873 This->primary->buffers[idx] = This->primary->buffers[This->primary->nbuffers-1];
874 This->primary->nbuffers--;
875 break;
876 }
877 }
878 setALContext(This->ctx);
879 if(This->source)
880 {
881 ALuint *sources;
882
883 alSourceStop(This->source);
884 alSourcei(This->source, AL_BUFFER, 0);
885 getALError();
886
887 sources = This->primary->sources;
888 if(This->primary->nsources == This->primary->sizesources)
889 {
890 sources = HeapReAlloc(GetProcessHeap(), 0, sources, sizeof(*sources)*(1+This->primary->nsources));
891 if(!sources)
892 alDeleteSources(1, &This->source);
893 else
894 This->primary->sizesources++;
895 }
896 if(sources)
897 {
898 sources[This->primary->nsources++] = This->source;
899 This->primary->sources = sources;
900 }
901 }
902 HeapFree(GetProcessHeap(), 0, This->notify);
903 This->source = 0;
904 if(This->buffer)
905 DS8Data_Release(This->buffer);
906 popALContext();
907 HeapFree(GetProcessHeap(), 0, This);
908 }
909
910 static inline DS8Buffer *impl_from_IDirectSoundBuffer8(IDirectSoundBuffer8 *iface)
911 {
912 return CONTAINING_RECORD(iface, DS8Buffer, IDirectSoundBuffer8_iface);
913 }
914
915 static HRESULT WINAPI DS8Buffer_QueryInterface(IDirectSoundBuffer8 *iface, REFIID riid, void **ppv)
916 {
917 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
918
919 TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
920
921 *ppv = NULL;
922 if(IsEqualIID(riid, &IID_IUnknown) ||
923 IsEqualIID(riid, &IID_IDirectSoundBuffer))
924 *ppv = &This->IDirectSoundBuffer8_iface;
925 else if(IsEqualIID(riid, &IID_IDirectSoundBuffer8))
926 {
927 if(This->primary->parent->is_8)
928 *ppv = &This->IDirectSoundBuffer8_iface;
929 }
930 else if(IsEqualIID(riid, &IID_IDirectSound3DBuffer))
931 {
932 if((This->buffer->dsbflags&DSBCAPS_CTRL3D))
933 *ppv = &This->IDirectSound3DBuffer_iface;
934 }
935 else if(IsEqualIID(riid, &IID_IDirectSoundNotify))
936 {
937 if((This->buffer->dsbflags&DSBCAPS_CTRLPOSITIONNOTIFY))
938 *ppv = &This->IDirectSoundNotify_iface;
939 }
940 else if(IsEqualIID(riid, &IID_IKsPropertySet))
941 *ppv = &This->IKsPropertySet_iface;
942 else
943 FIXME("Unhandled GUID: %s\n", debugstr_guid(riid));
944
945 if(*ppv)
946 {
947 IUnknown_AddRef((IUnknown*)*ppv);
948 return S_OK;
949 }
950
951 return E_NOINTERFACE;
952 }
953
954 static ULONG WINAPI DS8Buffer_AddRef(IDirectSoundBuffer8 *iface)
955 {
956 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
957 LONG ret;
958
959 InterlockedIncrement(&This->all_ref);
960 ret = InterlockedIncrement(&This->ref);
961 TRACE("new refcount %d\n", ret);
962
963 return ret;
964 }
965
966 static ULONG WINAPI DS8Buffer_Release(IDirectSoundBuffer8 *iface)
967 {
968 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
969 LONG ret;
970
971 ret = InterlockedDecrement(&This->ref);
972 TRACE("new refcount %d\n", ret);
973 if(InterlockedDecrement(&This->all_ref) == 0)
974 DS8Buffer_Destroy(This);
975
976 return ret;
977 }
978
979 static HRESULT WINAPI DS8Buffer_GetCaps(IDirectSoundBuffer8 *iface, DSBCAPS *caps)
980 {
981 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
982
983 TRACE("(%p)->(%p)\n", iface, caps);
984
985 if(!caps || caps->dwSize < sizeof(*caps))
986 {
987 WARN("Invalid DSBCAPS (%p, %u)\n", caps, (caps ? caps->dwSize : 0));
988 return DSERR_INVALIDPARAM;
989 }
990
991 caps->dwFlags = This->buffer->dsbflags;
992 caps->dwBufferBytes = This->buffer->buf_size;
993 caps->dwUnlockTransferRate = 4096;
994 caps->dwPlayCpuOverhead = 0;
995 return S_OK;
996 }
997
998 static HRESULT WINAPI DS8Buffer_GetCurrentPosition(IDirectSoundBuffer8 *iface, DWORD *playpos, DWORD *curpos)
999 {
1000 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1001 WAVEFORMATEX *format = &This->buffer->format.Format;
1002 UINT writecursor, pos;
1003
1004 TRACE("(%p)->(%p, %p)\n", iface, playpos, curpos);
1005
1006 EnterCriticalSection(This->crst);
1007 setALContext(This->ctx);
1008
1009 if(This->buffer->numsegs > 1)
1010 {
1011 ALint queued = QBUFFERS;
1012 alGetSourcei(This->source, AL_BUFFERS_QUEUED, &queued);
1013 getALError();
1014
1015 pos = (This->curidx+This->buffer->numsegs-queued)%This->buffer->numsegs;
1016 pos *= This->buffer->segsize;
1017 writecursor = This->curidx * This->buffer->segsize;
1018 }
1019 else if(This->ExtAL->BufferSubData || This->ExtAL->BufferSamplesSOFT)
1020 {
1021 ALint rwpos[2] = { 0, 0 };
1022
1023 alGetSourceiv(This->source, AL_BYTE_RW_OFFSETS_SOFT, rwpos);
1024 getALError();
1025
1026 pos = rwpos[0];
1027 writecursor = rwpos[1];
1028 }
1029 else
1030 {
1031 ALint status = 0;
1032 ALint ofs = 0;
1033
1034 alGetSourcei(This->source, AL_BYTE_OFFSET, &ofs);
1035 alGetSourcei(This->source, AL_SOURCE_STATE, &status);
1036 getALError();
1037
1038 pos = ofs;
1039 if(status == AL_PLAYING)
1040 {
1041 writecursor = format->nSamplesPerSec / 100;
1042 writecursor *= format->nBlockAlign;
1043 }
1044 else
1045 writecursor = 0;
1046 writecursor = (writecursor + pos) % This->buffer->buf_size;
1047 }
1048 TRACE("%p Play pos = %u, write pos = %u\n", This, pos, writecursor);
1049 if(pos >= This->buffer->buf_size)
1050 {
1051 ERR("playpos >= buf_size\n");
1052 pos %= This->buffer->buf_size;
1053 }
1054 if(writecursor >= This->buffer->buf_size)
1055 {
1056 ERR("writepos >= buf_size\n");
1057 writecursor %= This->buffer->buf_size;
1058 }
1059
1060 if(playpos) *playpos = pos;
1061 if(curpos) *curpos = writecursor;
1062
1063 popALContext();
1064 LeaveCriticalSection(This->crst);
1065
1066 return S_OK;
1067 }
1068
1069 static HRESULT WINAPI DS8Buffer_GetFormat(IDirectSoundBuffer8 *iface, WAVEFORMATEX *wfx, DWORD allocated, DWORD *written)
1070 {
1071 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1072 HRESULT hr = S_OK;
1073 UINT size;
1074
1075 TRACE("(%p)->(%p, %u, %p)\n", iface, wfx, allocated, written);
1076
1077 if(!wfx && !written)
1078 {
1079 WARN("Cannot report format or format size\n");
1080 return DSERR_INVALIDPARAM;
1081 }
1082
1083 EnterCriticalSection(This->crst);
1084 size = sizeof(This->buffer->format.Format) + This->buffer->format.Format.cbSize;
1085 if(wfx)
1086 {
1087 if(allocated < size)
1088 hr = DSERR_INVALIDPARAM;
1089 else
1090 memcpy(wfx, &This->buffer->format.Format, size);
1091 }
1092 if(written)
1093 *written = size;
1094 LeaveCriticalSection(This->crst);
1095
1096 return hr;
1097 }
1098
1099 static HRESULT WINAPI DS8Buffer_GetVolume(IDirectSoundBuffer8 *iface, LONG *vol)
1100 {
1101 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1102 HRESULT hr;
1103
1104 TRACE("(%p)->(%p)\n", iface, vol);
1105
1106 if(!vol)
1107 {
1108 WARN("Invalid pointer\n");
1109 return DSERR_INVALIDPARAM;
1110 }
1111
1112 EnterCriticalSection(This->crst);
1113
1114 hr = DSERR_CONTROLUNAVAIL;
1115 if(!(This->buffer->dsbflags&DSBCAPS_CTRLVOLUME))
1116 WARN("Volume control not set\n");
1117 else
1118 {
1119 ALfloat gain = 1.0f;
1120
1121 setALContext(This->ctx);
1122 alGetSourcef(This->source, AL_GAIN, &gain);
1123 getALError();
1124 popALContext();
1125
1126 *vol = gain_to_mB(gain);
1127 *vol = min(*vol, DSBVOLUME_MAX);
1128 *vol = max(*vol, DSBVOLUME_MIN);
1129
1130 hr = DS_OK;
1131 }
1132
1133 LeaveCriticalSection(This->crst);
1134 return hr;
1135 }
1136
1137 static HRESULT WINAPI DS8Buffer_GetPan(IDirectSoundBuffer8 *iface, LONG *pan)
1138 {
1139 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1140 HRESULT hr;
1141
1142 TRACE("(%p)->(%p)\n", iface, pan);
1143
1144 if(!pan)
1145 {
1146 WARN("Invalid pointer\n");
1147 return DSERR_INVALIDPARAM;
1148 }
1149
1150 EnterCriticalSection(This->crst);
1151
1152 hr = DSERR_CONTROLUNAVAIL;
1153 if(!(This->buffer->dsbflags&DSBCAPS_CTRLPAN))
1154 WARN("Panning control not set\n");
1155 else
1156 {
1157 ALfloat pos[3];
1158
1159 setALContext(This->ctx);
1160 alGetSourcefv(This->source, AL_POSITION, pos);
1161 getALError();
1162 popALContext();
1163
1164 *pan = (LONG)((pos[0]+1.0) * (DSBPAN_RIGHT-DSBPAN_LEFT) / 2.0 + 0.5) + DSBPAN_LEFT;
1165 *pan = min(*pan, DSBPAN_RIGHT);
1166 *pan = max(*pan, DSBPAN_LEFT);
1167
1168 hr = DS_OK;
1169 }
1170
1171 LeaveCriticalSection(This->crst);
1172 return hr;
1173 }
1174
1175 static HRESULT WINAPI DS8Buffer_GetFrequency(IDirectSoundBuffer8 *iface, DWORD *freq)
1176 {
1177 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1178 HRESULT hr;
1179
1180 TRACE("(%p)->(%p)\n", iface, freq);
1181
1182 if(!freq)
1183 {
1184 WARN("Invalid pointer\n");
1185 return DSERR_INVALIDPARAM;
1186 }
1187
1188 EnterCriticalSection(This->crst);
1189
1190 hr = DSERR_CONTROLUNAVAIL;
1191 if(!(This->buffer->dsbflags&DSBCAPS_CTRLFREQUENCY))
1192 WARN("Frequency control not set\n");
1193 else
1194 {
1195 ALfloat pitch = 1.0f;
1196
1197 setALContext(This->ctx);
1198 alGetSourcefv(This->source, AL_PITCH, &pitch);
1199 getALError();
1200 popALContext();
1201
1202 *freq = (DWORD)(This->buffer->format.Format.nSamplesPerSec * pitch);
1203
1204 hr = DS_OK;
1205 }
1206
1207 LeaveCriticalSection(This->crst);
1208 return hr;
1209 }
1210
1211 static HRESULT WINAPI DS8Buffer_GetStatus(IDirectSoundBuffer8 *iface, DWORD *status)
1212 {
1213 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1214 ALint state, looping;
1215
1216 TRACE("(%p)->(%p)\n", iface, status);
1217
1218 if(!status)
1219 {
1220 WARN("Invalid pointer\n");
1221 return DSERR_INVALIDPARAM;
1222 }
1223
1224 EnterCriticalSection(This->crst);
1225
1226 setALContext(This->ctx);
1227 alGetSourcei(This->source, AL_SOURCE_STATE, &state);
1228 looping = This->islooping;
1229 if(This->buffer->numsegs == 1)
1230 alGetSourcei(This->source, AL_LOOPING, &looping);
1231 else if(state != AL_PLAYING)
1232 state = This->isplaying ? AL_PLAYING : AL_PAUSED;
1233 getALError();
1234 popALContext();
1235
1236 *status = 0;
1237 if((This->buffer->dsbflags&DSBCAPS_LOCDEFER))
1238 {
1239 if((This->buffer->dsbflags&DSBCAPS_LOCSOFTWARE))
1240 *status |= DSBSTATUS_LOCSOFTWARE;
1241 else if((This->buffer->dsbflags&DSBCAPS_LOCHARDWARE))
1242 *status |= DSBSTATUS_LOCHARDWARE;
1243 }
1244 if(state == AL_PLAYING)
1245 *status |= DSBSTATUS_PLAYING | (looping ? DSBSTATUS_LOOPING : 0);
1246
1247 LeaveCriticalSection(This->crst);
1248
1249 return S_OK;
1250 }
1251
1252 static HRESULT WINAPI DS8Buffer_Initialize(IDirectSoundBuffer8 *iface, IDirectSound *ds, const DSBUFFERDESC *desc)
1253 {
1254 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1255 DS3DBUFFER *ds3dbuffer;
1256 HRESULT hr;
1257
1258 TRACE("(%p)->(%p, %p)\n", iface, ds, desc);
1259
1260 EnterCriticalSection(This->crst);
1261 setALContext(This->ctx);
1262
1263 hr = DSERR_ALREADYINITIALIZED;
1264 if(This->source)
1265 goto out;
1266
1267 if(!This->buffer)
1268 {
1269 hr = DSERR_INVALIDPARAM;
1270 if(!desc)
1271 {
1272 WARN("Missing DSound buffer description\n");
1273 goto out;
1274 }
1275 if(!desc->lpwfxFormat)
1276 {
1277 WARN("Missing buffer format (%p)\n", This);
1278 goto out;
1279 }
1280 if((desc->dwFlags&DSBCAPS_CTRL3D) && desc->lpwfxFormat->nChannels != 1)
1281 {
1282 if(This->primary->parent->is_8)
1283 {
1284 /* DirectSoundBuffer8 objects aren't allowed non-mono 3D
1285 * buffers */
1286 WARN("Can't create multi-channel 3D buffers\n");
1287 goto out;
1288 }
1289 ERR("Multi-channel 3D sounds are not spatialized\n");
1290 }
1291
1292 hr = DS8Data_Create(&This->buffer, desc, This->primary);
1293 if(FAILED(hr))
1294 goto out;
1295 else
1296 {
1297 DS8Data *buf = This->buffer;
1298
1299 if(buf->in_type == AL_UNSIGNED_BYTE)
1300 memset(buf->data, 0x80, buf->buf_size);
1301 else
1302 memset(buf->data, 0x00, buf->buf_size);
1303
1304 if(This->ExtAL->BufferDataStatic)
1305 This->ExtAL->BufferDataStatic(buf->buffers[0], buf->buf_format,
1306 buf->data, buf->buf_size,
1307 buf->format.Format.nSamplesPerSec);
1308 else if(This->ExtAL->BufferSamplesSOFT)
1309 This->ExtAL->BufferSamplesSOFT(buf->buffers[0],
1310 buf->format.Format.nSamplesPerSec, buf->buf_format,
1311 buf->buf_size/buf->format.Format.nBlockAlign,
1312 buf->in_chans, buf->in_type, buf->data);
1313 else if(This->ExtAL->BufferSubData)
1314 alBufferData(buf->buffers[0], buf->buf_format,
1315 buf->data, buf->buf_size,
1316 buf->format.Format.nSamplesPerSec);
1317 }
1318 getALError();
1319 }
1320
1321 hr = DSERR_GENERIC;
1322 if(This->primary->nsources)
1323 {
1324 This->source = This->primary->sources[--This->primary->nsources];
1325 alSourcef(This->source, AL_GAIN, 1.0f);
1326 alSourcef(This->source, AL_PITCH, 1.0f);
1327 getALError();
1328 }
1329 else
1330 {
1331 alGenSources(1, &This->source);
1332 if(alGetError() != AL_NO_ERROR)
1333 goto out;
1334 }
1335
1336 ds3dbuffer = &This->ds3dbuffer;
1337 ds3dbuffer->dwSize = sizeof(*ds3dbuffer);
1338 ds3dbuffer->vPosition.x = 0.0;
1339 ds3dbuffer->vPosition.y = 0.0;
1340 ds3dbuffer->vPosition.z = 0.0;
1341 ds3dbuffer->vVelocity.x = 0.0;
1342 ds3dbuffer->vVelocity.y = 0.0;
1343 ds3dbuffer->vVelocity.z = 0.0;
1344 ds3dbuffer->dwInsideConeAngle = DS3D_DEFAULTCONEANGLE;
1345 ds3dbuffer->dwOutsideConeAngle = DS3D_DEFAULTCONEANGLE;
1346 ds3dbuffer->vConeOrientation.x = 0.0;
1347 ds3dbuffer->vConeOrientation.y = 0.0;
1348 ds3dbuffer->vConeOrientation.z = 1.0;
1349 ds3dbuffer->lConeOutsideVolume = DS3D_DEFAULTCONEOUTSIDEVOLUME;
1350 ds3dbuffer->flMinDistance = DS3D_DEFAULTMINDISTANCE;
1351 ds3dbuffer->flMaxDistance = DS3D_DEFAULTMAXDISTANCE;
1352 ds3dbuffer->dwMode = DS3DMODE_NORMAL;
1353
1354 if((This->buffer->dsbflags&DSBCAPS_CTRL3D))
1355 {
1356 if(This->primary->auxslot != 0)
1357 {
1358 alSource3i(This->source, AL_AUXILIARY_SEND_FILTER, This->primary->auxslot, 0, AL_FILTER_NULL);
1359 getALError();
1360 }
1361
1362 hr = IDirectSound3DBuffer_SetAllParameters(&This->IDirectSound3DBuffer_iface, ds3dbuffer, DS3D_IMMEDIATE);
1363 if(FAILED(hr))
1364 {
1365 ERR("SetAllParameters failed\n");
1366 goto out;
1367 }
1368 }
1369 else
1370 {
1371 ALuint source = This->source;
1372
1373 if(This->primary->auxslot != 0)
1374 {
1375 /* Simple hack to make reverb affect non-3D sounds too */
1376 alSource3i(source, AL_AUXILIARY_SEND_FILTER, This->primary->auxslot, 0, AL_FILTER_NULL);
1377 /*alSource3i(source, AL_AUXILIARY_SEND_FILTER, 0, 0, AL_FILTER_NULL);*/
1378 }
1379
1380 /* Non-3D sources aren't distance attenuated */
1381 This->ds3dmode = DS3DMODE_DISABLE;
1382 alSource3f(source, AL_POSITION, 0.0f, 1.0f, 0.0f);
1383 alSource3f(source, AL_VELOCITY, 0.0f, 0.0f, 0.0f);
1384 alSource3f(source, AL_DIRECTION, 0.0f, 0.0f, 0.0f);
1385 alSourcef(source, AL_CONE_OUTER_GAIN, 1.0f);
1386 alSourcef(source, AL_REFERENCE_DISTANCE, 1.0f);
1387 alSourcef(source, AL_MAX_DISTANCE, 1000.0f);
1388 alSourcef(source, AL_ROLLOFF_FACTOR, 0.0f);
1389 alSourcei(source, AL_CONE_INNER_ANGLE, 360);
1390 alSourcei(source, AL_CONE_OUTER_ANGLE, 360);
1391 alSourcei(source, AL_SOURCE_RELATIVE, AL_TRUE);
1392 getALError();
1393 }
1394 hr = S_OK;
1395
1396 out:
1397 popALContext();
1398 LeaveCriticalSection(This->crst);
1399
1400 return hr;
1401 }
1402
1403 static HRESULT WINAPI DS8Buffer_Lock(IDirectSoundBuffer8 *iface, DWORD ofs, DWORD bytes, void **ptr1, DWORD *len1, void **ptr2, DWORD *len2, DWORD flags)
1404 {
1405 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1406 HRESULT hr;
1407 DWORD remain;
1408
1409 TRACE("(%p)->(%u, %u, %p, %p, %p, %p, 0x%x)\n", This, ofs, bytes, ptr1, len1, ptr2, len2, flags);
1410
1411 if(!ptr1 || !len1)
1412 {
1413 WARN("Invalid pointer/len %p %p\n", ptr1, len1);
1414 return DSERR_INVALIDPARAM;
1415 }
1416
1417 EnterCriticalSection(This->crst);
1418 setALContext(This->ctx);
1419
1420 *ptr1 = NULL;
1421 *len1 = 0;
1422 if(ptr2) *ptr2 = NULL;
1423 if(len2) *len2 = 0;
1424
1425 hr = DSERR_INVALIDPARAM;
1426 if((flags&DSBLOCK_FROMWRITECURSOR))
1427 DS8Buffer_GetCurrentPosition(iface, NULL, &ofs);
1428 else if(ofs >= This->buffer->buf_size)
1429 {
1430 WARN("Invalid ofs %u\n", ofs);
1431 goto out;
1432 }
1433 if((flags&DSBLOCK_ENTIREBUFFER))
1434 bytes = This->buffer->buf_size;
1435 else if(bytes > This->buffer->buf_size)
1436 {
1437 WARN("Invalid size %u\n", bytes);
1438 goto out;
1439 }
1440
1441 *ptr1 = This->buffer->data + ofs;
1442 if(ofs+bytes >= This->buffer->buf_size)
1443 {
1444 *len1 = This->buffer->buf_size - ofs;
1445 remain = bytes - *len1;
1446 }
1447 else
1448 {
1449 *len1 = bytes;
1450 remain = 0;
1451 }
1452
1453 This->buffer->locked = TRUE;
1454
1455 if(ptr2 && len2 && remain)
1456 {
1457 *ptr2 = This->buffer->data;
1458 *len2 = remain;
1459 }
1460 hr = S_OK;
1461
1462 out:
1463 popALContext();
1464 LeaveCriticalSection(This->crst);
1465 return hr;
1466 }
1467
1468 static HRESULT WINAPI DS8Buffer_Play(IDirectSoundBuffer8 *iface, DWORD res1, DWORD prio, DWORD flags)
1469 {
1470 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1471 ALint type, state = AL_STOPPED;
1472 HRESULT hr;
1473 (void)res1;
1474
1475 TRACE("%p\n", This);
1476
1477 EnterCriticalSection(This->crst);
1478 setALContext(This->ctx);
1479
1480 hr = DSERR_BUFFERLOST;
1481 if(This->bufferlost)
1482 {
1483 WARN("Buffer %p lost\n", This);
1484 goto out;
1485 }
1486
1487 if((This->buffer->dsbflags&DSBCAPS_LOCDEFER))
1488 {
1489 if(!(This->buffer->dsbflags&(DSBCAPS_LOCHARDWARE|DSBCAPS_LOCSOFTWARE)))
1490 {
1491 if(flags & DSBPLAY_LOCSOFTWARE)
1492 This->buffer->dsbflags |= DSBCAPS_LOCSOFTWARE;
1493 else
1494 This->buffer->dsbflags |= DSBCAPS_LOCHARDWARE;
1495 }
1496 }
1497 else if(prio)
1498 {
1499 ERR("Invalid priority set for non-deferred buffer %p, %u!\n", This->buffer, prio);
1500 hr = DSERR_INVALIDPARAM;
1501 goto out;
1502 }
1503
1504 alGetSourcei(This->source, AL_SOURCE_STATE, &state);
1505 if(This->buffer->numsegs > 1)
1506 {
1507 This->islooping = !!(flags&DSBPLAY_LOOPING);
1508 if(state != AL_PLAYING && This->isplaying)
1509 state = AL_PLAYING;
1510 }
1511 else
1512 {
1513 alGetSourcei(This->source, AL_SOURCE_TYPE, &type);
1514 alSourcei(This->source, AL_LOOPING, (flags&DSBPLAY_LOOPING) ? AL_TRUE : AL_FALSE);
1515 }
1516 getALError();
1517
1518 hr = S_OK;
1519 if(state == AL_PLAYING)
1520 goto out;
1521
1522 /* alSourceQueueBuffers will implicitly set type to streaming */
1523 if(This->buffer->numsegs == 1)
1524 {
1525 if(type != AL_STATIC)
1526 alSourcei(This->source, AL_BUFFER, This->buffer->buffers[0]);
1527 alSourcePlay(This->source);
1528 }
1529 if(alGetError() != AL_NO_ERROR)
1530 {
1531 ERR("Couldn't start source\n");
1532 This->curidx = (This->buffer->numsegs-1+This->curidx)%This->buffer->numsegs;
1533 alSourcei(This->source, AL_BUFFER, 0);
1534 getALError();
1535 hr = DSERR_GENERIC;
1536 goto out;
1537 }
1538 This->isplaying = TRUE;
1539
1540 if(This->nnotify)
1541 {
1542 DS8Buffer_addnotify(This);
1543 DS8Buffer_starttimer(This->primary);
1544 }
1545 else if(This->buffer->numsegs > 1)
1546 DS8Buffer_starttimer(This->primary);
1547
1548 out:
1549 popALContext();
1550 LeaveCriticalSection(This->crst);
1551 return hr;
1552 }
1553
1554 static HRESULT WINAPI DS8Buffer_SetCurrentPosition(IDirectSoundBuffer8 *iface, DWORD pos)
1555 {
1556 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1557 HRESULT hr;
1558 TRACE("%p\n", This);
1559
1560 EnterCriticalSection(This->crst);
1561 setALContext(This->ctx);
1562
1563 hr = DSERR_INVALIDPARAM;
1564 if(pos >= This->buffer->buf_size)
1565 goto out;
1566
1567 if(This->buffer->numsegs > 1)
1568 {
1569 DS8Data *buf = This->buffer;
1570 This->curidx = pos/buf->segsize;
1571 if(This->curidx >= buf->numsegs)
1572 This->curidx = buf->numsegs - 1;
1573 if(This->isplaying)
1574 {
1575 alSourceStop(This->source);
1576 alSourcei(This->source, AL_BUFFER, 0);
1577 getALError();
1578 }
1579 }
1580 else
1581 alSourcei(This->source, AL_BYTE_OFFSET, pos);
1582 This->lastpos = pos;
1583 hr = S_OK;
1584
1585 out:
1586 popALContext();
1587 LeaveCriticalSection(This->crst);
1588 return hr;
1589 }
1590
1591 static HRESULT WINAPI DS8Buffer_SetFormat(IDirectSoundBuffer8 *iface, const WAVEFORMATEX *wfx)
1592 {
1593 /* This call only works on primary buffers */
1594 WARN("(%p)->(%p)\n", iface, wfx);
1595 return DSERR_INVALIDCALL;
1596 }
1597
1598 static HRESULT WINAPI DS8Buffer_SetVolume(IDirectSoundBuffer8 *iface, LONG vol)
1599 {
1600 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1601 HRESULT hr = S_OK;
1602
1603 TRACE("(%p)->(%d)\n", iface, vol);
1604
1605 if(vol > DSBVOLUME_MAX || vol < DSBVOLUME_MIN)
1606 {
1607 WARN("Invalid volume (%d)\n", vol);
1608 return DSERR_INVALIDPARAM;
1609 }
1610
1611 EnterCriticalSection(This->crst);
1612 if(!(This->buffer->dsbflags&DSBCAPS_CTRLVOLUME))
1613 hr = DSERR_CONTROLUNAVAIL;
1614 if(SUCCEEDED(hr))
1615 {
1616 ALfloat fvol = mB_to_gain(vol);
1617 setALContext(This->ctx);
1618 alSourcef(This->source, AL_GAIN, fvol);
1619 popALContext();
1620 }
1621 LeaveCriticalSection(This->crst);
1622
1623 return hr;
1624 }
1625
1626 static HRESULT WINAPI DS8Buffer_SetPan(IDirectSoundBuffer8 *iface, LONG pan)
1627 {
1628 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1629 HRESULT hr = S_OK;
1630
1631 TRACE("(%p)->(%d)\n", iface, pan);
1632
1633 if(pan > DSBPAN_RIGHT || pan < DSBPAN_LEFT)
1634 {
1635 WARN("invalid parameter: pan = %d\n", pan);
1636 return DSERR_INVALIDPARAM;
1637 }
1638
1639 EnterCriticalSection(This->crst);
1640 if(!(This->buffer->dsbflags&DSBCAPS_CTRLPAN))
1641 hr = DSERR_CONTROLUNAVAIL;
1642 else
1643 {
1644 ALfloat pos[3];
1645 pos[0] = (pan-DSBPAN_LEFT) * 2.0 / (ALfloat)(DSBPAN_RIGHT-DSBPAN_LEFT) - 1.0;
1646 /* NOTE: Strict movement along the X plane can cause the sound to jump
1647 * between left and right sharply. Using a curved path helps smooth it
1648 * out */
1649 pos[1] = sqrt(1.0 - pos[0]*pos[0]);
1650 pos[2] = 0.0;
1651
1652 setALContext(This->ctx);
1653 alSourcefv(This->source, AL_POSITION, pos);
1654 getALError();
1655 popALContext();
1656
1657 if(pan != 0 && This->buffer->format.Format.nChannels > 1)
1658 FIXME("Panning for multi-channel buffers is not supported\n");
1659 }
1660 LeaveCriticalSection(This->crst);
1661
1662 return hr;
1663 }
1664
1665 static HRESULT WINAPI DS8Buffer_SetFrequency(IDirectSoundBuffer8 *iface, DWORD freq)
1666 {
1667 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1668 HRESULT hr = S_OK;
1669
1670 TRACE("(%p)->(%u)\n", iface, freq);
1671
1672 if(freq < DSBFREQUENCY_MIN || freq > DSBFREQUENCY_MAX)
1673 {
1674 WARN("invalid parameter: freq = %d\n", freq);
1675 return DSERR_INVALIDPARAM;
1676 }
1677
1678 EnterCriticalSection(This->crst);
1679 if(!(This->buffer->dsbflags&DSBCAPS_CTRLFREQUENCY))
1680 hr = DSERR_CONTROLUNAVAIL;
1681 else
1682 {
1683 ALfloat pitch = 1.0f;
1684 if(freq != DSBFREQUENCY_ORIGINAL)
1685 pitch = freq / (ALfloat)This->buffer->format.Format.nSamplesPerSec;
1686
1687 setALContext(This->ctx);
1688 alSourcef(This->source, AL_PITCH, pitch);
1689 getALError();
1690 popALContext();
1691 }
1692 LeaveCriticalSection(This->crst);
1693 return hr;
1694 }
1695
1696 static HRESULT WINAPI DS8Buffer_Stop(IDirectSoundBuffer8 *iface)
1697 {
1698 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1699 ALint state;
1700
1701 TRACE("(%p)->()\n", iface);
1702
1703 EnterCriticalSection(This->crst);
1704 setALContext(This->ctx);
1705
1706 alSourcePause(This->source);
1707 getALError();
1708 /* Mac OS X doesn't immediately report state change
1709 * if Play() is immediately called after Stop, this can be fatal,
1710 * the buffer would never be restarted
1711 */
1712 do {
1713 state = AL_PAUSED;
1714 alGetSourcei(This->source, AL_SOURCE_STATE, &state);
1715 if(state != AL_PLAYING)
1716 break;
1717 Sleep(1);
1718 } while(1);
1719
1720 /* Stopped, remove from notify list */
1721 if(This->nnotify)
1722 {
1723 HRESULT hr;
1724 DWORD pos = This->lastpos;
1725 hr = IDirectSoundBuffer8_GetCurrentPosition(iface, &pos, NULL);
1726 if(FAILED(hr))
1727 ERR("Own getcurrentposition failed!\n");
1728 trigger_notifies(This, This->lastpos, pos, TRUE);
1729 This->lastpos = pos;
1730 DS8Buffer_removenotify(This);
1731 }
1732
1733 This->isplaying = FALSE;
1734
1735 popALContext();
1736 LeaveCriticalSection(This->crst);
1737
1738 return S_OK;
1739 }
1740
1741 static HRESULT WINAPI DS8Buffer_Unlock(IDirectSoundBuffer8 *iface, void *ptr1, DWORD len1, void *ptr2, DWORD len2)
1742 {
1743 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1744 DS8Data *buf = This->buffer;
1745 DWORD bufsize = buf->buf_size;
1746 DWORD_PTR ofs1, ofs2;
1747 DWORD_PTR boundary = (DWORD_PTR)buf->data;
1748 HRESULT hr;
1749
1750 TRACE("(%p)->(%p, %u, %p, %u)\n", iface, ptr1, len1, ptr2, len2);
1751
1752 EnterCriticalSection(This->crst);
1753 setALContext(This->ctx);
1754
1755 This->buffer->locked = 0;
1756 hr = DSERR_INVALIDPARAM;
1757
1758 /* Make sure offset is between boundary and boundary + bufsize */
1759 ofs1 = (DWORD_PTR)ptr1;
1760 ofs2 = (DWORD_PTR)ptr2;
1761 if(ofs1 < boundary)
1762 goto out;
1763 if(ofs2 && ofs2 != boundary)
1764 goto out;
1765 ofs1 -= boundary;
1766 ofs2 = 0;
1767 if(bufsize-ofs1 < len1 || len2 > ofs1)
1768 goto out;
1769 if(!ptr2)
1770 len2 = 0;
1771
1772 hr = S_OK;
1773 if(!len1 && !len2)
1774 goto out;
1775
1776 if(This->ExtAL->BufferDataStatic)
1777 goto out;
1778
1779 if(This->ExtAL->BufferSubSamplesSOFT)
1780 {
1781 WAVEFORMATEX *format = &buf->format.Format;
1782
1783 ptr1 = (BYTE*)ptr1 - (ofs1%format->nBlockAlign);
1784 ofs1 /= format->nBlockAlign;
1785 len1 /= format->nBlockAlign;
1786 if(len1 > 0)
1787 This->ExtAL->BufferSubSamplesSOFT(buf->buffers[0], ofs1, len1,
1788 buf->in_chans, buf->in_type, ptr1);
1789 ptr2 = (BYTE*)ptr2 - (ofs2%format->nBlockAlign);
1790 ofs2 /= format->nBlockAlign;
1791 len2 /= format->nBlockAlign;
1792 if(len2 > 0)
1793 This->ExtAL->BufferSubSamplesSOFT(buf->buffers[0], ofs2, len2,
1794 buf->in_chans, buf->in_type, ptr2);
1795 getALError();
1796 }
1797 else if(This->ExtAL->BufferSubData)
1798 {
1799 WAVEFORMATEX *format = &buf->format.Format;
1800
1801 len1 -= len1%format->nBlockAlign;
1802 if(len1 > 0)
1803 This->ExtAL->BufferSubData(buf->buffers[0], buf->buf_format, ptr1,
1804 ofs1, len1);
1805 len2 -= len2%format->nBlockAlign;
1806 if(len2 > 0)
1807 This->ExtAL->BufferSubData(buf->buffers[0], buf->buf_format, ptr2,
1808 ofs2, len2);
1809 getALError();
1810 }
1811 else
1812 {
1813 alBufferData(buf->buffers[0], buf->buf_format,
1814 buf->data, buf->buf_size,
1815 buf->format.Format.nSamplesPerSec);
1816 getALError();
1817 }
1818
1819 out:
1820 if(hr != S_OK)
1821 WARN("Invalid parameters (0x%lx,%u) (%p,%u,%p,%u)\n", boundary, bufsize, ptr1, len1, ptr2, len2);
1822 popALContext();
1823 LeaveCriticalSection(This->crst);
1824 return hr;
1825 }
1826
1827 static HRESULT WINAPI DS8Buffer_Restore(IDirectSoundBuffer8 *iface)
1828 {
1829 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1830 HRESULT hr;
1831
1832 TRACE("(%p)->()\n", iface);
1833
1834 EnterCriticalSection(This->crst);
1835 if(This->primary->parent->prio_level < DSSCL_WRITEPRIMARY ||
1836 iface == This->primary->write_emu)
1837 {
1838 This->bufferlost = 0;
1839 hr = S_OK;
1840 }
1841 else
1842 hr = DSERR_BUFFERLOST;
1843 LeaveCriticalSection(This->crst);
1844
1845 return hr;
1846 }
1847
1848 static HRESULT WINAPI DS8Buffer_SetFX(IDirectSoundBuffer8 *iface, DWORD fxcount, DSEFFECTDESC *desc, DWORD *rescodes)
1849 {
1850 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1851 DWORD i;
1852
1853 TRACE("(%p)->(%u, %p, %p)\n", This, fxcount, desc, rescodes);
1854
1855 if(!(This->buffer->dsbflags&DSBCAPS_CTRLFX))
1856 {
1857 WARN("FX control not set\n");
1858 return DSERR_CONTROLUNAVAIL;
1859 }
1860
1861 if(fxcount == 0)
1862 {
1863 if(desc || rescodes)
1864 {
1865 WARN("Non-NULL desc and/or result pointer specified with no effects.\n");
1866 return DSERR_INVALIDPARAM;
1867 }
1868
1869 /* No effects; we can handle that */
1870 return DS_OK;
1871 }
1872
1873 if(!desc || !rescodes)
1874 {
1875 WARN("NULL desc and/or result pointer specified.\n");
1876 return DSERR_INVALIDPARAM;
1877 }
1878
1879 /* We don't (currently) handle DSound effects */
1880 for(i = 0;i < fxcount;++i)
1881 {
1882 FIXME("Cannot handle effect: %s\n", debugstr_guid(&desc[i].guidDSFXClass));
1883 rescodes[i] = DSFXR_FAILED;
1884 }
1885
1886 return DSERR_INVALIDPARAM;
1887 }
1888
1889 static HRESULT WINAPI DS8Buffer_AcquireResources(IDirectSoundBuffer8 *iface, DWORD flags, DWORD fxcount, DWORD *rescodes)
1890 {
1891 DS8Buffer *This = impl_from_IDirectSoundBuffer8(iface);
1892
1893 TRACE("(%p)->(%u, %u, %p)\n", This, flags, fxcount, rescodes);
1894
1895 /* effects aren't supported at the moment.. */
1896 if(fxcount != 0 || rescodes)
1897 {
1898 WARN("Non-zero effect count and/or result pointer specified with no effects.\n");
1899 return DSERR_INVALIDPARAM;
1900 }
1901
1902 EnterCriticalSection(This->crst);
1903 if((This->buffer->dsbflags&DSBCAPS_LOCDEFER))
1904 {
1905 This->buffer->dsbflags &= ~(DSBCAPS_LOCSOFTWARE|DSBCAPS_LOCHARDWARE);
1906 if((flags&DSBPLAY_LOCSOFTWARE))
1907 This->buffer->dsbflags |= DSBCAPS_LOCSOFTWARE;
1908 else
1909 This->buffer->dsbflags |= DSBCAPS_LOCHARDWARE;
1910 }
1911 LeaveCriticalSection(This->crst);
1912
1913 return S_OK;
1914 }
1915
1916 static HRESULT WINAPI DS8Buffer_GetObjectInPath(IDirectSoundBuffer8 *iface, REFGUID guid, DWORD idx, REFGUID rguidiface, void **ppv)
1917 {
1918 FIXME("(%p)->(%s, %u, %s, %p) : stub!\n", iface, debugstr_guid(guid), idx, debugstr_guid(rguidiface), ppv);
1919 return E_NOTIMPL;
1920 }
1921
1922 static const IDirectSoundBuffer8Vtbl DS8Buffer_Vtbl =
1923 {
1924 DS8Buffer_QueryInterface,
1925 DS8Buffer_AddRef,
1926 DS8Buffer_Release,
1927 DS8Buffer_GetCaps,
1928 DS8Buffer_GetCurrentPosition,
1929 DS8Buffer_GetFormat,
1930 DS8Buffer_GetVolume,
1931 DS8Buffer_GetPan,
1932 DS8Buffer_GetFrequency,
1933 DS8Buffer_GetStatus,
1934 DS8Buffer_Initialize,
1935 DS8Buffer_Lock,
1936 DS8Buffer_Play,
1937 DS8Buffer_SetCurrentPosition,
1938 DS8Buffer_SetFormat,
1939 DS8Buffer_SetVolume,
1940 DS8Buffer_SetPan,
1941 DS8Buffer_SetFrequency,
1942 DS8Buffer_Stop,
1943 DS8Buffer_Unlock,
1944 DS8Buffer_Restore,
1945 DS8Buffer_SetFX,
1946 DS8Buffer_AcquireResources,
1947 DS8Buffer_GetObjectInPath
1948 };
1949
1950 static inline DS8Buffer *impl_from_IDirectSound3DBuffer(IDirectSound3DBuffer *iface)
1951 {
1952 return CONTAINING_RECORD(iface, DS8Buffer, IDirectSound3DBuffer_iface);
1953 }
1954
1955 static HRESULT WINAPI DS8Buffer3D_QueryInterface(IDirectSound3DBuffer *iface, REFIID riid, void **ppv)
1956 {
1957 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
1958 return IDirectSoundBuffer8_QueryInterface(&This->IDirectSoundBuffer8_iface, riid, ppv);
1959 }
1960
1961 static ULONG WINAPI DS8Buffer3D_AddRef(IDirectSound3DBuffer *iface)
1962 {
1963 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
1964 LONG ret;
1965
1966 InterlockedIncrement(&This->all_ref);
1967 ret = InterlockedIncrement(&This->ds3d_ref);
1968 TRACE("new refcount %d\n", ret);
1969
1970 return ret;
1971 }
1972
1973 static ULONG WINAPI DS8Buffer3D_Release(IDirectSound3DBuffer *iface)
1974 {
1975 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
1976 LONG ret;
1977
1978 ret = InterlockedDecrement(&This->ds3d_ref);
1979 TRACE("new refcount %d\n", ret);
1980 if(InterlockedDecrement(&This->all_ref) == 0)
1981 DS8Buffer_Destroy(This);
1982
1983 return ret;
1984 }
1985
1986 static HRESULT WINAPI DS8Buffer3D_GetAllParameters(IDirectSound3DBuffer *iface, DS3DBUFFER *ds3dbuffer)
1987 {
1988 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
1989 DS3DBUFFER ds3dbuf;
1990 HRESULT hr;
1991
1992 TRACE("%p\n", This);
1993
1994 if(!ds3dbuffer || ds3dbuffer->dwSize < sizeof(*ds3dbuffer))
1995 {
1996 WARN("Invalid parameters %p %u\n", ds3dbuffer, ds3dbuffer ? ds3dbuffer->dwSize : 0);
1997 return DSERR_INVALIDPARAM;
1998 }
1999 ds3dbuf.dwSize = sizeof(ds3dbuf);
2000
2001 EnterCriticalSection(This->crst);
2002 setALContext(This->ctx);
2003
2004 hr = IDirectSound3DBuffer_GetPosition(iface, &ds3dbuf.vPosition);
2005 if(SUCCEEDED(hr))
2006 hr = IDirectSound3DBuffer_GetVelocity(iface, &ds3dbuf.vVelocity);
2007 if(SUCCEEDED(hr))
2008 hr = IDirectSound3DBuffer_GetConeAngles(iface, &ds3dbuf.dwInsideConeAngle, &ds3dbuf.dwOutsideConeAngle);
2009 if(SUCCEEDED(hr))
2010 hr = IDirectSound3DBuffer_GetConeOrientation(iface, &ds3dbuf.vConeOrientation);
2011 if(SUCCEEDED(hr))
2012 hr = IDirectSound3DBuffer_GetConeOutsideVolume(iface, &ds3dbuf.lConeOutsideVolume);
2013 if(SUCCEEDED(hr))
2014 hr = IDirectSound3DBuffer_GetMinDistance(iface, &ds3dbuf.flMinDistance);
2015 if(SUCCEEDED(hr))
2016 hr = IDirectSound3DBuffer_GetMaxDistance(iface, &ds3dbuf.flMaxDistance);
2017 if(SUCCEEDED(hr))
2018 hr = IDirectSound3DBuffer_GetMode(iface, &ds3dbuf.dwMode);
2019 if(SUCCEEDED(hr))
2020 memcpy(ds3dbuffer, &ds3dbuf, sizeof(ds3dbuf));
2021
2022 popALContext();
2023 LeaveCriticalSection(This->crst);
2024
2025 return hr;
2026 }
2027
2028 static HRESULT WINAPI DS8Buffer3D_GetConeAngles(IDirectSound3DBuffer *iface, DWORD *pdwInsideConeAngle, DWORD *pdwOutsideConeAngle)
2029 {
2030 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2031 ALint inangle, outangle;
2032
2033 TRACE("(%p)->(%p, %p)\n", This, pdwInsideConeAngle, pdwOutsideConeAngle);
2034 if(!pdwInsideConeAngle || !pdwOutsideConeAngle)
2035 {
2036 WARN("Invalid pointers (%p, %p)\n", pdwInsideConeAngle, pdwOutsideConeAngle);
2037 return DSERR_INVALIDPARAM;
2038 }
2039
2040 EnterCriticalSection(This->crst);
2041 setALContext(This->ctx);
2042
2043 alGetSourcei(This->source, AL_CONE_INNER_ANGLE, &inangle);
2044 alGetSourcei(This->source, AL_CONE_OUTER_ANGLE, &outangle);
2045 getALError();
2046 *pdwInsideConeAngle = inangle;
2047 *pdwOutsideConeAngle = outangle;
2048
2049 popALContext();
2050 LeaveCriticalSection(This->crst);
2051
2052 return S_OK;
2053 }
2054
2055 static HRESULT WINAPI DS8Buffer3D_GetConeOrientation(IDirectSound3DBuffer *iface, D3DVECTOR *orient)
2056 {
2057 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2058 ALfloat dir[3];
2059
2060 TRACE("(%p)->(%p)\n", This, orient);
2061 if(!orient)
2062 {
2063 WARN("Invalid pointer\n");
2064 return DSERR_INVALIDPARAM;
2065 }
2066
2067 EnterCriticalSection(This->crst);
2068 setALContext(This->ctx);
2069
2070 alGetSourcefv(This->source, AL_DIRECTION, dir);
2071 getALError();
2072 orient->x = dir[0];
2073 orient->y = dir[1];
2074 orient->z = -dir[2];
2075
2076 popALContext();
2077 LeaveCriticalSection(This->crst);
2078
2079 return S_OK;
2080 }
2081
2082 static HRESULT WINAPI DS8Buffer3D_GetConeOutsideVolume(IDirectSound3DBuffer *iface, LONG *vol)
2083 {
2084 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2085 ALfloat gain;
2086
2087 TRACE("(%p)->(%p)\n", This, vol);
2088 if(!vol)
2089 {
2090 WARN("Invalid pointer\n");
2091 return DSERR_INVALIDPARAM;
2092 }
2093
2094 EnterCriticalSection(This->crst);
2095 setALContext(This->ctx);
2096
2097 alGetSourcef(This->source, AL_CONE_OUTER_GAIN, &gain);
2098 getALError();
2099 *vol = gain_to_mB(gain);
2100 *vol = max(*vol, DSBVOLUME_MIN);
2101 *vol = min(*vol, DSBVOLUME_MAX);
2102
2103 popALContext();
2104 LeaveCriticalSection(This->crst);
2105 return S_OK;
2106 }
2107
2108 static HRESULT WINAPI DS8Buffer3D_GetMaxDistance(IDirectSound3DBuffer *iface, D3DVALUE *maxdist)
2109 {
2110 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2111 ALfloat dist;
2112
2113 TRACE("(%p)->(%p)\n", This, maxdist);
2114 if(!maxdist)
2115 {
2116 WARN("Invalid pointer\n");
2117 return DSERR_INVALIDPARAM;
2118 }
2119
2120 EnterCriticalSection(This->crst);
2121 setALContext(This->ctx);
2122
2123 alGetSourcef(This->source, AL_MAX_DISTANCE, &dist);
2124 getALError();
2125 *maxdist = dist;
2126
2127 popALContext();
2128 LeaveCriticalSection(This->crst);
2129
2130 return S_OK;
2131 }
2132
2133 static HRESULT WINAPI DS8Buffer3D_GetMinDistance(IDirectSound3DBuffer *iface, D3DVALUE *mindist)
2134 {
2135 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2136 ALfloat dist;
2137
2138 TRACE("(%p)->(%p)\n", This, mindist);
2139 if(!mindist)
2140 {
2141 WARN("Invalid pointer\n");
2142 return DSERR_INVALIDPARAM;
2143 }
2144
2145 EnterCriticalSection(This->crst);
2146 setALContext(This->ctx);
2147
2148 alGetSourcef(This->source, AL_REFERENCE_DISTANCE, &dist);
2149 getALError();
2150 *mindist = dist;
2151
2152 popALContext();
2153 LeaveCriticalSection(This->crst);
2154
2155 return S_OK;
2156 }
2157
2158 static HRESULT WINAPI DS8Buffer3D_GetMode(IDirectSound3DBuffer *iface, DWORD *mode)
2159 {
2160 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2161
2162 TRACE("(%p)->(%p)\n", This, mode);
2163 if(!mode)
2164 {
2165 WARN("Invalid pointer\n");
2166 return DSERR_INVALIDPARAM;
2167 }
2168
2169 EnterCriticalSection(This->crst);
2170 *mode = This->ds3dmode;
2171 LeaveCriticalSection(This->crst);
2172
2173 return S_OK;
2174 }
2175
2176 static HRESULT WINAPI DS8Buffer3D_GetPosition(IDirectSound3DBuffer *iface, D3DVECTOR *pos)
2177 {
2178 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2179 ALfloat alpos[3];
2180
2181 TRACE("(%p)->(%p)\n", This, pos);
2182 if(!pos)
2183 {
2184 WARN("Invalid pointer\n");
2185 return DSERR_INVALIDPARAM;
2186 }
2187
2188 EnterCriticalSection(This->crst);
2189 setALContext(This->ctx);
2190
2191 alGetSourcefv(This->source, AL_POSITION, alpos);
2192 getALError();
2193 pos->x = alpos[0];
2194 pos->y = alpos[1];
2195 pos->z = -alpos[2];
2196
2197 popALContext();
2198 LeaveCriticalSection(This->crst);
2199
2200 return S_OK;
2201 }
2202
2203 static HRESULT WINAPI DS8Buffer3D_GetVelocity(IDirectSound3DBuffer *iface, D3DVECTOR *vel)
2204 {
2205 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2206 ALfloat alvel[3];
2207
2208 TRACE("(%p)->(%p)\n", This, vel);
2209 if(!vel)
2210 {
2211 WARN("Invalid pointer\n");
2212 return DSERR_INVALIDPARAM;
2213 }
2214
2215 EnterCriticalSection(This->crst);
2216 setALContext(This->ctx);
2217
2218 alGetSourcefv(This->source, AL_VELOCITY, alvel);
2219 getALError();
2220 vel->x = alvel[0];
2221 vel->y = alvel[1];
2222 vel->z = -alvel[2];
2223
2224 popALContext();
2225 LeaveCriticalSection(This->crst);
2226
2227 return S_OK;
2228 }
2229
2230 static HRESULT WINAPI DS8Buffer3D_SetAllParameters(IDirectSound3DBuffer *iface, const DS3DBUFFER *ds3dbuffer, DWORD apply)
2231 {
2232 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2233 TRACE("(%p)->(%p, %u)\n", This, ds3dbuffer, apply);
2234
2235 if(!ds3dbuffer || ds3dbuffer->dwSize < sizeof(*ds3dbuffer))
2236 {
2237 WARN("Invalid DS3DBUFFER (%p, %u)\n", ds3dbuffer, ds3dbuffer ? ds3dbuffer->dwSize : 0);
2238 return DSERR_INVALIDPARAM;
2239 }
2240
2241 if(ds3dbuffer->dwInsideConeAngle > DS3D_MAXCONEANGLE ||
2242 ds3dbuffer->dwOutsideConeAngle > DS3D_MAXCONEANGLE)
2243 {
2244 WARN("Invalid cone angles (%u, %u)\n", ds3dbuffer->dwInsideConeAngle,
2245 ds3dbuffer->dwOutsideConeAngle);
2246 return DSERR_INVALIDPARAM;
2247 }
2248
2249 if(ds3dbuffer->lConeOutsideVolume > DSBVOLUME_MAX ||
2250 ds3dbuffer->lConeOutsideVolume < DSBVOLUME_MIN)
2251 {
2252 WARN("Invalid cone outside volume (%d)\n", ds3dbuffer->lConeOutsideVolume);
2253 return DSERR_INVALIDPARAM;
2254 }
2255
2256 if(ds3dbuffer->flMaxDistance < 0.0f)
2257 {
2258 WARN("Invalid max distance (%f)\n", ds3dbuffer->flMaxDistance);
2259 return DSERR_INVALIDPARAM;
2260 }
2261
2262 if(ds3dbuffer->flMinDistance < 0.0f)
2263 {
2264 WARN("Invalid min distance (%f)\n", ds3dbuffer->flMinDistance);
2265 return DSERR_INVALIDPARAM;
2266 }
2267
2268 if(ds3dbuffer->dwMode != DS3DMODE_NORMAL &&
2269 ds3dbuffer->dwMode != DS3DMODE_HEADRELATIVE &&
2270 ds3dbuffer->dwMode != DS3DMODE_DISABLE)
2271 {
2272 WARN("Invalid mode (%u)\n", ds3dbuffer->dwMode);
2273 return DSERR_INVALIDPARAM;
2274 }
2275
2276 EnterCriticalSection(This->crst);
2277 setALContext(This->ctx);
2278 IDirectSound3DBuffer_SetPosition(iface, ds3dbuffer->vPosition.x, ds3dbuffer->vPosition.y, ds3dbuffer->vPosition.z, apply);
2279 IDirectSound3DBuffer_SetVelocity(iface, ds3dbuffer->vVelocity.x, ds3dbuffer->vVelocity.y, ds3dbuffer->vVelocity.z, apply);
2280 IDirectSound3DBuffer_SetConeAngles(iface, ds3dbuffer->dwInsideConeAngle, ds3dbuffer->dwOutsideConeAngle, apply);
2281 IDirectSound3DBuffer_SetConeOrientation(iface, ds3dbuffer->vConeOrientation.x, ds3dbuffer->vConeOrientation.y, ds3dbuffer->vConeOrientation.z, apply);
2282 IDirectSound3DBuffer_SetConeOutsideVolume(iface, ds3dbuffer->lConeOutsideVolume, apply);
2283 IDirectSound3DBuffer_SetMinDistance(iface, ds3dbuffer->flMinDistance, apply);
2284 IDirectSound3DBuffer_SetMaxDistance(iface, ds3dbuffer->flMaxDistance, apply);
2285 IDirectSound3DBuffer_SetMode(iface, ds3dbuffer->dwMode, apply);
2286 popALContext();
2287 LeaveCriticalSection(This->crst);
2288
2289 return S_OK;
2290 }
2291
2292 static HRESULT WINAPI DS8Buffer3D_SetConeAngles(IDirectSound3DBuffer *iface, DWORD dwInsideConeAngle, DWORD dwOutsideConeAngle, DWORD apply)
2293 {
2294 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2295
2296 TRACE("(%p)->(%u, %u, %u)\n", This, dwInsideConeAngle, dwOutsideConeAngle, apply);
2297 if(dwInsideConeAngle > DS3D_MAXCONEANGLE ||
2298 dwOutsideConeAngle > DS3D_MAXCONEANGLE)
2299 {
2300 WARN("Invalid cone angles (%u, %u)\n", dwInsideConeAngle, dwOutsideConeAngle);
2301 return DSERR_INVALIDPARAM;
2302 }
2303
2304 EnterCriticalSection(This->crst);
2305 if(apply == DS3D_DEFERRED)
2306 {
2307 This->ds3dbuffer.dwInsideConeAngle = dwInsideConeAngle;
2308 This->ds3dbuffer.dwOutsideConeAngle = dwOutsideConeAngle;
2309 This->dirty.bit.cone_angles = 1;
2310 }
2311 else
2312 {
2313 setALContext(This->ctx);
2314 alSourcei(This->source, AL_CONE_INNER_ANGLE, dwInsideConeAngle);
2315 alSourcei(This->source, AL_CONE_OUTER_ANGLE, dwOutsideConeAngle);
2316 getALError();
2317 popALContext();
2318 }
2319 LeaveCriticalSection(This->crst);
2320
2321 return S_OK;
2322 }
2323
2324 static HRESULT WINAPI DS8Buffer3D_SetConeOrientation(IDirectSound3DBuffer *iface, D3DVALUE x, D3DVALUE y, D3DVALUE z, DWORD apply)
2325 {
2326 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2327
2328 TRACE("(%p)->(%f, %f, %f, %u)\n", This, x, y, z, apply);
2329
2330 EnterCriticalSection(This->crst);
2331 if(apply == DS3D_DEFERRED)
2332 {
2333 This->ds3dbuffer.vConeOrientation.x = x;
2334 This->ds3dbuffer.vConeOrientation.y = y;
2335 This->ds3dbuffer.vConeOrientation.z = z;
2336 This->dirty.bit.cone_orient = 1;
2337 }
2338 else
2339 {
2340 setALContext(This->ctx);
2341 alSource3f(This->source, AL_DIRECTION, x, y, -z);
2342 getALError();
2343 popALContext();
2344 }
2345 LeaveCriticalSection(This->crst);
2346
2347 return S_OK;
2348 }
2349
2350 static HRESULT WINAPI DS8Buffer3D_SetConeOutsideVolume(IDirectSound3DBuffer *iface, LONG vol, DWORD apply)
2351 {
2352 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2353
2354 TRACE("(%p)->(%u, %u)\n", This, vol, apply);
2355 if(vol < DSBVOLUME_MIN || vol > DSBVOLUME_MAX)
2356 {
2357 WARN("Invalid volume (%u)\n", vol);
2358 return DSERR_INVALIDPARAM;
2359 }
2360
2361 EnterCriticalSection(This->crst);
2362 if(apply == DS3D_DEFERRED)
2363 {
2364 This->ds3dbuffer.lConeOutsideVolume = vol;
2365 This->dirty.bit.cone_outsidevolume = 1;
2366 }
2367 else
2368 {
2369 setALContext(This->ctx);
2370 alSourcef(This->source, AL_CONE_OUTER_GAIN, mB_to_gain(vol));
2371 getALError();
2372 popALContext();
2373 }
2374 LeaveCriticalSection(This->crst);
2375
2376 return S_OK;
2377 }
2378
2379 static HRESULT WINAPI DS8Buffer3D_SetMaxDistance(IDirectSound3DBuffer *iface, D3DVALUE maxdist, DWORD apply)
2380 {
2381 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2382
2383 TRACE("(%p)->(%f, %u)\n", This, maxdist, apply);
2384 if(maxdist < 0.0f)
2385 {
2386 WARN("Invalid max distance (%f)\n", maxdist);
2387 return DSERR_INVALIDPARAM;
2388 }
2389
2390 EnterCriticalSection(This->crst);
2391 if(apply == DS3D_DEFERRED)
2392 {
2393 This->ds3dbuffer.flMaxDistance = maxdist;
2394 This->dirty.bit.max_distance = 1;
2395 }
2396 else
2397 {
2398 setALContext(This->ctx);
2399 alSourcef(This->source, AL_MAX_DISTANCE, maxdist);
2400 getALError();
2401 popALContext();
2402 }
2403 LeaveCriticalSection(This->crst);
2404
2405 return S_OK;
2406 }
2407
2408 static HRESULT WINAPI DS8Buffer3D_SetMinDistance(IDirectSound3DBuffer *iface, D3DVALUE mindist, DWORD apply)
2409 {
2410 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2411
2412 TRACE("(%p)->(%f, %u)\n", This, mindist, apply);
2413 if(mindist < 0.0f)
2414 {
2415 WARN("Invalid min distance (%f)\n", mindist);
2416 return DSERR_INVALIDPARAM;
2417 }
2418
2419 EnterCriticalSection(This->crst);
2420 if(apply == DS3D_DEFERRED)
2421 {
2422 This->ds3dbuffer.flMinDistance = mindist;
2423 This->dirty.bit.min_distance = 1;
2424 }
2425 else
2426 {
2427 setALContext(This->ctx);
2428 alSourcef(This->source, AL_REFERENCE_DISTANCE, mindist);
2429 getALError();
2430 popALContext();
2431 }
2432 LeaveCriticalSection(This->crst);
2433
2434 return S_OK;
2435 }
2436
2437 static HRESULT WINAPI DS8Buffer3D_SetMode(IDirectSound3DBuffer *iface, DWORD mode, DWORD apply)
2438 {
2439 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2440
2441 TRACE("(%p)->(%u, %u)\n", This, mode, apply);
2442 if(mode != DS3DMODE_NORMAL && mode != DS3DMODE_HEADRELATIVE &&
2443 mode != DS3DMODE_DISABLE)
2444 {
2445 WARN("Invalid mode (%u)\n", mode);
2446 return DSERR_INVALIDPARAM;
2447 }
2448
2449 EnterCriticalSection(This->crst);
2450 if(apply == DS3D_DEFERRED)
2451 {
2452 This->ds3dbuffer.dwMode = mode;
2453 This->dirty.bit.mode = 1;
2454 }
2455 else
2456 {
2457 setALContext(This->ctx);
2458 alSourcei(This->source, AL_SOURCE_RELATIVE,
2459 (mode != DS3DMODE_NORMAL) ? AL_TRUE : AL_FALSE);
2460 alSourcef(This->source, AL_ROLLOFF_FACTOR,
2461 (mode == DS3DMODE_DISABLE) ? 0.0f : This->primary->rollofffactor);
2462 This->ds3dmode = mode;
2463 getALError();
2464 popALContext();
2465 }
2466 LeaveCriticalSection(This->crst);
2467
2468 return S_OK;
2469 }
2470
2471 static HRESULT WINAPI DS8Buffer3D_SetPosition(IDirectSound3DBuffer *iface, D3DVALUE x, D3DVALUE y, D3DVALUE z, DWORD apply)
2472 {
2473 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2474
2475 TRACE("(%p)->(%f, %f, %f, %u)\n", This, x, y, z, apply);
2476
2477 EnterCriticalSection(This->crst);
2478 if(apply == DS3D_DEFERRED)
2479 {
2480 This->ds3dbuffer.vPosition.x = x;
2481 This->ds3dbuffer.vPosition.y = y;
2482 This->ds3dbuffer.vPosition.z = z;
2483 This->dirty.bit.pos = 1;
2484 }
2485 else
2486 {
2487 setALContext(This->ctx);
2488 alSource3f(This->source, AL_POSITION, x, y, -z);
2489 getALError();
2490 popALContext();
2491 }
2492 LeaveCriticalSection(This->crst);
2493
2494 return S_OK;
2495 }
2496
2497 static HRESULT WINAPI DS8Buffer3D_SetVelocity(IDirectSound3DBuffer *iface, D3DVALUE x, D3DVALUE y, D3DVALUE z, DWORD apply)
2498 {
2499 DS8Buffer *This = impl_from_IDirectSound3DBuffer(iface);
2500
2501 TRACE("(%p)->(%f, %f, %f, %u)\n", This, x, y, z, apply);
2502
2503 EnterCriticalSection(This->crst);
2504 if(apply == DS3D_DEFERRED)
2505 {
2506 This->ds3dbuffer.vVelocity.x = x;
2507 This->ds3dbuffer.vVelocity.y = y;
2508 This->ds3dbuffer.vVelocity.z = z;
2509 This->dirty.bit.vel = 1;
2510 }
2511 else
2512 {
2513 setALContext(This->ctx);
2514 alSource3f(This->source, AL_VELOCITY, x, y, -z);
2515 getALError();
2516 popALContext();
2517 }
2518 LeaveCriticalSection(This->crst);
2519
2520 return S_OK;
2521 }
2522
2523 static const IDirectSound3DBufferVtbl DS8Buffer3d_Vtbl =
2524 {
2525 DS8Buffer3D_QueryInterface,
2526 DS8Buffer3D_AddRef,
2527 DS8Buffer3D_Release,
2528 DS8Buffer3D_GetAllParameters,
2529 DS8Buffer3D_GetConeAngles,
2530 DS8Buffer3D_GetConeOrientation,
2531 DS8Buffer3D_GetConeOutsideVolume,
2532 DS8Buffer3D_GetMaxDistance,
2533 DS8Buffer3D_GetMinDistance,
2534 DS8Buffer3D_GetMode,
2535 DS8Buffer3D_GetPosition,
2536 DS8Buffer3D_GetVelocity,
2537 DS8Buffer3D_SetAllParameters,
2538 DS8Buffer3D_SetConeAngles,
2539 DS8Buffer3D_SetConeOrientation,
2540 DS8Buffer3D_SetConeOutsideVolume,
2541 DS8Buffer3D_SetMaxDistance,
2542 DS8Buffer3D_SetMinDistance,
2543 DS8Buffer3D_SetMode,
2544 DS8Buffer3D_SetPosition,
2545 DS8Buffer3D_SetVelocity
2546 };
2547
2548 static inline DS8Buffer *impl_from_IDirectSoundNotify(IDirectSoundNotify *iface)
2549 {
2550 return CONTAINING_RECORD(iface, DS8Buffer, IDirectSoundNotify_iface);
2551 }
2552
2553 static HRESULT WINAPI DS8BufferNot_QueryInterface(IDirectSoundNotify *iface, REFIID riid, void **ppv)
2554 {
2555 DS8Buffer *This = impl_from_IDirectSoundNotify(iface);
2556 return IDirectSoundBuffer8_QueryInterface(&This->IDirectSoundBuffer8_iface, riid, ppv);
2557 }
2558
2559 static ULONG WINAPI DS8BufferNot_AddRef(IDirectSoundNotify *iface)
2560 {
2561 DS8Buffer *This = impl_from_IDirectSoundNotify(iface);
2562 LONG ret;
2563
2564 InterlockedIncrement(&This->all_ref);
2565 ret = InterlockedIncrement(&This->not_ref);
2566 TRACE("new refcount %d\n", ret);
2567
2568 return ret;
2569 }
2570
2571 static ULONG WINAPI DS8BufferNot_Release(IDirectSoundNotify *iface)
2572 {
2573 DS8Buffer *This = impl_from_IDirectSoundNotify(iface);
2574 LONG ret;
2575
2576 ret = InterlockedDecrement(&This->not_ref);
2577 TRACE("new refcount %d\n", ret);
2578 if(InterlockedDecrement(&This->all_ref) == 0)
2579 DS8Buffer_Destroy(This);
2580
2581 return ret;
2582 }
2583
2584 static HRESULT WINAPI DS8BufferNot_SetNotificationPositions(IDirectSoundNotify *iface, DWORD count, const DSBPOSITIONNOTIFY *notifications)
2585 {
2586 DS8Buffer *This = impl_from_IDirectSoundNotify(iface);
2587 DSBPOSITIONNOTIFY *nots;
2588 DWORD state;
2589 HRESULT hr;
2590
2591 EnterCriticalSection(This->crst);
2592 hr = DSERR_INVALIDPARAM;
2593 if(count && !notifications)
2594 goto out;
2595
2596 hr = IDirectSoundBuffer8_GetStatus(&This->IDirectSoundBuffer8_iface, &state);
2597 if(FAILED(hr))
2598 goto out;
2599
2600 hr = DSERR_INVALIDCALL;
2601 if((state&DSBSTATUS_PLAYING))
2602 goto out;
2603
2604 if(!count)
2605 {
2606 HeapFree(GetProcessHeap(), 0, This->notify);
2607 This->notify = 0;
2608 This->nnotify = 0;
2609 hr = S_OK;
2610 }
2611 else
2612 {
2613 DWORD i;
2614
2615 hr = DSERR_INVALIDPARAM;
2616 for(i = 0;i < count;++i)
2617 {
2618 if(notifications[i].dwOffset >= This->buffer->buf_size &&
2619 notifications[i].dwOffset != (DWORD)DSBPN_OFFSETSTOP)
2620 goto out;
2621 }
2622
2623 hr = E_OUTOFMEMORY;
2624 nots = HeapAlloc(GetProcessHeap(), 0, count*sizeof(*nots));
2625 if(!nots)
2626 goto out;
2627 memcpy(nots, notifications, count*sizeof(*nots));
2628
2629 HeapFree(GetProcessHeap(), 0, This->notify);
2630 This->notify = nots;
2631 This->nnotify = count;
2632
2633 hr = S_OK;
2634 }
2635
2636 out:
2637 LeaveCriticalSection(This->crst);
2638 return hr;
2639 }
2640
2641 static const IDirectSoundNotifyVtbl DS8BufferNot_Vtbl =
2642 {
2643 DS8BufferNot_QueryInterface,
2644 DS8BufferNot_AddRef,
2645 DS8BufferNot_Release,
2646 DS8BufferNot_SetNotificationPositions
2647 };
2648
2649 /* NOTE: Due to some apparent quirks in DSound, the listener properties are
2650 handled through secondary buffers. */
2651 static inline DS8Buffer *impl_from_IKsPropertySet(IKsPropertySet *iface)
2652 {
2653 return CONTAINING_RECORD(iface, DS8Buffer, IKsPropertySet_iface);
2654 }
2655
2656 static HRESULT WINAPI DS8BufferProp_QueryInterface(IKsPropertySet *iface, REFIID riid, void **ppv)
2657 {
2658 DS8Buffer *This = impl_from_IKsPropertySet(iface);
2659 return IDirectSoundBuffer8_QueryInterface(&This->IDirectSoundBuffer8_iface, riid, ppv);
2660 }
2661
2662 static ULONG WINAPI DS8BufferProp_AddRef(IKsPropertySet *iface)
2663 {
2664 DS8Buffer *This = impl_from_IKsPropertySet(iface);
2665 LONG ret;
2666
2667 InterlockedIncrement(&This->all_ref);
2668 ret = InterlockedIncrement(&This->prop_ref);
2669 TRACE("new refcount %d\n", ret);
2670
2671 return ret;
2672 }
2673
2674 static ULONG WINAPI DS8BufferProp_Release(IKsPropertySet *iface)
2675 {
2676 DS8Buffer *This = impl_from_IKsPropertySet(iface);
2677 LONG ret;
2678
2679 ret = InterlockedDecrement(&This->prop_ref);
2680 TRACE("new refcount %d\n", ret);
2681 if(InterlockedDecrement(&This->all_ref) == 0)
2682 DS8Buffer_Destroy(This);
2683
2684 return ret;
2685 }
2686
2687 static HRESULT WINAPI DS8BufferProp_Get(IKsPropertySet *iface,
2688 REFGUID guidPropSet, ULONG dwPropID,
2689 LPVOID pInstanceData, ULONG cbInstanceData,
2690 LPVOID pPropData, ULONG cbPropData,
2691 PULONG pcbReturned)
2692 {
2693 DS8Buffer *This = impl_from_IKsPropertySet(iface);
2694 HRESULT hr = E_PROP_ID_UNSUPPORTED;
2695
2696 TRACE("(%p)->(%s, %u, %p, %u, %p, %u, %p)\n", iface, debugstr_guid(guidPropSet),
2697 dwPropID, pInstanceData, cbInstanceData, pPropData, cbPropData, pcbReturned);
2698
2699 if(!pcbReturned)
2700 return E_POINTER;
2701 *pcbReturned = 0;
2702
2703 #if 0
2704 if(IsEqualIID(guidPropSet, &DSPROPSETID_EAX20_BufferProperties))
2705 {
2706 }
2707 else
2708 #endif
2709 {
2710 /* Not a known buffer/source property. Pass it to the listener */
2711 hr = IKsPropertySet_Get(&This->primary->IKsPropertySet_iface, guidPropSet,
2712 dwPropID, pInstanceData, cbInstanceData, pPropData, cbPropData,
2713 pcbReturned);
2714 }
2715
2716 return hr;
2717 }
2718
2719 static HRESULT WINAPI DS8BufferProp_Set(IKsPropertySet *iface,
2720 REFGUID guidPropSet, ULONG dwPropID,
2721 LPVOID pInstanceData, ULONG cbInstanceData,
2722 LPVOID pPropData, ULONG cbPropData)
2723 {
2724 DS8Buffer *This = impl_from_IKsPropertySet(iface);
2725 HRESULT hr = E_PROP_ID_UNSUPPORTED;
2726
2727 TRACE("(%p)->(%s, %u, %p, %u, %p, %u)\n", iface, debugstr_guid(guidPropSet),
2728 dwPropID, pInstanceData, cbInstanceData, pPropData, cbPropData);
2729
2730 #if 0
2731 if(IsEqualIID(guidPropSet, &DSPROPSETID_EAX20_BufferProperties))
2732 {
2733 }
2734 else
2735 #endif
2736 {
2737 /* Not a known buffer/source property. Pass it to the listener */
2738 hr = IKsPropertySet_Set(&This->primary->IKsPropertySet_iface, guidPropSet,
2739 dwPropID, pInstanceData, cbInstanceData, pPropData,
2740 cbPropData);
2741 }
2742
2743 return hr;
2744 }
2745
2746 static HRESULT WINAPI DS8BufferProp_QuerySupport(IKsPropertySet *iface,
2747 REFGUID guidPropSet, ULONG dwPropID,
2748 PULONG pTypeSupport)
2749 {
2750 DS8Buffer *This = impl_from_IKsPropertySet(iface);
2751 HRESULT hr = E_PROP_ID_UNSUPPORTED;
2752
2753 TRACE("(%p)->(%s, %u, %p)\n", iface, debugstr_guid(guidPropSet), dwPropID, pTypeSupport);
2754
2755 if(!pTypeSupport)
2756 return E_POINTER;
2757 *pTypeSupport = 0;
2758
2759 #if 0
2760 if(IsEqualIID(guidPropSet, &DSPROPSETID_EAX20_BufferProperties))
2761 {
2762 }
2763 else
2764 #endif
2765 {
2766 /* Not a known buffer/source property. Pass it to the listener */
2767 hr = IKsPropertySet_QuerySupport(&This->primary->IKsPropertySet_iface,
2768 guidPropSet, dwPropID, pTypeSupport);
2769 }
2770
2771 return hr;
2772 }
2773
2774 static const IKsPropertySetVtbl DS8BufferProp_Vtbl =
2775 {
2776 DS8BufferProp_QueryInterface,
2777 DS8BufferProp_AddRef,
2778 DS8BufferProp_Release,
2779 DS8BufferProp_Get,
2780 DS8BufferProp_Set,
2781 DS8BufferProp_QuerySupport
2782 };
A DirectSound wrapper for OpenAL