dlls/dsound/dsound.c

   1 /* DirectSound
   2  *
   3  * Copyright 1998 Marcus Meissner
   4  * Copyright 1998 Rob Riggs
   5  * Copyright 2000-2002 TransGaming Technologies, Inc.
   6  * Copyright 2004 Robert Reif
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #include <assert.h>
  24 #include <stdarg.h>
  25 #include <stdio.h>
  26 #include <math.h>
  27
  28 #define COBJMACROS
  29
  30 #include "windef.h"
  31 #include "winbase.h"
  32 #include "winuser.h"
  33 #include "winternl.h"
  34 #include "mmddk.h"
  35 #include "wingdi.h"
  36 #include "mmreg.h"
  37 #include "ks.h"
  38 #include "ksmedia.h"
  39 #include "wine/debug.h"
  40 #include "dsound.h"
  41 #include "dsound_private.h"
  42
  43 WINE_DEFAULT_DEBUG_CHANNEL(dsound);
  44
  45 typedef struct IDirectSoundImpl {
  46     IUnknown            IUnknown_inner;
  47     IDirectSound8       IDirectSound8_iface;
  48     IUnknown           *outer_unk;      /* internal */
  49     LONG                ref, refds, numIfaces;
  50     DirectSoundDevice  *device;
  51     BOOL                has_ds8;
  52 } IDirectSoundImpl;
  53
  54 static const char * dumpCooperativeLevel(DWORD level)
  55 {
  56 #define LE(x) case x: return #x
  57     switch (level) {
  58         LE(DSSCL_NORMAL);
  59         LE(DSSCL_PRIORITY);
  60         LE(DSSCL_EXCLUSIVE);
  61         LE(DSSCL_WRITEPRIMARY);
  62     }
  63 #undef LE
  64     return wine_dbg_sprintf("Unknown(%08x)", level);
  65 }
  66
  67 static void _dump_DSCAPS(DWORD xmask) {
  68     struct {
  69         DWORD   mask;
  70         const char    *name;
  71     } flags[] = {
  72 #define FE(x) { x, #x },
  73         FE(DSCAPS_PRIMARYMONO)
  74         FE(DSCAPS_PRIMARYSTEREO)
  75         FE(DSCAPS_PRIMARY8BIT)
  76         FE(DSCAPS_PRIMARY16BIT)
  77         FE(DSCAPS_CONTINUOUSRATE)
  78         FE(DSCAPS_EMULDRIVER)
  79         FE(DSCAPS_CERTIFIED)
  80         FE(DSCAPS_SECONDARYMONO)
  81         FE(DSCAPS_SECONDARYSTEREO)
  82         FE(DSCAPS_SECONDARY8BIT)
  83         FE(DSCAPS_SECONDARY16BIT)
  84 #undef FE
  85     };
  86     unsigned int     i;
  87
  88     for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
  89         if ((flags[i].mask & xmask) == flags[i].mask)
  90             TRACE("%s ",flags[i].name);
  91 }
  92
  93 static void _dump_DSBCAPS(DWORD xmask) {
  94     struct {
  95         DWORD   mask;
  96         const char    *name;
  97     } flags[] = {
  98 #define FE(x) { x, #x },
  99         FE(DSBCAPS_PRIMARYBUFFER)
 100         FE(DSBCAPS_STATIC)
 101         FE(DSBCAPS_LOCHARDWARE)
 102         FE(DSBCAPS_LOCSOFTWARE)
 103         FE(DSBCAPS_CTRL3D)
 104         FE(DSBCAPS_CTRLFREQUENCY)
 105         FE(DSBCAPS_CTRLPAN)
 106         FE(DSBCAPS_CTRLVOLUME)
 107         FE(DSBCAPS_CTRLPOSITIONNOTIFY)
 108         FE(DSBCAPS_STICKYFOCUS)
 109         FE(DSBCAPS_GLOBALFOCUS)
 110         FE(DSBCAPS_GETCURRENTPOSITION2)
 111         FE(DSBCAPS_MUTE3DATMAXDISTANCE)
 112 #undef FE
 113     };
 114     unsigned int     i;
 115
 116     for (i=0;i<sizeof(flags)/sizeof(flags[0]);i++)
 117         if ((flags[i].mask & xmask) == flags[i].mask)
 118             TRACE("%s ",flags[i].name);
 119 }
 120
 121 /*******************************************************************************
 122  *        DirectSoundDevice
 123  */
 124 static HRESULT DirectSoundDevice_Create(DirectSoundDevice ** ppDevice)
 125 {
 126     DirectSoundDevice * device;
 127     TRACE("(%p)\n", ppDevice);
 128
 129     /* Allocate memory */
 130     device = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(DirectSoundDevice));
 131     if (device == NULL) {
 132         WARN("out of memory\n");
 133         return DSERR_OUTOFMEMORY;
 134     }
 135
 136     device->ref            = 1;
 137     device->priolevel      = DSSCL_NORMAL;
 138     device->stopped        = 1;
 139     device->speaker_config = DSSPEAKER_COMBINED(DSSPEAKER_STEREO, DSSPEAKER_GEOMETRY_WIDE);
 140
 141     DSOUND_ParseSpeakerConfig(device);
 142
 143     /* 3D listener initial parameters */
 144     device->ds3dl.dwSize   = sizeof(DS3DLISTENER);
 145     device->ds3dl.vPosition.x = 0.0;
 146     device->ds3dl.vPosition.y = 0.0;
 147     device->ds3dl.vPosition.z = 0.0;
 148     device->ds3dl.vVelocity.x = 0.0;
 149     device->ds3dl.vVelocity.y = 0.0;
 150     device->ds3dl.vVelocity.z = 0.0;
 151     device->ds3dl.vOrientFront.x = 0.0;
 152     device->ds3dl.vOrientFront.y = 0.0;
 153     device->ds3dl.vOrientFront.z = 1.0;
 154     device->ds3dl.vOrientTop.x = 0.0;
 155     device->ds3dl.vOrientTop.y = 1.0;
 156     device->ds3dl.vOrientTop.z = 0.0;
 157     device->ds3dl.flDistanceFactor = DS3D_DEFAULTDISTANCEFACTOR;
 158     device->ds3dl.flRolloffFactor = DS3D_DEFAULTROLLOFFFACTOR;
 159     device->ds3dl.flDopplerFactor = DS3D_DEFAULTDOPPLERFACTOR;
 160
 161     device->guid = GUID_NULL;
 162
 163     /* Set default wave format (may need it for waveOutOpen) */
 164     device->primary_pwfx = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,sizeof(WAVEFORMATEXTENSIBLE));
 165     if (!device->primary_pwfx) {
 166         WARN("out of memory\n");
 167         HeapFree(GetProcessHeap(),0,device);
 168         return DSERR_OUTOFMEMORY;
 169     }
 170
 171     device->primary_pwfx->wFormatTag = WAVE_FORMAT_PCM;
 172     device->primary_pwfx->nSamplesPerSec = 22050;
 173     device->primary_pwfx->wBitsPerSample = 8;
 174     device->primary_pwfx->nChannels = 2;
 175     device->primary_pwfx->nBlockAlign = device->primary_pwfx->wBitsPerSample * device->primary_pwfx->nChannels / 8;
 176     device->primary_pwfx->nAvgBytesPerSec = device->primary_pwfx->nSamplesPerSec * device->primary_pwfx->nBlockAlign;
 177     device->primary_pwfx->cbSize = 0;
 178
 179     InitializeCriticalSection(&(device->mixlock));
 180     device->mixlock.DebugInfo->Spare[0] = (DWORD_PTR)(__FILE__ ": DirectSoundDevice.mixlock");
 181
 182     RtlInitializeResource(&(device->buffer_list_lock));
 183
 184    *ppDevice = device;
 185
 186     return DS_OK;
 187 }
 188
 189 static ULONG DirectSoundDevice_AddRef(DirectSoundDevice * device)
 190 {
 191     ULONG ref = InterlockedIncrement(&(device->ref));
 192     TRACE("(%p) ref was %d\n", device, ref - 1);
 193     return ref;
 194 }
 195
 196 static ULONG DirectSoundDevice_Release(DirectSoundDevice * device)
 197 {
 198     HRESULT hr;
 199     ULONG ref = InterlockedDecrement(&(device->ref));
 200     TRACE("(%p) ref was %u\n", device, ref + 1);
 201     if (!ref) {
 202         int i;
 203
 204         SetEvent(device->sleepev);
 205         if (device->thread) {
 206             WaitForSingleObject(device->thread_finished, INFINITE);
 207             CloseHandle(device->thread);
 208             CloseHandle(device->thread_finished);
 209         }
 210         CloseHandle(device->sleepev);
 211
 212         EnterCriticalSection(&DSOUND_renderers_lock);
 213         list_remove(&device->entry);
 214         LeaveCriticalSection(&DSOUND_renderers_lock);
 215
 216         /* It is allowed to release this object even when buffers are playing */
 217         if (device->buffers) {
 218             WARN("%d secondary buffers not released\n", device->nrofbuffers);
 219             for( i=0;i<device->nrofbuffers;i++)
 220                 secondarybuffer_destroy(device->buffers[i]);
 221         }
 222
 223         hr = DSOUND_PrimaryDestroy(device);
 224         if (hr != DS_OK)
 225             WARN("DSOUND_PrimaryDestroy failed\n");
 226
 227         if(device->client) {
 228             IAudioClient_Stop(device->client);
 229             IAudioClient_Release(device->client);
 230         }
 231         if(device->render)
 232             IAudioRenderClient_Release(device->render);
 233         if(device->volume)
 234             IAudioStreamVolume_Release(device->volume);
 235         if(device->mmdevice)
 236             IMMDevice_Release(device->mmdevice);
 237         HeapFree(GetProcessHeap(), 0, device->tmp_buffer);
 238         HeapFree(GetProcessHeap(), 0, device->cp_buffer);
 239         HeapFree(GetProcessHeap(), 0, device->buffer);
 240         RtlDeleteResource(&device->buffer_list_lock);
 241         device->mixlock.DebugInfo->Spare[0] = 0;
 242         DeleteCriticalSection(&device->mixlock);
 243         HeapFree(GetProcessHeap(),0,device);
 244         TRACE("(%p) released\n", device);
 245     }
 246     return ref;
 247 }
 248
 249 BOOL DSOUND_check_supported(IAudioClient *client, DWORD rate,
 250         DWORD depth, WORD channels)
 251 {
 252     WAVEFORMATEX fmt, *junk;
 253     HRESULT hr;
 254
 255     fmt.wFormatTag = WAVE_FORMAT_PCM;
 256     fmt.nChannels = channels;
 257     fmt.nSamplesPerSec = rate;
 258     fmt.wBitsPerSample = depth;
 259     fmt.nBlockAlign = (channels * depth) / 8;
 260     fmt.nAvgBytesPerSec = rate * fmt.nBlockAlign;
 261     fmt.cbSize = 0;
 262
 263     hr = IAudioClient_IsFormatSupported(client, AUDCLNT_SHAREMODE_SHARED, &fmt, &junk);
 264     if(SUCCEEDED(hr))
 265         CoTaskMemFree(junk);
 266
 267     return hr == S_OK;
 268 }
 269
 270 static HRESULT DirectSoundDevice_Initialize(DirectSoundDevice ** ppDevice, LPCGUID lpcGUID)
 271 {
 272     HRESULT hr = DS_OK;
 273     GUID devGUID;
 274     DirectSoundDevice *device;
 275     IMMDevice *mmdevice;
 276
 277     TRACE("(%p,%s)\n",ppDevice,debugstr_guid(lpcGUID));
 278
 279     if (*ppDevice != NULL) {
 280         WARN("already initialized\n");
 281         return DSERR_ALREADYINITIALIZED;
 282     }
 283
 284     /* Default device? */
 285     if (!lpcGUID || IsEqualGUID(lpcGUID, &GUID_NULL))
 286         lpcGUID = &DSDEVID_DefaultPlayback;
 287
 288     if(IsEqualGUID(lpcGUID, &DSDEVID_DefaultCapture) ||
 289             IsEqualGUID(lpcGUID, &DSDEVID_DefaultVoiceCapture))
 290         return DSERR_NODRIVER;
 291
 292     if (GetDeviceID(lpcGUID, &devGUID) != DS_OK) {
 293         WARN("invalid parameter: lpcGUID\n");
 294         return DSERR_INVALIDPARAM;
 295     }
 296
 297     hr = get_mmdevice(eRender, &devGUID, &mmdevice);
 298     if(FAILED(hr))
 299         return hr;
 300
 301     EnterCriticalSection(&DSOUND_renderers_lock);
 302
 303     LIST_FOR_EACH_ENTRY(device, &DSOUND_renderers, DirectSoundDevice, entry){
 304         if(IsEqualGUID(&device->guid, &devGUID)){
 305             IMMDevice_Release(mmdevice);
 306             DirectSoundDevice_AddRef(device);
 307             *ppDevice = device;
 308             LeaveCriticalSection(&DSOUND_renderers_lock);
 309             return DS_OK;
 310         }
 311     }
 312
 313     hr = DirectSoundDevice_Create(&device);
 314     if(FAILED(hr)){
 315         WARN("DirectSoundDevice_Create failed\n");
 316         IMMDevice_Release(mmdevice);
 317         LeaveCriticalSection(&DSOUND_renderers_lock);
 318         return hr;
 319     }
 320
 321     device->mmdevice = mmdevice;
 322     device->guid = devGUID;
 323     device->sleepev = CreateEventW(0, 0, 0, 0);
 324     device->buflen = ds_hel_buflen;
 325
 326     hr = DSOUND_ReopenDevice(device, FALSE);
 327     if (FAILED(hr))
 328     {
 329         HeapFree(GetProcessHeap(), 0, device);
 330         LeaveCriticalSection(&DSOUND_renderers_lock);
 331         IMMDevice_Release(mmdevice);
 332         WARN("DSOUND_ReopenDevice failed: %08x\n", hr);
 333         return hr;
 334     }
 335
 336     ZeroMemory(&device->drvcaps, sizeof(device->drvcaps));
 337
 338     if(DSOUND_check_supported(device->client, 11025, 8, 1) ||
 339             DSOUND_check_supported(device->client, 22050, 8, 1) ||
 340             DSOUND_check_supported(device->client, 44100, 8, 1) ||
 341             DSOUND_check_supported(device->client, 48000, 8, 1) ||
 342             DSOUND_check_supported(device->client, 96000, 8, 1))
 343         device->drvcaps.dwFlags |= DSCAPS_PRIMARY8BIT | DSCAPS_PRIMARYMONO;
 344
 345     if(DSOUND_check_supported(device->client, 11025, 16, 1) ||
 346             DSOUND_check_supported(device->client, 22050, 16, 1) ||
 347             DSOUND_check_supported(device->client, 44100, 16, 1) ||
 348             DSOUND_check_supported(device->client, 48000, 16, 1) ||
 349             DSOUND_check_supported(device->client, 96000, 16, 1))
 350         device->drvcaps.dwFlags |= DSCAPS_PRIMARY16BIT | DSCAPS_PRIMARYMONO;
 351
 352     if(DSOUND_check_supported(device->client, 11025, 8, 2) ||
 353             DSOUND_check_supported(device->client, 22050, 8, 2) ||
 354             DSOUND_check_supported(device->client, 44100, 8, 2) ||
 355             DSOUND_check_supported(device->client, 48000, 8, 2) ||
 356             DSOUND_check_supported(device->client, 96000, 8, 2))
 357         device->drvcaps.dwFlags |= DSCAPS_PRIMARY8BIT | DSCAPS_PRIMARYSTEREO;
 358
 359     if(DSOUND_check_supported(device->client, 11025, 16, 2) ||
 360             DSOUND_check_supported(device->client, 22050, 16, 2) ||
 361             DSOUND_check_supported(device->client, 44100, 16, 2) ||
 362             DSOUND_check_supported(device->client, 48000, 16, 2) ||
 363             DSOUND_check_supported(device->client, 96000, 16, 2))
 364         device->drvcaps.dwFlags |= DSCAPS_PRIMARY16BIT | DSCAPS_PRIMARYSTEREO;
 365
 366     /* the dsound mixer supports all of the following */
 367     device->drvcaps.dwFlags |= DSCAPS_SECONDARY8BIT | DSCAPS_SECONDARY16BIT;
 368     device->drvcaps.dwFlags |= DSCAPS_SECONDARYMONO | DSCAPS_SECONDARYSTEREO;
 369     device->drvcaps.dwFlags |= DSCAPS_CONTINUOUSRATE;
 370
 371     /* pretend that the driver is certified */
 372     device->drvcaps.dwFlags |= DSCAPS_CERTIFIED;
 373
 374     device->drvcaps.dwPrimaryBuffers = 1;
 375     device->drvcaps.dwMinSecondarySampleRate = DSBFREQUENCY_MIN;
 376     device->drvcaps.dwMaxSecondarySampleRate = DSBFREQUENCY_MAX;
 377     device->drvcaps.dwMaxHwMixingAllBuffers = 16;
 378     device->drvcaps.dwMaxHwMixingStaticBuffers = device->drvcaps.dwMaxHwMixingAllBuffers;
 379     device->drvcaps.dwMaxHwMixingStreamingBuffers = device->drvcaps.dwMaxHwMixingAllBuffers;
 380     device->drvcaps.dwFreeHwMixingAllBuffers = device->drvcaps.dwMaxHwMixingAllBuffers;
 381     device->drvcaps.dwFreeHwMixingStaticBuffers = device->drvcaps.dwMaxHwMixingStaticBuffers;
 382     device->drvcaps.dwFreeHwMixingStreamingBuffers = device->drvcaps.dwMaxHwMixingStreamingBuffers;
 383
 384     ZeroMemory(&device->volpan, sizeof(device->volpan));
 385
 386     device->thread_finished = CreateEventW(0, 0, 0, 0);
 387     device->thread = CreateThread(0, 0, DSOUND_mixthread, device, 0, 0);
 388     SetThreadPriority(device->thread, THREAD_PRIORITY_TIME_CRITICAL);
 389
 390     *ppDevice = device;
 391     list_add_tail(&DSOUND_renderers, &device->entry);
 392
 393     LeaveCriticalSection(&DSOUND_renderers_lock);
 394
 395     return hr;
 396 }
 397
 398 static HRESULT DirectSoundDevice_CreateSoundBuffer(
 399     DirectSoundDevice * device,
 400     LPCDSBUFFERDESC dsbd,
 401     LPLPDIRECTSOUNDBUFFER ppdsb,
 402     LPUNKNOWN lpunk,
 403     BOOL from8)
 404 {
 405     HRESULT hres = DS_OK;
 406     TRACE("(%p,%p,%p,%p)\n",device,dsbd,ppdsb,lpunk);
 407
 408     if (device == NULL) {
 409         WARN("not initialized\n");
 410         return DSERR_UNINITIALIZED;
 411     }
 412
 413     if (dsbd == NULL) {
 414         WARN("invalid parameter: dsbd == NULL\n");
 415         return DSERR_INVALIDPARAM;
 416     }
 417
 418     if (dsbd->dwSize != sizeof(DSBUFFERDESC) &&
 419         dsbd->dwSize != sizeof(DSBUFFERDESC1)) {
 420         WARN("invalid parameter: dsbd\n");
 421         return DSERR_INVALIDPARAM;
 422     }
 423
 424     if (ppdsb == NULL) {
 425         WARN("invalid parameter: ppdsb == NULL\n");
 426         return DSERR_INVALIDPARAM;
 427     }
 428     *ppdsb = NULL;
 429
 430     if (TRACE_ON(dsound)) {
 431         TRACE("(structsize=%d)\n",dsbd->dwSize);
 432         TRACE("(flags=0x%08x:\n",dsbd->dwFlags);
 433         _dump_DSBCAPS(dsbd->dwFlags);
 434         TRACE(")\n");
 435         TRACE("(bufferbytes=%d)\n",dsbd->dwBufferBytes);
 436         TRACE("(lpwfxFormat=%p)\n",dsbd->lpwfxFormat);
 437     }
 438
 439     if (!(dsbd->dwFlags & DSBCAPS_PRIMARYBUFFER) &&
 440         dsbd->dwFlags & DSBCAPS_LOCHARDWARE &&
 441         device->drvcaps.dwFreeHwMixingAllBuffers == 0)
 442     {
 443         WARN("ran out of emulated hardware buffers\n");
 444         return DSERR_ALLOCATED;
 445     }
 446
 447     if (dsbd->dwFlags & DSBCAPS_PRIMARYBUFFER) {
 448         if (dsbd->lpwfxFormat != NULL) {
 449             WARN("invalid parameter: dsbd->lpwfxFormat must be NULL for "
 450                  "primary buffer\n");
 451             return DSERR_INVALIDPARAM;
 452         }
 453
 454         if (device->primary) {
 455             WARN("Primary Buffer already created\n");
 456             IDirectSoundBuffer8_AddRef(&device->primary->IDirectSoundBuffer8_iface);
 457             *ppdsb = (IDirectSoundBuffer *)&device->primary->IDirectSoundBuffer8_iface;
 458         } else {
 459             hres = primarybuffer_create(device, &device->primary, dsbd);
 460             if (device->primary) {
 461                 *ppdsb = (IDirectSoundBuffer*)&device->primary->IDirectSoundBuffer8_iface;
 462                 device->primary->dsbd.dwFlags &= ~(DSBCAPS_LOCHARDWARE | DSBCAPS_LOCSOFTWARE);
 463                 device->primary->dsbd.dwFlags |= DSBCAPS_LOCSOFTWARE;
 464             } else
 465                 WARN("primarybuffer_create() failed\n");
 466         }
 467     } else {
 468         if (dsbd->lpwfxFormat == NULL) {
 469             WARN("invalid parameter: dsbd->lpwfxFormat can't be NULL for "
 470                  "secondary buffer\n");
 471             return DSERR_INVALIDPARAM;
 472         }
 473
 474         if(dsbd->lpwfxFormat->wFormatTag != WAVE_FORMAT_PCM &&
 475                 dsbd->lpwfxFormat->wFormatTag != WAVE_FORMAT_IEEE_FLOAT &&
 476                 dsbd->lpwfxFormat->wFormatTag != WAVE_FORMAT_EXTENSIBLE) {
 477             WARN("We can't mix this format: 0x%x\n", dsbd->lpwfxFormat->wFormatTag);
 478             return E_NOTIMPL;
 479         }
 480
 481         if(dsbd->lpwfxFormat->wBitsPerSample < 8 || dsbd->lpwfxFormat->wBitsPerSample % 8 != 0 ||
 482                 dsbd->lpwfxFormat->nChannels == 0 || dsbd->lpwfxFormat->nSamplesPerSec == 0 ||
 483                 dsbd->lpwfxFormat->nAvgBytesPerSec == 0 ||
 484                 dsbd->lpwfxFormat->nBlockAlign != dsbd->lpwfxFormat->nChannels * dsbd->lpwfxFormat->wBitsPerSample / 8) {
 485             WARN("Format inconsistency\n");
 486             return DSERR_INVALIDPARAM;
 487         }
 488
 489         if (dsbd->lpwfxFormat->wFormatTag == WAVE_FORMAT_EXTENSIBLE)
 490         {
 491             WAVEFORMATEXTENSIBLE *pwfxe = (WAVEFORMATEXTENSIBLE*)dsbd->lpwfxFormat;
 492
 493             /* check if cbSize is at least 22 bytes */
 494             if (pwfxe->Format.cbSize < (sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX)))
 495             {
 496                 WARN("Too small a cbSize %u\n", pwfxe->Format.cbSize);
 497                 return DSERR_INVALIDPARAM;
 498             }
 499
 500             /* cbSize should be 22 bytes, with one possible exception */
 501             if (pwfxe->Format.cbSize > (sizeof(WAVEFORMATEXTENSIBLE) - sizeof(WAVEFORMATEX)) &&
 502                 !((IsEqualGUID(&pwfxe->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM) || IsEqualGUID(&pwfxe->SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT)) &&
 503                 pwfxe->Format.cbSize == sizeof(WAVEFORMATEXTENSIBLE)))
 504             {
 505                 WARN("Too big a cbSize %u\n", pwfxe->Format.cbSize);
 506                 return DSERR_CONTROLUNAVAIL;
 507             }
 508
 509             if ((!IsEqualGUID(&pwfxe->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM)) && (!IsEqualGUID(&pwfxe->SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT)))
 510             {
 511                 if (!IsEqualGUID(&pwfxe->SubFormat, &GUID_NULL))
 512                     FIXME("SubFormat %s not supported right now.\n", debugstr_guid(&pwfxe->SubFormat));
 513                 return DSERR_INVALIDPARAM;
 514             }
 515             if (pwfxe->Samples.wValidBitsPerSample > dsbd->lpwfxFormat->wBitsPerSample)
 516             {
 517                 WARN("Samples.wValidBitsPerSample(%d) > Format.wBitsPerSample (%d)\n", pwfxe->Samples.wValidBitsPerSample, pwfxe->Format.wBitsPerSample);
 518                 return DSERR_INVALIDPARAM;
 519             }
 520             if (pwfxe->Samples.wValidBitsPerSample && pwfxe->Samples.wValidBitsPerSample < dsbd->lpwfxFormat->wBitsPerSample)
 521             {
 522                 WARN("Non-packed formats may not function : %d/%d\n", pwfxe->Samples.wValidBitsPerSample, dsbd->lpwfxFormat->wBitsPerSample);
 523             }
 524         }
 525
 526         TRACE("(formattag=0x%04x,chans=%d,samplerate=%d,"
 527               "bytespersec=%d,blockalign=%d,bitspersamp=%d,cbSize=%d)\n",
 528               dsbd->lpwfxFormat->wFormatTag, dsbd->lpwfxFormat->nChannels,
 529               dsbd->lpwfxFormat->nSamplesPerSec,
 530               dsbd->lpwfxFormat->nAvgBytesPerSec,
 531               dsbd->lpwfxFormat->nBlockAlign,
 532               dsbd->lpwfxFormat->wBitsPerSample, dsbd->lpwfxFormat->cbSize);
 533
 534         if (from8 && (dsbd->dwFlags & DSBCAPS_CTRL3D) && (dsbd->lpwfxFormat->nChannels != 1)) {
 535             WARN("invalid parameter: 3D buffer format must be mono\n");
 536             return DSERR_INVALIDPARAM;
 537         }
 538
 539         if (from8 && (dsbd->dwFlags & DSBCAPS_CTRL3D) && (dsbd->dwFlags & DSBCAPS_CTRLPAN)) {
 540             WARN("invalid parameter: DSBCAPS_CTRL3D and DSBCAPS_CTRLPAN cannot be used together\n");
 541             return DSERR_INVALIDPARAM;
 542         }
 543
 544         hres = secondarybuffer_create(device, dsbd, ppdsb);
 545         if (SUCCEEDED(hres)) {
 546             if (dsbd->dwFlags & DSBCAPS_LOCHARDWARE)
 547                 device->drvcaps.dwFreeHwMixingAllBuffers--;
 548         } else
 549             WARN("IDirectSoundBufferImpl_Create failed\n");
 550    }
 551
 552    return hres;
 553 }
 554
 555 static HRESULT DirectSoundDevice_DuplicateSoundBuffer(
 556     DirectSoundDevice * device,
 557     LPDIRECTSOUNDBUFFER psb,
 558     LPLPDIRECTSOUNDBUFFER ppdsb)
 559 {
 560     HRESULT hres = DS_OK;
 561     IDirectSoundBufferImpl* dsb;
 562     TRACE("(%p,%p,%p)\n",device,psb,ppdsb);
 563
 564     if (device == NULL) {
 565         WARN("not initialized\n");
 566         return DSERR_UNINITIALIZED;
 567     }
 568
 569     if (psb == NULL) {
 570         WARN("invalid parameter: psb == NULL\n");
 571         return DSERR_INVALIDPARAM;
 572     }
 573
 574     if (ppdsb == NULL) {
 575         WARN("invalid parameter: ppdsb == NULL\n");
 576         return DSERR_INVALIDPARAM;
 577     }
 578
 579     /* make sure we have a secondary buffer */
 580     if (psb == (IDirectSoundBuffer *)&device->primary->IDirectSoundBuffer8_iface) {
 581         WARN("trying to duplicate primary buffer\n");
 582         *ppdsb = NULL;
 583         return DSERR_INVALIDCALL;
 584     }
 585
 586     /* duplicate the actual buffer implementation */
 587     hres = IDirectSoundBufferImpl_Duplicate(device, &dsb, (IDirectSoundBufferImpl*)psb);
 588     if (hres == DS_OK)
 589         *ppdsb = (IDirectSoundBuffer*)&dsb->IDirectSoundBuffer8_iface;
 590     else
 591         WARN("IDirectSoundBufferImpl_Duplicate failed\n");
 592
 593     return hres;
 594 }
 595
 596 /*
 597  * Add secondary buffer to buffer list.
 598  * Gets exclusive access to buffer for writing.
 599  */
 600 HRESULT DirectSoundDevice_AddBuffer(
 601     DirectSoundDevice * device,
 602     IDirectSoundBufferImpl * pDSB)
 603 {
 604     IDirectSoundBufferImpl **newbuffers;
 605     HRESULT hr = DS_OK;
 606
 607     TRACE("(%p, %p)\n", device, pDSB);
 608
 609     RtlAcquireResourceExclusive(&(device->buffer_list_lock), TRUE);
 610
 611     if (device->buffers)
 612         newbuffers = HeapReAlloc(GetProcessHeap(),0,device->buffers,sizeof(IDirectSoundBufferImpl*)*(device->nrofbuffers+1));
 613     else
 614         newbuffers = HeapAlloc(GetProcessHeap(),0,sizeof(IDirectSoundBufferImpl*)*(device->nrofbuffers+1));
 615
 616     if (newbuffers) {
 617         device->buffers = newbuffers;
 618         device->buffers[device->nrofbuffers] = pDSB;
 619         device->nrofbuffers++;
 620         TRACE("buffer count is now %d\n", device->nrofbuffers);
 621     } else {
 622         ERR("out of memory for buffer list! Current buffer count is %d\n", device->nrofbuffers);
 623         hr = DSERR_OUTOFMEMORY;
 624     }
 625
 626     RtlReleaseResource(&(device->buffer_list_lock));
 627
 628     return hr;
 629 }
 630
 631 /*
 632  * Remove secondary buffer from buffer list.
 633  * Gets exclusive access to buffer for writing.
 634  */
 635 void DirectSoundDevice_RemoveBuffer(DirectSoundDevice * device, IDirectSoundBufferImpl * pDSB)
 636 {
 637     int i;
 638
 639     TRACE("(%p, %p)\n", device, pDSB);
 640
 641     RtlAcquireResourceExclusive(&(device->buffer_list_lock), TRUE);
 642
 643     if (device->nrofbuffers == 1) {
 644         assert(device->buffers[0] == pDSB);
 645         HeapFree(GetProcessHeap(), 0, device->buffers);
 646         device->buffers = NULL;
 647     } else {
 648         for (i = 0; i < device->nrofbuffers; i++) {
 649             if (device->buffers[i] == pDSB) {
 650                 /* Put the last buffer of the list in the (now empty) position */
 651                 device->buffers[i] = device->buffers[device->nrofbuffers - 1];
 652                 break;
 653             }
 654         }
 655     }
 656     device->nrofbuffers--;
 657     TRACE("buffer count is now %d\n", device->nrofbuffers);
 658
 659     RtlReleaseResource(&(device->buffer_list_lock));
 660 }
 661
 662 /*******************************************************************************
 663  *      IUnknown Implementation for DirectSound
 664  */
 665
 666 static void directsound_destroy(IDirectSoundImpl *This)
 667 {
 668     if (This->device)
 669         DirectSoundDevice_Release(This->device);
 670     HeapFree(GetProcessHeap(),0,This);
 671     TRACE("(%p) released\n", This);
 672 }
 673
 674 static inline IDirectSoundImpl *impl_from_IUnknown(IUnknown *iface)
 675 {
 676     return CONTAINING_RECORD(iface, IDirectSoundImpl, IUnknown_inner);
 677 }
 678
 679 static HRESULT WINAPI IUnknownImpl_QueryInterface(IUnknown *iface, REFIID riid, void **ppv)
 680 {
 681     IDirectSoundImpl *This = impl_from_IUnknown(iface);
 682
 683     TRACE("(%p,%s,%p)\n", This, debugstr_guid(riid), ppv);
 684
 685     if (!ppv) {
 686         WARN("invalid parameter\n");
 687         return E_INVALIDARG;
 688     }
 689     *ppv = NULL;
 690
 691     if (IsEqualIID(riid, &IID_IUnknown))
 692         *ppv = &This->IUnknown_inner;
 693     else if (IsEqualIID(riid, &IID_IDirectSound) ||
 694             (IsEqualIID(riid, &IID_IDirectSound8) && This->has_ds8))
 695         *ppv = &This->IDirectSound8_iface;
 696     else {
 697         WARN("unknown IID %s\n", debugstr_guid(riid));
 698         return E_NOINTERFACE;
 699     }
 700
 701     IUnknown_AddRef((IUnknown*)*ppv);
 702     return S_OK;
 703 }
 704
 705 static ULONG WINAPI IUnknownImpl_AddRef(IUnknown *iface)
 706 {
 707     IDirectSoundImpl *This = impl_from_IUnknown(iface);
 708     ULONG ref = InterlockedIncrement(&This->ref);
 709
 710     TRACE("(%p) ref=%d\n", This, ref);
 711
 712     if(ref == 1)
 713         InterlockedIncrement(&This->numIfaces);
 714
 715     return ref;
 716 }
 717
 718 static ULONG WINAPI IUnknownImpl_Release(IUnknown *iface)
 719 {
 720     IDirectSoundImpl *This = impl_from_IUnknown(iface);
 721     ULONG ref = InterlockedDecrement(&This->ref);
 722
 723     TRACE("(%p) ref=%d\n", This, ref);
 724
 725     if (!ref && !InterlockedDecrement(&This->numIfaces))
 726         directsound_destroy(This);
 727
 728     return ref;
 729 }
 730
 731 static const IUnknownVtbl unk_vtbl =
 732 {
 733     IUnknownImpl_QueryInterface,
 734     IUnknownImpl_AddRef,
 735     IUnknownImpl_Release
 736 };
 737
 738 /*******************************************************************************
 739  *      IDirectSound and IDirectSound8 Implementation
 740  */
 741 static inline IDirectSoundImpl *impl_from_IDirectSound8(IDirectSound8 *iface)
 742 {
 743     return CONTAINING_RECORD(iface, IDirectSoundImpl, IDirectSound8_iface);
 744 }
 745
 746 static HRESULT WINAPI IDirectSound8Impl_QueryInterface(IDirectSound8 *iface, REFIID riid,
 747         void **ppv)
 748 {
 749     IDirectSoundImpl *This = impl_from_IDirectSound8(iface);
 750     TRACE("(%p,%s,%p)\n", This, debugstr_guid(riid), ppv);
 751     return IUnknown_QueryInterface(This->outer_unk, riid, ppv);
 752 }
 753
 754 static ULONG WINAPI IDirectSound8Impl_AddRef(IDirectSound8 *iface)
 755 {
 756     IDirectSoundImpl *This = impl_from_IDirectSound8(iface);
 757     ULONG ref = InterlockedIncrement(&This->refds);
 758
 759     TRACE("(%p) refds=%d\n", This, ref);
 760
 761     if(ref == 1)
 762         InterlockedIncrement(&This->numIfaces);
 763
 764     return ref;
 765 }
 766
 767 static ULONG WINAPI IDirectSound8Impl_Release(IDirectSound8 *iface)
 768 {
 769     IDirectSoundImpl *This = impl_from_IDirectSound8(iface);
 770     ULONG ref = InterlockedDecrement(&(This->refds));
 771
 772     TRACE("(%p) refds=%d\n", This, ref);
 773
 774     if (!ref && !InterlockedDecrement(&This->numIfaces))
 775         directsound_destroy(This);
 776
 777     return ref;
 778 }
 779
 780 static HRESULT WINAPI IDirectSound8Impl_CreateSoundBuffer(IDirectSound8 *iface,
 781         const DSBUFFERDESC *dsbd, IDirectSoundBuffer **ppdsb, IUnknown *lpunk)
 782 {
 783     IDirectSoundImpl *This = impl_from_IDirectSound8(iface);
 784     TRACE("(%p,%p,%p,%p)\n", This, dsbd, ppdsb, lpunk);
 785     return DirectSoundDevice_CreateSoundBuffer(This->device, dsbd, ppdsb, lpunk, This->has_ds8);
 786 }
 787
 788 static HRESULT WINAPI IDirectSound8Impl_GetCaps(IDirectSound8 *iface, DSCAPS *dscaps)
 789 {
 790     IDirectSoundImpl *This = impl_from_IDirectSound8(iface);
 791
 792     TRACE("(%p, %p)\n", This, dscaps);
 793
 794     if (!This->device) {
 795         WARN("not initialized\n");
 796         return DSERR_UNINITIALIZED;
 797     }
 798     if (!dscaps) {
 799         WARN("invalid parameter: dscaps = NULL\n");
 800         return DSERR_INVALIDPARAM;
 801     }
 802     if (dscaps->dwSize < sizeof(*dscaps)) {
 803         WARN("invalid parameter: dscaps->dwSize = %d\n", dscaps->dwSize);
 804         return DSERR_INVALIDPARAM;
 805     }
 806
 807     dscaps->dwFlags                        = This->device->drvcaps.dwFlags;
 808     dscaps->dwMinSecondarySampleRate       = This->device->drvcaps.dwMinSecondarySampleRate;
 809     dscaps->dwMaxSecondarySampleRate       = This->device->drvcaps.dwMaxSecondarySampleRate;
 810     dscaps->dwPrimaryBuffers               = This->device->drvcaps.dwPrimaryBuffers;
 811     dscaps->dwMaxHwMixingAllBuffers        = This->device->drvcaps.dwMaxHwMixingAllBuffers;
 812     dscaps->dwMaxHwMixingStaticBuffers     = This->device->drvcaps.dwMaxHwMixingStaticBuffers;
 813     dscaps->dwMaxHwMixingStreamingBuffers  = This->device->drvcaps.dwMaxHwMixingStreamingBuffers;
 814     dscaps->dwFreeHwMixingAllBuffers       = This->device->drvcaps.dwFreeHwMixingAllBuffers;
 815     dscaps->dwFreeHwMixingStaticBuffers    = This->device->drvcaps.dwFreeHwMixingAllBuffers;
 816     dscaps->dwFreeHwMixingStreamingBuffers = This->device->drvcaps.dwFreeHwMixingAllBuffers;
 817
 818     dscaps->dwMaxHw3DAllBuffers            = This->device->drvcaps.dwMaxHw3DAllBuffers;
 819     dscaps->dwMaxHw3DStaticBuffers         = This->device->drvcaps.dwMaxHw3DStaticBuffers;
 820     dscaps->dwMaxHw3DStreamingBuffers      = This->device->drvcaps.dwMaxHw3DStreamingBuffers;
 821     dscaps->dwFreeHw3DAllBuffers           = This->device->drvcaps.dwFreeHw3DAllBuffers;
 822     dscaps->dwFreeHw3DStaticBuffers        = This->device->drvcaps.dwFreeHw3DStaticBuffers;
 823     dscaps->dwFreeHw3DStreamingBuffers     = This->device->drvcaps.dwFreeHw3DStreamingBuffers;
 824     dscaps->dwTotalHwMemBytes              = This->device->drvcaps.dwTotalHwMemBytes;
 825     dscaps->dwFreeHwMemBytes               = This->device->drvcaps.dwFreeHwMemBytes;
 826     dscaps->dwMaxContigFreeHwMemBytes      = This->device->drvcaps.dwMaxContigFreeHwMemBytes;
 827     dscaps->dwUnlockTransferRateHwBuffers  = This->device->drvcaps.dwUnlockTransferRateHwBuffers;
 828     dscaps->dwPlayCpuOverheadSwBuffers     = This->device->drvcaps.dwPlayCpuOverheadSwBuffers;
 829
 830     if (TRACE_ON(dsound)) {
 831         TRACE("(flags=0x%08x:\n", dscaps->dwFlags);
 832         _dump_DSCAPS(dscaps->dwFlags);
 833         TRACE(")\n");
 834     }
 835
 836     return DS_OK;
 837 }
 838
 839 static HRESULT WINAPI IDirectSound8Impl_DuplicateSoundBuffer(IDirectSound8 *iface,
 840         IDirectSoundBuffer *psb, IDirectSoundBuffer **ppdsb)
 841 {
 842     IDirectSoundImpl *This = impl_from_IDirectSound8(iface);
 843     TRACE("(%p,%p,%p)\n", This, psb, ppdsb);
 844     return DirectSoundDevice_DuplicateSoundBuffer(This->device, psb, ppdsb);
 845 }
 846
 847 static HRESULT WINAPI IDirectSound8Impl_SetCooperativeLevel(IDirectSound8 *iface, HWND hwnd,
 848         DWORD level)
 849 {
 850     IDirectSoundImpl *This = impl_from_IDirectSound8(iface);
 851     DirectSoundDevice *device = This->device;
 852     HRESULT hr = S_OK;
 853
 854     TRACE("(%p,%p,%s)\n", This, hwnd, dumpCooperativeLevel(level));
 855
 856     if (!device) {
 857         WARN("not initialized\n");
 858         return DSERR_UNINITIALIZED;
 859     }
 860
 861     if (level == DSSCL_PRIORITY || level == DSSCL_EXCLUSIVE) {
 862         WARN("level=%s not fully supported\n",
 863              level==DSSCL_PRIORITY ? "DSSCL_PRIORITY" : "DSSCL_EXCLUSIVE");
 864     }
 865
 866     RtlAcquireResourceExclusive(&device->buffer_list_lock, TRUE);
 867     EnterCriticalSection(&device->mixlock);
 868     if ((level == DSSCL_WRITEPRIMARY) != (device->priolevel == DSSCL_WRITEPRIMARY))
 869         hr = DSOUND_ReopenDevice(device, level == DSSCL_WRITEPRIMARY);
 870     if (SUCCEEDED(hr))
 871         device->priolevel = level;
 872     LeaveCriticalSection(&device->mixlock);
 873     RtlReleaseResource(&device->buffer_list_lock);
 874     return hr;
 875 }
 876
 877 static HRESULT WINAPI IDirectSound8Impl_Compact(IDirectSound8 *iface)
 878 {
 879     IDirectSoundImpl *This = impl_from_IDirectSound8(iface);
 880
 881     TRACE("(%p)\n", This);
 882
 883     if (!This->device) {
 884         WARN("not initialized\n");
 885         return DSERR_UNINITIALIZED;
 886     }
 887
 888     if (This->device->priolevel < DSSCL_PRIORITY) {
 889         WARN("incorrect priority level\n");
 890         return DSERR_PRIOLEVELNEEDED;
 891     }
 892     return DS_OK;
 893 }
 894
 895 static HRESULT WINAPI IDirectSound8Impl_GetSpeakerConfig(IDirectSound8 *iface, DWORD *config)
 896 {
 897     IDirectSoundImpl *This = impl_from_IDirectSound8(iface);
 898
 899     TRACE("(%p, %p)\n", This, config);
 900
 901     if (!This->device) {
 902         WARN("not initialized\n");
 903         return DSERR_UNINITIALIZED;
 904     }
 905     if (!config) {
 906         WARN("invalid parameter: config == NULL\n");
 907         return DSERR_INVALIDPARAM;
 908     }
 909
 910     WARN("not fully functional\n");
 911     *config = This->device->speaker_config;
 912     return DS_OK;
 913 }
 914
 915 static HRESULT WINAPI IDirectSound8Impl_SetSpeakerConfig(IDirectSound8 *iface, DWORD config)
 916 {
 917     IDirectSoundImpl *This = impl_from_IDirectSound8(iface);
 918
 919     TRACE("(%p,0x%08x)\n", This, config);
 920
 921     if (!This->device) {
 922         WARN("not initialized\n");
 923         return DSERR_UNINITIALIZED;
 924     }
 925
 926     /* NOP on Vista and above */
 927
 928     return DS_OK;
 929 }
 930
 931 static HRESULT WINAPI IDirectSound8Impl_Initialize(IDirectSound8 *iface, const GUID *lpcGuid)
 932 {
 933     IDirectSoundImpl *This = impl_from_IDirectSound8(iface);
 934     TRACE("(%p, %s)\n", This, debugstr_guid(lpcGuid));
 935     return DirectSoundDevice_Initialize(&This->device, lpcGuid);
 936 }
 937
 938 static HRESULT WINAPI IDirectSound8Impl_VerifyCertification(IDirectSound8 *iface, DWORD *certified)
 939 {
 940     IDirectSoundImpl *This = impl_from_IDirectSound8(iface);
 941
 942     TRACE("(%p, %p)\n", This, certified);
 943
 944     if (!This->device) {
 945         WARN("not initialized\n");
 946         return DSERR_UNINITIALIZED;
 947     }
 948
 949     if (This->device->drvcaps.dwFlags & DSCAPS_CERTIFIED)
 950         *certified = DS_CERTIFIED;
 951     else
 952         *certified = DS_UNCERTIFIED;
 953
 954     return DS_OK;
 955 }
 956
 957 static const IDirectSound8Vtbl ds8_vtbl =
 958 {
 959     IDirectSound8Impl_QueryInterface,
 960     IDirectSound8Impl_AddRef,
 961     IDirectSound8Impl_Release,
 962     IDirectSound8Impl_CreateSoundBuffer,
 963     IDirectSound8Impl_GetCaps,
 964     IDirectSound8Impl_DuplicateSoundBuffer,
 965     IDirectSound8Impl_SetCooperativeLevel,
 966     IDirectSound8Impl_Compact,
 967     IDirectSound8Impl_GetSpeakerConfig,
 968     IDirectSound8Impl_SetSpeakerConfig,
 969     IDirectSound8Impl_Initialize,
 970     IDirectSound8Impl_VerifyCertification
 971 };
 972
 973 HRESULT IDirectSoundImpl_Create(IUnknown *outer_unk, REFIID riid, void **ppv, BOOL has_ds8)
 974 {
 975     IDirectSoundImpl *obj;
 976     HRESULT hr;
 977
 978     TRACE("(%s, %p)\n", debugstr_guid(riid), ppv);
 979
 980     *ppv = NULL;
 981     obj = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*obj));
 982     if (!obj) {
 983         WARN("out of memory\n");
 984         return DSERR_OUTOFMEMORY;
 985     }
 986
 987     setup_dsound_options();
 988
 989     obj->IUnknown_inner.lpVtbl = &unk_vtbl;
 990     obj->IDirectSound8_iface.lpVtbl = &ds8_vtbl;
 991     obj->ref = 1;
 992     obj->refds = 0;
 993     obj->numIfaces = 1;
 994     obj->device = NULL;
 995     obj->has_ds8 = has_ds8;
 996
 997     /* COM aggregation supported only internally */
 998     if (outer_unk)
 999         obj->outer_unk = outer_unk;
1000     else
1001         obj->outer_unk = &obj->IUnknown_inner;
1002
1003     hr = IUnknown_QueryInterface(&obj->IUnknown_inner, riid, ppv);
1004     IUnknown_Release(&obj->IUnknown_inner);
1005
1006     return hr;
1007 }
1008
1009 HRESULT DSOUND_Create(REFIID riid, void **ppv)
1010 {
1011     return IDirectSoundImpl_Create(NULL, riid, ppv, FALSE);
1012 }
1013
1014 HRESULT DSOUND_Create8(REFIID riid, void **ppv)
1015 {
1016     return IDirectSoundImpl_Create(NULL, riid, ppv, TRUE);
1017 }
1018
1019 /*******************************************************************************
1020  *              DirectSoundCreate (DSOUND.1)
1021  *
1022  *  Creates and initializes a DirectSound interface.
1023  *
1024  *  PARAMS
1025  *     lpcGUID   [I] Address of the GUID that identifies the sound device.
1026  *     ppDS      [O] Address of a variable to receive the interface pointer.
1027  *     pUnkOuter [I] Must be NULL.
1028  *
1029  *  RETURNS
1030  *     Success: DS_OK
1031  *     Failure: DSERR_ALLOCATED, DSERR_INVALIDPARAM, DSERR_NOAGGREGATION,
1032  *              DSERR_NODRIVER, DSERR_OUTOFMEMORY
1033  */
1034 HRESULT WINAPI DirectSoundCreate(
1035     LPCGUID lpcGUID,
1036     LPDIRECTSOUND *ppDS,
1037     IUnknown *pUnkOuter)
1038 {
1039     HRESULT hr;
1040     LPDIRECTSOUND pDS;
1041
1042     TRACE("(%s,%p,%p)\n",debugstr_guid(lpcGUID),ppDS,pUnkOuter);
1043
1044     if (ppDS == NULL) {
1045         WARN("invalid parameter: ppDS == NULL\n");
1046         return DSERR_INVALIDPARAM;
1047     }
1048
1049     if (pUnkOuter != NULL) {
1050         WARN("invalid parameter: pUnkOuter != NULL\n");
1051         *ppDS = 0;
1052         return DSERR_INVALIDPARAM;
1053     }
1054
1055     hr = DSOUND_Create(&IID_IDirectSound, (void **)&pDS);
1056     if (hr == DS_OK) {
1057         hr = IDirectSound_Initialize(pDS, lpcGUID);
1058         if (hr != DS_OK) {
1059             if (hr != DSERR_ALREADYINITIALIZED) {
1060                 IDirectSound_Release(pDS);
1061                 pDS = 0;
1062             } else
1063                 hr = DS_OK;
1064         }
1065     }
1066
1067     *ppDS = pDS;
1068
1069     return hr;
1070 }
1071
1072 /*******************************************************************************
1073  *        DirectSoundCreate8 (DSOUND.11)
1074  *
1075  *  Creates and initializes a DirectSound8 interface.
1076  *
1077  *  PARAMS
1078  *     lpcGUID   [I] Address of the GUID that identifies the sound device.
1079  *     ppDS      [O] Address of a variable to receive the interface pointer.
1080  *     pUnkOuter [I] Must be NULL.
1081  *
1082  *  RETURNS
1083  *     Success: DS_OK
1084  *     Failure: DSERR_ALLOCATED, DSERR_INVALIDPARAM, DSERR_NOAGGREGATION,
1085  *              DSERR_NODRIVER, DSERR_OUTOFMEMORY
1086  */
1087 HRESULT WINAPI DirectSoundCreate8(
1088     LPCGUID lpcGUID,
1089     LPDIRECTSOUND8 *ppDS,
1090     IUnknown *pUnkOuter)
1091 {
1092     HRESULT hr;
1093     LPDIRECTSOUND8 pDS;
1094
1095     TRACE("(%s,%p,%p)\n",debugstr_guid(lpcGUID),ppDS,pUnkOuter);
1096
1097     if (ppDS == NULL) {
1098         WARN("invalid parameter: ppDS == NULL\n");
1099         return DSERR_INVALIDPARAM;
1100     }
1101
1102     if (pUnkOuter != NULL) {
1103         WARN("invalid parameter: pUnkOuter != NULL\n");
1104         *ppDS = 0;
1105         return DSERR_INVALIDPARAM;
1106     }
1107
1108     hr = DSOUND_Create8(&IID_IDirectSound8, (void **)&pDS);
1109     if (hr == DS_OK) {
1110         hr = IDirectSound8_Initialize(pDS, lpcGUID);
1111         if (hr != DS_OK) {
1112             if (hr != DSERR_ALREADYINITIALIZED) {
1113                 IDirectSound8_Release(pDS);
1114                 pDS = 0;
1115             } else
1116                 hr = DS_OK;
1117         }
1118     }
1119
1120     *ppDS = pDS;
1121
1122     return hr;
1123 }
1124
1125 void DSOUND_ParseSpeakerConfig(DirectSoundDevice *device)
1126 {
1127     switch (DSSPEAKER_CONFIG(device->speaker_config)) {
1128         case DSSPEAKER_MONO:
1129             device->speaker_angles[0] = M_PI/180.0f * 0.0f;
1130             device->speaker_num[0] = 0;
1131             device->num_speakers = 1;
1132             device->lfe_channel = -1;
1133         break;
1134
1135         case DSSPEAKER_STEREO:
1136         case DSSPEAKER_HEADPHONE:
1137             device->speaker_angles[0] = M_PI/180.0f * -90.0f;
1138             device->speaker_angles[1] = M_PI/180.0f *  90.0f;
1139             device->speaker_num[0] = 0; /* Left */
1140             device->speaker_num[1] = 1; /* Right */
1141             device->num_speakers = 2;
1142             device->lfe_channel = -1;
1143         break;
1144
1145         case DSSPEAKER_QUAD:
1146             device->speaker_angles[0] = M_PI/180.0f * -135.0f;
1147             device->speaker_angles[1] = M_PI/180.0f *  -45.0f;
1148             device->speaker_angles[2] = M_PI/180.0f *   45.0f;
1149             device->speaker_angles[3] = M_PI/180.0f *  135.0f;
1150             device->speaker_num[0] = 2; /* Rear left */
1151             device->speaker_num[1] = 0; /* Front left */
1152             device->speaker_num[2] = 1; /* Front right */
1153             device->speaker_num[3] = 3; /* Rear right */
1154             device->num_speakers = 4;
1155             device->lfe_channel = -1;
1156         break;
1157
1158         case DSSPEAKER_5POINT1_BACK:
1159             device->speaker_angles[0] = M_PI/180.0f * -135.0f;
1160             device->speaker_angles[1] = M_PI/180.0f *  -45.0f;
1161             device->speaker_angles[2] = M_PI/180.0f *    0.0f;
1162             device->speaker_angles[3] = M_PI/180.0f *   45.0f;
1163             device->speaker_angles[4] = M_PI/180.0f *  135.0f;
1164             device->speaker_angles[5] = 9999.0f;
1165             device->speaker_num[0] = 4; /* Rear left */
1166             device->speaker_num[1] = 0; /* Front left */
1167             device->speaker_num[2] = 2; /* Front centre */
1168             device->speaker_num[3] = 1; /* Front right */
1169             device->speaker_num[4] = 5; /* Rear right */
1170             device->speaker_num[5] = 3; /* LFE */
1171             device->num_speakers = 6;
1172             device->lfe_channel = 3;
1173         break;
1174
1175         case DSSPEAKER_5POINT1_SURROUND:
1176             device->speaker_angles[0] = M_PI/180.0f *  -90.0f;
1177             device->speaker_angles[1] = M_PI/180.0f *  -30.0f;
1178             device->speaker_angles[2] = M_PI/180.0f *    0.0f;
1179             device->speaker_angles[3] = M_PI/180.0f *   30.0f;
1180             device->speaker_angles[4] = M_PI/180.0f *   90.0f;
1181             device->speaker_angles[5] = 9999.0f;
1182             device->speaker_num[0] = 4; /* Rear left */
1183             device->speaker_num[1] = 0; /* Front left */
1184             device->speaker_num[2] = 2; /* Front centre */
1185             device->speaker_num[3] = 1; /* Front right */
1186             device->speaker_num[4] = 5; /* Rear right */
1187             device->speaker_num[5] = 3; /* LFE */
1188             device->num_speakers = 6;
1189             device->lfe_channel = 3;
1190         break;
1191
1192         default:
1193             WARN("unknown speaker_config %u\n", device->speaker_config);
1194     }
1195 }