dmusic_wave.h File Reference

#include <stdarg.h>
#include <stddef.h>
#include "windef.h"
#include "winbase.h"
#include "objbase.h"
#include "dmusici.h"

Include dependency graph for dmusic_wave.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Macros
#define	COBJMACROS

Functions
HRESULT	wave_create (IDirectMusicObject **ret_iface)
HRESULT	wave_create_from_soundfont (struct soundfont *soundfont, UINT index, IDirectMusicObject **out)
HRESULT	wave_create_from_chunk (IStream *stream, struct chunk_entry *parent, IDirectMusicObject **out)
HRESULT	wave_download_to_port (IDirectMusicObject *iface, IDirectMusicPortDownload *port, DWORD *id)
HRESULT	wave_download_to_dsound (IDirectMusicObject *iface, IDirectSound *dsound, IDirectSoundBuffer **ret_iface)
HRESULT	wave_get_duration (IDirectMusicObject *iface, REFERENCE_TIME *duration)

Macro Definition Documentation

COBJMACROS

#define COBJMACROS

Definition at line 22 of file dmusic_wave.h.

Function Documentation

wave_create()

HRESULT wave_create

(

IDirectMusicObject **

ret_iface

)

Definition at line 277 of file wave.c.

{
    struct wave *obj;
 
    if (!(obj = calloc(1, sizeof(*obj)))) return E_OUTOFMEMORY;
    obj->IUnknown_iface.lpVtbl = &unknown_vtbl;
    obj->ref = 1;
    dmobject_init(&obj->dmobj, &CLSID_DirectSoundWave, &obj->IUnknown_iface);
    obj->dmobj.IDirectMusicObject_iface.lpVtbl = &wave_object_vtbl;
    obj->dmobj.IPersistStream_iface.lpVtbl = &wave_persist_stream_vtbl;
 
    *ret_iface = &obj->dmobj.IDirectMusicObject_iface;
    return S_OK;
}

Referenced by wave_create_from_chunk(), wave_create_from_soundfont(), and WaveCF_CreateInstance().

wave_create_from_chunk()

HRESULT wave_create_from_chunk	(	IStream *	stream,
		struct chunk_entry *	parent,
		IDirectMusicObject **	out
	)

Definition at line 292 of file wave.c.

{
    struct wave *This;
    IDirectMusicObject *iface;
    HRESULT hr;
 
    TRACE("(%p, %p, %p)\n", stream, parent, ret_iface);
 
    if (FAILED(hr = wave_create(&iface))) return hr;
    This = impl_from_IDirectMusicObject(iface);
 
    if (FAILED(hr = parse_wave_chunk(This, stream, parent)))
    {
        IDirectMusicObject_Release(iface);
        return DMUS_E_UNSUPPORTED_STREAM;
    }
 
    if (TRACE_ON(dmusic))
    {
        UINT i;
 
        TRACE("*** Created DirectMusicWave %p\n", This);
        TRACE(" - format: %p\n", This->format);
        if (This->format)
        {
            TRACE("    - wFormatTag: %u\n", This->format->wFormatTag);
            TRACE("    - nChannels: %u\n", This->format->nChannels);
            TRACE("    - nSamplesPerSec: %lu\n", This->format->nSamplesPerSec);
            TRACE("    - nAvgBytesPerSec: %lu\n", This->format->nAvgBytesPerSec);
            TRACE("    - nBlockAlign: %u\n", This->format->nBlockAlign);
            TRACE("    - wBitsPerSample: %u\n", This->format->wBitsPerSample);
            TRACE("    - cbSize: %u\n", This->format->cbSize);
        }
        if (This->sample)
        {
            TRACE(" - sample: {size: %lu, unity_note: %u, fine_tune: %d, attenuation: %ld, options: %#lx, loops: %lu}\n",
                    This->sample->head.cbSize, This->sample->head.usUnityNote,
                    This->sample->head.sFineTune, This->sample->head.lAttenuation,
                    This->sample->head.fulOptions, This->sample->head.cSampleLoops);
            for (i = 0; i < This->sample->head.cSampleLoops; i++)
                TRACE(" - loops[%u]: {size: %lu, type: %lu, start: %lu, length: %lu}\n", i,
                        This->sample->loops[i].cbSize, This->sample->loops[i].ulType,
                        This->sample->loops[i].ulStart, This->sample->loops[i].ulLength);
        }
    }
 
    *ret_iface = iface;
    return S_OK;
}

Referenced by parse_wvpl_list(), and wave_track_create_from_chunk().

wave_create_from_soundfont()

HRESULT wave_create_from_soundfont	(	struct soundfont *	soundfont,
		UINT	index,
		IDirectMusicObject **	out
	)

Definition at line 342 of file wave.c.

{
    struct sf_sample *sf_sample = soundfont->shdr + index;
    struct sample *sample = NULL;
    WAVEFORMATEX *format = NULL;
    HRESULT hr = E_OUTOFMEMORY;
    DWORD data_size, offset;
    struct wave *This;
    IStream *stream = NULL;
    IDirectMusicObject *iface;
    const LARGE_INTEGER zero = { .QuadPart = 0 };
 
    TRACE("(%p, %u, %p)\n", soundfont, index, ret_iface);
 
    if (sf_sample->sample_link) FIXME("Stereo sample not supported\n");
 
    if (!(format = calloc(1, sizeof(*format)))) goto failed;
    format->wFormatTag = WAVE_FORMAT_PCM;
    format->nChannels = 1;
    format->wBitsPerSample = 16;
    format->nSamplesPerSec = sf_sample->sample_rate;
    format->nBlockAlign = format->wBitsPerSample * format->nChannels / 8;
    format->nAvgBytesPerSec = format->nBlockAlign * format->nSamplesPerSec;
 
    if (!(sample = calloc(1, offsetof(struct sample, loops[1])))) goto failed;
    sample->head.cbSize = sizeof(sample->head);
    sample->head.cSampleLoops = 1;
    sample->loops[0].ulStart = sf_sample->start_loop - sf_sample->start;
    sample->loops[0].ulLength = sf_sample->end_loop - sf_sample->start_loop;
 
    data_size = sf_sample->end - sf_sample->start;
    if (FAILED(hr = CreateStreamOnHGlobal(NULL, TRUE, &stream))) goto failed;
    offset = sf_sample->start * format->nBlockAlign / format->nChannels;
    if (FAILED(hr = IStream_Write(stream, soundfont->sdta + offset, data_size, &data_size))) goto failed;
    if (FAILED(hr = IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL))) goto failed;
 
    if (FAILED(hr = wave_create(&iface))) goto failed;
 
    This = impl_from_IDirectMusicObject(iface);
    This->format = format;
    This->sample = sample;
    This->data_size = data_size;
    This->data = stream;
 
    if (TRACE_ON(dmusic))
    {
        UINT i;
 
        TRACE("*** Created DirectMusicWave %p\n", This);
        TRACE(" - format: %p\n", This->format);
        if (This->format)
        {
            TRACE("    - wFormatTag: %u\n", This->format->wFormatTag);
            TRACE("    - nChannels: %u\n", This->format->nChannels);
            TRACE("    - nSamplesPerSec: %lu\n", This->format->nSamplesPerSec);
            TRACE("    - nAvgBytesPerSec: %lu\n", This->format->nAvgBytesPerSec);
            TRACE("    - nBlockAlign: %u\n", This->format->nBlockAlign);
            TRACE("    - wBitsPerSample: %u\n", This->format->wBitsPerSample);
            TRACE("    - cbSize: %u\n", This->format->cbSize);
        }
 
        TRACE(" - sample: {size: %lu, unity_note: %u, fine_tune: %d, attenuation: %ld, options: %#lx, loops: %lu}\n",
                This->sample->head.cbSize, This->sample->head.usUnityNote,
                This->sample->head.sFineTune, This->sample->head.lAttenuation,
                This->sample->head.fulOptions, This->sample->head.cSampleLoops);
        for (i = 0; i < This->sample->head.cSampleLoops; i++)
            TRACE(" - loops[%u]: {size: %lu, type: %lu, start: %lu, length: %lu}\n", i,
                    This->sample->loops[i].cbSize, This->sample->loops[i].ulType,
                    This->sample->loops[i].ulStart, This->sample->loops[i].ulLength);
    }
 
    *ret_iface = iface;
    return S_OK;
 
failed:
    if (stream) IStream_Release(stream);
    free(sample);
    free(format);
    return hr;
}

Referenced by parse_sfbk_chunk().

wave_download_to_dsound()

HRESULT wave_download_to_dsound	(	IDirectMusicObject *	iface,
		IDirectSound *	dsound,
		IDirectSoundBuffer **	ret_iface
	)

Definition at line 481 of file wave.c.

{
    struct wave *This = impl_from_IDirectMusicObject(iface);
    DSBUFFERDESC desc =
    {
        .dwSize = sizeof(desc),
        .dwBufferBytes = This->data_size,
        .lpwfxFormat = This->format,
    };
    IDirectSoundBuffer *buffer;
    HRESULT hr;
    void *data;
    DWORD size;
 
    TRACE("%p, %p, %p\n", This, dsound, ret_iface);
 
    if (FAILED(hr = IDirectSound_CreateSoundBuffer(dsound, &desc, &buffer, NULL)))
    {
        WARN("Failed to create direct sound buffer, hr %#lx\n", hr);
        return hr;
    }
 
    if (SUCCEEDED(hr = IDirectSoundBuffer_Lock(buffer, 0, This->data_size, &data, &size, NULL, 0, 0)))
    {
        if (FAILED(hr = wave_read_data(This, data, &size)))
            WARN("Failed to read wave data from stream, hr %#lx\n", hr);
        hr = IDirectSoundBuffer_Unlock(buffer, data, size, NULL, 0);
    }
 
    if (FAILED(hr))
    {
        WARN("Failed to download wave to dsound, hr %#lx\n", hr);
        IDirectSoundBuffer_Release(buffer);
        return hr;
    }
 
    *ret_iface = buffer;
    return S_OK;
}

Referenced by wave_track_SetParam().

wave_download_to_port()

HRESULT wave_download_to_port	(	IDirectMusicObject *	iface,
		IDirectMusicPortDownload *	port,
		DWORD *	id
	)

Definition at line 437 of file wave.c.

{
    struct download_buffer
    {
        DMUS_DOWNLOADINFO info;
        ULONG offsets[2];
        DMUS_WAVE wave;
        DMUS_WAVEDATA data;
    } *buffer;
 
    struct wave *This = impl_from_IDirectMusicObject(iface);
    DWORD size = offsetof(struct download_buffer, data.byData[This->data_size]);
    IDirectMusicDownload *download;
    HRESULT hr;
 
    if (FAILED(hr = IDirectMusicPortDownload_AllocateBuffer(port, size, &download))) return hr;
 
    if (SUCCEEDED(hr = IDirectMusicDownload_GetBuffer(download, (void **)&buffer, &size))
            && SUCCEEDED(hr = IDirectMusicPortDownload_GetDLId(port, &buffer->info.dwDLId, 1)))
    {
        buffer->info.dwDLType = DMUS_DOWNLOADINFO_WAVE;
        buffer->info.dwNumOffsetTableEntries = 2;
        buffer->info.cbSize = size;
 
        buffer->offsets[0] = offsetof(struct download_buffer, wave);
        buffer->offsets[1] = offsetof(struct download_buffer, data);
 
        buffer->wave.WaveformatEx = *This->format;
        buffer->wave.ulWaveDataIdx = 1;
        buffer->wave.ulCopyrightIdx = 0;
        buffer->wave.ulFirstExtCkIdx = 0;
 
        if (FAILED(hr = wave_read_data(This, buffer->data.byData, &buffer->data.cbSize)))
            WARN("Failed to read wave data from stream, hr %#lx\n", hr);
        else if (FAILED(hr = IDirectMusicPortDownload_Download(port, download)))
            WARN("Failed to download wave to port, hr %#lx\n", hr);
        else
            *id = buffer->info.dwDLId;
    }
 
    IDirectMusicDownload_Release(download);
    return hr;
}

Referenced by instrument_download_to_port().

wave_get_duration()

HRESULT wave_get_duration	(	IDirectMusicObject *	iface,
		REFERENCE_TIME *	duration
	)

Definition at line 521 of file wave.c.

{
    struct wave *This = impl_from_IDirectMusicObject(iface);
    *duration = (REFERENCE_TIME)This->data_size * 10000000 / This->format->nAvgBytesPerSec;
    return S_OK;
}

Referenced by wave_track_create_from_chunk().