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