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