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