audiopath.c File Reference

#include "dmime_private.h"

Include dependency graph for audiopath.c:

Go to the source code of this file.

Classes
struct	IDirectMusicAudioPathImpl
struct	audio_path_pchannel_to_buffer
struct	audio_path_port_config
struct	audio_path_config

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (dmime)
	C_ASSERT (sizeof(struct audio_path_pchannel_to_buffer)==offsetof(struct audio_path_pchannel_to_buffer, guids[0]))
static struct IDirectMusicAudioPathImpl *	impl_from_IDirectMusicAudioPath (IDirectMusicAudioPath *iface)
static struct audio_path_config *	impl_from_IPersistStream (IPersistStream *iface)
void	set_audiopath_perf_pointer (IDirectMusicAudioPath *iface, IDirectMusicPerformance8 *performance)
void	set_audiopath_dsound_buffer (IDirectMusicAudioPath *iface, IDirectSoundBuffer *buffer)
void	set_audiopath_primary_dsound_buffer (IDirectMusicAudioPath *iface, IDirectSoundBuffer *buffer)
static HRESULT WINAPI	IDirectMusicAudioPathImpl_QueryInterface (IDirectMusicAudioPath *iface, REFIID riid, void **ppobj)
static ULONG WINAPI	IDirectMusicAudioPathImpl_AddRef (IDirectMusicAudioPath *iface)
static ULONG WINAPI	IDirectMusicAudioPathImpl_Release (IDirectMusicAudioPath *iface)
static HRESULT WINAPI	IDirectMusicAudioPathImpl_GetObjectInPath (IDirectMusicAudioPath *iface, DWORD dwPChannel, DWORD dwStage, DWORD dwBuffer, REFGUID guidObject, DWORD dwIndex, REFGUID iidInterface, void **ppObject)
static HRESULT WINAPI	IDirectMusicAudioPathImpl_Activate (IDirectMusicAudioPath *iface, BOOL activate)
static HRESULT WINAPI	IDirectMusicAudioPathImpl_SetVolume (IDirectMusicAudioPath *iface, LONG lVolume, DWORD dwDuration)
static HRESULT WINAPI	IDirectMusicAudioPathImpl_ConvertPChannel (IDirectMusicAudioPath *iface, DWORD dwPChannelIn, DWORD *pdwPChannelOut)
static HRESULT WINAPI	path_config_IDirectMusicObject_ParseDescriptor (IDirectMusicObject *iface, IStream *stream, DMUS_OBJECTDESC *desc)
static HRESULT	parse_pchannel_to_buffers_list (struct audio_path_port_config *This, IStream *stream, const struct chunk_entry *pchl)
static void	port_config_destroy (struct audio_path_port_config *port_config)
static HRESULT	parse_port_config_list (struct audio_path_config *This, IStream *stream, const struct chunk_entry *pcfl)
static HRESULT	parse_port_configs_list (struct audio_path_config *This, IStream *stream, const struct chunk_entry *pcsl)
static HRESULT WINAPI	path_config_IPersistStream_Load (IPersistStream *iface, IStream *stream)
static struct audio_path_config *	impl_from_IUnknown (IUnknown *iface)
static HRESULT WINAPI	path_config_IUnknown_QueryInterface (IUnknown *iface, REFIID riid, void **ppobj)
static ULONG WINAPI	path_config_IUnknown_AddRef (IUnknown *unk)
static ULONG WINAPI	path_config_IUnknown_Release (IUnknown *unk)
HRESULT	path_config_get_audio_path_params (IUnknown *iface, WAVEFORMATEX *format, DSBUFFERDESC *desc, DMUS_PORTPARAMS *params)
HRESULT	create_dmaudiopath (REFIID riid, void **ppobj)
HRESULT	create_dmaudiopath_config (REFIID riid, void **ppobj)

Variables
static const IDirectMusicAudioPathVtbl	DirectMusicAudioPathVtbl
static const IDirectMusicObjectVtbl	dmobject_vtbl
static const IPersistStreamVtbl	persiststream_vtbl
static const IUnknownVtbl	path_config_unk_vtbl

Function Documentation

C_ASSERT()

C_ASSERT

(

sizeof(struct audio_path_pchannel_to_buffer)

= =offsetof(struct audio_path_pchannel_to_buffer, guids[0])

)

create_dmaudiopath()

HRESULT create_dmaudiopath	(	REFIID	riid,
		void **	ppobj
	)

Definition at line 736 of file audiopath.c.

{
    IDirectMusicAudioPathImpl* obj;
    HRESULT hr;
 
    *ppobj = NULL;
    if (!(obj = calloc(1, sizeof(*obj)))) return E_OUTOFMEMORY;
    obj->IDirectMusicAudioPath_iface.lpVtbl = &DirectMusicAudioPathVtbl;
    obj->ref = 1;
 
    hr = IDirectMusicAudioPath_QueryInterface(&obj->IDirectMusicAudioPath_iface, riid, ppobj);
    IDirectMusicAudioPath_Release(&obj->IDirectMusicAudioPath_iface);
    return hr;
}

Referenced by performance_CreateAudioPath(), and performance_CreateStandardAudioPath().

create_dmaudiopath_config()

HRESULT create_dmaudiopath_config	(	REFIID	riid,
		void **	ppobj
	)

Definition at line 751 of file audiopath.c.

{
    struct audio_path_config *obj;
    HRESULT hr;
 
    *ppobj = NULL;
    if (!(obj = calloc(1, sizeof(*obj)))) return E_OUTOFMEMORY;
    dmobject_init(&obj->dmobj, &CLSID_DirectMusicAudioPathConfig, &obj->IUnknown_iface);
    obj->IUnknown_iface.lpVtbl = &path_config_unk_vtbl;
    obj->dmobj.IDirectMusicObject_iface.lpVtbl = &dmobject_vtbl;
    obj->dmobj.IPersistStream_iface.lpVtbl = &persiststream_vtbl;
    obj->ref = 1;
 
    list_init(&obj->port_config_entries);
 
    hr = IUnknown_QueryInterface(&obj->IUnknown_iface, riid, ppobj);
    IUnknown_Release(&obj->IUnknown_iface);
    return hr;
}

IDirectMusicAudioPathImpl_Activate()

static HRESULT WINAPI IDirectMusicAudioPathImpl_Activate ( IDirectMusicAudioPath *  iface, BOOL  activate  )

static

Definition at line 240 of file audiopath.c.

{
    struct IDirectMusicAudioPathImpl *This = impl_from_IDirectMusicAudioPath(iface);
 
    FIXME("(%p, %d): semi-stub\n", This, activate);
 
    if (!!activate == This->fActive)
        return S_FALSE;
 
    if (!activate && This->pDSBuffer) {
        /* Path is being deactivated */
        IDirectSoundBuffer_Stop(This->pDSBuffer);
    }
 
    This->fActive = !!activate;
 
    return S_OK;
}

IDirectMusicAudioPathImpl_AddRef()

static ULONG WINAPI IDirectMusicAudioPathImpl_AddRef ( IDirectMusicAudioPath *  iface )

static

Definition at line 117 of file audiopath.c.

{
    struct IDirectMusicAudioPathImpl *This = impl_from_IDirectMusicAudioPath(iface);
    ULONG ref = InterlockedIncrement(&This->ref);
 
    TRACE("(%p): ref=%ld\n", This, ref);
 
    return ref;
}

IDirectMusicAudioPathImpl_ConvertPChannel()

static HRESULT WINAPI IDirectMusicAudioPathImpl_ConvertPChannel ( IDirectMusicAudioPath *  iface, DWORD  dwPChannelIn, DWORD *  pdwPChannelOut  )

static

Definition at line 266 of file audiopath.c.

{
  struct IDirectMusicAudioPathImpl *This = impl_from_IDirectMusicAudioPath(iface);
  FIXME("(%p, %ld, %p): stub\n", This, dwPChannelIn, pdwPChannelOut);
  return S_OK;
}

IDirectMusicAudioPathImpl_GetObjectInPath()

static HRESULT WINAPI IDirectMusicAudioPathImpl_GetObjectInPath ( IDirectMusicAudioPath *  iface, DWORD  dwPChannel, DWORD  dwStage, DWORD  dwBuffer, REFGUID  guidObject, DWORD  dwIndex, REFGUID  iidInterface, void **  ppObject  )

static

Definition at line 146 of file audiopath.c.

{
    struct IDirectMusicAudioPathImpl *This = impl_from_IDirectMusicAudioPath(iface);
    HRESULT hr;
 
    FIXME("(%p, %ld, %ld, %ld, %s, %ld, %s, %p): stub\n", This, dwPChannel, dwStage, dwBuffer, debugstr_dmguid(guidObject),
            dwIndex, debugstr_dmguid(iidInterface), ppObject);
        
    switch (dwStage) {
        case DMUS_PATH_BUFFER:
          if (This->pDSBuffer)
          {
              if (IsEqualIID (iidInterface, &IID_IUnknown) ||
                  IsEqualIID (iidInterface, &IID_IDirectSoundBuffer)  ||
                  IsEqualIID (iidInterface, &IID_IDirectSoundBuffer8) ||
                  IsEqualIID (iidInterface, &IID_IDirectSound3DBuffer)) {
                  return IDirectSoundBuffer_QueryInterface(This->pDSBuffer, iidInterface, ppObject);
              }
 
              WARN("Unsupported interface %s\n", debugstr_dmguid(iidInterface));
              *ppObject = NULL;
              return E_NOINTERFACE;
          }
          break;
 
    case DMUS_PATH_PRIMARY_BUFFER: {
      if (IsEqualIID (iidInterface, &IID_IDirectSound3DListener)) {
            IDirectSoundBuffer_QueryInterface(This->pPrimary, &IID_IDirectSound3DListener, ppObject);
        return S_OK;
      } else {
        FIXME("bad iid...\n");
      }
    }
    break;
 
    case DMUS_PATH_AUDIOPATH_GRAPH:
      {
        if (IsEqualIID (iidInterface, &IID_IDirectMusicGraph)) {
          if (NULL == This->pToolGraph) {
        IDirectMusicGraph* pGraph;
        hr = create_dmgraph(&IID_IDirectMusicGraph, (void**)&pGraph);
        if (FAILED(hr))
          return hr;
        This->pToolGraph = pGraph;
          }
          *ppObject = This->pToolGraph;
          IDirectMusicGraph_AddRef((LPDIRECTMUSICGRAPH) *ppObject);
          return S_OK;
        }
      }
      break;
 
    case DMUS_PATH_AUDIOPATH_TOOL:
      {
        /* TODO */
      }
      break;
 
    case DMUS_PATH_PERFORMANCE:
      {
        /* TODO check wanted GUID */
        *ppObject = This->pPerf;
        IUnknown_AddRef((LPUNKNOWN) *ppObject);
        return S_OK;
      }
      break;
 
    case DMUS_PATH_PERFORMANCE_GRAPH:
      {
        IDirectMusicGraph* pPerfoGraph = NULL; 
        IDirectMusicPerformance8_GetGraph(This->pPerf, &pPerfoGraph);
        if (NULL == pPerfoGraph) {
          IDirectMusicGraph* pGraph = NULL;
          hr = create_dmgraph(&IID_IDirectMusicGraph, (void**)&pGraph);
          if (FAILED(hr))
        return hr;
          IDirectMusicPerformance8_SetGraph(This->pPerf, pGraph);
          pPerfoGraph = pGraph;
        }
        *ppObject = pPerfoGraph;
        return S_OK;
      }
      break;
 
    case DMUS_PATH_PERFORMANCE_TOOL:
    default:
      break;
    }
 
    *ppObject = NULL;
    return E_INVALIDARG;
}

IDirectMusicAudioPathImpl_QueryInterface()

static HRESULT WINAPI IDirectMusicAudioPathImpl_QueryInterface ( IDirectMusicAudioPath *  iface, REFIID  riid, void **  ppobj  )

static

Definition at line 97 of file audiopath.c.

{
    struct IDirectMusicAudioPathImpl *This = impl_from_IDirectMusicAudioPath(iface);
 
    TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 
    *ppobj = NULL;
 
    if (IsEqualIID (riid, &IID_IDirectMusicAudioPath) || IsEqualIID (riid, &IID_IUnknown))
        *ppobj = &This->IDirectMusicAudioPath_iface;
 
    if (*ppobj) {
        IUnknown_AddRef((IUnknown*)*ppobj);
        return S_OK;
    }
 
    WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
    return E_NOINTERFACE;
}

IDirectMusicAudioPathImpl_Release()

static ULONG WINAPI IDirectMusicAudioPathImpl_Release ( IDirectMusicAudioPath *  iface )

static

Definition at line 127 of file audiopath.c.

{
    struct IDirectMusicAudioPathImpl *This = impl_from_IDirectMusicAudioPath(iface);
    ULONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("(%p): ref=%ld\n", This, ref);
 
    if (ref == 0) {
        if (This->pPrimary)
            IDirectSoundBuffer_Release(This->pPrimary);
        if (This->pDSBuffer)
            IDirectSoundBuffer_Release(This->pDSBuffer);
        This->pPerf = NULL;
        free(This);
    }
 
    return ref;
}

IDirectMusicAudioPathImpl_SetVolume()

static HRESULT WINAPI IDirectMusicAudioPathImpl_SetVolume ( IDirectMusicAudioPath *  iface, LONG  lVolume, DWORD  dwDuration  )

static

Definition at line 259 of file audiopath.c.

{
  struct IDirectMusicAudioPathImpl *This = impl_from_IDirectMusicAudioPath(iface);
  FIXME("(%p, %li, %ld): stub\n", This, lVolume, dwDuration);
  return S_OK;
}

impl_from_IDirectMusicAudioPath()

static struct IDirectMusicAudioPathImpl * impl_from_IDirectMusicAudioPath ( IDirectMusicAudioPath *  iface )

inlinestatic

Definition at line 66 of file audiopath.c.

{
    return CONTAINING_RECORD(iface, struct IDirectMusicAudioPathImpl, IDirectMusicAudioPath_iface);
}

Referenced by IDirectMusicAudioPathImpl_Activate(), IDirectMusicAudioPathImpl_AddRef(), IDirectMusicAudioPathImpl_ConvertPChannel(), IDirectMusicAudioPathImpl_GetObjectInPath(), IDirectMusicAudioPathImpl_QueryInterface(), IDirectMusicAudioPathImpl_Release(), IDirectMusicAudioPathImpl_SetVolume(), set_audiopath_dsound_buffer(), set_audiopath_perf_pointer(), and set_audiopath_primary_dsound_buffer().

impl_from_IPersistStream()

static struct audio_path_config * impl_from_IPersistStream ( IPersistStream *  iface )

inlinestatic

Definition at line 71 of file audiopath.c.

{
    return CONTAINING_RECORD(iface, struct audio_path_config, dmobj.IPersistStream_iface);
}

Referenced by path_config_IPersistStream_Load().

impl_from_IUnknown()

static struct audio_path_config * impl_from_IUnknown ( IUnknown *  iface )

inlinestatic

Definition at line 585 of file audiopath.c.

{
    return CONTAINING_RECORD(iface, struct audio_path_config, IUnknown_iface);
}

Referenced by path_config_get_audio_path_params(), path_config_IUnknown_AddRef(), path_config_IUnknown_QueryInterface(), and path_config_IUnknown_Release().

parse_pchannel_to_buffers_list()

static HRESULT parse_pchannel_to_buffers_list ( struct audio_path_port_config *  This, IStream *  stream, const struct chunk_entry *  pchl  )

static

Definition at line 326 of file audiopath.c.

{
    struct chunk_entry chunk = { .parent = pchl };
    struct audio_path_pchannel_to_buffer *pchannel_to_buffer = NULL;
    DMUS_IO_PCHANNELTOBUFFER_HEADER header;
    SIZE_T bytes;
    ULONG i;
    HRESULT hr;
 
    while ((hr = stream_next_chunk(stream, &chunk)) == S_OK)
    {
        switch (chunk.id)
        {
        case DMUS_FOURCC_PCHANNELS_ITEM:
            hr = stream_read(stream, &header, sizeof(header));
            if (FAILED(hr))
                break;
 
            TRACE("Got PChannelToBuffer header:\n");
            TRACE("\tdwPChannelCount: %lu\n", header.dwPChannelCount);
            TRACE("\tdwPChannelBase: %lu\n", header.dwPChannelBase);
            TRACE("\tdwBufferCount: %lu\n", header.dwBufferCount);
            TRACE("\tdwFlags: %lx\n", header.dwFlags);
 
            bytes = chunk.size - sizeof(header);
 
            if (bytes != sizeof(GUID) * header.dwBufferCount)
            {
                WARN("Invalid size of GUIDs array\n");
                hr = E_FAIL;
                break;
            }
 
            pchannel_to_buffer = calloc(1, sizeof(*pchannel_to_buffer) + bytes);
            if (!pchannel_to_buffer)
            {
                hr = E_OUTOFMEMORY;
                break;
            }
 
            pchannel_to_buffer->header = header;
            TRACE("number of GUIDs: %lu\n", pchannel_to_buffer->header.dwBufferCount);
 
            hr = stream_read(stream, pchannel_to_buffer->guids, bytes);
            if (FAILED(hr))
                break;
 
            for (i = 0; i < pchannel_to_buffer->header.dwBufferCount; i++)
                TRACE("\tguids[%lu]: %s\n", i, debugstr_dmguid(&pchannel_to_buffer->guids[i]));
 
            list_add_tail(&This->pchannel_to_buffer_entries, &pchannel_to_buffer->entry);
            pchannel_to_buffer = NULL;
            break;
        case FOURCC_LIST:
            if (chunk.type == DMUS_FOURCC_UNFO_LIST)
                TRACE("Unfo list in PChannelToBuffer is ignored\n");
            else
                WARN("Unknown %s\n", debugstr_chunk(&chunk));
            break;
        case MAKEFOURCC('p','b','g','d'):
            FIXME("Undocumented %s\n", debugstr_chunk(&chunk));
            break;
        default:
            WARN("Unknown %s\n", debugstr_chunk(&chunk));
            break;
        }
 
        if (FAILED(hr))
            break;
    }
 
    if (FAILED(hr) && pchannel_to_buffer)
        free(pchannel_to_buffer);
    return hr;
}

Referenced by parse_port_config_list().

parse_port_config_list()

static HRESULT parse_port_config_list ( struct audio_path_config *  This, IStream *  stream, const struct chunk_entry *  pcfl  )

static

Definition at line 414 of file audiopath.c.

{
    struct chunk_entry chunk = { .parent = pcfl };
    struct audio_path_port_config *port_config = calloc(1, sizeof(*port_config));
    HRESULT hr;
 
    if (!port_config)
        return E_OUTOFMEMORY;
 
    list_init(&port_config->pchannel_to_buffer_entries);
 
    while ((hr = stream_next_chunk(stream, &chunk)) == S_OK)
    {
        switch (chunk.id)
        {
        case DMUS_FOURCC_PORTCONFIG_ITEM:
            hr = stream_chunk_get_data(stream, &chunk, &port_config->header, sizeof(port_config->header));
            if (FAILED(hr))
                break;
            TRACE("Got PortConfig header:\n");
            TRACE("\tdwPChannelBase: %lu\n", port_config->header.dwPChannelBase);
            TRACE("\tdwPChannelCount: %lu\n", port_config->header.dwPChannelCount);
            TRACE("\tdwFlags: %lx\n", port_config->header.dwFlags);
            TRACE("\tguidPort: %s\n", debugstr_dmguid(&port_config->header.guidPort));
            break;
        case DMUS_FOURCC_PORTPARAMS_ITEM:
            hr = stream_chunk_get_data(stream, &chunk, &port_config->params, sizeof(port_config->params));
            if (FAILED(hr))
                break;
            TRACE("Got PortConfig params:\n");
            TRACE("\tdwSize: %lu\n", port_config->params.dwSize);
            TRACE("\tdwValidParams: %lx\n", port_config->params.dwValidParams);
            if (port_config->params.dwValidParams & DMUS_PORTPARAMS_VOICES)
                TRACE("\tvoices: %lu\n", port_config->params.dwVoices);
            if (port_config->params.dwValidParams & DMUS_PORTPARAMS_CHANNELGROUPS)
                TRACE("\tchannel groups: %lu\n", port_config->params.dwChannelGroups);
            if (port_config->params.dwValidParams & DMUS_PORTPARAMS_AUDIOCHANNELS)
                TRACE("\taudio channels: %lu\n", port_config->params.dwAudioChannels);
            if (port_config->params.dwValidParams & DMUS_PORTPARAMS_SAMPLERATE)
                TRACE("\tsample rate: %lu\n", port_config->params.dwSampleRate);
            if (port_config->params.dwValidParams & DMUS_PORTPARAMS_EFFECTS)
                TRACE("\teffects: %lx\n", port_config->params.dwEffectFlags);
            if (port_config->params.dwValidParams & DMUS_PORTPARAMS_SHARE)
                TRACE("\tshare: %d\n", port_config->params.fShare);
            if (port_config->params.dwValidParams & DMUS_PORTPARAMS_FEATURES)
                TRACE("\tfeatures: %lx\n", port_config->params.dwFeatures);
            break;
        case FOURCC_LIST:
            if (chunk.type == DMUS_FOURCC_DSBUFFER_LIST)
                FIXME("DirectSound buffer descriptors is not supported\n");
            else if (chunk.type == DMUS_FOURCC_PCHANNELS_LIST)
                hr = parse_pchannel_to_buffers_list(port_config, stream, &chunk);
            else if (chunk.type == DMUS_FOURCC_UNFO_LIST)
                TRACE("Unfo list in PortConfig is ignored\n");
            else
                WARN("Unknown %s\n", debugstr_chunk(&chunk));
            break;
        default:
            WARN("Unknown %s\n", debugstr_chunk(&chunk));
        }
 
        if (FAILED(hr))
            break;
    }
 
    if (FAILED(hr))
        port_config_destroy(port_config);
    else
        list_add_tail(&This->port_config_entries, &port_config->entry);
    return hr;
}

Referenced by parse_port_configs_list().

parse_port_configs_list()

static HRESULT parse_port_configs_list ( struct audio_path_config *  This, IStream *  stream, const struct chunk_entry *  pcsl  )

static

Definition at line 486 of file audiopath.c.

{
    struct chunk_entry chunk = { .parent = pcsl };
    HRESULT hr;
 
    while ((hr = stream_next_chunk(stream, &chunk)) == S_OK)
    {
        switch (MAKE_IDTYPE(chunk.id, chunk.type))
        {
        case MAKE_IDTYPE(FOURCC_LIST, DMUS_FOURCC_PORTCONFIG_LIST):
            hr = parse_port_config_list(This, stream, &chunk);
            if (FAILED(hr))
                return hr;
            break;
        default:
            WARN("Unknown %s\n", debugstr_chunk(&chunk));
            break;
        }
    }
    return SUCCEEDED(hr) ? S_OK : hr;
}

Referenced by path_config_IPersistStream_Load().

path_config_get_audio_path_params()

HRESULT path_config_get_audio_path_params	(	IUnknown *	iface,
		WAVEFORMATEX *	format,
		DSBUFFERDESC *	desc,
		DMUS_PORTPARAMS *	params
	)

Definition at line 652 of file audiopath.c.

{
    struct audio_path_config *This = impl_from_IUnknown(iface);
    struct list *first_port_config, *first_pchannel_to_buffer;
    struct audio_path_port_config *port_config;
    struct audio_path_pchannel_to_buffer *pchannel_to_buffer;
    GUID *guids;
 
    first_port_config = list_head(&This->port_config_entries);
    if (list_next(&This->port_config_entries, first_port_config))
        FIXME("Only one port config supported. %p -> %p\n", first_port_config, list_next(&This->port_config_entries, first_port_config));
    port_config = LIST_ENTRY(first_port_config, struct audio_path_port_config, entry);
    first_pchannel_to_buffer = list_head(&port_config->pchannel_to_buffer_entries);
    if (list_next(&port_config->pchannel_to_buffer_entries, first_pchannel_to_buffer))
        FIXME("Only one pchannel to buffer entry supported.\n");
    pchannel_to_buffer = LIST_ENTRY(first_pchannel_to_buffer, struct audio_path_pchannel_to_buffer, entry);
 
    /* Secondary buffer description */
    memset(format, 0, sizeof(*format));
    format->wFormatTag = WAVE_FORMAT_PCM;
    format->nChannels = 1;
    format->nSamplesPerSec = 44000;
    format->nAvgBytesPerSec = 44000 * 2;
    format->nBlockAlign = 2;
    format->wBitsPerSample = 16;
    format->cbSize = 0;
 
    memset(desc, 0, sizeof(*desc));
    desc->dwSize = sizeof(*desc);
    desc->dwFlags = DSBCAPS_CTRLFX | DSBCAPS_CTRLVOLUME | DSBCAPS_GLOBALFOCUS;
    desc->dwBufferBytes = DSBSIZE_MIN;
    desc->dwReserved = 0;
    desc->lpwfxFormat = format;
    desc->guid3DAlgorithm = GUID_NULL;
 
    guids = pchannel_to_buffer->guids;
    if (pchannel_to_buffer->header.dwBufferCount == 2)
    {
        if ((!IsEqualGUID(&guids[0], &GUID_Buffer_Reverb) && !IsEqualGUID(&guids[0], &GUID_Buffer_Stereo)) ||
                (!IsEqualGUID(&guids[1], &GUID_Buffer_Reverb) && !IsEqualGUID(&guids[1], &GUID_Buffer_Stereo)) ||
                IsEqualGUID(&guids[0], &guids[1]))
            FIXME("Only a stereo plus reverb buffer is supported\n");
        else
        {
            desc->dwFlags |= DSBCAPS_CTRLPAN | DSBCAPS_CTRLFREQUENCY;
            format->nChannels = 2;
            format->nBlockAlign *= 2;
            format->nAvgBytesPerSec *= 2;
        }
    }
    else if (pchannel_to_buffer->header.dwBufferCount == 1)
    {
        if (IsEqualGUID(guids, &GUID_Buffer_Stereo))
        {
            desc->dwFlags |= DSBCAPS_CTRLPAN | DSBCAPS_CTRLFREQUENCY;
            format->nChannels = 2;
            format->nBlockAlign *= 2;
            format->nAvgBytesPerSec *= 2;
        }
        else if (IsEqualGUID(guids, &GUID_Buffer_3D_Dry))
            desc->dwFlags |= DSBCAPS_CTRL3D | DSBCAPS_CTRLFREQUENCY | DSBCAPS_MUTE3DATMAXDISTANCE;
        else if (IsEqualGUID(guids, &GUID_Buffer_Mono))
            desc->dwFlags |= DSBCAPS_CTRLPAN | DSBCAPS_CTRLFREQUENCY;
        else
            FIXME("Unsupported buffer guid %s\n", debugstr_dmguid(guids));
    }
    else
        FIXME("Multiple buffers not supported\n");
 
    *params = port_config->params;
    if (!(params->dwValidParams & DMUS_PORTPARAMS_CHANNELGROUPS))
    {
        params->dwValidParams |= DMUS_PORTPARAMS_CHANNELGROUPS;
        params->dwChannelGroups = (port_config->header.dwPChannelCount + 15) / 16;
    }
    if (!(params->dwValidParams & DMUS_PORTPARAMS_AUDIOCHANNELS))
    {
        params->dwValidParams |= DMUS_PORTPARAMS_AUDIOCHANNELS;
        params->dwAudioChannels = format->nChannels;
    }
    return S_OK;
}

Referenced by performance_CreateAudioPath().

path_config_IDirectMusicObject_ParseDescriptor()

static HRESULT WINAPI path_config_IDirectMusicObject_ParseDescriptor ( IDirectMusicObject *  iface, IStream *  stream, DMUS_OBJECTDESC *  desc  )

static

Definition at line 284 of file audiopath.c.

{
    struct chunk_entry riff = {0};
    HRESULT hr;
 
    TRACE("(%p, %p, %p)\n", iface, stream, desc);
 
    if (!stream)
        return E_POINTER;
    if (!desc || desc->dwSize != sizeof(*desc))
        return E_INVALIDARG;
 
    if ((hr = stream_get_chunk(stream, &riff)) != S_OK)
        return hr;
    if (riff.id != FOURCC_RIFF || riff.type != DMUS_FOURCC_AUDIOPATH_FORM) {
        TRACE("loading failed: unexpected %s\n", debugstr_chunk(&riff));
        stream_skip_chunk(stream, &riff);
        return DMUS_E_CHUNKNOTFOUND;
    }
 
    hr = dmobj_parsedescriptor(stream, &riff, desc,
            DMUS_OBJ_OBJECT|DMUS_OBJ_NAME|DMUS_OBJ_CATEGORY|DMUS_OBJ_VERSION);
    if (FAILED(hr))
        return hr;
 
    desc->guidClass = CLSID_DirectMusicAudioPathConfig;
    desc->dwValidData |= DMUS_OBJ_CLASS;
 
    dump_DMUS_OBJECTDESC(desc);
    return S_OK;
}

path_config_IPersistStream_Load()

static HRESULT WINAPI path_config_IPersistStream_Load ( IPersistStream *  iface, IStream *  stream  )

static

Definition at line 509 of file audiopath.c.

{
    struct audio_path_config *This = impl_from_IPersistStream(iface);
    struct chunk_entry riff = {0}, chunk = {0};
    HRESULT hr = S_OK;
 
    FIXME("(%p, %p): Loading\n", This, stream);
 
    if (!stream)
        return E_POINTER;
 
    hr = stream_get_chunk(stream, &riff);
    if (FAILED(hr))
    {
        WARN("Failed to get chunk %#lx.\n", hr);
        return hr;
    }
 
    if (MAKE_IDTYPE(riff.id, riff.type) != MAKE_IDTYPE(FOURCC_RIFF, DMUS_FOURCC_AUDIOPATH_FORM))
    {
        WARN("loading failed: unexpected %s\n", debugstr_chunk(&riff));
        return E_UNEXPECTED;
    }
 
    if (FAILED(hr = dmobj_parsedescriptor(stream, &riff, &This->dmobj.desc,
            DMUS_OBJ_OBJECT | DMUS_OBJ_VERSION | DMUS_OBJ_NAME | DMUS_OBJ_CATEGORY))
                || FAILED(hr = stream_reset_chunk_data(stream, &riff)))
    {
        WARN("Failed to parse descriptor %#lx.\n", hr);
        return hr;
    }
    This->dmobj.desc.guidClass = CLSID_DirectMusicAudioPathConfig;
    This->dmobj.desc.dwValidData |= DMUS_OBJ_CLASS;
 
    chunk.parent = &riff;
    while ((hr = stream_next_chunk(stream, &chunk)) == S_OK)
    {
        switch (MAKE_IDTYPE(chunk.id, chunk.type))
        {
        case MAKE_IDTYPE(FOURCC_LIST,  DMUS_FOURCC_PORTCONFIGS_LIST):
            hr = parse_port_configs_list(This, stream, &chunk);
            if (FAILED(hr))
                return hr;
        case MAKE_IDTYPE(FOURCC_LIST, DMUS_FOURCC_DSBUFFER_LIST):
            FIXME("buffer attributes are not supported\n");
            break;
        case MAKE_IDTYPE(FOURCC_LIST, MAKEFOURCC('p','a','p','d')):
            FIXME("Undocumented %s\n", debugstr_chunk(&chunk));
            break;
        case MAKE_IDTYPE(FOURCC_LIST, DMUS_FOURCC_UNFO_LIST):
            WARN("Unknown %s\n", debugstr_chunk(&chunk));
            break;
        case DMUS_FOURCC_GUID_CHUNK:
        case DMUS_FOURCC_VERSION_CHUNK:
            /* Already parsed in dmobj_parsedescriptor. */
            break;
        default:
            WARN("Unknown %s\n", debugstr_chunk(&chunk));
            break;
        }
    }
    TRACE("Finished parsing %#lx\n", hr);
    return SUCCEEDED(hr) ? S_OK : hr;
}

path_config_IUnknown_AddRef()

static ULONG WINAPI path_config_IUnknown_AddRef ( IUnknown *  unk )

static

Definition at line 615 of file audiopath.c.

{
    struct audio_path_config *This = impl_from_IUnknown(unk);
    ULONG ref = InterlockedIncrement(&This->ref);
 
    TRACE("(%p): ref=%ld\n", This, ref);
 
    return ref;
}

path_config_IUnknown_QueryInterface()

static HRESULT WINAPI path_config_IUnknown_QueryInterface ( IUnknown *  iface, REFIID  riid, void **  ppobj  )

static

Definition at line 590 of file audiopath.c.

{
    struct audio_path_config *This = impl_from_IUnknown(iface);
 
    TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 
    *ppobj = NULL;
 
    if (IsEqualIID (riid, &IID_IUnknown))
        *ppobj = &This->IUnknown_iface;
    else if (IsEqualIID (riid, &IID_IDirectMusicObject))
        *ppobj = &This->dmobj.IDirectMusicObject_iface;
    else if (IsEqualIID (riid, &IID_IPersistStream))
        *ppobj = &This->dmobj.IPersistStream_iface;
 
    if (*ppobj)
    {
        IUnknown_AddRef((IUnknown*)*ppobj);
        return S_OK;
    }
 
    WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
    return E_NOINTERFACE;
}

path_config_IUnknown_Release()

static ULONG WINAPI path_config_IUnknown_Release ( IUnknown *  unk )

static

Definition at line 625 of file audiopath.c.

{
    struct audio_path_config *This = impl_from_IUnknown(unk);
    ULONG ref = InterlockedDecrement(&This->ref);
 
    TRACE("(%p): ref=%ld\n", This, ref);
 
    if (!ref)
    {
        struct audio_path_port_config *config, *next_config;
        LIST_FOR_EACH_ENTRY_SAFE(config, next_config, &This->port_config_entries, struct audio_path_port_config, entry)
        {
            list_remove(&config->entry);
            port_config_destroy(config);
        }
        free(This);
    }
    return ref;
}

port_config_destroy()

static void port_config_destroy ( struct audio_path_port_config *  port_config )

static

Definition at line 402 of file audiopath.c.

{
    struct audio_path_pchannel_to_buffer *pchannel_to_buffer, *next_pchannel_to_buffer;
    LIST_FOR_EACH_ENTRY_SAFE(pchannel_to_buffer, next_pchannel_to_buffer, &port_config->pchannel_to_buffer_entries,
        struct audio_path_pchannel_to_buffer, entry)
    {
        list_remove(&pchannel_to_buffer->entry);
        free(pchannel_to_buffer);
    }
    free(port_config);
}

Referenced by parse_port_config_list(), and path_config_IUnknown_Release().

set_audiopath_dsound_buffer()

void set_audiopath_dsound_buffer	(	IDirectMusicAudioPath *	iface,
		IDirectSoundBuffer *	buffer
	)

Definition at line 82 of file audiopath.c.

{
    struct IDirectMusicAudioPathImpl *This = impl_from_IDirectMusicAudioPath(iface);
    This->pDSBuffer = buffer;
}

Referenced by performance_CreateAudioPath(), and performance_CreateStandardAudioPath().

set_audiopath_perf_pointer()

void set_audiopath_perf_pointer	(	IDirectMusicAudioPath *	iface,
		IDirectMusicPerformance8 *	performance
	)

Definition at line 76 of file audiopath.c.

{
    struct IDirectMusicAudioPathImpl *This = impl_from_IDirectMusicAudioPath(iface);
    This->pPerf = performance;
}

Referenced by performance_CreateAudioPath(), performance_CreateStandardAudioPath(), and performance_SetDefaultAudioPath().

set_audiopath_primary_dsound_buffer()

void set_audiopath_primary_dsound_buffer	(	IDirectMusicAudioPath *	iface,
		IDirectSoundBuffer *	buffer
	)

Definition at line 88 of file audiopath.c.

{
    struct IDirectMusicAudioPathImpl *This = impl_from_IDirectMusicAudioPath(iface);
    This->pPrimary = buffer;
}

Referenced by performance_CreateAudioPath(), and performance_CreateStandardAudioPath().

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

dmime

)

Variable Documentation

DirectMusicAudioPathVtbl

const IDirectMusicAudioPathVtbl DirectMusicAudioPathVtbl

static

Initial value:

= {
  IDirectMusicAudioPathImpl_QueryInterface,
  IDirectMusicAudioPathImpl_AddRef,
  IDirectMusicAudioPathImpl_Release,
  IDirectMusicAudioPathImpl_GetObjectInPath,
  IDirectMusicAudioPathImpl_Activate,
  IDirectMusicAudioPathImpl_SetVolume,
  IDirectMusicAudioPathImpl_ConvertPChannel
}

Definition at line 273 of file audiopath.c.

Referenced by create_dmaudiopath().

dmobject_vtbl

const IDirectMusicObjectVtbl dmobject_vtbl

static

Initial value:

= {
    dmobj_IDirectMusicObject_QueryInterface,
    dmobj_IDirectMusicObject_AddRef,
    dmobj_IDirectMusicObject_Release,
    dmobj_IDirectMusicObject_GetDescriptor,
    dmobj_IDirectMusicObject_SetDescriptor,
    path_config_IDirectMusicObject_ParseDescriptor
}

Definition at line 317 of file audiopath.c.

Referenced by create_dmaudiopath_config().

path_config_unk_vtbl

const IUnknownVtbl path_config_unk_vtbl

static

Initial value:

=
{
    path_config_IUnknown_QueryInterface,
    path_config_IUnknown_AddRef,
    path_config_IUnknown_Release,
}

Definition at line 645 of file audiopath.c.

Referenced by create_dmaudiopath_config().

persiststream_vtbl

const IPersistStreamVtbl persiststream_vtbl

static

Initial value:

= {
    dmobj_IPersistStream_QueryInterface,
    dmobj_IPersistStream_AddRef,
    dmobj_IPersistStream_Release,
    dmobj_IPersistStream_GetClassID,
    unimpl_IPersistStream_IsDirty,
    path_config_IPersistStream_Load,
    unimpl_IPersistStream_Save,
    unimpl_IPersistStream_GetSizeMax
}

Definition at line 574 of file audiopath.c.

Referenced by create_dmaudiopath_config().