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