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