kernel32/tests: Sparc fixes.
[wine] / dlls / dsound / sound3d.c
1 /*                      DirectSound
2  *
3  * Copyright 1998 Marcus Meissner
4  * Copyright 1998 Rob Riggs
5  * Copyright 2000-2001 TransGaming Technologies, Inc.
6  * Copyright 2002-2003 Rok Mandeljc <rok.mandeljc@gimb.org>
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  * Most thread locking is complete. There may be a few race
24  * conditions still lurking.
25  *
26  * Tested with a Soundblaster clone, a Gravis UltraSound Classic,
27  * and a Turtle Beach Tropez+.
28  *
29  * TODO:
30  *      Implement SetCooperativeLevel properly (need to address focus issues)
31  *      Implement DirectSound3DBuffers (stubs in place)
32  *      Use hardware 3D support if available
33  *      Add critical section locking inside Release and AddRef methods
34  *      Handle static buffers - put those in hardware, non-static not in hardware
35  *      Hardware DuplicateSoundBuffer
36  *      Proper volume calculation, and setting volume in HEL primary buffer
37  *      Optimize WINMM and negotiate fragment size, decrease DS_HEL_MARGIN
38  */
39
40 #include <stdarg.h>
41 #include <math.h>       /* Insomnia - pow() function */
42
43 #define NONAMELESSUNION
44 #define NONAMELESSSTRUCT
45 #include "windef.h"
46 #include "winbase.h"
47 #include "winuser.h"
48 #include "mmsystem.h"
49 #include "winternl.h"
50 #include "mmddk.h"
51 #include "wine/debug.h"
52 #include "dsound.h"
53 #include "dsdriver.h"
54 #include "dsound_private.h"
55
56 /* default velocity of sound in the air */
57 #define DEFAULT_VELOCITY 340
58
59 WINE_DEFAULT_DEBUG_CHANNEL(dsound3d);
60
61 /*******************************************************************************
62  *              Auxiliary functions
63  */
64
65 /* scalar product (i believe it's called dot product in english) */
66 static inline D3DVALUE ScalarProduct (const D3DVECTOR *a, const D3DVECTOR *b)
67 {
68         D3DVALUE c;
69         c = (a->x*b->x) + (a->y*b->y) + (a->z*b->z);
70         TRACE("(%f,%f,%f) * (%f,%f,%f) = %f)\n", a->x, a->y, a->z, b->x, b->y,
71               b->z, c);
72         return c;
73 }
74
75 /* vector product (i believe it's called cross product in english */
76 static inline D3DVECTOR VectorProduct (const D3DVECTOR *a, const D3DVECTOR *b)
77 {
78         D3DVECTOR c;
79         c.x = (a->y*b->z) - (a->z*b->y);
80         c.y = (a->z*b->x) - (a->x*b->z);
81         c.z = (a->x*b->y) - (a->y*b->x);
82         TRACE("(%f,%f,%f) x (%f,%f,%f) = (%f,%f,%f)\n", a->x, a->y, a->z, b->x, b->y,
83               b->z, c.x, c.y, c.z);
84         return c;
85 }
86
87 /* magnitude (length) of vector */
88 static inline D3DVALUE VectorMagnitude (const D3DVECTOR *a)
89 {
90         D3DVALUE l;
91         l = sqrt (ScalarProduct (a, a));
92         TRACE("|(%f,%f,%f)| = %f\n", a->x, a->y, a->z, l);
93         return l;
94 }
95
96 /* conversion between radians and degrees */
97 static inline D3DVALUE RadToDeg (D3DVALUE angle)
98 {
99         D3DVALUE newangle;
100         newangle = angle * (360/(2*M_PI));
101         TRACE("%f rad = %f deg\n", angle, newangle);
102         return newangle;
103 }
104
105 /* angle between vectors - rad version */
106 static inline D3DVALUE AngleBetweenVectorsRad (const D3DVECTOR *a, const D3DVECTOR *b)
107 {
108         D3DVALUE la, lb, product, angle, cos;
109         /* definition of scalar product: a*b = |a|*|b|*cos... therefore: */
110         product = ScalarProduct (a,b);
111         la = VectorMagnitude (a);
112         lb = VectorMagnitude (b);
113         if (!la || !lb)
114                 return 0;
115
116         cos = product/(la*lb);
117         angle = acos(cos);
118         TRACE("angle between (%f,%f,%f) and (%f,%f,%f) = %f radians (%f degrees)\n",  a->x, a->y, a->z, b->x,
119               b->y, b->z, angle, RadToDeg(angle));
120         return angle;   
121 }
122
123 static inline D3DVALUE AngleBetweenVectorsDeg (const D3DVECTOR *a, const D3DVECTOR *b)
124 {
125         return RadToDeg(AngleBetweenVectorsRad(a, b));
126 }
127
128 /* calculates vector between two points */
129 static inline D3DVECTOR VectorBetweenTwoPoints (const D3DVECTOR *a, const D3DVECTOR *b)
130 {
131         D3DVECTOR c;
132         c.x = b->x - a->x;
133         c.y = b->y - a->y;
134         c.z = b->z - a->z;
135         TRACE("A (%f,%f,%f), B (%f,%f,%f), AB = (%f,%f,%f)\n", a->x, a->y, a->z, b->x, b->y,
136               b->z, c.x, c.y, c.z);
137         return c;
138 }
139
140 /* calculates the length of vector's projection on another vector */
141 static inline D3DVALUE ProjectVector (const D3DVECTOR *a, const D3DVECTOR *p)
142 {
143         D3DVALUE prod, result;
144         prod = ScalarProduct(a, p);
145         result = prod/VectorMagnitude(p);
146         TRACE("length projection of (%f,%f,%f) on (%f,%f,%f) = %f\n", a->x, a->y, a->z, p->x,
147               p->y, p->z, result);
148         return result;
149 }
150
151 /*******************************************************************************
152  *              3D Buffer and Listener mixing
153  */
154
155 void DSOUND_Calc3DBuffer(IDirectSoundBufferImpl *dsb)
156 {
157         /* volume, at which the sound will be played after all calcs. */
158         D3DVALUE lVolume = 0;
159         /* stuff for distance related stuff calc. */
160         D3DVECTOR vDistance;
161         D3DVALUE flDistance = 0;
162         /* panning related stuff */
163         D3DVALUE flAngle;
164         D3DVECTOR vLeft;
165         /* doppler shift related stuff */
166 #if 0
167         D3DVALUE flFreq, flBufferVel, flListenerVel;
168 #endif
169
170         TRACE("(%p)\n",dsb);
171
172         /* initial buffer volume */
173         lVolume = dsb->ds3db_lVolume;
174         
175         switch (dsb->ds3db_ds3db.dwMode)
176         {
177                 case DS3DMODE_DISABLE:
178                         TRACE("3D processing disabled\n");
179                         /* this one is here only to eliminate annoying warning message */
180                         DSOUND_RecalcVolPan (&dsb->volpan);
181                         break;
182                 case DS3DMODE_NORMAL:
183                         TRACE("Normal 3D processing mode\n");
184                         /* we need to calculate distance between buffer and listener*/
185                         vDistance = VectorBetweenTwoPoints(&dsb->ds3db_ds3db.vPosition, &dsb->device->ds3dl.vPosition);
186                         flDistance = VectorMagnitude (&vDistance);
187                         break;
188                 case DS3DMODE_HEADRELATIVE:
189                         TRACE("Head-relative 3D processing mode\n");
190                         /* distance between buffer and listener is same as buffer's position */
191                         flDistance = VectorMagnitude (&dsb->ds3db_ds3db.vPosition);
192                         break;
193         }
194         
195         if (flDistance > dsb->ds3db_ds3db.flMaxDistance)
196         {
197                 /* some apps don't want you to hear too distant sounds... */
198                 if (dsb->dsbd.dwFlags & DSBCAPS_MUTE3DATMAXDISTANCE)
199                 {
200                         dsb->volpan.lVolume = DSBVOLUME_MIN;
201                         DSOUND_RecalcVolPan (&dsb->volpan);             
202                         /* i guess mixing here would be a waste of power */
203                         return;
204                 }
205                 else
206                         flDistance = dsb->ds3db_ds3db.flMaxDistance;
207         }               
208
209         if (flDistance < dsb->ds3db_ds3db.flMinDistance)
210                 flDistance = dsb->ds3db_ds3db.flMinDistance;
211         
212         /* attenuation proportional to the distance squared, converted to millibels as in lVolume*/
213         lVolume -= log10(flDistance/dsb->ds3db_ds3db.flMinDistance * flDistance/dsb->ds3db_ds3db.flMinDistance)*1000;
214         TRACE("dist. att: Distance = %f, MinDistance = %f => adjusting volume %d to %f\n", flDistance, dsb->ds3db_ds3db.flMinDistance, dsb->ds3db_lVolume, lVolume);
215
216         /* conning */
217         /* sometimes it happens that vConeOrientation vector = (0,0,0); in this case angle is "nan" and it's useless*/
218         if (dsb->ds3db_ds3db.vConeOrientation.x == 0 && dsb->ds3db_ds3db.vConeOrientation.y == 0 && dsb->ds3db_ds3db.vConeOrientation.z == 0)
219         {
220                 TRACE("conning: cones not set\n");
221         }
222         else
223         {
224                 /* calculate angle */
225                 flAngle = AngleBetweenVectorsDeg(&dsb->ds3db_ds3db.vConeOrientation, &vDistance);
226                 /* if by any chance it happens that OutsideConeAngle = InsideConeAngle (that means that conning has no effect) */
227                 if (dsb->ds3db_ds3db.dwInsideConeAngle != dsb->ds3db_ds3db.dwOutsideConeAngle)
228                 {
229                         /* my test show that for my way of calc., we need only half of angles */
230                         DWORD dwInsideConeAngle = dsb->ds3db_ds3db.dwInsideConeAngle/2;
231                         DWORD dwOutsideConeAngle = dsb->ds3db_ds3db.dwOutsideConeAngle/2;
232                         if (dwOutsideConeAngle == dwInsideConeAngle)
233                                 ++dwOutsideConeAngle;
234
235                         /* full volume */
236                         if (flAngle < dwInsideConeAngle)
237                                 flAngle = dwInsideConeAngle;
238                         /* min (app defined) volume */
239                         if (flAngle > dwOutsideConeAngle)
240                                 flAngle = dwOutsideConeAngle;
241                         /* this probably isn't the right thing, but it's ok for the time being */
242                         lVolume += ((dsb->ds3db_ds3db.lConeOutsideVolume)/((dwOutsideConeAngle) - (dwInsideConeAngle))) * flAngle;
243                 }
244                 TRACE("conning: Angle = %f deg; InsideConeAngle(/2) = %d deg; OutsideConeAngle(/2) = %d deg; ConeOutsideVolume = %d => adjusting volume to %f\n",
245                        flAngle, dsb->ds3db_ds3db.dwInsideConeAngle/2, dsb->ds3db_ds3db.dwOutsideConeAngle/2, dsb->ds3db_ds3db.lConeOutsideVolume, lVolume);
246         }
247         dsb->volpan.lVolume = lVolume;
248         
249         /* panning */
250         if (dsb->device->ds3dl.vPosition.x == dsb->ds3db_ds3db.vPosition.x &&
251             dsb->device->ds3dl.vPosition.y == dsb->ds3db_ds3db.vPosition.y &&
252             dsb->device->ds3dl.vPosition.z == dsb->ds3db_ds3db.vPosition.z) {
253                 dsb->volpan.lPan = 0;
254                 flAngle = 0.0;
255         }
256         else
257         {
258                 vDistance = VectorBetweenTwoPoints(&dsb->device->ds3dl.vPosition, &dsb->ds3db_ds3db.vPosition);
259                 vLeft = VectorProduct(&dsb->device->ds3dl.vOrientFront, &dsb->device->ds3dl.vOrientTop);
260                 flAngle = AngleBetweenVectorsRad(&vLeft, &vDistance);
261                 /* for now, we'll use "linear formula" (which is probably incorrect); if someone has it in book, correct it */
262                 dsb->volpan.lPan = 10000*2*flAngle/M_PI - 10000;
263         }
264         TRACE("panning: Angle = %f rad, lPan = %d\n", flAngle, dsb->volpan.lPan);
265
266         /* FIXME: Doppler Effect disabled since i have no idea which frequency to change and how to do it */
267 #if 0   
268         /* doppler shift*/
269         if ((VectorMagnitude(&ds3db_ds3db.vVelocity) == 0) && (VectorMagnitude(&dsb->device->ds3dl.vVelocity) == 0))
270         {
271                 TRACE("doppler: Buffer and Listener don't have velocities\n");
272         }
273         else if (ds3db_ds3db.vVelocity != dsb->device->ds3dl.vVelocity)
274         {
275                 /* calculate length of ds3db_ds3db.vVelocity component which causes Doppler Effect
276                    NOTE: if buffer moves TOWARDS the listener, it's velocity component is NEGATIVE
277                          if buffer moves AWAY from listener, it's velocity component is POSITIVE */
278                 flBufferVel = ProjectVector(&dsb->ds3db_ds3db.vVelocity, &vDistance);
279                 /* calculate length of ds3dl.vVelocity component which causes Doppler Effect
280                    NOTE: if listener moves TOWARDS the buffer, it's velocity component is POSITIVE
281                          if listener moves AWAY from buffer, it's velocity component is NEGATIVE */
282                 flListenerVel = ProjectVector(&dsb->device->ds3dl.vVelocity, &vDistance);
283                 /* formula taken from Gianicoli D.: Physics, 4th edition: */
284                 /* FIXME: replace dsb->freq with appropriate frequency ! */
285                 flFreq = dsb->freq * ((DEFAULT_VELOCITY + flListenerVel)/(DEFAULT_VELOCITY + flBufferVel));
286                 TRACE("doppler: Buffer velocity (component) = %lf, Listener velocity (component) = %lf => Doppler shift: %ld Hz -> %lf Hz\n", flBufferVel, flListenerVel,
287                       dsb->freq, flFreq);
288                 /* FIXME: replace following line with correct frequency setting ! */
289                 dsb->freq = flFreq;
290                 DSOUND_RecalcFormat(dsb);
291                 DSOUND_MixToTemporary(dsb, 0, dsb->buflen);
292         }
293 #endif  
294         
295         /* time for remix */
296         DSOUND_RecalcVolPan(&dsb->volpan);
297 }
298
299 static void DSOUND_Mix3DBuffer(IDirectSoundBufferImpl *dsb)
300 {
301         TRACE("(%p)\n",dsb);
302
303         DSOUND_Calc3DBuffer(dsb);
304 }
305
306 static void DSOUND_ChangeListener(IDirectSound3DListenerImpl *ds3dl)
307 {
308         int i;
309         TRACE("(%p)\n",ds3dl);
310         for (i = 0; i < ds3dl->device->nrofbuffers; i++)
311         {
312                 /* check if this buffer is waiting for recalculation */
313                 if (ds3dl->device->buffers[i]->ds3db_need_recalc)
314                 {
315                         DSOUND_Mix3DBuffer(ds3dl->device->buffers[i]);
316                 }
317         }
318 }
319
320 /*******************************************************************************
321  *              IDirectSound3DBuffer
322  */
323
324 /* IUnknown methods */
325 static HRESULT WINAPI IDirectSound3DBufferImpl_QueryInterface(
326         LPDIRECTSOUND3DBUFFER iface, REFIID riid, LPVOID *ppobj)
327 {
328         IDirectSound3DBufferImpl *This = (IDirectSound3DBufferImpl *)iface;
329
330         TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
331         return IDirectSoundBuffer_QueryInterface((LPDIRECTSOUNDBUFFER8)This->dsb, riid, ppobj);
332 }
333
334 static ULONG WINAPI IDirectSound3DBufferImpl_AddRef(LPDIRECTSOUND3DBUFFER iface)
335 {
336     IDirectSound3DBufferImpl *This = (IDirectSound3DBufferImpl *)iface;
337     ULONG ref = InterlockedIncrement(&(This->ref));
338     TRACE("(%p) ref was %d\n", This, ref - 1);
339     return ref;
340 }
341
342 static ULONG WINAPI IDirectSound3DBufferImpl_Release(LPDIRECTSOUND3DBUFFER iface)
343 {
344     IDirectSound3DBufferImpl *This = (IDirectSound3DBufferImpl *)iface;
345     ULONG ref = InterlockedDecrement(&(This->ref));
346     TRACE("(%p) ref was %d\n", This, ref + 1);
347
348     if (!ref) {
349         This->dsb->ds3db = NULL;
350         IDirectSoundBuffer_Release((LPDIRECTSOUNDBUFFER8)This->dsb);
351         HeapFree(GetProcessHeap(), 0, This);
352         TRACE("(%p) released\n", This);
353     }
354     return ref;
355 }
356
357 /* IDirectSound3DBuffer methods */
358 static HRESULT WINAPI IDirectSound3DBufferImpl_GetAllParameters(
359         LPDIRECTSOUND3DBUFFER iface,
360         LPDS3DBUFFER lpDs3dBuffer)
361 {
362         IDirectSound3DBufferImpl *This = (IDirectSound3DBufferImpl *)iface;
363         TRACE("(%p,%p)\n",This,lpDs3dBuffer);
364
365         if (lpDs3dBuffer == NULL) {
366                 WARN("invalid parameter: lpDs3dBuffer == NULL\n");
367                 return DSERR_INVALIDPARAM;
368         }
369
370         if (lpDs3dBuffer->dwSize < sizeof(*lpDs3dBuffer)) {
371                 WARN("invalid parameter: lpDs3dBuffer->dwSize = %d\n",lpDs3dBuffer->dwSize);
372                 return DSERR_INVALIDPARAM;
373         }
374         
375         TRACE("returning: all parameters\n");
376         *lpDs3dBuffer = This->dsb->ds3db_ds3db;
377         return DS_OK;
378 }
379
380 static HRESULT WINAPI IDirectSound3DBufferImpl_GetConeAngles(
381         LPDIRECTSOUND3DBUFFER iface,
382         LPDWORD lpdwInsideConeAngle,
383         LPDWORD lpdwOutsideConeAngle)
384 {
385         IDirectSound3DBufferImpl *This = (IDirectSound3DBufferImpl *)iface;
386         TRACE("returning: Inside Cone Angle = %d degrees; Outside Cone Angle = %d degrees\n",
387                 This->dsb->ds3db_ds3db.dwInsideConeAngle, This->dsb->ds3db_ds3db.dwOutsideConeAngle);
388         *lpdwInsideConeAngle = This->dsb->ds3db_ds3db.dwInsideConeAngle;
389         *lpdwOutsideConeAngle = This->dsb->ds3db_ds3db.dwOutsideConeAngle;
390         return DS_OK;
391 }
392
393 static HRESULT WINAPI IDirectSound3DBufferImpl_GetConeOrientation(
394         LPDIRECTSOUND3DBUFFER iface,
395         LPD3DVECTOR lpvConeOrientation)
396 {
397         IDirectSound3DBufferImpl *This = (IDirectSound3DBufferImpl *)iface;
398         TRACE("returning: Cone Orientation vector = (%f,%f,%f)\n",
399                 This->dsb->ds3db_ds3db.vConeOrientation.x,
400                 This->dsb->ds3db_ds3db.vConeOrientation.y,
401                 This->dsb->ds3db_ds3db.vConeOrientation.z);
402         *lpvConeOrientation = This->dsb->ds3db_ds3db.vConeOrientation;
403         return DS_OK;
404 }
405
406 static HRESULT WINAPI IDirectSound3DBufferImpl_GetConeOutsideVolume(
407         LPDIRECTSOUND3DBUFFER iface,
408         LPLONG lplConeOutsideVolume)
409 {
410         IDirectSound3DBufferImpl *This = (IDirectSound3DBufferImpl *)iface;
411         TRACE("returning: Cone Outside Volume = %d\n", This->dsb->ds3db_ds3db.lConeOutsideVolume);
412         *lplConeOutsideVolume = This->dsb->ds3db_ds3db.lConeOutsideVolume;
413         return DS_OK;
414 }
415
416 static HRESULT WINAPI IDirectSound3DBufferImpl_GetMaxDistance(
417         LPDIRECTSOUND3DBUFFER iface,
418         LPD3DVALUE lpfMaxDistance)
419 {
420         IDirectSound3DBufferImpl *This = (IDirectSound3DBufferImpl *)iface;
421         TRACE("returning: Max Distance = %f\n", This->dsb->ds3db_ds3db.flMaxDistance);
422         *lpfMaxDistance = This->dsb->ds3db_ds3db.flMaxDistance;
423         return DS_OK;
424 }
425
426 static HRESULT WINAPI IDirectSound3DBufferImpl_GetMinDistance(
427         LPDIRECTSOUND3DBUFFER iface,
428         LPD3DVALUE lpfMinDistance)
429 {
430         IDirectSound3DBufferImpl *This = (IDirectSound3DBufferImpl *)iface;
431         TRACE("returning: Min Distance = %f\n", This->dsb->ds3db_ds3db.flMinDistance);
432         *lpfMinDistance = This->dsb->ds3db_ds3db.flMinDistance;
433         return DS_OK;
434 }
435
436 static HRESULT WINAPI IDirectSound3DBufferImpl_GetMode(
437         LPDIRECTSOUND3DBUFFER iface,
438         LPDWORD lpdwMode)
439 {
440         IDirectSound3DBufferImpl *This = (IDirectSound3DBufferImpl *)iface;
441         TRACE("returning: Mode = %d\n", This->dsb->ds3db_ds3db.dwMode);
442         *lpdwMode = This->dsb->ds3db_ds3db.dwMode;
443         return DS_OK;
444 }
445
446 static HRESULT WINAPI IDirectSound3DBufferImpl_GetPosition(
447         LPDIRECTSOUND3DBUFFER iface,
448         LPD3DVECTOR lpvPosition)
449 {
450         IDirectSound3DBufferImpl *This = (IDirectSound3DBufferImpl *)iface;
451         TRACE("returning: Position vector = (%f,%f,%f)\n",
452                 This->dsb->ds3db_ds3db.vPosition.x,
453                 This->dsb->ds3db_ds3db.vPosition.y,
454                 This->dsb->ds3db_ds3db.vPosition.z);
455         *lpvPosition = This->dsb->ds3db_ds3db.vPosition;
456         return DS_OK;
457 }
458
459 static HRESULT WINAPI IDirectSound3DBufferImpl_GetVelocity(
460         LPDIRECTSOUND3DBUFFER iface,
461         LPD3DVECTOR lpvVelocity)
462 {
463         IDirectSound3DBufferImpl *This = (IDirectSound3DBufferImpl *)iface;
464         TRACE("returning: Velocity vector = (%f,%f,%f)\n",
465                 This->dsb->ds3db_ds3db.vVelocity.x,
466                 This->dsb->ds3db_ds3db.vVelocity.y,
467                 This->dsb->ds3db_ds3db.vVelocity.z);
468         *lpvVelocity = This->dsb->ds3db_ds3db.vVelocity;
469         return DS_OK;
470 }
471
472 static HRESULT WINAPI IDirectSound3DBufferImpl_SetAllParameters(
473         LPDIRECTSOUND3DBUFFER iface,
474         LPCDS3DBUFFER lpcDs3dBuffer,
475         DWORD dwApply)
476 {
477         IDirectSound3DBufferImpl *This = (IDirectSound3DBufferImpl *)iface;
478         DWORD status = DSERR_INVALIDPARAM;
479         TRACE("(%p,%p,%x)\n",iface,lpcDs3dBuffer,dwApply);
480
481         if (lpcDs3dBuffer == NULL) {
482                 WARN("invalid parameter: lpcDs3dBuffer == NULL\n");
483                 return status;
484         }
485
486         if (lpcDs3dBuffer->dwSize != sizeof(DS3DBUFFER)) {
487                 WARN("invalid parameter: lpcDs3dBuffer->dwSize = %d\n", lpcDs3dBuffer->dwSize);
488                 return status;
489         }
490
491         TRACE("setting: all parameters; dwApply = %d\n", dwApply);
492         This->dsb->ds3db_ds3db = *lpcDs3dBuffer;
493
494         if (dwApply == DS3D_IMMEDIATE)
495         {
496                 DSOUND_Mix3DBuffer(This->dsb);
497         }
498         This->dsb->ds3db_need_recalc = TRUE;
499         status = DS_OK;
500
501         return status;
502 }
503
504 static HRESULT WINAPI IDirectSound3DBufferImpl_SetConeAngles(
505         LPDIRECTSOUND3DBUFFER iface,
506         DWORD dwInsideConeAngle,
507         DWORD dwOutsideConeAngle,
508         DWORD dwApply)
509 {
510         IDirectSound3DBufferImpl *This = (IDirectSound3DBufferImpl *)iface;
511         TRACE("setting: Inside Cone Angle = %d; Outside Cone Angle = %d; dwApply = %d\n",
512                 dwInsideConeAngle, dwOutsideConeAngle, dwApply);
513         This->dsb->ds3db_ds3db.dwInsideConeAngle = dwInsideConeAngle;
514         This->dsb->ds3db_ds3db.dwOutsideConeAngle = dwOutsideConeAngle;
515         if (dwApply == DS3D_IMMEDIATE)
516         {
517                 DSOUND_Mix3DBuffer(This->dsb);
518         }
519         This->dsb->ds3db_need_recalc = TRUE;
520         return DS_OK;
521 }
522
523 static HRESULT WINAPI IDirectSound3DBufferImpl_SetConeOrientation(
524         LPDIRECTSOUND3DBUFFER iface,
525         D3DVALUE x, D3DVALUE y, D3DVALUE z,
526         DWORD dwApply)
527 {
528         IDirectSound3DBufferImpl *This = (IDirectSound3DBufferImpl *)iface;
529         TRACE("setting: Cone Orientation vector = (%f,%f,%f); dwApply = %d\n", x, y, z, dwApply);
530         This->dsb->ds3db_ds3db.vConeOrientation.x = x;
531         This->dsb->ds3db_ds3db.vConeOrientation.y = y;
532         This->dsb->ds3db_ds3db.vConeOrientation.z = z;
533         if (dwApply == DS3D_IMMEDIATE)
534         {
535                 This->dsb->ds3db_need_recalc = FALSE;
536                 DSOUND_Mix3DBuffer(This->dsb);
537         }
538         This->dsb->ds3db_need_recalc = TRUE;
539         return DS_OK;
540 }
541
542 static HRESULT WINAPI IDirectSound3DBufferImpl_SetConeOutsideVolume(
543         LPDIRECTSOUND3DBUFFER iface,
544         LONG lConeOutsideVolume,
545         DWORD dwApply)
546 {
547         IDirectSound3DBufferImpl *This = (IDirectSound3DBufferImpl *)iface;
548         TRACE("setting: ConeOutsideVolume = %d; dwApply = %d\n", lConeOutsideVolume, dwApply);
549         This->dsb->ds3db_ds3db.lConeOutsideVolume = lConeOutsideVolume;
550         if (dwApply == DS3D_IMMEDIATE)
551         {
552                 This->dsb->ds3db_need_recalc = FALSE;
553                 DSOUND_Mix3DBuffer(This->dsb);
554         }
555         This->dsb->ds3db_need_recalc = TRUE;
556         return DS_OK;
557 }
558
559 static HRESULT WINAPI IDirectSound3DBufferImpl_SetMaxDistance(
560         LPDIRECTSOUND3DBUFFER iface,
561         D3DVALUE fMaxDistance,
562         DWORD dwApply)
563 {
564         IDirectSound3DBufferImpl *This = (IDirectSound3DBufferImpl *)iface;
565         TRACE("setting: MaxDistance = %f; dwApply = %d\n", fMaxDistance, dwApply);
566         This->dsb->ds3db_ds3db.flMaxDistance = fMaxDistance;
567         if (dwApply == DS3D_IMMEDIATE)
568         {
569                 This->dsb->ds3db_need_recalc = FALSE;
570                 DSOUND_Mix3DBuffer(This->dsb);
571         }
572         This->dsb->ds3db_need_recalc = TRUE;
573         return DS_OK;
574 }
575
576 static HRESULT WINAPI IDirectSound3DBufferImpl_SetMinDistance(
577         LPDIRECTSOUND3DBUFFER iface,
578         D3DVALUE fMinDistance,
579         DWORD dwApply)
580 {
581         IDirectSound3DBufferImpl *This = (IDirectSound3DBufferImpl *)iface;
582         TRACE("setting: MinDistance = %f; dwApply = %d\n", fMinDistance, dwApply);
583         This->dsb->ds3db_ds3db.flMinDistance = fMinDistance;
584         if (dwApply == DS3D_IMMEDIATE)
585         {
586                 This->dsb->ds3db_need_recalc = FALSE;
587                 DSOUND_Mix3DBuffer(This->dsb);
588         }
589         This->dsb->ds3db_need_recalc = TRUE;
590         return DS_OK;
591 }
592
593 static HRESULT WINAPI IDirectSound3DBufferImpl_SetMode(
594         LPDIRECTSOUND3DBUFFER iface,
595         DWORD dwMode,
596         DWORD dwApply)
597 {
598         IDirectSound3DBufferImpl *This = (IDirectSound3DBufferImpl *)iface;
599         TRACE("setting: Mode = %d; dwApply = %d\n", dwMode, dwApply);
600         This->dsb->ds3db_ds3db.dwMode = dwMode;
601         if (dwApply == DS3D_IMMEDIATE)
602         {
603                 This->dsb->ds3db_need_recalc = FALSE;
604                 DSOUND_Mix3DBuffer(This->dsb);
605         }
606         This->dsb->ds3db_need_recalc = TRUE;
607         return DS_OK;
608 }
609
610 static HRESULT WINAPI IDirectSound3DBufferImpl_SetPosition(
611         LPDIRECTSOUND3DBUFFER iface,
612         D3DVALUE x, D3DVALUE y, D3DVALUE z,
613         DWORD dwApply)
614 {
615         IDirectSound3DBufferImpl *This = (IDirectSound3DBufferImpl *)iface;
616         TRACE("setting: Position vector = (%f,%f,%f); dwApply = %d\n", x, y, z, dwApply);
617         This->dsb->ds3db_ds3db.vPosition.x = x;
618         This->dsb->ds3db_ds3db.vPosition.y = y;
619         This->dsb->ds3db_ds3db.vPosition.z = z;
620         if (dwApply == DS3D_IMMEDIATE)
621         {
622                 This->dsb->ds3db_need_recalc = FALSE;
623                 DSOUND_Mix3DBuffer(This->dsb);
624         }
625         This->dsb->ds3db_need_recalc = TRUE;
626         return DS_OK;
627 }
628
629 static HRESULT WINAPI IDirectSound3DBufferImpl_SetVelocity(
630         LPDIRECTSOUND3DBUFFER iface,
631         D3DVALUE x, D3DVALUE y, D3DVALUE z,
632         DWORD dwApply)
633 {
634         IDirectSound3DBufferImpl *This = (IDirectSound3DBufferImpl *)iface;
635         TRACE("setting: Velocity vector = (%f,%f,%f); dwApply = %d\n", x, y, z, dwApply);
636         This->dsb->ds3db_ds3db.vVelocity.x = x;
637         This->dsb->ds3db_ds3db.vVelocity.y = y;
638         This->dsb->ds3db_ds3db.vVelocity.z = z;
639         if (dwApply == DS3D_IMMEDIATE)
640         {
641                 This->dsb->ds3db_need_recalc = FALSE;
642                 DSOUND_Mix3DBuffer(This->dsb);
643         }
644         This->dsb->ds3db_need_recalc = TRUE;
645         return DS_OK;
646 }
647
648 static const IDirectSound3DBufferVtbl ds3dbvt =
649 {
650         /* IUnknown methods */
651         IDirectSound3DBufferImpl_QueryInterface,
652         IDirectSound3DBufferImpl_AddRef,
653         IDirectSound3DBufferImpl_Release,
654         /* IDirectSound3DBuffer methods */
655         IDirectSound3DBufferImpl_GetAllParameters,
656         IDirectSound3DBufferImpl_GetConeAngles,
657         IDirectSound3DBufferImpl_GetConeOrientation,
658         IDirectSound3DBufferImpl_GetConeOutsideVolume,
659         IDirectSound3DBufferImpl_GetMaxDistance,
660         IDirectSound3DBufferImpl_GetMinDistance,
661         IDirectSound3DBufferImpl_GetMode,
662         IDirectSound3DBufferImpl_GetPosition,
663         IDirectSound3DBufferImpl_GetVelocity,
664         IDirectSound3DBufferImpl_SetAllParameters,
665         IDirectSound3DBufferImpl_SetConeAngles,
666         IDirectSound3DBufferImpl_SetConeOrientation,
667         IDirectSound3DBufferImpl_SetConeOutsideVolume,
668         IDirectSound3DBufferImpl_SetMaxDistance,
669         IDirectSound3DBufferImpl_SetMinDistance,
670         IDirectSound3DBufferImpl_SetMode,
671         IDirectSound3DBufferImpl_SetPosition,
672         IDirectSound3DBufferImpl_SetVelocity,
673 };
674
675 HRESULT IDirectSound3DBufferImpl_Create(
676         IDirectSoundBufferImpl *dsb,
677         IDirectSound3DBufferImpl **pds3db)
678 {
679         IDirectSound3DBufferImpl *ds3db;
680         TRACE("(%p,%p)\n",dsb,pds3db);
681
682         ds3db = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(*ds3db));
683
684         if (ds3db == NULL) {
685                 WARN("out of memory\n");
686                 *pds3db = 0;
687                 return DSERR_OUTOFMEMORY;
688         }
689
690         ds3db->ref = 0;
691         ds3db->dsb = dsb;
692         ds3db->lpVtbl = &ds3dbvt;
693
694         ds3db->dsb->ds3db_ds3db.dwSize = sizeof(DS3DBUFFER);
695         ds3db->dsb->ds3db_ds3db.vPosition.x = 0.0;
696         ds3db->dsb->ds3db_ds3db.vPosition.y = 0.0;
697         ds3db->dsb->ds3db_ds3db.vPosition.z = 0.0;
698         ds3db->dsb->ds3db_ds3db.vVelocity.x = 0.0;
699         ds3db->dsb->ds3db_ds3db.vVelocity.y = 0.0;
700         ds3db->dsb->ds3db_ds3db.vVelocity.z = 0.0;
701         ds3db->dsb->ds3db_ds3db.dwInsideConeAngle = DS3D_DEFAULTCONEANGLE;
702         ds3db->dsb->ds3db_ds3db.dwOutsideConeAngle = DS3D_DEFAULTCONEANGLE;
703         ds3db->dsb->ds3db_ds3db.vConeOrientation.x = 0.0;
704         ds3db->dsb->ds3db_ds3db.vConeOrientation.y = 0.0;
705         ds3db->dsb->ds3db_ds3db.vConeOrientation.z = 0.0;
706         ds3db->dsb->ds3db_ds3db.lConeOutsideVolume = DS3D_DEFAULTCONEOUTSIDEVOLUME;
707         ds3db->dsb->ds3db_ds3db.flMinDistance = DS3D_DEFAULTMINDISTANCE;
708         ds3db->dsb->ds3db_ds3db.flMaxDistance = DS3D_DEFAULTMAXDISTANCE;
709         ds3db->dsb->ds3db_ds3db.dwMode = DS3DMODE_NORMAL;
710
711         ds3db->dsb->ds3db_need_recalc = TRUE;
712
713         IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER8)dsb);
714
715         *pds3db = ds3db;
716         return S_OK;
717 }
718
719 HRESULT IDirectSound3DBufferImpl_Destroy(
720     IDirectSound3DBufferImpl *pds3db)
721 {
722     TRACE("(%p)\n",pds3db);
723
724     while (IDirectSound3DBufferImpl_Release((LPDIRECTSOUND3DBUFFER)pds3db) > 0);
725
726     return S_OK;
727 }
728
729 /*******************************************************************************
730  *            IDirectSound3DListener
731  */
732
733 /* IUnknown methods */
734 static HRESULT WINAPI IDirectSound3DListenerImpl_QueryInterface(
735         LPDIRECTSOUND3DLISTENER iface, REFIID riid, LPVOID *ppobj)
736 {
737         IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface;
738
739         TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
740
741         if (ppobj == NULL) {
742                 WARN("invalid parameter\n");
743                 return E_INVALIDARG;
744         }
745
746         *ppobj = NULL;  /* assume failure */
747
748         if ( IsEqualGUID(riid, &IID_IUnknown) ||
749              IsEqualGUID(riid, &IID_IDirectSound3DListener ) ) {
750                 IDirectSound3DListener_AddRef((LPDIRECTSOUND3DLISTENER)This);
751                 *ppobj = This;
752                 return S_OK;
753         }
754
755         if ( IsEqualGUID(riid, &IID_IDirectSoundBuffer) ) {
756                 if (!This->device->primary)
757                         PrimaryBufferImpl_Create(This->device, &(This->device->primary), &(This->device->dsbd));
758                 if (This->device->primary) {
759                         *ppobj = This->device->primary;
760                         IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER)*ppobj);
761                         return S_OK;
762                 }
763         }
764
765         FIXME( "Unknown IID %s\n", debugstr_guid( riid ) );
766         return E_NOINTERFACE;
767 }
768
769 static ULONG WINAPI IDirectSound3DListenerImpl_AddRef(LPDIRECTSOUND3DLISTENER iface)
770 {
771     IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface;
772     ULONG ref = InterlockedIncrement(&(This->ref));
773     TRACE("(%p) ref was %d\n", This, ref - 1);
774     return ref;
775 }
776
777 static ULONG WINAPI IDirectSound3DListenerImpl_Release(LPDIRECTSOUND3DLISTENER iface)
778 {
779     IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface;
780     ULONG ref = InterlockedDecrement(&(This->ref));
781     TRACE("(%p) ref was %d\n", This, ref + 1);
782
783     if (!ref) {
784         This->device->listener = 0;
785         HeapFree(GetProcessHeap(), 0, This);
786         TRACE("(%p) released\n", This);
787     }
788     return ref;
789 }
790
791 /* IDirectSound3DListener methods */
792 static HRESULT WINAPI IDirectSound3DListenerImpl_GetAllParameter(
793         LPDIRECTSOUND3DLISTENER iface,
794         LPDS3DLISTENER lpDS3DL)
795 {
796         IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface;
797         TRACE("(%p,%p)\n",This,lpDS3DL);
798
799         if (lpDS3DL == NULL) {
800                 WARN("invalid parameter: lpDS3DL == NULL\n");
801                 return DSERR_INVALIDPARAM;
802         }
803
804         if (lpDS3DL->dwSize < sizeof(*lpDS3DL)) {
805                 WARN("invalid parameter: lpDS3DL->dwSize = %d\n",lpDS3DL->dwSize);
806                 return DSERR_INVALIDPARAM;
807         }
808         
809         TRACE("returning: all parameters\n");
810         *lpDS3DL = This->device->ds3dl;
811         return DS_OK;
812 }
813
814 static HRESULT WINAPI IDirectSound3DListenerImpl_GetDistanceFactor(
815         LPDIRECTSOUND3DLISTENER iface,
816         LPD3DVALUE lpfDistanceFactor)
817 {
818         IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface;
819         TRACE("returning: Distance Factor = %f\n", This->device->ds3dl.flDistanceFactor);
820         *lpfDistanceFactor = This->device->ds3dl.flDistanceFactor;
821         return DS_OK;
822 }
823
824 static HRESULT WINAPI IDirectSound3DListenerImpl_GetDopplerFactor(
825         LPDIRECTSOUND3DLISTENER iface,
826         LPD3DVALUE lpfDopplerFactor)
827 {
828         IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface;
829         TRACE("returning: Doppler Factor = %f\n", This->device->ds3dl.flDopplerFactor);
830         *lpfDopplerFactor = This->device->ds3dl.flDopplerFactor;
831         return DS_OK;
832 }
833
834 static HRESULT WINAPI IDirectSound3DListenerImpl_GetOrientation(
835         LPDIRECTSOUND3DLISTENER iface,
836         LPD3DVECTOR lpvOrientFront,
837         LPD3DVECTOR lpvOrientTop)
838 {
839         IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface;
840         TRACE("returning: OrientFront vector = (%f,%f,%f); OrientTop vector = (%f,%f,%f)\n", This->device->ds3dl.vOrientFront.x,
841         This->device->ds3dl.vOrientFront.y, This->device->ds3dl.vOrientFront.z, This->device->ds3dl.vOrientTop.x, This->device->ds3dl.vOrientTop.y,
842         This->device->ds3dl.vOrientTop.z);
843         *lpvOrientFront = This->device->ds3dl.vOrientFront;
844         *lpvOrientTop = This->device->ds3dl.vOrientTop;
845         return DS_OK;
846 }
847
848 static HRESULT WINAPI IDirectSound3DListenerImpl_GetPosition(
849         LPDIRECTSOUND3DLISTENER iface,
850         LPD3DVECTOR lpvPosition)
851 {
852         IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface;
853         TRACE("returning: Position vector = (%f,%f,%f)\n", This->device->ds3dl.vPosition.x, This->device->ds3dl.vPosition.y, This->device->ds3dl.vPosition.z);
854         *lpvPosition = This->device->ds3dl.vPosition;
855         return DS_OK;
856 }
857
858 static HRESULT WINAPI IDirectSound3DListenerImpl_GetRolloffFactor(
859         LPDIRECTSOUND3DLISTENER iface,
860         LPD3DVALUE lpfRolloffFactor)
861 {
862         IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface;
863         TRACE("returning: RolloffFactor = %f\n", This->device->ds3dl.flRolloffFactor);
864         *lpfRolloffFactor = This->device->ds3dl.flRolloffFactor;
865         return DS_OK;
866 }
867
868 static HRESULT WINAPI IDirectSound3DListenerImpl_GetVelocity(
869         LPDIRECTSOUND3DLISTENER iface,
870         LPD3DVECTOR lpvVelocity)
871 {
872         IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface;
873         TRACE("returning: Velocity vector = (%f,%f,%f)\n", This->device->ds3dl.vVelocity.x, This->device->ds3dl.vVelocity.y, This->device->ds3dl.vVelocity.z);
874         *lpvVelocity = This->device->ds3dl.vVelocity;
875         return DS_OK;
876 }
877
878 static HRESULT WINAPI IDirectSound3DListenerImpl_SetAllParameters(
879         LPDIRECTSOUND3DLISTENER iface,
880         LPCDS3DLISTENER lpcDS3DL,
881         DWORD dwApply)
882 {
883         IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface;
884         TRACE("setting: all parameters; dwApply = %d\n", dwApply);
885         This->device->ds3dl = *lpcDS3DL;
886         if (dwApply == DS3D_IMMEDIATE)
887         {
888                 This->device->ds3dl_need_recalc = FALSE;
889                 DSOUND_ChangeListener(This);
890         }
891         This->device->ds3dl_need_recalc = TRUE;
892         return DS_OK;
893 }
894
895 static HRESULT WINAPI IDirectSound3DListenerImpl_SetDistanceFactor(
896         LPDIRECTSOUND3DLISTENER iface,
897         D3DVALUE fDistanceFactor,
898         DWORD dwApply)
899 {
900         IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface;
901         TRACE("setting: Distance Factor = %f; dwApply = %d\n", fDistanceFactor, dwApply);
902         This->device->ds3dl.flDistanceFactor = fDistanceFactor;
903         if (dwApply == DS3D_IMMEDIATE)
904         {
905                 This->device->ds3dl_need_recalc = FALSE;
906                 DSOUND_ChangeListener(This);
907         }
908         This->device->ds3dl_need_recalc = TRUE;
909         return DS_OK;
910 }
911
912 static HRESULT WINAPI IDirectSound3DListenerImpl_SetDopplerFactor(
913         LPDIRECTSOUND3DLISTENER iface,
914         D3DVALUE fDopplerFactor,
915         DWORD dwApply)
916 {
917         IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface;
918         TRACE("setting: Doppler Factor = %f; dwApply = %d\n", fDopplerFactor, dwApply);
919         This->device->ds3dl.flDopplerFactor = fDopplerFactor;
920         if (dwApply == DS3D_IMMEDIATE)
921         {
922                 This->device->ds3dl_need_recalc = FALSE;
923                 DSOUND_ChangeListener(This);
924         }
925         This->device->ds3dl_need_recalc = TRUE;
926         return DS_OK;
927 }
928
929 static HRESULT WINAPI IDirectSound3DListenerImpl_SetOrientation(
930         LPDIRECTSOUND3DLISTENER iface,
931         D3DVALUE xFront, D3DVALUE yFront, D3DVALUE zFront,
932         D3DVALUE xTop, D3DVALUE yTop, D3DVALUE zTop,
933         DWORD dwApply)
934 {
935         IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface;
936         TRACE("setting: Front vector = (%f,%f,%f); Top vector = (%f,%f,%f); dwApply = %d\n",
937         xFront, yFront, zFront, xTop, yTop, zTop, dwApply);
938         This->device->ds3dl.vOrientFront.x = xFront;
939         This->device->ds3dl.vOrientFront.y = yFront;
940         This->device->ds3dl.vOrientFront.z = zFront;
941         This->device->ds3dl.vOrientTop.x = xTop;
942         This->device->ds3dl.vOrientTop.y = yTop;
943         This->device->ds3dl.vOrientTop.z = zTop;
944         if (dwApply == DS3D_IMMEDIATE)
945         {
946                 This->device->ds3dl_need_recalc = FALSE;
947                 DSOUND_ChangeListener(This);
948         }
949         This->device->ds3dl_need_recalc = TRUE;
950         return DS_OK;
951 }
952
953 static HRESULT WINAPI IDirectSound3DListenerImpl_SetPosition(
954         LPDIRECTSOUND3DLISTENER iface,
955         D3DVALUE x, D3DVALUE y, D3DVALUE z,
956         DWORD dwApply)
957 {
958         IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface;
959         TRACE("setting: Position vector = (%f,%f,%f); dwApply = %d\n", x, y, z, dwApply);
960         This->device->ds3dl.vPosition.x = x;
961         This->device->ds3dl.vPosition.y = y;
962         This->device->ds3dl.vPosition.z = z;
963         if (dwApply == DS3D_IMMEDIATE)
964         {
965                 This->device->ds3dl_need_recalc = FALSE;
966                 DSOUND_ChangeListener(This);
967         }
968         This->device->ds3dl_need_recalc = TRUE;
969         return DS_OK;
970 }
971
972 static HRESULT WINAPI IDirectSound3DListenerImpl_SetRolloffFactor(
973         LPDIRECTSOUND3DLISTENER iface,
974         D3DVALUE fRolloffFactor,
975         DWORD dwApply)
976 {
977         IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface;
978         TRACE("setting: Rolloff Factor = %f; dwApply = %d\n", fRolloffFactor, dwApply);
979         This->device->ds3dl.flRolloffFactor = fRolloffFactor;
980         if (dwApply == DS3D_IMMEDIATE)
981         {
982                 This->device->ds3dl_need_recalc = FALSE;
983                 DSOUND_ChangeListener(This);
984         }
985         This->device->ds3dl_need_recalc = TRUE;
986         return DS_OK;
987 }
988
989 static HRESULT WINAPI IDirectSound3DListenerImpl_SetVelocity(
990         LPDIRECTSOUND3DLISTENER iface,
991         D3DVALUE x, D3DVALUE y, D3DVALUE z,
992         DWORD dwApply)
993 {
994         IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface;
995         TRACE("setting: Velocity vector = (%f,%f,%f); dwApply = %d\n", x, y, z, dwApply);
996         This->device->ds3dl.vVelocity.x = x;
997         This->device->ds3dl.vVelocity.y = y;
998         This->device->ds3dl.vVelocity.z = z;
999         if (dwApply == DS3D_IMMEDIATE)
1000         {
1001                 This->device->ds3dl_need_recalc = FALSE;
1002                 DSOUND_ChangeListener(This);
1003         }
1004         This->device->ds3dl_need_recalc = TRUE;
1005         return DS_OK;
1006 }
1007
1008 static HRESULT WINAPI IDirectSound3DListenerImpl_CommitDeferredSettings(
1009         LPDIRECTSOUND3DLISTENER iface)
1010 {
1011         IDirectSound3DListenerImpl *This = (IDirectSound3DListenerImpl *)iface;
1012         TRACE("\n");
1013         DSOUND_ChangeListener(This);
1014         return DS_OK;
1015 }
1016
1017 static const IDirectSound3DListenerVtbl ds3dlvt =
1018 {
1019         /* IUnknown methods */
1020         IDirectSound3DListenerImpl_QueryInterface,
1021         IDirectSound3DListenerImpl_AddRef,
1022         IDirectSound3DListenerImpl_Release,
1023         /* IDirectSound3DListener methods */
1024         IDirectSound3DListenerImpl_GetAllParameter,
1025         IDirectSound3DListenerImpl_GetDistanceFactor,
1026         IDirectSound3DListenerImpl_GetDopplerFactor,
1027         IDirectSound3DListenerImpl_GetOrientation,
1028         IDirectSound3DListenerImpl_GetPosition,
1029         IDirectSound3DListenerImpl_GetRolloffFactor,
1030         IDirectSound3DListenerImpl_GetVelocity,
1031         IDirectSound3DListenerImpl_SetAllParameters,
1032         IDirectSound3DListenerImpl_SetDistanceFactor,
1033         IDirectSound3DListenerImpl_SetDopplerFactor,
1034         IDirectSound3DListenerImpl_SetOrientation,
1035         IDirectSound3DListenerImpl_SetPosition,
1036         IDirectSound3DListenerImpl_SetRolloffFactor,
1037         IDirectSound3DListenerImpl_SetVelocity,
1038         IDirectSound3DListenerImpl_CommitDeferredSettings,
1039 };
1040
1041 HRESULT IDirectSound3DListenerImpl_Create(
1042         DirectSoundDevice * device,
1043         IDirectSound3DListenerImpl ** ppdsl)
1044 {
1045         IDirectSound3DListenerImpl *pdsl;
1046         TRACE("(%p,%p)\n",device,ppdsl);
1047
1048         pdsl = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(*pdsl));
1049
1050         if (pdsl == NULL) {
1051                 WARN("out of memory\n");
1052                 *ppdsl = 0;
1053                 return DSERR_OUTOFMEMORY;
1054         }
1055
1056         pdsl->ref = 0;
1057         pdsl->lpVtbl = &ds3dlvt;
1058
1059         pdsl->device = device;
1060
1061         pdsl->device->ds3dl.dwSize = sizeof(DS3DLISTENER);
1062         pdsl->device->ds3dl.vPosition.x = 0.0;
1063         pdsl->device->ds3dl.vPosition.y = 0.0;
1064         pdsl->device->ds3dl.vPosition.z = 0.0;
1065         pdsl->device->ds3dl.vVelocity.x = 0.0;
1066         pdsl->device->ds3dl.vVelocity.y = 0.0;
1067         pdsl->device->ds3dl.vVelocity.z = 0.0;
1068         pdsl->device->ds3dl.vOrientFront.x = 0.0;
1069         pdsl->device->ds3dl.vOrientFront.y = 0.0;
1070         pdsl->device->ds3dl.vOrientFront.z = 1.0;
1071         pdsl->device->ds3dl.vOrientTop.x = 0.0;
1072         pdsl->device->ds3dl.vOrientTop.y = 1.0;
1073         pdsl->device->ds3dl.vOrientTop.z = 0.0;
1074         pdsl->device->ds3dl.flDistanceFactor = DS3D_DEFAULTDISTANCEFACTOR;
1075         pdsl->device->ds3dl.flRolloffFactor = DS3D_DEFAULTROLLOFFFACTOR;
1076         pdsl->device->ds3dl.flDopplerFactor = DS3D_DEFAULTDOPPLERFACTOR;
1077
1078         pdsl->device->ds3dl_need_recalc = TRUE;
1079
1080         *ppdsl = pdsl;
1081         return S_OK;
1082 }