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