buffer.c

/* DirectSound COM interface
 *
 * Copyright 2009 Maarten Lankhorst
 *
 * Some code taken from the original dsound-openal implementation
 *    Copyright 2007-2009 Chris Robinson
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
 */

#define CONST_VTABLE
#include <stdarg.h>
#include <string.h>

#include "windows.h"
#include "dsound.h"
#include "mmsystem.h"
#include "ks.h"
#include <devpropdef.h>

#include "dsound_private.h"


#ifndef DS_INCOMPLETE
#define DS_INCOMPLETE                   ((HRESULT)0x08780020)
#endif

#ifndef WAVE_FORMAT_IEEE_FLOAT
#define WAVE_FORMAT_IEEE_FLOAT 3
#endif


/* TODO: when bufferlost is set, return from all calls except initialize with
 * DSERR_BUFFERLOST
 */
static IDirectSoundBuffer8Vtbl DSBuffer_Vtbl;
static IDirectSound3DBufferVtbl DSBuffer3d_Vtbl;
static IDirectSoundNotifyVtbl DSBufferNot_Vtbl;
static IKsPropertySetVtbl DSBufferProp_Vtbl;


static inline DSBuffer *impl_from_IDirectSoundBuffer8(IDirectSoundBuffer8 *iface)
{
    return CONTAINING_RECORD(iface, DSBuffer, IDirectSoundBuffer8_iface);
}

static inline DSBuffer *impl_from_IDirectSoundBuffer(IDirectSoundBuffer *iface)
{
    return CONTAINING_RECORD(iface, DSBuffer, IDirectSoundBuffer8_iface);
}

static inline DSBuffer *impl_from_IDirectSound3DBuffer(IDirectSound3DBuffer *iface)
{
    return CONTAINING_RECORD(iface, DSBuffer, IDirectSound3DBuffer_iface);
}

static inline DSBuffer *impl_from_IDirectSoundNotify(IDirectSoundNotify *iface)
{
    return CONTAINING_RECORD(iface, DSBuffer, IDirectSoundNotify_iface);
}

static inline DSBuffer *impl_from_IKsPropertySet(IKsPropertySet *iface)
{
    return CONTAINING_RECORD(iface, DSBuffer, IKsPropertySet_iface);
}


/* Should be called with critsect held and context set.. */
static void DSBuffer_addnotify(DSBuffer *buf)
{
    DSPrimary *prim = buf->primary;
    DSBuffer **list;
    DWORD i;

    list = prim->notifies;
    for(i = 0; i < prim->nnotifies; ++i)
    {
        if(buf == list[i])
        {
            ERR("Buffer %p already in notification list\n", buf);
            return;
        }
    }
    if(prim->nnotifies == prim->sizenotifies)
    {
        list = HeapReAlloc(GetProcessHeap(), 0, list, (prim->nnotifies + 1) * sizeof(*list));
        if(!list) return;
        prim->sizenotifies++;
    }
    list[prim->nnotifies++] = buf;
    prim->notifies = list;
}


static const char *get_fmtstr_PCM(const DSPrimary *prim, const WAVEFORMATEX *format, WAVEFORMATEXTENSIBLE *out)
{
    out->Format = *format;
    out->Format.cbSize = 0;

    if(out->Format.nChannels != 1 && out->Format.nChannels != 2 &&
       !HAS_EXTENSION(prim->share, EXT_MCFORMATS))
    {
        WARN("Multi-channel not available\n");
        return NULL;
    }

    if(format->wBitsPerSample == 8)
    {
        switch(format->nChannels)
        {
        case 1: return "AL_FORMAT_MONO8";
        case 2: return "AL_FORMAT_STEREO8";
        case 4: return "AL_FORMAT_QUAD8";
        case 6: return "AL_FORMAT_51CHN8";
        case 7: return "AL_FORMAT_61CHN8";
        case 8: return "AL_FORMAT_71CHN8";
        }
    }
    else if(format->wBitsPerSample == 16)
    {
        switch(format->nChannels)
        {
        case 1: return "AL_FORMAT_MONO16";
        case 2: return "AL_FORMAT_STEREO16";
        case 4: return "AL_FORMAT_QUAD16";
        case 6: return "AL_FORMAT_51CHN16";
        case 7: return "AL_FORMAT_61CHN16";
        case 8: return "AL_FORMAT_71CHN16";
        }
    }

    FIXME("Could not get OpenAL format (%d-bit, %d channels)\n",
          format->wBitsPerSample, format->nChannels);
    return NULL;
}

static const char *get_fmtstr_FLOAT(const DSPrimary *prim, const WAVEFORMATEX *format, WAVEFORMATEXTENSIBLE *out)
{
    out->Format = *format;
    out->Format.cbSize = 0;

    if(out->Format.nChannels != 1 && out->Format.nChannels != 2 &&
       !HAS_EXTENSION(prim->share, EXT_MCFORMATS))
    {
        WARN("Multi-channel not available\n");
        return NULL;
    }

    if(format->wBitsPerSample == 32 && HAS_EXTENSION(prim->share, EXT_FLOAT32))
    {
        switch(format->nChannels)
        {
        case 1: return "AL_FORMAT_MONO_FLOAT32";
        case 2: return "AL_FORMAT_STEREO_FLOAT32";
        case 4: return "AL_FORMAT_QUAD32";
        case 6: return "AL_FORMAT_51CHN32";
        case 7: return "AL_FORMAT_61CHN32";
        case 8: return "AL_FORMAT_71CHN32";
        }
    }

    FIXME("Could not get OpenAL format (%d-bit, %d channels)\n",
          format->wBitsPerSample, format->nChannels);
    return NULL;
}

/* Speaker configs */
#define MONO SPEAKER_FRONT_CENTER
#define STEREO (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT)
#define REAR (SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT)
#define QUAD (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT)
#define X5DOT1 (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT)
#define X6DOT1 (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_CENTER|SPEAKER_SIDE_LEFT|SPEAKER_SIDE_RIGHT)
#define X7DOT1 (SPEAKER_FRONT_LEFT|SPEAKER_FRONT_RIGHT|SPEAKER_FRONT_CENTER|SPEAKER_LOW_FREQUENCY|SPEAKER_BACK_LEFT|SPEAKER_BACK_RIGHT|SPEAKER_SIDE_LEFT|SPEAKER_SIDE_RIGHT)

static const char *get_fmtstr_EXT(const DSPrimary *prim, const WAVEFORMATEX *format, WAVEFORMATEXTENSIBLE *out)
{
    *out = *CONTAINING_RECORD(format, const WAVEFORMATEXTENSIBLE, Format);
    out->Format.cbSize = sizeof(*out) - sizeof(out->Format);

    if(!out->Samples.wValidBitsPerSample)
        out->Samples.wValidBitsPerSample = out->Format.wBitsPerSample;
    else if(out->Samples.wValidBitsPerSample > out->Format.wBitsPerSample)
    {
        WARN("Invalid ValidBitsPerSample (%u > %u)\n", out->Samples.wValidBitsPerSample, out->Format.wBitsPerSample);
        return NULL;
    }
    else if(out->Samples.wValidBitsPerSample < out->Format.wBitsPerSample)
    {
        FIXME("Padded samples not supported (%u of %u)\n", out->Samples.wValidBitsPerSample, out->Format.wBitsPerSample);
        return NULL;
    }

    if(out->dwChannelMask != MONO && out->dwChannelMask != STEREO &&
       !HAS_EXTENSION(prim->share, EXT_MCFORMATS))
    {
        WARN("Multi-channel not available\n");
        return NULL;
    }

    if(IsEqualGUID(&out->SubFormat, &KSDATAFORMAT_SUBTYPE_PCM))
    {
        if(out->Samples.wValidBitsPerSample == 8)
        {
            switch(out->dwChannelMask)
            {
            case   MONO: return "AL_FORMAT_MONO8";
            case STEREO: return "AL_FORMAT_STEREO8";
            case   REAR: return "AL_FORMAT_REAR8";
            case   QUAD: return "AL_FORMAT_QUAD8";
            case X5DOT1: return "AL_FORMAT_51CHN8";
            case X6DOT1: return "AL_FORMAT_61CHN8";
            case X7DOT1: return "AL_FORMAT_71CHN8";
            }
        }
        else if(out->Samples.wValidBitsPerSample == 16)
        {
            switch(out->dwChannelMask)
            {
            case   MONO: return "AL_FORMAT_MONO16";
            case STEREO: return "AL_FORMAT_STEREO16";
            case   REAR: return "AL_FORMAT_REAR16";
            case   QUAD: return "AL_FORMAT_QUAD16";
            case X5DOT1: return "AL_FORMAT_51CHN16";
            case X6DOT1: return "AL_FORMAT_61CHN16";
            case X7DOT1: return "AL_FORMAT_71CHN16";
            }
        }

        FIXME("Could not get OpenAL PCM format (%d-bit, channelmask %#lx)\n",
              out->Samples.wValidBitsPerSample, out->dwChannelMask);
        return NULL;
    }
    else if(IsEqualGUID(&out->SubFormat, &KSDATAFORMAT_SUBTYPE_IEEE_FLOAT) &&
            HAS_EXTENSION(prim->share, EXT_FLOAT32))
    {
        if(out->Samples.wValidBitsPerSample == 32)
        {
            switch(out->dwChannelMask)
            {
            case   MONO: return "AL_FORMAT_MONO_FLOAT32";
            case STEREO: return "AL_FORMAT_STEREO_FLOAT32";
            case   REAR: return "AL_FORMAT_REAR32";
            case   QUAD: return "AL_FORMAT_QUAD32";
            case X5DOT1: return "AL_FORMAT_51CHN32";
            case X6DOT1: return "AL_FORMAT_61CHN32";
            case X7DOT1: return "AL_FORMAT_71CHN32";
            }
        }
        else
        {
            WARN("Invalid float bits: %u\n", out->Samples.wValidBitsPerSample);
            return NULL;
        }

        FIXME("Could not get OpenAL float format (%d-bit, channelmask %#lx)\n",
              out->Samples.wValidBitsPerSample, out->dwChannelMask);
        return NULL;
    }
    else if(!IsEqualGUID(&out->SubFormat, &GUID_NULL))
        ERR("Unhandled extensible format: %s\n", debugstr_guid(&out->SubFormat));
    return NULL;
}

static void DSData_Release(DSData *This);
static HRESULT DSData_Create(DSData **ppv, const DSBUFFERDESC *desc, DSPrimary *prim)
{
    HRESULT hr = DSERR_INVALIDPARAM;
    const WAVEFORMATEX *format;
    const char *fmt_str = NULL;
    DSData *pBuffer;
    DWORD buf_size;

    format = desc->lpwfxFormat;
    TRACE("Requested buffer format:\n"
          "    FormatTag      = 0x%04x\n"
          "    Channels       = %d\n"
          "    SamplesPerSec  = %lu\n"
          "    AvgBytesPerSec = %lu\n"
          "    BlockAlign     = %d\n"
          "    BitsPerSample  = %d\n",
          format->wFormatTag, format->nChannels,
          format->nSamplesPerSec, format->nAvgBytesPerSec,
          format->nBlockAlign, format->wBitsPerSample);

    if(format->nChannels <= 0)
    {
        WARN("Invalid Channels %d\n", format->nChannels);
        return DSERR_INVALIDPARAM;
    }
    if(format->nSamplesPerSec < DSBFREQUENCY_MIN || format->nSamplesPerSec > DSBFREQUENCY_MAX)
    {
        WARN("Invalid SamplesPerSec %lu\n", format->nSamplesPerSec);
        return DSERR_INVALIDPARAM;
    }
    if(format->nBlockAlign <= 0)
    {
        WARN("Invalid BlockAlign %d\n", format->nBlockAlign);
        return DSERR_INVALIDPARAM;
    }
    if(format->wBitsPerSample == 0 || (format->wBitsPerSample%8) != 0)
    {
        WARN("Invalid BitsPerSample %d\n", format->wBitsPerSample);
        return DSERR_INVALIDPARAM;
    }
    if(format->nBlockAlign != format->nChannels*format->wBitsPerSample/8)
    {
        WARN("Invalid BlockAlign %d (expected %u = %u*%u/8)\n",
             format->nBlockAlign, format->nChannels*format->wBitsPerSample/8,
             format->nChannels, format->wBitsPerSample);
        return DSERR_INVALIDPARAM;
    }
    /* HACK: Some games provide an incorrect value here and expect to work.
     * This is clearly not supposed to succeed with just anything, but until
     * the amount of leeway allowed is discovered, be very lenient.
     */
    if(format->nAvgBytesPerSec == 0)
    {
        WARN("Invalid AvgBytesPerSec %lu (expected %lu = %lu*%u)\n",
             format->nAvgBytesPerSec, format->nSamplesPerSec*format->nBlockAlign,
             format->nSamplesPerSec, format->nBlockAlign);
        return DSERR_INVALIDPARAM;
    }
    if(format->nAvgBytesPerSec != format->nBlockAlign*format->nSamplesPerSec)
        WARN("Unexpected AvgBytesPerSec %lu (expected %lu = %lu*%u)\n",
             format->nAvgBytesPerSec, format->nSamplesPerSec*format->nBlockAlign,
             format->nSamplesPerSec, format->nBlockAlign);

    if((desc->dwFlags&(DSBCAPS_LOCSOFTWARE|DSBCAPS_LOCHARDWARE)) == (DSBCAPS_LOCSOFTWARE|DSBCAPS_LOCHARDWARE))
    {
        WARN("Hardware and software location requested\n");
        return DSERR_INVALIDPARAM;
    }

    buf_size  = desc->dwBufferBytes + format->nBlockAlign - 1;
    buf_size -= buf_size%format->nBlockAlign;
    if(buf_size < DSBSIZE_MIN) return DSERR_BUFFERTOOSMALL;
    if(buf_size > DSBSIZE_MAX) return DSERR_INVALIDPARAM;

    /* Generate a new buffer. Supporting the DSBCAPS_LOC* flags properly
     * will need the EAX-RAM extension. Currently, we just tell the app it
     * gets what it wanted. */
    if(!HAS_EXTENSION(prim->share, SOFTX_MAP_BUFFER))
        pBuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*pBuffer)+buf_size);
    else
        pBuffer = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*pBuffer));
    if(!pBuffer) return E_OUTOFMEMORY;
    pBuffer->ref = 1;
    pBuffer->primary = prim;

    pBuffer->dsbflags = desc->dwFlags;
    pBuffer->buf_size = buf_size;

    if(format->wFormatTag == WAVE_FORMAT_PCM)
        fmt_str = get_fmtstr_PCM(prim, format, &pBuffer->format);
    else if(format->wFormatTag == WAVE_FORMAT_IEEE_FLOAT)
        fmt_str = get_fmtstr_FLOAT(prim, format, &pBuffer->format);
    else if(format->wFormatTag == WAVE_FORMAT_EXTENSIBLE)
    {
        const WAVEFORMATEXTENSIBLE *wfe;

        if(format->cbSize != sizeof(WAVEFORMATEXTENSIBLE)-sizeof(WAVEFORMATEX) &&
            format->cbSize != sizeof(WAVEFORMATEXTENSIBLE))
            goto fail;

        wfe = CONTAINING_RECORD(format, const WAVEFORMATEXTENSIBLE, Format);
        TRACE("Extensible values:\n"
                "    Samples     = %d\n"
                "    ChannelMask = 0x%lx\n"
                "    SubFormat   = %s\n",
                wfe->Samples.wReserved, wfe->dwChannelMask,
                debugstr_guid(&wfe->SubFormat));

        fmt_str = get_fmtstr_EXT(prim, format, &pBuffer->format);
    }
    else
        ERR("Unhandled formattag 0x%04x\n", format->wFormatTag);
    if(!fmt_str) goto fail;

    alGetError();
    pBuffer->buf_format = alGetEnumValue(fmt_str);
    if(alGetError() != AL_NO_ERROR || pBuffer->buf_format == 0 ||
       pBuffer->buf_format == -1)
    {
        WARN("Could not get OpenAL format from %s\n", fmt_str);
        goto fail;
    }

    hr = E_OUTOFMEMORY;
    if(!HAS_EXTENSION(prim->share, SOFTX_MAP_BUFFER))
    {
        pBuffer->data = (BYTE*)(pBuffer+1);

        alGenBuffers(1, &pBuffer->bid);
        checkALError();
    }
    else
    {
        const ALbitfieldSOFT map_bits = AL_MAP_READ_BIT_SOFT | AL_MAP_WRITE_BIT_SOFT |
                                        AL_MAP_PERSISTENT_BIT_SOFT;
        alGenBuffers(1, &pBuffer->bid);
        alBufferStorageSOFT(pBuffer->bid, pBuffer->buf_format, NULL, pBuffer->buf_size,
                            pBuffer->format.Format.nSamplesPerSec, map_bits);
        pBuffer->data = alMapBufferSOFT(pBuffer->bid, 0, pBuffer->buf_size, map_bits);
        checkALError();

        if(!pBuffer->data) goto fail;
    }

    *ppv = pBuffer;
    return S_OK;

fail:
    DSData_Release(pBuffer);
    return hr;
}

static void DSData_AddRef(DSData *data)
{
    InterlockedIncrement(&data->ref);
}

/* This function is always called with the device lock held */
static void DSData_Release(DSData *This)
{
    if(InterlockedDecrement(&This->ref)) return;

    TRACE("Deleting %p\n", This);
    if(This->bid)
    {
        DSPrimary *prim = This->primary;
        if(HAS_EXTENSION(prim->share, SOFTX_MAP_BUFFER))
            alUnmapBufferSOFT(This->bid);
        alDeleteBuffers(1, &This->bid);
        checkALError();
    }
    HeapFree(GetProcessHeap(), 0, This);
}


HRESULT DSBuffer_Create(DSBuffer **ppv, DSPrimary *prim, IDirectSoundBuffer *orig)
{
    DSBuffer *This = NULL;
    DWORD i;

    *ppv = NULL;
    EnterCriticalSection(&prim->share->crst);
    for(i = 0;i < prim->NumBufferGroups;++i)
    {
        if(prim->BufferGroups[i].FreeBuffers)
        {
            int idx = CTZ64(prim->BufferGroups[i].FreeBuffers);
            This = prim->BufferGroups[i].Buffers + idx;
            memset(This, 0, sizeof(*This));
            prim->BufferGroups[i].FreeBuffers &= ~(U64(1) << idx);
            break;
        }
    }
    if(!This)
    {
        struct DSBufferGroup *grp = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
            (prim->NumBufferGroups+1)*sizeof(prim->BufferGroups[0]));
        if(grp)
        {
            for(i = 0;i < prim->NumBufferGroups;i++)
                grp[i] = prim->BufferGroups[i];
            grp[i].FreeBuffers = ~U64(0);
            grp[i].Buffers = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
                                       64*sizeof(grp[0].Buffers[0]));
            if(!grp[i].Buffers)
            {
                HeapFree(GetProcessHeap(), 0, grp);
                grp = NULL;
            }
            else
            {
                HeapFree(GetProcessHeap(), 0, prim->BufferGroups);
                prim->BufferGroups = grp;
                prim->NumBufferGroups++;

                This = prim->BufferGroups[i].Buffers + 0;
                memset(This, 0, sizeof(*This));
                prim->BufferGroups[i].FreeBuffers &= ~(U64(1) << 0);
            }
        }
    }
    LeaveCriticalSection(&prim->share->crst);
    if(!This)
    {
        WARN("Out of memory allocating buffers\n");
        return DSERR_OUTOFMEMORY;
    }

    This->IDirectSoundBuffer8_iface.lpVtbl = &DSBuffer_Vtbl;
    This->IDirectSound3DBuffer_iface.lpVtbl = &DSBuffer3d_Vtbl;
    This->IDirectSoundNotify_iface.lpVtbl = &DSBufferNot_Vtbl;
    This->IKsPropertySet_iface.lpVtbl = &DSBufferProp_Vtbl;

    This->share = prim->share;
    This->primary = prim;
    This->ctx = prim->ctx;

    This->current.vol = 0;
    This->current.pan = 0;
    This->current.frequency = 0;
    This->current.ds3d.dwSize = sizeof(This->current.ds3d);
    This->current.ds3d.vPosition.x = 0.0f;
    This->current.ds3d.vPosition.y = 0.0f;
    This->current.ds3d.vPosition.z = 0.0f;
    This->current.ds3d.vVelocity.x = 0.0f;
    This->current.ds3d.vVelocity.y = 0.0f;
    This->current.ds3d.vVelocity.z = 0.0f;
    This->current.ds3d.dwInsideConeAngle = DS3D_DEFAULTCONEANGLE;
    This->current.ds3d.dwOutsideConeAngle = DS3D_DEFAULTCONEANGLE;
    This->current.ds3d.vConeOrientation.x = 0.0f;
    This->current.ds3d.vConeOrientation.y = 0.0f;
    This->current.ds3d.vConeOrientation.z = 1.0f;
    This->current.ds3d.lConeOutsideVolume = DS3D_DEFAULTCONEOUTSIDEVOLUME;
    This->current.ds3d.flMinDistance = DS3D_DEFAULTMINDISTANCE;
    This->current.ds3d.flMaxDistance = DS3D_DEFAULTMAXDISTANCE;
    This->current.ds3d.dwMode = DS3DMODE_NORMAL;

    if(orig)
    {
        DSBuffer *org = impl_from_IDirectSoundBuffer(orig);
        DSData *data = org->buffer;

        if(org->bufferlost)
        {
            DSBuffer_Destroy(This);
            return DSERR_BUFFERLOST;
        }
        DSData_AddRef(data);
        This->buffer = data;

        /* According to MSDN, volume isn't copied. */
        if((data->dsbflags&DSBCAPS_CTRLPAN))
            This->current.pan = org->current.pan;
        if((data->dsbflags&DSBCAPS_CTRLFREQUENCY))
            This->current.frequency = org->current.frequency;
        if((data->dsbflags&DSBCAPS_CTRL3D))
            This->current.ds3d = org->current.ds3d;
    }

    This->deferred.ds3d = This->current.ds3d;

    This->vm_voicepriority = (DWORD)-1;
    
    *ppv = This;
    return DS_OK;
}

void DSBuffer_Destroy(DSBuffer *This)
{
    DSPrimary *prim = This->primary;
    DWORD i;

    if(!prim) return;
    TRACE("Destroying %p\n", This);

    EnterCriticalSection(&prim->share->crst);
    /* Remove from list, if in list */
    for(i = 0;i < prim->nnotifies;++i)
    {
        if(This == prim->notifies[i])
        {
            prim->notifies[i] = prim->notifies[--prim->nnotifies];
            break;
        }
    }

    setALContext(This->ctx);
    if(This->source)
    {
        DeviceShare *share = This->share;

        alDeleteSources(1, &This->source);
        This->source = 0;
        checkALError();

        if(This->loc_status == DSBSTATUS_LOCHARDWARE)
            share->sources.availhw_num += 1;
        else
            share->sources.availsw_num += 1;
    }
    if(This->stream_bids[0])
        alDeleteBuffers(QBUFFERS, This->stream_bids);

    if(This->buffer)
        DSData_Release(This->buffer);

    popALContext();

    HeapFree(GetProcessHeap(), 0, This->notify);

    for(i = 0;i < prim->NumBufferGroups;++i)
    {
        DWORD_PTR idx = This - prim->BufferGroups[i].Buffers;
        if(idx < 64)
        {
            prim->BufferGroups[i].FreeBuffers |= U64(1) << idx;
            This = NULL;
            break;
        }
    }
    LeaveCriticalSection(&prim->share->crst);
}

HRESULT DSBuffer_GetInterface(DSBuffer *buf, REFIID riid, void **ppv)
{
    *ppv = NULL;
    if(IsEqualIID(riid, &IID_IDirectSoundBuffer))
        *ppv = &buf->IDirectSoundBuffer8_iface;
    else if(IsEqualIID(riid, &IID_IDirectSoundBuffer8))
    {
        if(buf->primary->parent->is_8)
            *ppv = &buf->IDirectSoundBuffer8_iface;
    }
    else if(IsEqualIID(riid, &IID_IDirectSound3DBuffer))
    {
        if((buf->buffer->dsbflags&DSBCAPS_CTRL3D))
            *ppv = &buf->IDirectSound3DBuffer_iface;
    }
    else if(IsEqualIID(riid, &IID_IDirectSoundNotify))
    {
        if((buf->buffer->dsbflags&DSBCAPS_CTRLPOSITIONNOTIFY))
            *ppv = &buf->IDirectSoundNotify_iface;
    }
    else if(IsEqualIID(riid, &IID_IKsPropertySet))
        *ppv = &buf->IKsPropertySet_iface;
    else if(IsEqualIID(riid, &IID_IUnknown))
        *ppv = &buf->IDirectSoundBuffer8_iface;
    else
        FIXME("Unhandled GUID: %s\n", debugstr_guid(riid));

    if(*ppv)
    {
        IUnknown_AddRef((IUnknown*)*ppv);
        return S_OK;
    }

    return E_NOINTERFACE;
}

static HRESULT DSBuffer_SetLoc(DSBuffer *buf, DWORD loc_status)
{
    DeviceShare *share = buf->share;
    DSData *data = buf->buffer;

    if((loc_status && buf->loc_status == loc_status) || (!loc_status && buf->loc_status))
        return DS_OK;

    /* If we have a source, we're changing location, so return the source we
     * have to get a new one.
     */
    if(buf->source)
    {
        alDeleteSources(1, &buf->source);
        buf->source = 0;
        checkALError();

        if(buf->loc_status == DSBSTATUS_LOCHARDWARE)
            share->sources.availhw_num += 1;
        else
            share->sources.availsw_num += 1;
    }
    buf->loc_status = 0;

    if(!loc_status)
    {
        if(share->sources.availhw_num)
            loc_status = DSBSTATUS_LOCHARDWARE;
        else if(share->sources.availsw_num)
            loc_status = DSBSTATUS_LOCSOFTWARE;
    }

    if((loc_status == DSBSTATUS_LOCHARDWARE && !share->sources.availhw_num) ||
       (loc_status == DSBSTATUS_LOCSOFTWARE && !share->sources.availsw_num) ||
       !loc_status)
    {
        ERR("Out of %s sources\n",
            (loc_status == DSBSTATUS_LOCHARDWARE) ? "hardware" :
            (loc_status == DSBSTATUS_LOCSOFTWARE) ? "software" : "any"
        );
        return DSERR_ALLOCATED;
    }

    if(loc_status == DSBSTATUS_LOCHARDWARE)
        share->sources.availhw_num -= 1;
    else
        share->sources.availsw_num -= 1;
    alGenSources(1, &buf->source);
    alSourcef(buf->source, AL_GAIN, mB_to_gain((float)buf->current.vol));
    alSourcef(buf->source, AL_PITCH,
        buf->current.frequency ? (float)buf->current.frequency/data->format.Format.nSamplesPerSec
                               : 1.0f);
    checkALError();

    /* TODO: Don't set EAX parameters or connect to effect slots for software
     * buffers. Need to check if EAX buffer properties are still tracked, or if
     * they're lost/reset when leaving hardware.
     *
     * Alternatively, we can just allow it and say software processing supports
     * EAX too. Depends if apps may get upset over that.
     */

    if((data->dsbflags&DSBCAPS_CTRL3D))
    {
        const DSPrimary *prim = buf->primary;
        const ALuint source = buf->source;
        const DS3DBUFFER *params = &buf->current.ds3d;

        alSource3f(source, AL_POSITION, params->vPosition.x, params->vPosition.y,
                                       -params->vPosition.z);
        alSource3f(source, AL_VELOCITY, params->vVelocity.x, params->vVelocity.y,
                                       -params->vVelocity.z);
        alSourcei(source, AL_CONE_INNER_ANGLE, params->dwInsideConeAngle);
        alSourcei(source, AL_CONE_OUTER_ANGLE, params->dwOutsideConeAngle);
        alSource3f(source, AL_DIRECTION, params->vConeOrientation.x,
                                         params->vConeOrientation.y,
                                        -params->vConeOrientation.z);
        alSourcef(source, AL_CONE_OUTER_GAIN, mB_to_gain((float)params->lConeOutsideVolume));
        alSourcef(source, AL_REFERENCE_DISTANCE, params->flMinDistance);
        alSourcef(source, AL_MAX_DISTANCE, params->flMaxDistance);
        if(HAS_EXTENSION(share, SOFT_SOURCE_SPATIALIZE))
            alSourcei(source, AL_SOURCE_SPATIALIZE_SOFT,
                (params->dwMode==DS3DMODE_DISABLE) ? AL_FALSE : AL_TRUE
            );
        alSourcei(source, AL_SOURCE_RELATIVE,
            (params->dwMode!=DS3DMODE_NORMAL) ? AL_TRUE : AL_FALSE
        );

        alSourcef(source, AL_ROLLOFF_FACTOR, prim->current.ds3d.flRolloffFactor);
        checkALError();
    }
    else
    {
        const ALuint source = buf->source;
        const ALfloat x = (ALfloat)(buf->current.pan-DSBPAN_LEFT)/(DSBPAN_RIGHT-DSBPAN_LEFT) -
                          0.5f;

        alSource3f(source, AL_POSITION, x, 0.0f, -sqrtf(1.0f - x*x));
        alSource3f(source, AL_VELOCITY, 0.0f, 0.0f, 0.0f);
        alSource3f(source, AL_DIRECTION, 0.0f, 0.0f, 0.0f);
        alSourcef(source, AL_CONE_OUTER_GAIN, 1.0f);
        alSourcef(source, AL_REFERENCE_DISTANCE, 1.0f);
        alSourcef(source, AL_MAX_DISTANCE, 1000.0f);
        alSourcef(source, AL_ROLLOFF_FACTOR, 0.0f);
        alSourcef(source, AL_DOPPLER_FACTOR, 0.0f);
        alSourcei(source, AL_CONE_INNER_ANGLE, 360);
        alSourcei(source, AL_CONE_OUTER_ANGLE, 360);
        alSourcei(source, AL_SOURCE_RELATIVE, AL_TRUE);
        if(HAS_EXTENSION(share, SOFT_SOURCE_SPATIALIZE))
        {
            /* Set to auto so panning works for mono, and multi-channel works
             * as expected.
             */
            alSourcei(source, AL_SOURCE_SPATIALIZE_SOFT, AL_AUTO_SOFT);
        }
        if(HAS_EXTENSION(share, EXT_EAX))
        {
            static const GUID NullSlots[EAX_MAX_ACTIVE_FXSLOTS] = { { 0 } };
            EAXSet(&EAXPROPERTYID_EAX40_Source, EAXSOURCE_ACTIVEFXSLOTID, source, (void*)NullSlots,
                sizeof(NullSlots));
        }
        checkALError();
    }

    buf->loc_status = loc_status;
    return DS_OK;
}


static HRESULT WINAPI DSBuffer_QueryInterface(IDirectSoundBuffer8 *iface, REFIID riid, void **ppv)
{
    DSBuffer *This = impl_from_IDirectSoundBuffer8(iface);
    TRACE("(%p)->(%s, %p)\n", iface, debugstr_guid(riid), ppv);
    return DSBuffer_GetInterface(This, riid, ppv);
}

static ULONG WINAPI DSBuffer_AddRef(IDirectSoundBuffer8 *iface)
{
    DSBuffer *This = impl_from_IDirectSoundBuffer8(iface);
    LONG ret;

    InterlockedIncrement(&This->all_ref);
    ret = InterlockedIncrement(&This->ref);
    TRACE("(%p) ref %lu\n", iface, ret);

    return ret;
}

static ULONG WINAPI DSBuffer_Release(IDirectSoundBuffer8 *iface)
{
    DSBuffer *This = impl_from_IDirectSoundBuffer8(iface);
    LONG ret;

    ret = InterlockedDecrement(&This->ref);
    TRACE("(%p) ref %lu\n", iface, ret);
    if(InterlockedDecrement(&This->all_ref) == 0)
        DSBuffer_Destroy(This);

    return ret;
}

static HRESULT WINAPI DSBuffer_GetCaps(IDirectSoundBuffer8 *iface, DSBCAPS *caps)
{
    DSBuffer *This = impl_from_IDirectSoundBuffer8(iface);
    DSData *data;

    TRACE("(%p)->(%p)\n", iface, caps);

    if(!caps || caps->dwSize < sizeof(*caps))
    {
        WARN("Invalid DSBCAPS (%p, %lu)\n", caps, (caps ? caps->dwSize : 0));
        return DSERR_INVALIDPARAM;
    }
    data = This->buffer;

    caps->dwFlags = data->dsbflags;
    if(!(data->dsbflags&DSBCAPS_LOCDEFER))
    {
        if(This->loc_status == DSBSTATUS_LOCHARDWARE)
            caps->dwFlags |= DSBCAPS_LOCHARDWARE;
        else if(This->loc_status == DSBSTATUS_LOCSOFTWARE)
            caps->dwFlags |= DSBCAPS_LOCSOFTWARE;
    }
    caps->dwBufferBytes = data->buf_size;
    caps->dwUnlockTransferRate = 4096;
    caps->dwPlayCpuOverhead = 0;

    return S_OK;
}

HRESULT WINAPI DSBuffer_GetCurrentPosition(IDirectSoundBuffer8 *iface, DWORD *playpos, DWORD *curpos)
{
    DSBuffer *This = impl_from_IDirectSoundBuffer8(iface);
    ALsizei writecursor, pos;
    DSData *data;

    TRACE("(%p)->(%p, %p)\n", iface, playpos, curpos);

    data = This->buffer;
    if(This->segsize != 0)
    {
        ALint queued = QBUFFERS;
        ALint status = AL_INITIAL;
        ALint ofs = 0;

        EnterCriticalSection(&This->share->crst);

        if(LIKELY(This->source))
        {
            setALContext(This->ctx);
            alGetSourcei(This->source, AL_BUFFERS_QUEUED, &queued);
            alGetSourcei(This->source, AL_BYTE_OFFSET, &ofs);
            alGetSourcei(This->source, AL_SOURCE_STATE, &status);
            checkALError();
            popALContext();
        }

        if(status == AL_STOPPED)
            pos = This->segsize*queued + This->queue_base;
        else
            pos = ofs + This->queue_base;
        if(pos >= data->buf_size)
        {
            if(This->islooping)
                pos %= data->buf_size;
            else if(This->isplaying)
            {
                pos = data->buf_size;
                alSourceStop(This->source);
                alSourcei(This->source, AL_BUFFER, 0);
                This->curidx = 0;
                This->isplaying = FALSE;
            }
        }
        if(This->isplaying)
            writecursor = (This->segsize*QBUFFERS + pos) % data->buf_size;
        else
            writecursor = pos % data->buf_size;

        LeaveCriticalSection(&This->share->crst);
    }
    else
    {
        const WAVEFORMATEX *format = &data->format.Format;
        ALint status = AL_INITIAL;
        ALint ofs = 0;

        if(LIKELY(This->source))
        {
            setALContext(This->ctx);
            alGetSourcei(This->source, AL_BYTE_OFFSET, &ofs);
            alGetSourcei(This->source, AL_SOURCE_STATE, &status);
            checkALError();
            popALContext();
        }

        if(status == AL_PLAYING)
        {
            pos = ofs;
            writecursor = format->nSamplesPerSec / This->primary->refresh;
            writecursor *= format->nBlockAlign;
        }
        else
        {
            /* AL_STOPPED means the source naturally reached its end, where
             * DirectSound's position should be at the end (OpenAL reports 0
             * for stopped sources). The Stop method correlates to pausing,
             * which would put the source into an AL_PAUSED state and correctly
             * hold its current position. AL_INITIAL means the buffer hasn't
             * been played since last changing location.
             */
            switch(status)
            {
                case AL_STOPPED: pos = data->buf_size; break;
                case AL_PAUSED: pos = ofs; break;
                case AL_INITIAL: pos = This->lastpos; break;
                default: pos = 0;
            }
            writecursor = 0;
        }
        writecursor = (writecursor + pos) % data->buf_size;
    }
    TRACE("%p Play pos = %u, write pos = %u\n", This, pos, writecursor);

    if(pos > data->buf_size)
    {
        ERR("playpos > buf_size\n");
        pos %= data->buf_size;
    }
    if(writecursor >= data->buf_size)
    {
        ERR("writepos >= buf_size\n");
        writecursor %= data->buf_size;
    }

    if(playpos) *playpos = pos;
    if(curpos)  *curpos = writecursor;

    return S_OK;
}

static HRESULT WINAPI DSBuffer_GetFormat(IDirectSoundBuffer8 *iface, WAVEFORMATEX *wfx, DWORD allocated, DWORD *written)
{
    DSBuffer *This = impl_from_IDirectSoundBuffer8(iface);
    HRESULT hr = S_OK;
    UINT size;

    TRACE("(%p)->(%p, %lu, %p)\n", iface, wfx, allocated, written);

    if(!wfx && !written)
    {
        WARN("Cannot report format or format size\n");
        return DSERR_INVALIDPARAM;
    }

    size = sizeof(This->buffer->format.Format) + This->buffer->format.Format.cbSize;
    if(wfx)
    {
        if(allocated < size)
            hr = DSERR_INVALIDPARAM;
        else
            memcpy(wfx, &This->buffer->format.Format, size);
    }
    if(written)
        *written = size;

    return hr;
}

static HRESULT WINAPI DSBuffer_GetVolume(IDirectSoundBuffer8 *iface, LONG *vol)
{
    DSBuffer *This = impl_from_IDirectSoundBuffer8(iface);
    HRESULT hr;

    TRACE("(%p)->(%p)\n", iface, vol);

    if(!vol)
    {
        WARN("Invalid pointer\n");
        return DSERR_INVALIDPARAM;
    }

    hr = DSERR_CONTROLUNAVAIL;
    if(!(This->buffer->dsbflags&DSBCAPS_CTRLVOLUME))