git.oblomov.eu Git - wine/blob - dlls/dsound/dsound_main.c

   1 /*                      DirectSound
   2  *
   3  * Copyright 1998 Marcus Meissner
   4  * Copyright 1998 Rob Riggs
   5  * Copyright 2000-2002 TransGaming Technologies, Inc.
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  20  */
  21 /*
  22  * Most thread locking is complete. There may be a few race
  23  * conditions still lurking.
  24  *
  25  * Tested with a Soundblaster clone, a Gravis UltraSound Classic,
  26  * and a Turtle Beach Tropez+.
  27  *
  28  * TODO:
  29  *      Implement SetCooperativeLevel properly (need to address focus issues)
  30  *      Implement DirectSound3DBuffers (stubs in place)
  31  *      Use hardware 3D support if available
  32  *      Add critical section locking inside Release and AddRef methods
  33  *      Handle static buffers - put those in hardware, non-static not in hardware
  34  *      Hardware DuplicateSoundBuffer
  35  *      Proper volume calculation, and setting volume in HEL primary buffer
  36  *      Optimize WINMM and negotiate fragment size, decrease DS_HEL_MARGIN
  37  */
  38
  39 #include "config.h"
  40 #include "wine/port.h"
  41
  42 #include <assert.h>
  43 #include <stdarg.h>
  44 #include <stdio.h>
  45 #include <sys/types.h>
  46 #include <sys/fcntl.h>
  47 #ifdef HAVE_UNISTD_H
  48 # include <unistd.h>
  49 #endif
  50 #include <stdlib.h>
  51 #include <string.h>
  52 #include <math.h>
  53
  54 #define NONAMELESSSTRUCT
  55 #define NONAMELESSUNION
  56 #include "windef.h"
  57 #include "winbase.h"
  58 #include "winreg.h"
  59 #include "winuser.h"
  60 #include "wingdi.h"
  61 #include "winuser.h"
  62 #include "winerror.h"
  63 #include "mmsystem.h"
  64 #include "winternl.h"
  65 #include "mmddk.h"
  66 #include "wine/windef16.h"
  67 #include "wine/winbase16.h"
  68 #include "wine/debug.h"
  69 #include "dsound.h"
  70 #include "dsdriver.h"
  71 #include "dsound_private.h"
  72 #include "dsconf.h"
  73
  74 WINE_DEFAULT_DEBUG_CHANNEL(dsound);
  75
  76 /* these are eligible for tuning... they must be high on slow machines... */
  77 /* some stuff may get more responsive with lower values though... */
  78 #define DS_EMULDRIVER 0 /* some games (Quake 2, UT) refuse to accept
  79                                 emulated dsound devices. set to 0 ! */
  80 #define DS_HEL_MARGIN 5 /* HEL only: number of waveOut fragments ahead to mix in new buffers
  81                          * (keep this close or equal to DS_HEL_QUEUE for best results) */
  82 #define DS_HEL_QUEUE  5 /* HEL only: number of waveOut fragments ahead to queue to driver
  83                          * (this will affect HEL sound reliability and latency) */
  84
  85 #define DS_SND_QUEUE_MAX 28 /* max number of fragments to prebuffer */
  86 #define DS_SND_QUEUE_MIN 12 /* min number of fragments to prebuffer */
  87
  88 IDirectSoundImpl*       dsound = NULL;
  89
  90 HRESULT mmErr(UINT err)
  91 {
  92         switch(err) {
  93         case MMSYSERR_NOERROR:
  94                 return DS_OK;
  95         case MMSYSERR_ALLOCATED:
  96                 return DSERR_ALLOCATED;
  97         case MMSYSERR_ERROR:
  98         case MMSYSERR_INVALHANDLE:
  99         case WAVERR_STILLPLAYING:
 100                 return DSERR_GENERIC; /* FIXME */
 101         case MMSYSERR_NODRIVER:
 102                 return DSERR_NODRIVER;
 103         case MMSYSERR_NOMEM:
 104                 return DSERR_OUTOFMEMORY;
 105         case MMSYSERR_INVALPARAM:
 106         case WAVERR_BADFORMAT:
 107         case WAVERR_UNPREPARED:
 108                 return DSERR_INVALIDPARAM;
 109         case MMSYSERR_NOTSUPPORTED:
 110                 return DSERR_UNSUPPORTED;
 111         default:
 112                 FIXME("Unknown MMSYS error %d\n",err);
 113                 return DSERR_GENERIC;
 114         }
 115 }
 116
 117 int ds_emuldriver = DS_EMULDRIVER;
 118 int ds_hel_margin = DS_HEL_MARGIN;
 119 int ds_hel_queue = DS_HEL_QUEUE;
 120 int ds_snd_queue_max = DS_SND_QUEUE_MAX;
 121 int ds_snd_queue_min = DS_SND_QUEUE_MIN;
 122 int ds_hw_accel = DS_HW_ACCEL_FULL;
 123 int ds_default_playback = 0;
 124 int ds_default_capture = 0;
 125
 126 /*
 127  * Get a config key from either the app-specific or the default config
 128  */
 129
 130 inline static DWORD get_config_key( HKEY defkey, HKEY appkey, const char *name,
 131                                     char *buffer, DWORD size )
 132 {
 133     if (appkey && !RegQueryValueExA( appkey, name, 0, NULL, buffer, &size )) return 0;
 134     return RegQueryValueExA( defkey, name, 0, NULL, buffer, &size );
 135 }
 136
 137
 138 /*
 139  * Setup the dsound options.
 140  */
 141
 142 void setup_dsound_options(void)
 143 {
 144     char buffer[MAX_PATH+1];
 145     HKEY hkey, appkey = 0;
 146
 147     buffer[MAX_PATH]='\0';
 148
 149     if (RegCreateKeyExA( HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\dsound", 0, NULL,
 150                          REG_OPTION_VOLATILE, KEY_ALL_ACCESS, NULL, &hkey, NULL ))
 151     {
 152         ERR("Cannot create config registry key\n" );
 153         ExitProcess(1);
 154     }
 155
 156     if (GetModuleFileNameA( 0, buffer, MAX_PATH ))
 157     {
 158         HKEY tmpkey;
 159
 160         if (!RegOpenKeyA( HKEY_LOCAL_MACHINE, "Software\\Wine\\Wine\\Config\\AppDefaults", &tmpkey ))
 161         {
 162            char appname[MAX_PATH+16];
 163            char *p = strrchr( buffer, '\\' );
 164            if (p!=NULL) {
 165                    appname[MAX_PATH]='\0';
 166                    strncpy(appname,p+1,MAX_PATH);
 167                    strcat(appname,"\\dsound");
 168                    TRACE("appname = [%s] \n",appname);
 169                    if (RegOpenKeyA( tmpkey, appname, &appkey )) appkey = 0;
 170                        RegCloseKey( tmpkey );
 171            }
 172         }
 173     }
 174
 175     /* get options */
 176
 177     if (!get_config_key( hkey, appkey, "EmulDriver", buffer, MAX_PATH ))
 178         ds_emuldriver = strcmp(buffer, "N");
 179
 180     if (!get_config_key( hkey, appkey, "HELmargin", buffer, MAX_PATH ))
 181         ds_hel_margin = atoi(buffer);
 182
 183     if (!get_config_key( hkey, appkey, "HELqueue", buffer, MAX_PATH ))
 184         ds_hel_queue = atoi(buffer);
 185
 186     if (!get_config_key( hkey, appkey, "SndQueueMax", buffer, MAX_PATH ))
 187         ds_snd_queue_max = atoi(buffer);
 188
 189     if (!get_config_key( hkey, appkey, "SndQueueMin", buffer, MAX_PATH ))
 190         ds_snd_queue_min = atoi(buffer);
 191
 192     if (!get_config_key( hkey, appkey, "HardwareAcceleration", buffer, MAX_PATH )) {
 193         if (strcmp(buffer, "Full") == 0)
 194             ds_hw_accel = DS_HW_ACCEL_FULL;
 195         else if (strcmp(buffer, "Standard") == 0)
 196             ds_hw_accel = DS_HW_ACCEL_STANDARD;
 197         else if (strcmp(buffer, "Basic") == 0)
 198             ds_hw_accel = DS_HW_ACCEL_BASIC;
 199         else if (strcmp(buffer, "Emulation") == 0)
 200             ds_hw_accel = DS_HW_ACCEL_EMULATION;
 201     }
 202
 203     if (!get_config_key( hkey, appkey, "DefaultPlayback", buffer, MAX_PATH ))
 204             ds_default_playback = atoi(buffer);
 205
 206     if (!get_config_key( hkey, appkey, "DefaultCapture", buffer, MAX_PATH ))
 207             ds_default_capture = atoi(buffer);
 208
 209     if (appkey) RegCloseKey( appkey );
 210     RegCloseKey( hkey );
 211
 212     if (ds_emuldriver != DS_EMULDRIVER )
 213        WARN("ds_emuldriver = %d (default=%d)\n",ds_emuldriver, DS_EMULDRIVER);
 214     if (ds_hel_margin != DS_HEL_MARGIN )
 215        WARN("ds_hel_margin = %d (default=%d)\n",ds_hel_margin, DS_HEL_MARGIN );
 216     if (ds_hel_queue != DS_HEL_QUEUE )
 217        WARN("ds_hel_queue = %d (default=%d)\n",ds_hel_queue, DS_HEL_QUEUE );
 218     if (ds_snd_queue_max != DS_SND_QUEUE_MAX)
 219        WARN("ds_snd_queue_max = %d (default=%d)\n",ds_snd_queue_max ,DS_SND_QUEUE_MAX);
 220     if (ds_snd_queue_min != DS_SND_QUEUE_MIN)
 221        WARN("ds_snd_queue_min = %d (default=%d)\n",ds_snd_queue_min ,DS_SND_QUEUE_MIN);
 222     if (ds_hw_accel != DS_HW_ACCEL_FULL)
 223         WARN("ds_hw_accel = %s (default=Full)\n",
 224             ds_hw_accel==DS_HW_ACCEL_FULL ? "Full" :
 225             ds_hw_accel==DS_HW_ACCEL_STANDARD ? "Standard" :
 226             ds_hw_accel==DS_HW_ACCEL_BASIC ? "Basic" :
 227             ds_hw_accel==DS_HW_ACCEL_EMULATION ? "Emulation" :
 228             "Unknown");
 229     if (ds_default_playback != 0)
 230         WARN("ds_default_playback = %d (default=0)\n",ds_default_playback);
 231     if (ds_default_capture != 0)
 232         WARN("ds_default_capture = %d (default=0)\n",ds_default_playback);
 233 }
 234
 235
 236
 237 /***************************************************************************
 238  * GetDeviceID  [DSOUND.9]
 239  *
 240  * Retrieves unique identifier of default device specified
 241  *
 242  * PARAMS
 243  *    pGuidSrc  [I] Address of device GUID.
 244  *    pGuidDest [O] Address to receive unique device GUID.
 245  *
 246  * RETURNS
 247  *    Success: DS_OK
 248  *    Failure: DSERR_INVALIDPARAM
 249  *
 250  * NOTES
 251  *    pGuidSrc is a valid device GUID or DSDEVID_DefaultPlayback,
 252  *    DSDEVID_DefaultCapture, DSDEVID_DefaultVoicePlayback, or
 253  *    DSDEVID_DefaultVoiceCapture.
 254  *    Returns pGuidSrc if pGuidSrc is a valid device or the device
 255  *    GUID for the specified constants.
 256  */
 257 HRESULT WINAPI GetDeviceID(LPCGUID pGuidSrc, LPGUID pGuidDest)
 258 {
 259     TRACE("(%p,%p)\n",pGuidSrc,pGuidDest);
 260
 261     if ( pGuidSrc == NULL) {
 262         WARN("invalid parameter: pGuidSrc == NULL\n");
 263         return DSERR_INVALIDPARAM;
 264     }
 265
 266     if ( pGuidDest == NULL ) {
 267         WARN("invalid parameter: pGuidDest == NULL\n");
 268         return DSERR_INVALIDPARAM;
 269     }
 270
 271     if ( IsEqualGUID( &DSDEVID_DefaultPlayback, pGuidSrc ) ||
 272         IsEqualGUID( &DSDEVID_DefaultVoicePlayback, pGuidSrc ) ) {
 273         GUID guid;
 274         int err = mmErr(waveOutMessage((HWAVEOUT)ds_default_playback,DRV_QUERYDSOUNDGUID,(DWORD)&guid,0));
 275         if (err == DS_OK) {
 276             memcpy(pGuidDest, &guid, sizeof(GUID));
 277             return DS_OK;
 278         }
 279     }
 280
 281     if ( IsEqualGUID( &DSDEVID_DefaultCapture, pGuidSrc ) ||
 282         IsEqualGUID( &DSDEVID_DefaultVoiceCapture, pGuidSrc ) ) {
 283         GUID guid;
 284         int err = mmErr(waveInMessage((HWAVEIN)ds_default_capture,DRV_QUERYDSOUNDGUID,(DWORD)&guid,0));
 285         if (err == DS_OK) {
 286             memcpy(pGuidDest, &guid, sizeof(GUID));
 287             return DS_OK;
 288         }
 289     }
 290
 291     memcpy(pGuidDest, pGuidSrc, sizeof(GUID));
 292
 293     return DS_OK;
 294 }
 295
 296
 297 /***************************************************************************
 298  * DirectSoundEnumerateA [DSOUND.2]
 299  *
 300  * Enumerate all DirectSound drivers installed in the system
 301  *
 302  * PARAMS
 303  *    lpDSEnumCallback  [I] Address of callback function.
 304  *    lpContext         [I] Address of user defined context passed to callback function.
 305  *
 306  * RETURNS
 307  *    Success: DS_OK
 308  *    Failure: DSERR_INVALIDPARAM
 309  */
 310 HRESULT WINAPI DirectSoundEnumerateA(
 311     LPDSENUMCALLBACKA lpDSEnumCallback,
 312     LPVOID lpContext)
 313 {
 314     unsigned devs, wod;
 315     DSDRIVERDESC desc;
 316     GUID guid;
 317     int err;
 318
 319     TRACE("lpDSEnumCallback = %p, lpContext = %p\n",
 320         lpDSEnumCallback, lpContext);
 321
 322     if (lpDSEnumCallback == NULL) {
 323         WARN("invalid parameter: lpDSEnumCallback == NULL\n");
 324         return DSERR_INVALIDPARAM;
 325     }
 326
 327     devs = waveOutGetNumDevs();
 328     if (devs > 0) {
 329         if (GetDeviceID(&DSDEVID_DefaultPlayback, &guid) == DS_OK) {
 330             GUID temp;
 331             for (wod = 0; wod < devs; ++wod) {
 332                 err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDGUID,(DWORD)&temp,0));
 333                 if (err == DS_OK) {
 334                     if (IsEqualGUID( &guid, &temp ) ) {
 335                         err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDDESC,(DWORD)&desc,0));
 336                         if (err == DS_OK) {
 337                             TRACE("calling lpDSEnumCallback(NULL,\"%s\",\"%s\",%p)\n",
 338                                 "Primary Sound Driver",desc.szDrvName,lpContext);
 339                             if (lpDSEnumCallback(NULL, "Primary Sound Driver", desc.szDrvName, lpContext) == FALSE)
 340                                 return DS_OK;
 341                         }
 342                     }
 343                 }
 344             }
 345         }
 346     }
 347
 348     for (wod = 0; wod < devs; ++wod) {
 349         err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDDESC,(DWORD)&desc,0));
 350         if (err == DS_OK) {
 351             err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDGUID,(DWORD)&guid,0));
 352             if (err == DS_OK) {
 353                 TRACE("calling lpDSEnumCallback(%s,\"%s\",\"%s\",%p)\n",
 354                     debugstr_guid(&guid),desc.szDesc,desc.szDrvName,lpContext);
 355                 if (lpDSEnumCallback(&guid, desc.szDesc, desc.szDrvName, lpContext) == FALSE)
 356                     return DS_OK;
 357             }
 358         }
 359     }
 360     return DS_OK;
 361 }
 362
 363 /***************************************************************************
 364  * DirectSoundEnumerateW [DSOUND.3]
 365  *
 366  * Enumerate all DirectSound drivers installed in the system
 367  *
 368  * PARAMS
 369  *    lpDSEnumCallback  [I] Address of callback function.
 370  *    lpContext         [I] Address of user defined context passed to callback function.
 371  *
 372  * RETURNS
 373  *    Success: DS_OK
 374  *    Failure: DSERR_INVALIDPARAM
 375  */
 376 HRESULT WINAPI DirectSoundEnumerateW(
 377         LPDSENUMCALLBACKW lpDSEnumCallback,
 378         LPVOID lpContext )
 379 {
 380     unsigned devs, wod;
 381     DSDRIVERDESC desc;
 382     GUID guid;
 383     int err;
 384     WCHAR wDesc[MAXPNAMELEN];
 385     WCHAR wName[MAXPNAMELEN];
 386
 387     TRACE("lpDSEnumCallback = %p, lpContext = %p\n",
 388         lpDSEnumCallback, lpContext);
 389
 390     if (lpDSEnumCallback == NULL) {
 391         WARN("invalid parameter: lpDSEnumCallback == NULL\n");
 392         return DSERR_INVALIDPARAM;
 393     }
 394
 395     devs = waveOutGetNumDevs();
 396     if (devs > 0) {
 397         if (GetDeviceID(&DSDEVID_DefaultPlayback, &guid) == DS_OK) {
 398             GUID temp;
 399             for (wod = 0; wod < devs; ++wod) {
 400                 err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDGUID,(DWORD)&temp,0));
 401                 if (err == DS_OK) {
 402                     if (IsEqualGUID( &guid, &temp ) ) {
 403                         err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDDESC,(DWORD)&desc,0));
 404                         if (err == DS_OK) {
 405                             TRACE("calling lpDSEnumCallback(NULL,\"%s\",\"%s\",%p)\n",
 406                                 "Primary Sound Driver",desc.szDrvName,lpContext);
 407                             MultiByteToWideChar( CP_ACP, 0, "Primary Sound Driver", -1,
 408                                 wDesc, sizeof(wDesc)/sizeof(WCHAR) );
 409                                 MultiByteToWideChar( CP_ACP, 0, desc.szDrvName, -1,
 410                                 wName, sizeof(wName)/sizeof(WCHAR) );
 411                             if (lpDSEnumCallback(NULL, wDesc, wName, lpContext) == FALSE)
 412                                 return DS_OK;
 413                         }
 414                     }
 415                 }
 416             }
 417         }
 418     }
 419
 420     for (wod = 0; wod < devs; ++wod) {
 421         err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDDESC,(DWORD)&desc,0));
 422         if (err == DS_OK) {
 423             err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDGUID,(DWORD)&guid,0));
 424             if (err == DS_OK) {
 425                 TRACE("calling lpDSEnumCallback(%s,\"%s\",\"%s\",%p)\n",
 426                     debugstr_guid(&guid),desc.szDesc,desc.szDrvName,lpContext);
 427                 MultiByteToWideChar( CP_ACP, 0, desc.szDesc, -1,
 428                     wDesc, sizeof(wDesc)/sizeof(WCHAR) );
 429                     MultiByteToWideChar( CP_ACP, 0, desc.szDrvName, -1,
 430                     wName, sizeof(wName)/sizeof(WCHAR) );
 431                 if (lpDSEnumCallback(&guid, wDesc, wName, lpContext) == FALSE)
 432                     return DS_OK;
 433             }
 434         }
 435     }
 436     return DS_OK;
 437 }
 438
 439
 440 static void _dump_DSBCAPS(DWORD xmask) {
 441         struct {
 442                 DWORD   mask;
 443                 char    *name;
 444         } flags[] = {
 445 #define FE(x) { x, #x },
 446                 FE(DSBCAPS_PRIMARYBUFFER)
 447                 FE(DSBCAPS_STATIC)
 448                 FE(DSBCAPS_LOCHARDWARE)
 449                 FE(DSBCAPS_LOCSOFTWARE)
 450                 FE(DSBCAPS_CTRL3D)
 451                 FE(DSBCAPS_CTRLFREQUENCY)
 452                 FE(DSBCAPS_CTRLPAN)
 453                 FE(DSBCAPS_CTRLVOLUME)
 454                 FE(DSBCAPS_CTRLPOSITIONNOTIFY)
 455                 FE(DSBCAPS_CTRLDEFAULT)
 456                 FE(DSBCAPS_CTRLALL)
 457                 FE(DSBCAPS_STICKYFOCUS)
 458                 FE(DSBCAPS_GLOBALFOCUS)
 459                 FE(DSBCAPS_GETCURRENTPOSITION2)
 460                 FE(DSBCAPS_MUTE3DATMAXDISTANCE)
 461 #undef FE
 462         };
 463         int     i;
 464
 465         for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 466                 if ((flags[i].mask & xmask) == flags[i].mask)
 467                         DPRINTF("%s ",flags[i].name);
 468 }
 469
 470 /*******************************************************************************
 471  *              IDirectSound
 472  */
 473
 474 static HRESULT WINAPI IDirectSoundImpl_SetCooperativeLevel(
 475         LPDIRECTSOUND8 iface,HWND hwnd,DWORD level
 476 ) {
 477         ICOM_THIS(IDirectSoundImpl,iface);
 478         TRACE("(%p,%08lx,%ld)\n",This,(DWORD)hwnd,level);
 479
 480         if (level==DSSCL_PRIORITY || level==DSSCL_EXCLUSIVE) {
 481                 FIXME("level=%s not fully supported\n",
 482                         level==DSSCL_PRIORITY ? "DSSCL_PRIORITY" : "DSSCL_EXCLUSIVE");
 483         }
 484
 485         This->priolevel = level;
 486
 487         return DS_OK;
 488 }
 489
 490 static HRESULT WINAPI IDirectSoundImpl_CreateSoundBuffer(
 491         LPDIRECTSOUND8 iface,LPCDSBUFFERDESC dsbd,LPLPDIRECTSOUNDBUFFER8 ppdsb,LPUNKNOWN lpunk
 492 ) {
 493         ICOM_THIS(IDirectSoundImpl,iface);
 494         LPWAVEFORMATEX  wfex;
 495         HRESULT hres = DS_OK;
 496
 497         TRACE("(%p,%p,%p,%p)\n",This,dsbd,ppdsb,lpunk);
 498
 499         if (This == NULL) {
 500                 WARN("invalid parameter: This == NULL\n");
 501                 return DSERR_INVALIDPARAM;
 502         }
 503
 504         if (dsbd == NULL) {
 505                 WARN("invalid parameter: dsbd == NULL\n");
 506                 return DSERR_INVALIDPARAM;
 507         }
 508
 509         if (ppdsb == NULL) {
 510                 WARN("invalid parameter: ppdsb == NULL\n");
 511                 return DSERR_INVALIDPARAM;
 512         }
 513
 514         if (TRACE_ON(dsound)) {
 515                 TRACE("(structsize=%ld)\n",dsbd->dwSize);
 516                 TRACE("(flags=0x%08lx:\n",dsbd->dwFlags);
 517                 _dump_DSBCAPS(dsbd->dwFlags);
 518                 DPRINTF(")\n");
 519                 TRACE("(bufferbytes=%ld)\n",dsbd->dwBufferBytes);
 520                 TRACE("(lpwfxFormat=%p)\n",dsbd->lpwfxFormat);
 521         }
 522
 523         wfex = dsbd->lpwfxFormat;
 524
 525         if (wfex)
 526                 TRACE("(formattag=0x%04x,chans=%d,samplerate=%ld,"
 527                    "bytespersec=%ld,blockalign=%d,bitspersamp=%d,cbSize=%d)\n",
 528                    wfex->wFormatTag, wfex->nChannels, wfex->nSamplesPerSec,
 529                    wfex->nAvgBytesPerSec, wfex->nBlockAlign,
 530                    wfex->wBitsPerSample, wfex->cbSize);
 531
 532         if (dsbd->dwFlags & DSBCAPS_PRIMARYBUFFER) {
 533                 if (This->primary) {
 534                         WARN("Primary Buffer already created\n");
 535                         IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER8)(This->primary));
 536                         *ppdsb = (LPDIRECTSOUNDBUFFER8)(This->primary);
 537                 } else {
 538                         This->dsbd = *dsbd;
 539                         hres = PrimaryBufferImpl_Create(This, (PrimaryBufferImpl**)&(This->primary), &(This->dsbd));
 540                         if (This->primary) {
 541                                 IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER8)(This->primary));
 542                                 *ppdsb = (LPDIRECTSOUNDBUFFER8)(This->primary);
 543                         } else
 544                                 WARN("PrimaryBufferImpl_Create failed\n");
 545                 }
 546         } else {
 547                 IDirectSoundBufferImpl * dsb;
 548                 hres = IDirectSoundBufferImpl_Create(This, (IDirectSoundBufferImpl**)&dsb, dsbd);
 549                 if (dsb) {
 550                         hres = SecondaryBufferImpl_Create(dsb, (SecondaryBufferImpl**)ppdsb);
 551                         if (*ppdsb) {
 552                                 dsb->dsb = (SecondaryBufferImpl*)*ppdsb;
 553                                 IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER8)*ppdsb);
 554                         } else
 555                                 WARN("SecondaryBufferImpl_Create failed\n");
 556                 } else
 557                         WARN("IDirectSoundBufferImpl_Create failed\n");
 558         }
 559
 560         return hres;
 561 }
 562
 563 static HRESULT WINAPI IDirectSoundImpl_DuplicateSoundBuffer(
 564         LPDIRECTSOUND8 iface,LPDIRECTSOUNDBUFFER8 psb,LPLPDIRECTSOUNDBUFFER8 ppdsb
 565 ) {
 566         ICOM_THIS(IDirectSoundImpl,iface);
 567         IDirectSoundBufferImpl* pdsb;
 568         IDirectSoundBufferImpl* dsb;
 569         HRESULT hres = DS_OK;
 570         TRACE("(%p,%p,%p)\n",This,psb,ppdsb);
 571
 572         if (This == NULL) {
 573                 WARN("invalid parameter: This == NULL\n");
 574                 return DSERR_INVALIDPARAM;
 575         }
 576
 577         if (psb == NULL) {
 578                 WARN("invalid parameter: psb == NULL\n");
 579                 return DSERR_INVALIDPARAM;
 580         }
 581
 582         if (ppdsb == NULL) {
 583                 WARN("invalid parameter: ppdsb == NULL\n");
 584                 return DSERR_INVALIDPARAM;
 585         }
 586
 587         /* FIXME: hack to make sure we have a secondary buffer */
 588         if ((DWORD)((SecondaryBufferImpl *)psb)->dsb == (DWORD)This) {
 589                 ERR("trying to duplicate primary buffer\n");
 590                 *ppdsb = NULL;
 591                 return DSERR_INVALIDCALL;
 592         }
 593
 594         pdsb = ((SecondaryBufferImpl *)psb)->dsb;
 595
 596         dsb = (IDirectSoundBufferImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(*dsb));
 597
 598         if (dsb == NULL) {
 599                 WARN("out of memory\n");
 600                 *ppdsb = NULL;
 601                 return DSERR_OUTOFMEMORY;
 602         }
 603
 604         memcpy(dsb, pdsb, sizeof(IDirectSoundBufferImpl));
 605
 606         if (pdsb->hwbuf) {
 607                 TRACE("duplicating hardware buffer\n");
 608
 609                 hres = IDsDriver_DuplicateSoundBuffer(This->driver, pdsb->hwbuf, (LPVOID *)&dsb->hwbuf);
 610                 if (hres != DS_OK) {
 611                         TRACE("IDsDriver_DuplicateSoundBuffer failed, falling back to software buffer\n");
 612                         dsb->hwbuf = NULL;
 613                         /* allocate buffer */
 614                         if (This->drvdesc.dwFlags & DSDDESC_USESYSTEMMEMORY) {
 615                                 dsb->buffer = HeapAlloc(GetProcessHeap(),0,sizeof(*(dsb->buffer)));
 616                                 if (dsb->buffer == NULL) {
 617                                         WARN("out of memory\n");
 618                                         HeapFree(GetProcessHeap(),0,dsb);
 619                                         *ppdsb = NULL;
 620                                         return DSERR_OUTOFMEMORY;
 621                                 }
 622
 623                                 dsb->buffer->memory = (LPBYTE)HeapAlloc(GetProcessHeap(),0,dsb->buflen);
 624                                 if (dsb->buffer->memory == NULL) {
 625                                         WARN("out of memory\n");
 626                                         HeapFree(GetProcessHeap(),0,dsb->buffer);
 627                                         HeapFree(GetProcessHeap(),0,dsb);
 628                                         *ppdsb = NULL;
 629                                         return DSERR_OUTOFMEMORY;
 630                                 }
 631                                 dsb->buffer->ref = 1;
 632
 633                                 /* FIXME: copy buffer ? */
 634                         }
 635                 }
 636         } else {
 637                 dsb->hwbuf = NULL;
 638                 dsb->buffer->ref++;
 639         }
 640
 641         dsb->ref = 0;
 642         dsb->state = STATE_STOPPED;
 643         dsb->playpos = 0;
 644         dsb->buf_mixpos = 0;
 645         dsb->dsound = This;
 646         dsb->ds3db = NULL;
 647         dsb->iks = NULL; /* FIXME? */
 648         dsb->dsb = NULL;
 649         memcpy(&(dsb->wfx), &(pdsb->wfx), sizeof(dsb->wfx));
 650         InitializeCriticalSection(&(dsb->lock));
 651         /* register buffer */
 652         RtlAcquireResourceExclusive(&(This->lock), TRUE);
 653         {
 654                 IDirectSoundBufferImpl **newbuffers;
 655                 if (This->buffers)
 656                         newbuffers = (IDirectSoundBufferImpl**)HeapReAlloc(GetProcessHeap(),0,This->buffers,sizeof(IDirectSoundBufferImpl**)*(This->nrofbuffers+1));
 657                 else
 658                         newbuffers = (IDirectSoundBufferImpl**)HeapAlloc(GetProcessHeap(),0,sizeof(IDirectSoundBufferImpl**)*(This->nrofbuffers+1));
 659
 660                 if (newbuffers) {
 661                         This->buffers = newbuffers;
 662                         This->buffers[This->nrofbuffers] = dsb;
 663                         This->nrofbuffers++;
 664                         TRACE("buffer count is now %d\n", This->nrofbuffers);
 665                 } else {
 666                         ERR("out of memory for buffer list! Current buffer count is %d\n", This->nrofbuffers);
 667                         IDirectSoundBuffer8_Release(psb);
 668                         DeleteCriticalSection(&(dsb->lock));
 669                         RtlReleaseResource(&(This->lock));
 670                         HeapFree(GetProcessHeap(),0,dsb);
 671                         *ppdsb = 0;
 672                         return DSERR_OUTOFMEMORY;
 673                 }
 674         }
 675         RtlReleaseResource(&(This->lock));
 676         IDirectSound_AddRef(iface);
 677         hres = SecondaryBufferImpl_Create(dsb, (SecondaryBufferImpl**)ppdsb);
 678         if (*ppdsb) {
 679                 dsb->dsb = (SecondaryBufferImpl*)*ppdsb;
 680                 IDirectSoundBuffer_AddRef((LPDIRECTSOUNDBUFFER8)*ppdsb);
 681         } else
 682                 WARN("SecondaryBufferImpl_Create failed\n");
 683
 684         return hres;
 685 }
 686
 687 static HRESULT WINAPI IDirectSoundImpl_GetCaps(LPDIRECTSOUND8 iface,LPDSCAPS lpDSCaps) {
 688         ICOM_THIS(IDirectSoundImpl,iface);
 689         TRACE("(%p,%p)\n",This,lpDSCaps);
 690
 691         if (This == NULL) {
 692                 WARN("invalid parameter: This == NULL\n");
 693                 return DSERR_INVALIDPARAM;
 694         }
 695
 696         if (lpDSCaps == NULL) {
 697                 WARN("invalid parameter: lpDSCaps = NULL\n");
 698                 return DSERR_INVALIDPARAM;
 699         }
 700
 701         /* check is there is enough room */
 702         if (lpDSCaps->dwSize < sizeof(*lpDSCaps)) {
 703                 WARN("invalid parameter: lpDSCaps->dwSize = %ld < %d\n",
 704                         lpDSCaps->dwSize, sizeof(*lpDSCaps));
 705                 return DSERR_INVALIDPARAM;
 706         }
 707
 708         lpDSCaps->dwFlags                               = This->drvcaps.dwFlags;
 709         TRACE("(flags=0x%08lx)\n",lpDSCaps->dwFlags);
 710
 711         lpDSCaps->dwMinSecondarySampleRate              = This->drvcaps.dwMinSecondarySampleRate;
 712         lpDSCaps->dwMaxSecondarySampleRate              = This->drvcaps.dwMaxSecondarySampleRate;
 713
 714         lpDSCaps->dwPrimaryBuffers                      = This->drvcaps.dwPrimaryBuffers;
 715
 716         lpDSCaps->dwMaxHwMixingAllBuffers               = This->drvcaps.dwMaxHwMixingAllBuffers;
 717         lpDSCaps->dwMaxHwMixingStaticBuffers            = This->drvcaps.dwMaxHwMixingStaticBuffers;
 718         lpDSCaps->dwMaxHwMixingStreamingBuffers         = This->drvcaps.dwMaxHwMixingStreamingBuffers;
 719
 720         lpDSCaps->dwFreeHwMixingAllBuffers              = This->drvcaps.dwFreeHwMixingAllBuffers;
 721         lpDSCaps->dwFreeHwMixingStaticBuffers           = This->drvcaps.dwFreeHwMixingStaticBuffers;
 722         lpDSCaps->dwFreeHwMixingStreamingBuffers        = This->drvcaps.dwFreeHwMixingStreamingBuffers;
 723
 724         lpDSCaps->dwMaxHw3DAllBuffers                   = This->drvcaps.dwMaxHw3DAllBuffers;
 725         lpDSCaps->dwMaxHw3DStaticBuffers                = This->drvcaps.dwMaxHw3DStaticBuffers;
 726         lpDSCaps->dwMaxHw3DStreamingBuffers             = This->drvcaps.dwMaxHw3DStreamingBuffers;
 727
 728         lpDSCaps->dwFreeHw3DAllBuffers                  = This->drvcaps.dwFreeHw3DAllBuffers;
 729         lpDSCaps->dwFreeHw3DStaticBuffers               = This->drvcaps.dwFreeHw3DStaticBuffers;
 730         lpDSCaps->dwFreeHw3DStreamingBuffers            = This->drvcaps.dwFreeHw3DStreamingBuffers;
 731
 732         lpDSCaps->dwTotalHwMemBytes                     = This->drvcaps.dwTotalHwMemBytes;
 733
 734         lpDSCaps->dwFreeHwMemBytes                      = This->drvcaps.dwFreeHwMemBytes;
 735
 736         lpDSCaps->dwMaxContigFreeHwMemBytes             = This->drvcaps.dwMaxContigFreeHwMemBytes;
 737
 738         /* driver doesn't have these */
 739         lpDSCaps->dwUnlockTransferRateHwBuffers         = 4096; /* But we have none... */
 740
 741         lpDSCaps->dwPlayCpuOverheadSwBuffers            = 1;    /* 1% */
 742
 743         return DS_OK;
 744 }
 745
 746 static ULONG WINAPI IDirectSoundImpl_AddRef(LPDIRECTSOUND8 iface) {
 747         ICOM_THIS(IDirectSoundImpl,iface);
 748         TRACE("(%p) ref was %ld, thread is %04lx\n", This, This->ref, GetCurrentThreadId());
 749         return InterlockedIncrement(&This->ref);
 750 }
 751
 752 static ULONG WINAPI IDirectSoundImpl_Release(LPDIRECTSOUND8 iface) {
 753         ICOM_THIS(IDirectSoundImpl,iface);
 754         ULONG ulReturn;
 755
 756         TRACE("(%p) ref was %ld, thread is %04lx\n", This, This->ref, GetCurrentThreadId());
 757         ulReturn = InterlockedDecrement(&This->ref);
 758         if (ulReturn == 0) {
 759                 HRESULT hres;
 760                 UINT i;
 761
 762                 timeKillEvent(This->timerID);
 763                 timeEndPeriod(DS_TIME_RES);
 764                 /* wait for timer to expire */
 765                 Sleep(DS_TIME_RES+1);
 766
 767                 RtlAcquireResourceShared(&(This->lock), TRUE);
 768
 769                 if (This->buffers) {
 770                         for( i=0;i<This->nrofbuffers;i++)
 771                                 IDirectSoundBuffer8_Release((LPDIRECTSOUNDBUFFER8)This->buffers[i]);
 772                 }
 773
 774                 RtlReleaseResource(&(This->lock));
 775
 776                 if (This->primary) {
 777                         WARN("primary buffer not released\n");
 778                         IDirectSoundBuffer8_Release((LPDIRECTSOUNDBUFFER8)This->primary);
 779                 }
 780
 781                 hres = DSOUND_PrimaryDestroy(This);
 782                 if (hres != DS_OK)
 783                         WARN("DSOUND_PrimaryDestroy failed\n");
 784
 785                 if (This->driver)
 786                         IDsDriver_Close(This->driver);
 787
 788                 if (This->drvdesc.dwFlags & DSDDESC_DOMMSYSTEMOPEN)
 789                         waveOutClose(This->hwo);
 790
 791                 if (This->driver)
 792                         IDsDriver_Release(This->driver);
 793
 794                 RtlDeleteResource(&This->lock);
 795                 DeleteCriticalSection(&This->mixlock);
 796                 DeleteCriticalSection(&This->ds3dl_lock);
 797                 HeapFree(GetProcessHeap(),0,This);
 798                 dsound = NULL;
 799                 TRACE("(%p) released\n",This);
 800         }
 801
 802         return ulReturn;
 803 }
 804
 805 static HRESULT WINAPI IDirectSoundImpl_SetSpeakerConfig(
 806         LPDIRECTSOUND8 iface,DWORD config
 807 ) {
 808         ICOM_THIS(IDirectSoundImpl,iface);
 809         TRACE("(%p,0x%08lx)\n",This,config);
 810
 811         This->speaker_config = config;
 812
 813         WARN("not fully functional\n");
 814         return DS_OK;
 815 }
 816
 817 static HRESULT WINAPI IDirectSoundImpl_QueryInterface(
 818         LPDIRECTSOUND8 iface,REFIID riid,LPVOID *ppobj
 819 ) {
 820         ICOM_THIS(IDirectSoundImpl,iface);
 821         TRACE("(%p,%s,%p)\n",This,debugstr_guid(riid),ppobj);
 822
 823         if (ppobj == NULL) {
 824                 WARN("invalid parameter\n");
 825                 return E_INVALIDARG;
 826         }
 827
 828         *ppobj = NULL;  /* assume failure */
 829
 830         if ( IsEqualGUID(riid, &IID_IUnknown) ||
 831              IsEqualGUID(riid, &IID_IDirectSound) ||
 832              IsEqualGUID(riid, &IID_IDirectSound8) ) {
 833                 IDirectSound8_AddRef((LPDIRECTSOUND8)This);
 834                 *ppobj = This;
 835                 return S_OK;
 836         }
 837
 838         if ( IsEqualGUID( &IID_IDirectSound3DListener, riid ) ) {
 839                 WARN("app requested IDirectSound3DListener on dsound object\n");
 840                 return E_NOINTERFACE;
 841         }
 842
 843         FIXME( "Unknown IID %s\n", debugstr_guid( riid ) );
 844         return E_NOINTERFACE;
 845 }
 846
 847 static HRESULT WINAPI IDirectSoundImpl_Compact(
 848         LPDIRECTSOUND8 iface)
 849 {
 850         ICOM_THIS(IDirectSoundImpl,iface);
 851         TRACE("(%p)\n", This);
 852         return DS_OK;
 853 }
 854
 855 static HRESULT WINAPI IDirectSoundImpl_GetSpeakerConfig(
 856         LPDIRECTSOUND8 iface,
 857         LPDWORD lpdwSpeakerConfig)
 858 {
 859         ICOM_THIS(IDirectSoundImpl,iface);
 860         TRACE("(%p, %p)\n", This, lpdwSpeakerConfig);
 861
 862         if (lpdwSpeakerConfig == NULL) {
 863                 WARN("invalid parameter\n");
 864                 return DSERR_INVALIDPARAM;
 865         }
 866
 867         WARN("not fully functional\n");
 868
 869         *lpdwSpeakerConfig = This->speaker_config;
 870
 871         return DS_OK;
 872 }
 873
 874 static HRESULT WINAPI IDirectSoundImpl_Initialize(
 875         LPDIRECTSOUND8 iface,
 876         LPCGUID lpcGuid)
 877 {
 878         ICOM_THIS(IDirectSoundImpl,iface);
 879         TRACE("(%p, %s)\n", This, debugstr_guid(lpcGuid));
 880         return DS_OK;
 881 }
 882
 883 static HRESULT WINAPI IDirectSoundImpl_VerifyCertification(
 884         LPDIRECTSOUND8 iface,
 885         LPDWORD pdwCertified)
 886 {
 887         ICOM_THIS(IDirectSoundImpl,iface);
 888         TRACE("(%p, %p)\n", This, pdwCertified);
 889         *pdwCertified = DS_CERTIFIED;
 890         return DS_OK;
 891 }
 892
 893 static ICOM_VTABLE(IDirectSound8) dsvt =
 894 {
 895         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 896         IDirectSoundImpl_QueryInterface,
 897         IDirectSoundImpl_AddRef,
 898         IDirectSoundImpl_Release,
 899         IDirectSoundImpl_CreateSoundBuffer,
 900         IDirectSoundImpl_GetCaps,
 901         IDirectSoundImpl_DuplicateSoundBuffer,
 902         IDirectSoundImpl_SetCooperativeLevel,
 903         IDirectSoundImpl_Compact,
 904         IDirectSoundImpl_GetSpeakerConfig,
 905         IDirectSoundImpl_SetSpeakerConfig,
 906         IDirectSoundImpl_Initialize,
 907         IDirectSoundImpl_VerifyCertification
 908 };
 909
 910
 911 /*******************************************************************************
 912  *              DirectSoundCreate (DSOUND.1)
 913  *
 914  *  Creates and initializes a DirectSound interface.
 915  *
 916  *  PARAMS
 917  *     lpcGUID   [I] Address of the GUID that identifies the sound device.
 918  *     ppDS      [O] Address of a variable to receive the interface pointer.
 919  *     pUnkOuter [I] Must be NULL.
 920  *
 921  *  RETURNS
 922  *     Success: DS_OK
 923  *     Failure: DSERR_ALLOCATED, DSERR_INVALIDPARAM, DSERR_NOAGGREGATION,
 924  *              DSERR_NODRIVER, DSERR_OUTOFMEMORY
 925  */
 926 HRESULT WINAPI DirectSoundCreate8(LPCGUID lpcGUID,LPDIRECTSOUND8 *ppDS,IUnknown *pUnkOuter )
 927 {
 928         IDirectSoundImpl** ippDS=(IDirectSoundImpl**)ppDS;
 929         PIDSDRIVER drv = NULL;
 930         unsigned wod, wodn;
 931         HRESULT err = DSERR_INVALIDPARAM;
 932         GUID devGuid;
 933         BOOLEAN found = FALSE;
 934
 935         TRACE("(%s,%p,%p)\n",debugstr_guid(lpcGUID),ippDS,pUnkOuter);
 936
 937         if (ippDS == NULL) {
 938                 WARN("invalid parameter: ippDS == NULL\n");
 939                 return DSERR_INVALIDPARAM;
 940         }
 941
 942         /* Get dsound configuration */
 943         setup_dsound_options();
 944
 945         /* Default device? */
 946         if (!lpcGUID || IsEqualGUID(lpcGUID, &GUID_NULL))
 947                 lpcGUID = &DSDEVID_DefaultPlayback;
 948
 949         if (GetDeviceID(lpcGUID, &devGuid) != DS_OK) {
 950                 WARN("invalid parameter: lpcGUID\n");
 951                 *ippDS = NULL;
 952                 return DSERR_INVALIDPARAM;
 953         }
 954
 955         if (dsound) {
 956                 if (IsEqualGUID(&devGuid, &dsound->guid) ) {
 957                         /* FIXME: this is wrong, need to create a new instance */
 958                         ERR("dsound already opened\n");
 959                         IDirectSound_AddRef((LPDIRECTSOUND)dsound);
 960                         *ippDS = dsound;
 961                         return DS_OK;
 962                 } else {
 963                         ERR("different dsound already opened\n");
 964                 }
 965         }
 966
 967         /* Enumerate WINMM audio devices and find the one we want */
 968         wodn = waveOutGetNumDevs();
 969         if (!wodn) {
 970                 WARN("no driver\n");
 971                 *ippDS = NULL;
 972                 return DSERR_NODRIVER;
 973         }
 974
 975         TRACE(" expecting GUID %s.\n", debugstr_guid(&devGuid));
 976
 977         for (wod=0; wod<wodn; wod++) {
 978                 GUID guid;
 979                 err = mmErr(waveOutMessage((HWAVEOUT)wod,DRV_QUERYDSOUNDGUID,(DWORD)(&guid),0));
 980                 if (err != DS_OK) {
 981                         WARN("waveOutMessage failed; err=%lx\n",err);
 982                         *ippDS = NULL;
 983                         return err;
 984                 }
 985                 TRACE("got GUID %s for wod %d.\n", debugstr_guid(&guid), wod);
 986                 if (IsEqualGUID( &devGuid, &guid) ) {
 987                         err = DS_OK;
 988                         found = TRUE;
 989                         break;
 990                 }
 991         }
 992
 993         if (err != DS_OK) {
 994                 WARN("invalid parameter\n");
 995                 *ippDS = NULL;
 996                 return DSERR_INVALIDPARAM;
 997         }
 998
 999         if (found == FALSE) {
1000                 WARN("No device found matching given ID - trying with default one !\n");
1001                 wod = ds_default_playback;
1002         }
1003
1004         /* DRV_QUERYDSOUNDIFACE is a "Wine extension" to get the DSound interface */
1005         waveOutMessage((HWAVEOUT)wod, DRV_QUERYDSOUNDIFACE, (DWORD)&drv, 0);
1006
1007         /* Disable the direct sound driver to force emulation if requested. */
1008         if (ds_hw_accel == DS_HW_ACCEL_EMULATION)
1009             drv = NULL;
1010
1011         /* Allocate memory */
1012         *ippDS = (IDirectSoundImpl*)HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(IDirectSoundImpl));
1013         if (*ippDS == NULL) {
1014                 WARN("out of memory\n");
1015                 return DSERR_OUTOFMEMORY;
1016         }
1017
1018         (*ippDS)->lpVtbl        = &dsvt;
1019         (*ippDS)->ref           = 1;
1020
1021         (*ippDS)->driver        = drv;
1022         (*ippDS)->priolevel     = DSSCL_NORMAL;
1023         (*ippDS)->fraglen       = 0;
1024         (*ippDS)->hwbuf         = NULL;
1025         (*ippDS)->buffer        = NULL;
1026         (*ippDS)->buflen        = 0;
1027         (*ippDS)->writelead     = 0;
1028         (*ippDS)->state         = STATE_STOPPED;
1029         (*ippDS)->nrofbuffers   = 0;
1030         (*ippDS)->buffers       = NULL;
1031         (*ippDS)->primary       = NULL;
1032         (*ippDS)->speaker_config = DSSPEAKER_STEREO | (DSSPEAKER_GEOMETRY_NARROW << 16);
1033
1034         /* 3D listener initial parameters */
1035         (*ippDS)->listener      = NULL;
1036         (*ippDS)->ds3dl.dwSize = sizeof(DS3DLISTENER);
1037         (*ippDS)->ds3dl.vPosition.x = 0.0;
1038         (*ippDS)->ds3dl.vPosition.y = 0.0;
1039         (*ippDS)->ds3dl.vPosition.z = 0.0;
1040         (*ippDS)->ds3dl.vVelocity.x = 0.0;
1041         (*ippDS)->ds3dl.vVelocity.y = 0.0;
1042         (*ippDS)->ds3dl.vVelocity.z = 0.0;
1043         (*ippDS)->ds3dl.vOrientFront.x = 0.0;
1044         (*ippDS)->ds3dl.vOrientFront.y = 0.0;
1045         (*ippDS)->ds3dl.vOrientFront.z = 1.0;
1046         (*ippDS)->ds3dl.vOrientTop.x = 0.0;
1047         (*ippDS)->ds3dl.vOrientTop.y = 1.0;
1048         (*ippDS)->ds3dl.vOrientTop.z = 0.0;
1049         (*ippDS)->ds3dl.flDistanceFactor = DS3D_DEFAULTDISTANCEFACTOR;
1050         (*ippDS)->ds3dl.flRolloffFactor = DS3D_DEFAULTROLLOFFFACTOR;
1051         (*ippDS)->ds3dl.flDopplerFactor = DS3D_DEFAULTDOPPLERFACTOR;
1052
1053         InitializeCriticalSection(&(*ippDS)->ds3dl_lock);
1054
1055         (*ippDS)->prebuf        = ds_snd_queue_max;
1056         (*ippDS)->guid          = devGuid;
1057
1058         /* Get driver description */
1059         if (drv) {
1060                 err = IDsDriver_GetDriverDesc(drv,&((*ippDS)->drvdesc));
1061                 if (err != DS_OK) {
1062                         WARN("IDsDriver_GetDriverDesc failed\n");
1063                         HeapFree(GetProcessHeap(),0,*ippDS);
1064                         *ippDS = NULL;
1065                         return err;
1066                 }
1067         } else {
1068                 /* if no DirectSound interface available, use WINMM API instead */
1069                 (*ippDS)->drvdesc.dwFlags = DSDDESC_DOMMSYSTEMOPEN | DSDDESC_DOMMSYSTEMSETFORMAT;
1070         }
1071
1072         (*ippDS)->drvdesc.dnDevNode = wod;
1073
1074         /* Set default wave format (may need it for waveOutOpen) */
1075         (*ippDS)->wfx.wFormatTag        = WAVE_FORMAT_PCM;
1076         /* We rely on the sound driver to return the actual sound format of
1077          * the device if it does not support 22050x8x2 and is given the
1078          * WAVE_DIRECTSOUND flag.
1079          */
1080         (*ippDS)->wfx.nSamplesPerSec = 22050;
1081         (*ippDS)->wfx.wBitsPerSample = 8;
1082         (*ippDS)->wfx.nChannels = 2;
1083         (*ippDS)->wfx.nBlockAlign = (*ippDS)->wfx.wBitsPerSample * (*ippDS)->wfx.nChannels / 8;
1084         (*ippDS)->wfx.nAvgBytesPerSec = (*ippDS)->wfx.nSamplesPerSec * (*ippDS)->wfx.nBlockAlign;
1085         (*ippDS)->wfx.cbSize = 0;
1086
1087         /* If the driver requests being opened through MMSYSTEM
1088          * (which is recommended by the DDK), it is supposed to happen
1089          * before the DirectSound interface is opened */
1090         if ((*ippDS)->drvdesc.dwFlags & DSDDESC_DOMMSYSTEMOPEN)
1091         {
1092                 DWORD flags = CALLBACK_FUNCTION;
1093
1094                 /* disable direct sound if requested */
1095                 if (ds_hw_accel != DS_HW_ACCEL_EMULATION)
1096                     flags |= WAVE_DIRECTSOUND;
1097
1098                 err = mmErr(waveOutOpen(&((*ippDS)->hwo),
1099                                           (*ippDS)->drvdesc.dnDevNode, &((*ippDS)->wfx),
1100                                           (DWORD)DSOUND_callback, (DWORD)(*ippDS),
1101                                           flags));
1102                 if (err != DS_OK) {
1103                         WARN("waveOutOpen failed\n");
1104                         HeapFree(GetProcessHeap(),0,*ippDS);
1105                         *ippDS = NULL;
1106                         return err;
1107                 }
1108         }
1109
1110         if (drv) {
1111                 err = IDsDriver_Open(drv);
1112                 if (err != DS_OK) {
1113                         WARN("IDsDriver_Open failed\n");
1114                         HeapFree(GetProcessHeap(),0,*ippDS);
1115                         *ippDS = NULL;
1116                         return err;
1117                 }
1118
1119                 /* the driver is now open, so it's now allowed to call GetCaps */
1120                 err = IDsDriver_GetCaps(drv,&((*ippDS)->drvcaps));
1121                 if (err != DS_OK) {
1122                         WARN("IDsDriver_GetCaps failed\n");
1123                         HeapFree(GetProcessHeap(),0,*ippDS);
1124                         *ippDS = NULL;
1125                         return err;
1126                 }
1127         } else {
1128                 WAVEOUTCAPSA woc;
1129                 err = mmErr(waveOutGetDevCapsA((*ippDS)->drvdesc.dnDevNode, &woc, sizeof(woc)));
1130                 if (err != DS_OK) {
1131                         WARN("waveOutGetDevCaps failed\n");
1132                         HeapFree(GetProcessHeap(),0,*ippDS);
1133                         *ippDS = NULL;
1134                         return err;
1135                 }
1136                 ZeroMemory(&(*ippDS)->drvcaps, sizeof((*ippDS)->drvcaps));
1137                 if ((woc.dwFormats & WAVE_FORMAT_1M08) ||
1138                     (woc.dwFormats & WAVE_FORMAT_2M08) ||
1139                     (woc.dwFormats & WAVE_FORMAT_4M08) ||
1140                     (woc.dwFormats & WAVE_FORMAT_48M08) ||
1141                     (woc.dwFormats & WAVE_FORMAT_96M08)) {
1142                         (*ippDS)->drvcaps.dwFlags |= DSCAPS_PRIMARY8BIT;
1143                         (*ippDS)->drvcaps.dwFlags |= DSCAPS_PRIMARYMONO;
1144                 }
1145                 if ((woc.dwFormats & WAVE_FORMAT_1M16) ||
1146                     (woc.dwFormats & WAVE_FORMAT_2M16) ||
1147                     (woc.dwFormats & WAVE_FORMAT_4M16) ||
1148                     (woc.dwFormats & WAVE_FORMAT_48M16) ||
1149                     (woc.dwFormats & WAVE_FORMAT_96M16)) {
1150                         (*ippDS)->drvcaps.dwFlags |= DSCAPS_PRIMARY16BIT;
1151                         (*ippDS)->drvcaps.dwFlags |= DSCAPS_PRIMARYMONO;
1152                 }
1153                 if ((woc.dwFormats & WAVE_FORMAT_1S08) ||
1154                     (woc.dwFormats & WAVE_FORMAT_2S08) ||
1155                     (woc.dwFormats & WAVE_FORMAT_4S08) ||
1156                     (woc.dwFormats & WAVE_FORMAT_48S08) ||
1157                     (woc.dwFormats & WAVE_FORMAT_96S08)) {
1158                         (*ippDS)->drvcaps.dwFlags |= DSCAPS_PRIMARY8BIT;
1159                         (*ippDS)->drvcaps.dwFlags |= DSCAPS_PRIMARYSTEREO;
1160                 }
1161                 if ((woc.dwFormats & WAVE_FORMAT_1S16) ||
1162                     (woc.dwFormats & WAVE_FORMAT_2S16) ||
1163                     (woc.dwFormats & WAVE_FORMAT_4S16) ||
1164                     (woc.dwFormats & WAVE_FORMAT_48S16) ||
1165                     (woc.dwFormats & WAVE_FORMAT_96S16)) {
1166                         (*ippDS)->drvcaps.dwFlags |= DSCAPS_PRIMARY16BIT;
1167                         (*ippDS)->drvcaps.dwFlags |= DSCAPS_PRIMARYSTEREO;
1168                 }
1169                 if (ds_emuldriver)
1170                     (*ippDS)->drvcaps.dwFlags |= DSCAPS_EMULDRIVER;
1171                 (*ippDS)->drvcaps.dwMinSecondarySampleRate = DSBFREQUENCY_MIN;
1172                 (*ippDS)->drvcaps.dwMaxSecondarySampleRate = DSBFREQUENCY_MAX;
1173                 (*ippDS)->drvcaps.dwPrimaryBuffers = 1;
1174         }
1175
1176         (*ippDS)->volpan.lVolume = 0;
1177         (*ippDS)->volpan.lPan = 0;
1178         DSOUND_RecalcVolPan(&((*ippDS)->volpan));
1179
1180         InitializeCriticalSection(&((*ippDS)->mixlock));
1181         RtlInitializeResource(&((*ippDS)->lock));
1182
1183         if (!dsound) {
1184                 HRESULT hres;
1185                 dsound = (*ippDS);
1186                 hres = DSOUND_PrimaryCreate(dsound);
1187                 if (hres != DS_OK) {
1188                         WARN("DSOUND_PrimaryCreate failed\n");
1189                         return hres;
1190                 }
1191                 timeBeginPeriod(DS_TIME_RES);
1192                 dsound->timerID = timeSetEvent(DS_TIME_DEL, DS_TIME_RES, DSOUND_timer,
1193                                                (DWORD)dsound, TIME_PERIODIC | TIME_CALLBACK_FUNCTION);
1194         }
1195
1196         return DS_OK;
1197 }
1198
1199
1200 /*******************************************************************************
1201  * DirectSound ClassFactory
1202  */
1203
1204 static HRESULT WINAPI
1205 DSCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
1206         ICOM_THIS(IClassFactoryImpl,iface);
1207
1208         FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
1209         return E_NOINTERFACE;
1210 }
1211
1212 static ULONG WINAPI
1213 DSCF_AddRef(LPCLASSFACTORY iface) {
1214         ICOM_THIS(IClassFactoryImpl,iface);
1215         TRACE("(%p) ref was %ld\n", This, This->ref);
1216         return ++(This->ref);
1217 }
1218
1219 static ULONG WINAPI DSCF_Release(LPCLASSFACTORY iface) {
1220         ICOM_THIS(IClassFactoryImpl,iface);
1221         /* static class, won't be  freed */
1222         TRACE("(%p) ref was %ld\n", This, This->ref);
1223         return --(This->ref);
1224 }
1225
1226 static HRESULT WINAPI DSCF_CreateInstance(
1227         LPCLASSFACTORY iface,LPUNKNOWN pOuter,REFIID riid,LPVOID *ppobj
1228 ) {
1229         ICOM_THIS(IClassFactoryImpl,iface);
1230         TRACE("(%p)->(%p,%s,%p)\n",This,pOuter,debugstr_guid(riid),ppobj);
1231
1232         if (ppobj == NULL) {
1233                 WARN("invalid parameter\n");
1234                 return DSERR_INVALIDPARAM;
1235         }
1236
1237         *ppobj = NULL;
1238
1239         if ( IsEqualGUID( &IID_IDirectSound, riid ) ||
1240              IsEqualGUID( &IID_IDirectSound8, riid ) ) {
1241                 /* FIXME: reuse already created dsound if present? */
1242                 return DirectSoundCreate8(0,(LPDIRECTSOUND8*)ppobj,pOuter);
1243         }
1244
1245         WARN("(%p,%p,%s,%p) Interface not found!\n",This,pOuter,debugstr_guid(riid),ppobj);
1246         return E_NOINTERFACE;
1247 }
1248
1249 static HRESULT WINAPI DSCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
1250         ICOM_THIS(IClassFactoryImpl,iface);
1251         FIXME("(%p)->(%d),stub!\n",This,dolock);
1252         return S_OK;
1253 }
1254
1255 static ICOM_VTABLE(IClassFactory) DSCF_Vtbl = {
1256         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1257         DSCF_QueryInterface,
1258         DSCF_AddRef,
1259         DSCF_Release,
1260         DSCF_CreateInstance,
1261         DSCF_LockServer
1262 };
1263
1264 static IClassFactoryImpl DSOUND_CF = { &DSCF_Vtbl, 1 };
1265
1266 /*******************************************************************************
1267  * DirectSoundPrivate ClassFactory
1268  */
1269
1270 static HRESULT WINAPI
1271 DSPCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
1272         ICOM_THIS(IClassFactoryImpl,iface);
1273
1274         FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
1275         return E_NOINTERFACE;
1276 }
1277
1278 static ULONG WINAPI
1279 DSPCF_AddRef(LPCLASSFACTORY iface) {
1280         ICOM_THIS(IClassFactoryImpl,iface);
1281         TRACE("(%p) ref was %ld\n", This, This->ref);
1282         return ++(This->ref);
1283 }
1284
1285 static ULONG WINAPI
1286 DSPCF_Release(LPCLASSFACTORY iface) {
1287         ICOM_THIS(IClassFactoryImpl,iface);
1288         /* static class, won't be  freed */
1289         TRACE("(%p) ref was %ld\n", This, This->ref);
1290         return --(This->ref);
1291 }
1292
1293 static HRESULT WINAPI
1294 DSPCF_CreateInstance(
1295         LPCLASSFACTORY iface,LPUNKNOWN pOuter,REFIID riid,LPVOID *ppobj
1296 ) {
1297         ICOM_THIS(IClassFactoryImpl,iface);
1298         TRACE("(%p)->(%p,%s,%p)\n",This,pOuter,debugstr_guid(riid),ppobj);
1299
1300         if (ppobj == NULL) {
1301                 WARN("invalid parameter\n");
1302                 return DSERR_INVALIDPARAM;
1303         }
1304
1305         *ppobj = NULL;
1306
1307         if ( IsEqualGUID( &IID_IKsPropertySet, riid ) ) {
1308                 return IKsPrivatePropertySetImpl_Create((IKsPrivatePropertySetImpl**)ppobj);
1309         }
1310
1311         WARN("(%p,%p,%s,%p) Interface not found!\n",This,pOuter,debugstr_guid(riid),ppobj);
1312         return E_NOINTERFACE;
1313 }
1314
1315 static HRESULT WINAPI
1316 DSPCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
1317         ICOM_THIS(IClassFactoryImpl,iface);
1318         FIXME("(%p)->(%d),stub!\n",This,dolock);
1319         return S_OK;
1320 }
1321
1322 static ICOM_VTABLE(IClassFactory) DSPCF_Vtbl = {
1323         ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
1324         DSPCF_QueryInterface,
1325         DSPCF_AddRef,
1326         DSPCF_Release,
1327         DSPCF_CreateInstance,
1328         DSPCF_LockServer
1329 };
1330
1331 static IClassFactoryImpl DSOUND_PRIVATE_CF = { &DSPCF_Vtbl, 1 };
1332
1333 /*******************************************************************************
1334  * DllGetClassObject [DSOUND.5]
1335  * Retrieves class object from a DLL object
1336  *
1337  * NOTES
1338  *    Docs say returns STDAPI
1339  *
1340  * PARAMS
1341  *    rclsid [I] CLSID for the class object
1342  *    riid   [I] Reference to identifier of interface for class object
1343  *    ppv    [O] Address of variable to receive interface pointer for riid
1344  *
1345  * RETURNS
1346  *    Success: S_OK
1347  *    Failure: CLASS_E_CLASSNOTAVAILABLE, E_OUTOFMEMORY, E_INVALIDARG,
1348  *             E_UNEXPECTED
1349  */
1350 DWORD WINAPI DSOUND_DllGetClassObject(REFCLSID rclsid,REFIID riid,LPVOID *ppv)
1351 {
1352     TRACE("(%s,%s,%p)\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
1353
1354     if (ppv == NULL) {
1355         WARN("invalid parameter\n");
1356         return E_INVALIDARG;
1357     }
1358
1359     *ppv = NULL;
1360
1361     if ( IsEqualCLSID( &CLSID_DirectSound, rclsid ) ||
1362          IsEqualCLSID( &CLSID_DirectSound8, rclsid ) ) {
1363         if ( IsEqualCLSID( &IID_IClassFactory, riid ) ) {
1364             *ppv = (LPVOID)&DSOUND_CF;
1365             IClassFactory_AddRef((IClassFactory*)*ppv);
1366             return S_OK;
1367         }
1368         WARN("(%s,%s,%p): no interface found.\n",
1369             debugstr_guid(rclsid), debugstr_guid(riid), ppv);
1370         return S_FALSE;
1371     }
1372
1373     if ( IsEqualCLSID( &CLSID_DirectSoundCapture, rclsid ) ||
1374          IsEqualCLSID( &CLSID_DirectSoundCapture8, rclsid ) ) {
1375         if ( IsEqualCLSID( &IID_IClassFactory, riid ) ) {
1376             *ppv = (LPVOID)&DSOUND_CAPTURE_CF;
1377             IClassFactory_AddRef((IClassFactory*)*ppv);
1378             return S_OK;
1379         }
1380         WARN("(%s,%s,%p): no interface found.\n",
1381             debugstr_guid(rclsid), debugstr_guid(riid), ppv);
1382         return S_FALSE;
1383     }
1384
1385     if ( IsEqualCLSID( &CLSID_DirectSoundFullDuplex, rclsid ) ) {
1386         if ( IsEqualCLSID( &IID_IClassFactory, riid ) ) {
1387             *ppv = (LPVOID)&DSOUND_FULLDUPLEX_CF;
1388             IClassFactory_AddRef((IClassFactory*)*ppv);
1389             return S_OK;
1390         }
1391         WARN("(%s,%s,%p): no interface found.\n",
1392             debugstr_guid(rclsid), debugstr_guid(riid), ppv);
1393         return S_FALSE;
1394     }
1395
1396     if ( IsEqualCLSID( &CLSID_DirectSoundPrivate, rclsid ) ) {
1397         if ( IsEqualCLSID( &IID_IClassFactory, riid ) ) {
1398             *ppv = (LPVOID)&DSOUND_PRIVATE_CF;
1399             IClassFactory_AddRef((IClassFactory*)*ppv);
1400             return S_OK;
1401         }
1402         WARN("(%s,%s,%p): no interface found.\n",
1403             debugstr_guid(rclsid), debugstr_guid(riid), ppv);
1404         return S_FALSE;
1405     }
1406
1407     WARN("(%s,%s,%p): no class found.\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
1408     return CLASS_E_CLASSNOTAVAILABLE;
1409 }
1410
1411
1412 /*******************************************************************************
1413  * DllCanUnloadNow [DSOUND.4]
1414  * Determines whether the DLL is in use.
1415  *
1416  * RETURNS
1417  *    Success: S_OK
1418  *    Failure: S_FALSE
1419  */
1420 DWORD WINAPI DSOUND_DllCanUnloadNow(void)
1421 {
1422     FIXME("(void): stub\n");
1423     return S_FALSE;
1424 }