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