mirror of
git://source.winehq.org/git/wine.git
synced 2024-09-30 12:38:29 +00:00
1674 lines
67 KiB
C
1674 lines
67 KiB
C
/*
|
|
* Unit tests for dmusic functions
|
|
*
|
|
* Copyright (C) 2012 Christian Costa
|
|
*
|
|
* 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 COBJMACROS
|
|
|
|
#include <stdio.h>
|
|
|
|
#include "wine/test.h"
|
|
#include "uuids.h"
|
|
#include "ole2.h"
|
|
#include "initguid.h"
|
|
#include "dmusici.h"
|
|
#include "dmusicf.h"
|
|
#include "dmksctrl.h"
|
|
|
|
static ULONG get_refcount(void *iface)
|
|
{
|
|
IUnknown *unknown = iface;
|
|
IUnknown_AddRef(unknown);
|
|
return IUnknown_Release(unknown);
|
|
}
|
|
|
|
#define check_interface(a, b, c) check_interface_(__LINE__, a, b, c)
|
|
static void check_interface_(unsigned int line, void *iface_ptr, REFIID iid, BOOL supported)
|
|
{
|
|
ULONG expect_ref = get_refcount(iface_ptr);
|
|
IUnknown *iface = iface_ptr;
|
|
HRESULT hr, expected;
|
|
IUnknown *unk;
|
|
|
|
expected = supported ? S_OK : E_NOINTERFACE;
|
|
hr = IUnknown_QueryInterface(iface, iid, (void **)&unk);
|
|
ok_(__FILE__, line)(hr == expected, "got hr %#lx, expected %#lx.\n", hr, expected);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
LONG ref = get_refcount(unk);
|
|
ok_(__FILE__, line)(ref == expect_ref + 1, "got %ld\n", ref);
|
|
IUnknown_Release(unk);
|
|
ref = get_refcount(iface_ptr);
|
|
ok_(__FILE__, line)(ref == expect_ref, "got %ld\n", ref);
|
|
}
|
|
}
|
|
|
|
static void stream_begin_chunk(IStream *stream, const char type[5], ULARGE_INTEGER *offset)
|
|
{
|
|
static const LARGE_INTEGER zero = {0};
|
|
HRESULT hr;
|
|
hr = IStream_Write(stream, type, 4, NULL);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
hr = IStream_Seek(stream, zero, STREAM_SEEK_CUR, offset);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
hr = IStream_Write(stream, "\0\0\0\0", 4, NULL);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
}
|
|
|
|
static void stream_end_chunk(IStream *stream, ULARGE_INTEGER *offset)
|
|
{
|
|
static const LARGE_INTEGER zero = {0};
|
|
ULARGE_INTEGER position;
|
|
HRESULT hr;
|
|
UINT size;
|
|
hr = IStream_Seek(stream, zero, STREAM_SEEK_CUR, &position);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
hr = IStream_Seek(stream, *(LARGE_INTEGER *)offset, STREAM_SEEK_SET, NULL);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
size = position.QuadPart - offset->QuadPart - 4;
|
|
hr = IStream_Write(stream, &size, 4, NULL);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
hr = IStream_Seek(stream, *(LARGE_INTEGER *)&position, STREAM_SEEK_SET, NULL);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
hr = IStream_Write(stream, &zero, (position.QuadPart & 1), NULL);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
}
|
|
|
|
#define CHUNK_BEGIN(stream, type) \
|
|
do { \
|
|
ULARGE_INTEGER __off; \
|
|
IStream *__stream = (stream); \
|
|
stream_begin_chunk(stream, type, &__off); \
|
|
do
|
|
|
|
#define CHUNK_RIFF(stream, form) \
|
|
do { \
|
|
ULARGE_INTEGER __off; \
|
|
IStream *__stream = (stream); \
|
|
stream_begin_chunk(stream, "RIFF", &__off); \
|
|
IStream_Write(stream, form, 4, NULL); \
|
|
do
|
|
|
|
#define CHUNK_LIST(stream, form) \
|
|
do { \
|
|
ULARGE_INTEGER __off; \
|
|
IStream *__stream = (stream); \
|
|
stream_begin_chunk(stream, "LIST", &__off); \
|
|
IStream_Write(stream, form, 4, NULL); \
|
|
do
|
|
|
|
#define CHUNK_END \
|
|
while (0); \
|
|
stream_end_chunk(__stream, &__off); \
|
|
} while (0)
|
|
|
|
#define CHUNK_DATA(stream, type, data) \
|
|
CHUNK_BEGIN(stream, type) \
|
|
{ \
|
|
IStream_Write((stream), &(data), sizeof(data), NULL); \
|
|
} \
|
|
CHUNK_END
|
|
|
|
static BOOL compare_time(REFERENCE_TIME x, REFERENCE_TIME y, unsigned int max_diff)
|
|
{
|
|
REFERENCE_TIME diff = x > y ? x - y : y - x;
|
|
return diff <= max_diff;
|
|
}
|
|
|
|
static void test_dmusic(void)
|
|
{
|
|
IDirectMusic *dmusic = NULL;
|
|
HRESULT hr;
|
|
ULONG index = 0;
|
|
DMUS_PORTCAPS port_caps;
|
|
DMUS_PORTPARAMS port_params;
|
|
IDirectMusicPort *port = NULL;
|
|
|
|
hr = CoCreateInstance(&CLSID_DirectMusic, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectMusic, (LPVOID*)&dmusic);
|
|
ok(hr == S_OK, "Cannot create DirectMusic object: %#lx\n", hr);
|
|
|
|
port_params.dwSize = sizeof(port_params);
|
|
port_params.dwValidParams = DMUS_PORTPARAMS_CHANNELGROUPS | DMUS_PORTPARAMS_AUDIOCHANNELS;
|
|
port_params.dwChannelGroups = 1;
|
|
port_params.dwAudioChannels = 2;
|
|
|
|
/* No port can be created before SetDirectSound is called */
|
|
hr = IDirectMusic_CreatePort(dmusic, &GUID_NULL, &port_params, &port, NULL);
|
|
ok(hr == DMUS_E_DSOUND_NOT_SET, "IDirectMusic_CreatePort returned: %#lx\n", hr);
|
|
|
|
hr = IDirectMusic_SetDirectSound(dmusic, NULL, NULL);
|
|
ok(hr == S_OK, "IDirectMusic_SetDirectSound returned: %#lx\n", hr);
|
|
|
|
/* Check wrong params */
|
|
hr = IDirectMusic_CreatePort(dmusic, &GUID_NULL, &port_params, &port, (IUnknown*)dmusic);
|
|
ok(hr == CLASS_E_NOAGGREGATION, "IDirectMusic_CreatePort returned: %#lx\n", hr);
|
|
hr = IDirectMusic_CreatePort(dmusic, NULL, &port_params, &port, NULL);
|
|
ok(hr == E_POINTER, "IDirectMusic_CreatePort returned: %#lx\n", hr);
|
|
hr = IDirectMusic_CreatePort(dmusic, &GUID_NULL, NULL, &port, NULL);
|
|
ok(hr == E_INVALIDARG, "IDirectMusic_CreatePort returned: %#lx\n", hr);
|
|
hr = IDirectMusic_CreatePort(dmusic, &GUID_NULL, &port_params, NULL, NULL);
|
|
ok(hr == E_POINTER, "IDirectMusic_CreatePort returned: %#lx\n", hr);
|
|
|
|
/* Test creation of default port with GUID_NULL */
|
|
hr = IDirectMusic_CreatePort(dmusic, &GUID_NULL, &port_params, &port, NULL);
|
|
ok(hr == S_OK, "IDirectMusic_CreatePort returned: %#lx\n", hr);
|
|
|
|
port_caps.dwSize = sizeof(port_caps);
|
|
while (IDirectMusic_EnumPort(dmusic, index, &port_caps) == S_OK)
|
|
{
|
|
ok(port_caps.dwSize == sizeof(port_caps), "DMUS_PORTCAPS dwSize member is wrong (%lu)\n", port_caps.dwSize);
|
|
trace("Port %lu:\n", index);
|
|
trace(" dwFlags = %lx\n", port_caps.dwFlags);
|
|
trace(" guidPort = %s\n", wine_dbgstr_guid(&port_caps.guidPort));
|
|
trace(" dwClass = %lu\n", port_caps.dwClass);
|
|
trace(" dwType = %lu\n", port_caps.dwType);
|
|
trace(" dwMemorySize = %lu\n", port_caps.dwMemorySize);
|
|
trace(" dwMaxChannelGroups = %lu\n", port_caps.dwMaxChannelGroups);
|
|
trace(" dwMaxVoices = %lu\n", port_caps.dwMaxVoices);
|
|
trace(" dwMaxAudioChannels = %lu\n", port_caps.dwMaxAudioChannels);
|
|
trace(" dwEffectFlags = %lx\n", port_caps.dwEffectFlags);
|
|
trace(" wszDescription = %s\n", wine_dbgstr_w(port_caps.wszDescription));
|
|
index++;
|
|
}
|
|
|
|
if (port)
|
|
IDirectMusicPort_Release(port);
|
|
IDirectMusic_Release(dmusic);
|
|
}
|
|
|
|
static void test_setdsound(void)
|
|
{
|
|
IDirectMusic *dmusic;
|
|
IDirectSound *dsound, *dsound2;
|
|
DMUS_PORTPARAMS params;
|
|
IDirectMusicPort *port = NULL;
|
|
HRESULT hr;
|
|
ULONG ref;
|
|
|
|
params.dwSize = sizeof(params);
|
|
params.dwValidParams = DMUS_PORTPARAMS_CHANNELGROUPS | DMUS_PORTPARAMS_AUDIOCHANNELS;
|
|
params.dwChannelGroups = 1;
|
|
params.dwAudioChannels = 2;
|
|
|
|
/* Old dsound without SetCooperativeLevel() */
|
|
hr = DirectSoundCreate(NULL, &dsound, NULL);
|
|
if (hr == DSERR_NODRIVER ) {
|
|
skip("No driver\n");
|
|
return;
|
|
}
|
|
ok(hr == S_OK, "DirectSoundCreate failed: %#lx\n", hr);
|
|
hr = CoCreateInstance(&CLSID_DirectMusic, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectMusic8,
|
|
(void **)&dmusic);
|
|
ok(hr == S_OK, "DirectMusic create failed: %#lx\n", hr);
|
|
hr = IDirectMusic_SetDirectSound(dmusic, dsound, NULL);
|
|
ok(hr == S_OK, "SetDirectSound failed: %#lx\n", hr);
|
|
hr = IDirectMusic_CreatePort(dmusic, &GUID_NULL, ¶ms, &port, NULL);
|
|
ok(hr == S_OK, "CreatePort returned: %#lx\n", hr);
|
|
IDirectMusicPort_Release(port);
|
|
IDirectMusic_Release(dmusic);
|
|
IDirectSound_Release(dsound);
|
|
|
|
/* dsound ref counting */
|
|
hr = CoCreateInstance(&CLSID_DirectMusic, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectMusic8,
|
|
(void **)&dmusic);
|
|
ok(hr == S_OK, "DirectMusic create failed: %#lx\n", hr);
|
|
hr = DirectSoundCreate8(NULL, (IDirectSound8 **)&dsound, NULL);
|
|
ok(hr == S_OK, "DirectSoundCreate failed: %#lx\n", hr);
|
|
hr = IDirectSound_SetCooperativeLevel(dsound, GetForegroundWindow(), DSSCL_PRIORITY);
|
|
ok(hr == S_OK, "SetCooperativeLevel failed: %#lx\n", hr);
|
|
hr = IDirectMusic_SetDirectSound(dmusic, dsound, NULL);
|
|
ok(hr == S_OK, "SetDirectSound failed: %#lx\n", hr);
|
|
ref = get_refcount(dsound);
|
|
ok(ref == 2, "dsound ref count got %ld expected 2\n", ref);
|
|
hr = IDirectMusic_CreatePort(dmusic, &GUID_NULL, ¶ms, &port, NULL);
|
|
ok(hr == S_OK, "CreatePort returned: %#lx\n", hr);
|
|
ref = get_refcount(dsound);
|
|
ok(ref == 2, "dsound ref count got %ld expected 2\n", ref);
|
|
IDirectMusicPort_AddRef(port);
|
|
ref = IDirectMusicPort_Release(port);
|
|
ok(ref == 1, "port ref count got %ld expected 1\n", ref);
|
|
hr = IDirectMusicPort_Activate(port, TRUE);
|
|
ok(hr == S_OK, "Port Activate returned: %#lx\n", hr);
|
|
ref = get_refcount(dsound);
|
|
ok(ref == 4, "dsound ref count got %ld expected 4\n", ref);
|
|
IDirectMusicPort_AddRef(port);
|
|
ref = IDirectMusicPort_Release(port);
|
|
ok(ref == 1, "port ref count got %ld expected 1\n", ref);
|
|
|
|
/* Releasing dsound from dmusic */
|
|
hr = IDirectMusic_SetDirectSound(dmusic, NULL, NULL);
|
|
ok(hr == DMUS_E_DSOUND_ALREADY_SET, "SetDirectSound failed: %#lx\n", hr);
|
|
hr = IDirectMusicPort_Activate(port, FALSE);
|
|
ok(hr == S_OK, "Port Activate returned: %#lx\n", hr);
|
|
ref = get_refcount(dsound);
|
|
ok(ref == 2, "dsound ref count got %ld expected 2\n", ref);
|
|
hr = IDirectMusic_SetDirectSound(dmusic, NULL, NULL);
|
|
ok(hr == S_OK, "SetDirectSound failed: %#lx\n", hr);
|
|
ref = get_refcount(dsound);
|
|
ok(ref == 1, "dsound ref count got %ld expected 1\n", ref);
|
|
|
|
/* Setting the same dsound twice */
|
|
hr = IDirectMusic_SetDirectSound(dmusic, dsound, NULL);
|
|
ok(hr == S_OK, "SetDirectSound failed: %#lx\n", hr);
|
|
ref = get_refcount(dsound);
|
|
ok(ref == 2, "dsound ref count got %ld expected 2\n", ref);
|
|
hr = IDirectMusic_SetDirectSound(dmusic, dsound, NULL);
|
|
ok(hr == S_OK, "SetDirectSound failed: %#lx\n", hr);
|
|
ref = get_refcount(dsound);
|
|
ok(ref == 2, "dsound ref count got %ld expected 2\n", ref);
|
|
|
|
/* Replacing one dsound with another */
|
|
hr = DirectSoundCreate8(NULL, (IDirectSound8 **)&dsound2, NULL);
|
|
ok(hr == S_OK, "DirectSoundCreate failed: %#lx\n", hr);
|
|
hr = IDirectMusic_SetDirectSound(dmusic, dsound2, NULL);
|
|
ok(hr == S_OK, "SetDirectSound failed: %#lx\n", hr);
|
|
ref = get_refcount(dsound);
|
|
ok(ref == 1, "dsound ref count got %ld expected 1\n", ref);
|
|
ref = get_refcount(dsound2);
|
|
ok(ref == 2, "dsound2 ref count got %ld expected 2\n", ref);
|
|
|
|
/* Replacing the dsound in the port */
|
|
hr = IDirectMusicPort_SetDirectSound(port, dsound, NULL);
|
|
ok(hr == S_OK, "SetDirectSound failed: %#lx\n", hr);
|
|
ref = get_refcount(dsound);
|
|
ok(ref == 2, "dsound ref count got %ld expected 2\n", ref);
|
|
ref = get_refcount(dsound2);
|
|
ok(ref == 2, "dsound2 ref count got %ld expected 2\n", ref);
|
|
/* Setting the dsound again on the port will mess with the parent dmusic */
|
|
hr = IDirectMusicPort_SetDirectSound(port, dsound, NULL);
|
|
ok(hr == S_OK, "SetDirectSound failed: %#lx\n", hr);
|
|
ref = get_refcount(dsound);
|
|
ok(ref == 3, "dsound ref count got %ld expected 3\n", ref);
|
|
ref = get_refcount(dsound2);
|
|
ok(ref == 1, "dsound2 ref count got %ld expected 1\n", ref);
|
|
IDirectSound_AddRef(dsound2); /* Crash prevention */
|
|
hr = IDirectMusicPort_Activate(port, TRUE);
|
|
ok(hr == S_OK, "Activate returned: %#lx\n", hr);
|
|
ref = get_refcount(dsound);
|
|
ok(ref == 4, "dsound ref count got %ld expected 4\n", ref);
|
|
ref = get_refcount(dsound2);
|
|
ok(ref == 2, "dsound2 ref count got %ld expected 2\n", ref);
|
|
hr = IDirectMusicPort_Activate(port, TRUE);
|
|
ok(hr == S_FALSE, "Activate returned: %#lx\n", hr);
|
|
ref = get_refcount(dsound);
|
|
ok(ref == 4, "dsound ref count got %ld expected 4\n", ref);
|
|
ref = get_refcount(dsound2);
|
|
ok(ref == 2, "dsound2 ref count got %ld expected 2\n", ref);
|
|
|
|
/* Deactivating the port messes with the dsound refcount in the parent dmusic */
|
|
hr = IDirectMusicPort_Activate(port, FALSE);
|
|
ok(hr == S_OK, "Port Activate returned: %#lx\n", hr);
|
|
ref = get_refcount(dsound);
|
|
ok(ref == 3, "dsound ref count got %ld expected 3\n", ref);
|
|
ref = get_refcount(dsound2);
|
|
ok(ref == 1, "dsound2 ref count got %ld expected 1\n", ref);
|
|
hr = IDirectMusicPort_Activate(port, FALSE);
|
|
ok(hr == S_FALSE, "Port Activate returned: %#lx\n", hr);
|
|
ref = get_refcount(dsound);
|
|
ok(ref == 3, "dsound ref count got %ld expected 3\n", ref);
|
|
ref = get_refcount(dsound2);
|
|
ok(ref == 1, "dsound2 ref count got %ld expected 1\n", ref);
|
|
|
|
IDirectMusicPort_Release(port);
|
|
IDirectMusic_Release(dmusic);
|
|
while (IDirectSound_Release(dsound));
|
|
}
|
|
|
|
static void test_dmbuffer(void)
|
|
{
|
|
IDirectMusic *dmusic;
|
|
IDirectMusicBuffer *dmbuffer = NULL;
|
|
HRESULT hr;
|
|
DMUS_BUFFERDESC desc;
|
|
GUID format;
|
|
DWORD size;
|
|
DWORD bytes;
|
|
REFERENCE_TIME time;
|
|
LPBYTE data;
|
|
|
|
hr = CoCreateInstance(&CLSID_DirectMusic, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectMusic, (LPVOID*)&dmusic);
|
|
ok(hr == S_OK, "Cannot create DirectMusic object: %#lx\n", hr);
|
|
|
|
desc.dwSize = sizeof(DMUS_BUFFERDESC);
|
|
desc.dwFlags = 0;
|
|
desc.cbBuffer = 1023;
|
|
memcpy(&desc.guidBufferFormat, &GUID_NULL, sizeof(GUID));
|
|
|
|
hr = IDirectMusic_CreateMusicBuffer(dmusic, &desc, &dmbuffer, NULL);
|
|
ok(hr == S_OK, "IDirectMusic_CreateMusicBuffer returned %#lx\n", hr);
|
|
|
|
hr = IDirectMusicBuffer_GetBufferFormat(dmbuffer, &format);
|
|
ok(hr == S_OK, "IDirectMusicBuffer_GetBufferFormat returned %#lx\n", hr);
|
|
ok(IsEqualGUID(&format, &KSDATAFORMAT_SUBTYPE_MIDI), "Wrong format returned %s\n", wine_dbgstr_guid(&format));
|
|
hr = IDirectMusicBuffer_GetMaxBytes(dmbuffer, &size);
|
|
ok(hr == S_OK, "IDirectMusicBuffer_GetMaxBytes returned %#lx\n", hr);
|
|
ok(size == 1024, "Buffer size is %lu instead of 1024\n", size);
|
|
|
|
hr = IDirectMusicBuffer_GetStartTime(dmbuffer, &time);
|
|
ok(hr == DMUS_E_BUFFER_EMPTY, "IDirectMusicBuffer_GetStartTime returned %#lx\n", hr);
|
|
hr = IDirectMusicBuffer_SetStartTime(dmbuffer, 10);
|
|
ok(hr == S_OK, "IDirectMusicBuffer_GetStartTime returned %#lx\n", hr);
|
|
hr = IDirectMusicBuffer_GetStartTime(dmbuffer, &time);
|
|
ok(hr == DMUS_E_BUFFER_EMPTY, "IDirectMusicBuffer_GetStartTime returned %#lx\n", hr);
|
|
|
|
hr = IDirectMusicBuffer_PackStructured(dmbuffer, 20, 0, 0);
|
|
ok(hr == DMUS_E_INVALID_EVENT, "IDirectMusicBuffer_PackStructured returned %#lx\n", hr);
|
|
hr = IDirectMusicBuffer_PackStructured(dmbuffer, 20, 0, 0x000090); /* note on : chan 0, note 0 & vel 0 */
|
|
ok(hr == S_OK, "IDirectMusicBuffer_PackStructured returned %#lx\n", hr);
|
|
hr = IDirectMusicBuffer_PackStructured(dmbuffer, 30, 0, 0x000080); /* note off : chan 0, note 0 & vel 0 */
|
|
ok(hr == S_OK, "IDirectMusicBuffer_PackStructured returned %#lx\n", hr);
|
|
hr = IDirectMusicBuffer_GetUsedBytes(dmbuffer, &bytes);
|
|
ok(hr == S_OK, "IDirectMusicBuffer_GetUsedBytes returned %#lx\n", hr);
|
|
ok(bytes == 48, "Buffer size is %lu instead of 48\n", bytes);
|
|
|
|
hr = IDirectMusicBuffer_GetStartTime(dmbuffer, &time);
|
|
ok(hr == S_OK, "IDirectMusicBuffer_GetStartTime returned %#lx\n", hr);
|
|
ok(time == 20, "Buffer start time is wrong\n");
|
|
hr = IDirectMusicBuffer_SetStartTime(dmbuffer, 40);
|
|
ok(hr == S_OK, "IDirectMusicBuffer_GetStartTime returned %#lx\n", hr);
|
|
hr = IDirectMusicBuffer_GetStartTime(dmbuffer, &time);
|
|
ok(hr == S_OK, "IDirectMusicBuffer_GetStartTime returned %#lx\n", hr);
|
|
ok(time == 40, "Buffer start time is wrong\n");
|
|
|
|
hr = IDirectMusicBuffer_GetRawBufferPtr(dmbuffer, &data);
|
|
ok(hr == S_OK, "IDirectMusicBuffer_GetRawBufferPtr returned %#lx\n", hr);
|
|
if (hr == S_OK)
|
|
{
|
|
DMUS_EVENTHEADER* header;
|
|
DWORD message;
|
|
|
|
/* Check message 1 */
|
|
header = (DMUS_EVENTHEADER*)data;
|
|
data += sizeof(DMUS_EVENTHEADER);
|
|
ok(header->cbEvent == 3, "cbEvent is %lu instead of 3\n", header->cbEvent);
|
|
ok(header->dwChannelGroup == 0, "dwChannelGroup is %lu instead of 0\n", header->dwChannelGroup);
|
|
ok(header->rtDelta == 0, "rtDelta is %s instead of 0\n", wine_dbgstr_longlong(header->rtDelta));
|
|
ok(header->dwFlags == DMUS_EVENT_STRUCTURED, "dwFlags is %lx instead of %x\n", header->dwFlags, DMUS_EVENT_STRUCTURED);
|
|
message = *(DWORD*)data & 0xffffff; /* Only 3 bytes are relevant */
|
|
data += sizeof(DWORD);
|
|
ok(message == 0x000090, "Message is %0lx instead of 0x000090\n", message);
|
|
|
|
/* Check message 2 */
|
|
header = (DMUS_EVENTHEADER*)data;
|
|
data += sizeof(DMUS_EVENTHEADER);
|
|
ok(header->cbEvent == 3, "cbEvent is %lu instead of 3\n", header->cbEvent);
|
|
ok(header->dwChannelGroup == 0, "dwChannelGroup is %lu instead of 0\n", header->dwChannelGroup);
|
|
ok(header->rtDelta == 10, "rtDelta is %s instead of 0\n", wine_dbgstr_longlong(header->rtDelta));
|
|
ok(header->dwFlags == DMUS_EVENT_STRUCTURED, "dwFlags is %lx instead of %x\n", header->dwFlags, DMUS_EVENT_STRUCTURED);
|
|
message = *(DWORD*)data & 0xffffff; /* Only 3 bytes are relevant */
|
|
ok(message == 0x000080, "Message 2 is %0lx instead of 0x000080\n", message);
|
|
}
|
|
|
|
if (dmbuffer)
|
|
IDirectMusicBuffer_Release(dmbuffer);
|
|
IDirectMusic_Release(dmusic);
|
|
}
|
|
|
|
static void test_COM(void)
|
|
{
|
|
IDirectMusic8 *dm8 = (IDirectMusic8*)0xdeadbeef;
|
|
IDirectMusic *dm;
|
|
IUnknown *unk;
|
|
ULONG refcount;
|
|
HRESULT hr;
|
|
|
|
/* COM aggregation */
|
|
hr = CoCreateInstance(&CLSID_DirectMusic, (IUnknown *)0xdeadbeef, CLSCTX_INPROC_SERVER, &IID_IUnknown,
|
|
(void**)&dm8);
|
|
ok(hr == CLASS_E_NOAGGREGATION,
|
|
"DirectMusic8 create failed: %#lx, expected CLASS_E_NOAGGREGATION\n", hr);
|
|
ok(!dm8, "dm8 = %p\n", dm8);
|
|
|
|
/* Invalid RIID */
|
|
hr = CoCreateInstance(&CLSID_DirectMusic, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectMusicObject,
|
|
(void**)&dm8);
|
|
ok(hr == E_NOINTERFACE, "DirectMusic8 create failed: %#lx, expected E_NOINTERFACE\n", hr);
|
|
|
|
/* Same refcount for DirectMusic and DirectMusic8 */
|
|
hr = CoCreateInstance(&CLSID_DirectMusic, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectMusic8,
|
|
(void**)&dm8);
|
|
if (hr == E_NOINTERFACE)
|
|
{
|
|
win_skip("DirectMusic too old (no IDirectMusic8)\n");
|
|
return;
|
|
}
|
|
ok(hr == S_OK, "DirectMusic8 create failed: %#lx, expected S_OK\n", hr);
|
|
refcount = IDirectMusic8_AddRef(dm8);
|
|
ok(refcount == 2, "refcount == %lu, expected 2\n", refcount);
|
|
|
|
hr = IDirectMusic8_QueryInterface(dm8, &IID_IDirectMusic, (void**)&dm);
|
|
ok(hr == S_OK, "QueryInterface for IID_IDirectMusic failed: %#lx\n", hr);
|
|
refcount = IDirectMusic_AddRef(dm);
|
|
ok(refcount == 4, "refcount == %lu, expected 4\n", refcount);
|
|
IDirectMusic_Release(dm);
|
|
|
|
hr = IDirectMusic8_QueryInterface(dm8, &IID_IUnknown, (void**)&unk);
|
|
ok(hr == S_OK, "QueryInterface for IID_IUnknown failed: %#lx\n", hr);
|
|
refcount = IUnknown_AddRef(unk);
|
|
ok(refcount == 5, "refcount == %lu, expected 5\n", refcount);
|
|
refcount = IUnknown_Release(unk);
|
|
|
|
ok(refcount == 4, "refcount == %lu, expected 4\n", refcount);
|
|
while (IDirectMusic8_Release(dm8));
|
|
}
|
|
|
|
static void test_COM_dmcoll(void)
|
|
{
|
|
IDirectMusicCollection *dmc = (IDirectMusicCollection*)0xdeadbeef;
|
|
IDirectMusicObject *dmo;
|
|
IPersistStream *ps;
|
|
IUnknown *unk;
|
|
ULONG refcount;
|
|
HRESULT hr;
|
|
|
|
/* COM aggregation */
|
|
hr = CoCreateInstance(&CLSID_DirectMusicCollection, (IUnknown *)0xdeadbeef, CLSCTX_INPROC_SERVER,
|
|
&IID_IUnknown, (void**)&dmc);
|
|
ok(hr == CLASS_E_NOAGGREGATION,
|
|
"DirectMusicCollection create failed: %#lx, expected CLASS_E_NOAGGREGATION\n", hr);
|
|
ok(!dmc, "dmc = %p\n", dmc);
|
|
|
|
/* Invalid RIID */
|
|
hr = CoCreateInstance(&CLSID_DirectMusicCollection, NULL, CLSCTX_INPROC_SERVER,
|
|
&IID_IClassFactory, (void**)&dmc);
|
|
ok(hr == E_NOINTERFACE, "DirectMusicCollection create failed: %#lx, expected E_NOINTERFACE\n", hr);
|
|
|
|
/* Same refcount for all DirectMusicCollection interfaces */
|
|
hr = CoCreateInstance(&CLSID_DirectMusicCollection, NULL, CLSCTX_INPROC_SERVER,
|
|
&IID_IDirectMusicCollection, (void**)&dmc);
|
|
ok(hr == S_OK, "DirectMusicCollection create failed: %#lx, expected S_OK\n", hr);
|
|
refcount = IDirectMusicCollection_AddRef(dmc);
|
|
ok(refcount == 2, "refcount == %lu, expected 2\n", refcount);
|
|
|
|
hr = IDirectMusicCollection_QueryInterface(dmc, &IID_IDirectMusicObject, (void**)&dmo);
|
|
ok(hr == S_OK, "QueryInterface for IID_IDirectMusicObject failed: %#lx\n", hr);
|
|
refcount = IDirectMusicObject_AddRef(dmo);
|
|
ok(refcount == 4, "refcount == %lu, expected 4\n", refcount);
|
|
refcount = IDirectMusicObject_Release(dmo);
|
|
|
|
hr = IDirectMusicCollection_QueryInterface(dmc, &IID_IPersistStream, (void**)&ps);
|
|
ok(hr == S_OK, "QueryInterface for IID_IPersistStream failed: %#lx\n", hr);
|
|
refcount = IPersistStream_AddRef(ps);
|
|
ok(refcount == 5, "refcount == %lu, expected 5\n", refcount);
|
|
refcount = IPersistStream_Release(ps);
|
|
|
|
hr = IDirectMusicCollection_QueryInterface(dmc, &IID_IUnknown, (void**)&unk);
|
|
ok(hr == S_OK, "QueryInterface for IID_IUnknown failed: %#lx\n", hr);
|
|
refcount = IUnknown_AddRef(unk);
|
|
ok(refcount == 6, "refcount == %lu, expected 6\n", refcount);
|
|
refcount = IUnknown_Release(unk);
|
|
|
|
ok(refcount == 5, "refcount == %lu, expected 5\n", refcount);
|
|
while (IDirectMusicCollection_Release(dmc));
|
|
}
|
|
|
|
static void test_dmcoll(void)
|
|
{
|
|
IDirectMusicCollection *dmc;
|
|
IDirectMusicObject *dmo;
|
|
IPersistStream *ps;
|
|
DMUS_OBJECTDESC desc;
|
|
CLSID class;
|
|
ULARGE_INTEGER size;
|
|
HRESULT hr;
|
|
|
|
hr = CoCreateInstance(&CLSID_DirectMusicCollection, NULL, CLSCTX_INPROC_SERVER,
|
|
&IID_IDirectMusicCollection, (void**)&dmc);
|
|
ok(hr == S_OK, "DirectMusicCollection create failed: %#lx, expected S_OK\n", hr);
|
|
|
|
/* IDirectMusicObject */
|
|
hr = IDirectMusicCollection_QueryInterface(dmc, &IID_IDirectMusicObject, (void**)&dmo);
|
|
ok(hr == S_OK, "QueryInterface for IID_IDirectMusicObject failed: %#lx\n", hr);
|
|
hr = IDirectMusicObject_GetDescriptor(dmo, NULL);
|
|
ok(hr == E_POINTER, "IDirectMusicObject_GetDescriptor: expected E_POINTER, got %#lx\n", hr);
|
|
hr = IDirectMusicObject_SetDescriptor(dmo, NULL);
|
|
ok(hr == E_POINTER, "IDirectMusicObject_SetDescriptor: expected E_POINTER, got %#lx\n", hr);
|
|
ZeroMemory(&desc, sizeof(desc));
|
|
hr = IDirectMusicObject_GetDescriptor(dmo, &desc);
|
|
ok(hr == S_OK, "IDirectMusicObject_GetDescriptor failed: %#lx\n", hr);
|
|
ok(desc.dwValidData == DMUS_OBJ_CLASS,
|
|
"Fresh object has more valid data (%#lx) than DMUS_OBJ_CLASS\n", desc.dwValidData);
|
|
/* DMUS_OBJ_CLASS is immutable */
|
|
desc.dwValidData = DMUS_OBJ_CLASS;
|
|
hr = IDirectMusicObject_SetDescriptor(dmo, &desc);
|
|
ok(hr == S_FALSE , "IDirectMusicObject_SetDescriptor failed: %#lx\n", hr);
|
|
ok(!desc.dwValidData, "dwValidData wasn't cleared: %#lx\n", desc.dwValidData);
|
|
desc.dwValidData = DMUS_OBJ_CLASS;
|
|
desc.guidClass = CLSID_DirectMusicSegment;
|
|
hr = IDirectMusicObject_SetDescriptor(dmo, &desc);
|
|
ok(hr == S_FALSE && !desc.dwValidData, "IDirectMusicObject_SetDescriptor failed: %#lx\n", hr);
|
|
hr = IDirectMusicObject_GetDescriptor(dmo, &desc);
|
|
ok(hr == S_OK, "IDirectMusicObject_GetDescriptor failed: %#lx\n", hr);
|
|
ok(IsEqualGUID(&desc.guidClass, &CLSID_DirectMusicCollection),
|
|
"guidClass changed, should be CLSID_DirectMusicCollection\n");
|
|
|
|
/* Unimplemented IPersistStream methods*/
|
|
hr = IDirectMusicCollection_QueryInterface(dmc, &IID_IPersistStream, (void**)&ps);
|
|
ok(hr == S_OK, "QueryInterface for IID_IPersistStream failed: %#lx\n", hr);
|
|
hr = IPersistStream_GetClassID(ps, &class);
|
|
ok(hr == E_NOTIMPL, "IPersistStream_GetClassID failed: %#lx\n", hr);
|
|
hr = IPersistStream_IsDirty(ps);
|
|
ok(hr == S_FALSE, "IPersistStream_IsDirty failed: %#lx\n", hr);
|
|
hr = IPersistStream_GetSizeMax(ps, &size);
|
|
ok(hr == E_NOTIMPL, "IPersistStream_GetSizeMax failed: %#lx\n", hr);
|
|
hr = IPersistStream_Save(ps, NULL, TRUE);
|
|
ok(hr == E_NOTIMPL, "IPersistStream_Save failed: %#lx\n", hr);
|
|
|
|
while (IDirectMusicCollection_Release(dmc));
|
|
}
|
|
|
|
static BOOL missing_dmusic(void)
|
|
{
|
|
IDirectMusic8 *dm;
|
|
HRESULT hr = CoCreateInstance(&CLSID_DirectMusic, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectMusic,
|
|
(void**)&dm);
|
|
|
|
if (hr == S_OK && dm)
|
|
{
|
|
IDirectMusic_Release(dm);
|
|
return FALSE;
|
|
}
|
|
return TRUE;
|
|
}
|
|
|
|
static IDirectMusicPort *create_synth_port(IDirectMusic **dmusic)
|
|
{
|
|
IDirectMusicPort *port = NULL;
|
|
DMUS_PORTPARAMS params;
|
|
HRESULT hr;
|
|
|
|
hr = CoCreateInstance(&CLSID_DirectMusic, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectMusic, (void **)dmusic);
|
|
ok(hr == S_OK, "Cannot create DirectMusic object: %#lx\n", hr);
|
|
|
|
params.dwSize = sizeof(params);
|
|
params.dwValidParams = DMUS_PORTPARAMS_CHANNELGROUPS | DMUS_PORTPARAMS_AUDIOCHANNELS;
|
|
params.dwChannelGroups = 1;
|
|
params.dwAudioChannels = 2;
|
|
hr = IDirectMusic_SetDirectSound(*dmusic, NULL, NULL);
|
|
ok(hr == S_OK, "IDirectMusic_SetDirectSound failed: %#lx\n", hr);
|
|
hr = IDirectMusic_CreatePort(*dmusic, &GUID_NULL, ¶ms, &port, NULL);
|
|
ok(hr == S_OK, "IDirectMusic_CreatePort failed: %#lx\n", hr);
|
|
|
|
return port;
|
|
}
|
|
|
|
static void test_COM_synthport(void)
|
|
{
|
|
IDirectMusic *dmusic;
|
|
IDirectMusicPort *port;
|
|
IDirectMusicPortDownload *dmpd;
|
|
IDirectMusicThru *dmt;
|
|
IKsControl *iksc;
|
|
IReferenceClock *clock;
|
|
IUnknown *unk;
|
|
ULONG refcount;
|
|
HRESULT hr;
|
|
|
|
port = create_synth_port(&dmusic);
|
|
|
|
/* Same refcount for all DirectMusicPort interfaces */
|
|
refcount = IDirectMusicPort_AddRef(port);
|
|
ok(refcount == 2, "refcount == %lu, expected 2\n", refcount);
|
|
|
|
hr = IDirectMusicPort_QueryInterface(port, &IID_IDirectMusicPortDownload, (void**)&dmpd);
|
|
ok(hr == S_OK, "QueryInterface for IID_IDirectMusicPortDownload failed: %#lx\n", hr);
|
|
refcount = IDirectMusicPortDownload_AddRef(dmpd);
|
|
ok(refcount == 4, "refcount == %lu, expected 4\n", refcount);
|
|
IDirectMusicPortDownload_Release(dmpd);
|
|
|
|
hr = IDirectMusicPort_QueryInterface(port, &IID_IKsControl, (void**)&iksc);
|
|
ok(hr == S_OK, "QueryInterface for IID_IKsControl failed: %#lx\n", hr);
|
|
refcount = IKsControl_AddRef(iksc);
|
|
ok(refcount == 5, "refcount == %lu, expected 5\n", refcount);
|
|
IKsControl_Release(iksc);
|
|
|
|
hr = IDirectMusicPort_QueryInterface(port, &IID_IUnknown, (void**)&unk);
|
|
ok(hr == S_OK, "QueryInterface for IID_IUnknown failed: %#lx\n", hr);
|
|
refcount = IUnknown_AddRef(unk);
|
|
ok(refcount == 6, "refcount == %lu, expected 6\n", refcount);
|
|
IUnknown_Release(unk);
|
|
|
|
/* Unsupported interface */
|
|
hr = IDirectMusicPort_QueryInterface(port, &IID_IDirectMusicThru, (void**)&dmt);
|
|
todo_wine ok(hr == E_NOINTERFACE, "QueryInterface for IID_IDirectMusicThru failed: %#lx\n", hr);
|
|
hr = IDirectMusicPort_QueryInterface(port, &IID_IReferenceClock, (void**)&clock);
|
|
ok(hr == E_NOINTERFACE, "QueryInterface for IID_IReferenceClock failed: %#lx\n", hr);
|
|
|
|
while (IDirectMusicPort_Release(port));
|
|
refcount = IDirectMusic_Release(dmusic);
|
|
ok(!refcount, "Got outstanding refcount %ld.\n", refcount);
|
|
}
|
|
|
|
struct chunk {
|
|
FOURCC id;
|
|
DWORD size;
|
|
FOURCC type;
|
|
};
|
|
|
|
#define CHUNK_HDR_SIZE (sizeof(FOURCC) + sizeof(DWORD))
|
|
|
|
/* Generate a RIFF file format stream from an array of FOURCC ids.
|
|
RIFF and LIST need to be followed by the form type respectively list type,
|
|
followed by the chunks of the list and terminated with 0. */
|
|
static IStream *gen_riff_stream(const FOURCC *ids)
|
|
{
|
|
static const LARGE_INTEGER zero;
|
|
int level = -1;
|
|
DWORD *sizes[4]; /* Stack for the sizes of RIFF and LIST chunks */
|
|
char riff[1024];
|
|
char *p = riff;
|
|
struct chunk *ck;
|
|
IStream *stream;
|
|
|
|
do {
|
|
ck = (struct chunk *)p;
|
|
ck->id = *ids++;
|
|
switch (ck->id) {
|
|
case 0:
|
|
*sizes[level] = p - (char *)sizes[level] - sizeof(DWORD);
|
|
level--;
|
|
break;
|
|
case FOURCC_LIST:
|
|
case FOURCC_RIFF:
|
|
level++;
|
|
sizes[level] = &ck->size;
|
|
ck->type = *ids++;
|
|
p += sizeof(*ck);
|
|
break;
|
|
case DMUS_FOURCC_GUID_CHUNK:
|
|
ck->size = sizeof(GUID_NULL);
|
|
p += CHUNK_HDR_SIZE;
|
|
memcpy(p, &GUID_NULL, sizeof(GUID_NULL));
|
|
p += ck->size;
|
|
break;
|
|
case DMUS_FOURCC_VERSION_CHUNK:
|
|
{
|
|
DMUS_VERSION ver = {5, 8};
|
|
|
|
ck->size = sizeof(ver);
|
|
p += CHUNK_HDR_SIZE;
|
|
memcpy(p, &ver, sizeof(ver));
|
|
p += ck->size;
|
|
break;
|
|
}
|
|
case mmioFOURCC('I','N','A','M'):
|
|
ck->size = 5;
|
|
p += CHUNK_HDR_SIZE;
|
|
strcpy(p, "INAM");
|
|
p += ck->size + 1; /* WORD aligned */
|
|
break;
|
|
default:
|
|
{
|
|
/* Just convert the FOURCC id to a WCHAR string */
|
|
WCHAR *s;
|
|
|
|
ck->size = 5 * sizeof(WCHAR);
|
|
p += CHUNK_HDR_SIZE;
|
|
s = (WCHAR *)p;
|
|
s[0] = (char)(ck->id);
|
|
s[1] = (char)(ck->id >> 8);
|
|
s[2] = (char)(ck->id >> 16);
|
|
s[3] = (char)(ck->id >> 24);
|
|
s[4] = 0;
|
|
p += ck->size;
|
|
}
|
|
}
|
|
} while (level >= 0);
|
|
|
|
ck = (struct chunk *)riff;
|
|
CreateStreamOnHGlobal(NULL, TRUE, &stream);
|
|
IStream_Write(stream, riff, ck->size + CHUNK_HDR_SIZE, NULL);
|
|
IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
|
|
|
|
return stream;
|
|
}
|
|
|
|
static void test_parsedescriptor(void)
|
|
{
|
|
IDirectMusicObject *dmo;
|
|
IStream *stream;
|
|
DMUS_OBJECTDESC desc = {0};
|
|
HRESULT hr;
|
|
const FOURCC alldesc[] =
|
|
{
|
|
FOURCC_RIFF, FOURCC_DLS, DMUS_FOURCC_CATEGORY_CHUNK, FOURCC_LIST,
|
|
DMUS_FOURCC_UNFO_LIST, DMUS_FOURCC_UNAM_CHUNK, DMUS_FOURCC_UCOP_CHUNK,
|
|
DMUS_FOURCC_UCMT_CHUNK, DMUS_FOURCC_USBJ_CHUNK, 0, DMUS_FOURCC_VERSION_CHUNK,
|
|
DMUS_FOURCC_GUID_CHUNK, 0
|
|
};
|
|
const FOURCC dupes[] =
|
|
{
|
|
FOURCC_RIFF, FOURCC_DLS, DMUS_FOURCC_CATEGORY_CHUNK, DMUS_FOURCC_CATEGORY_CHUNK,
|
|
DMUS_FOURCC_VERSION_CHUNK, DMUS_FOURCC_VERSION_CHUNK, DMUS_FOURCC_GUID_CHUNK,
|
|
DMUS_FOURCC_GUID_CHUNK, FOURCC_LIST, DMUS_FOURCC_INFO_LIST, mmioFOURCC('I','N','A','M'), 0,
|
|
FOURCC_LIST, DMUS_FOURCC_INFO_LIST, mmioFOURCC('I','N','A','M'), 0, 0
|
|
};
|
|
FOURCC empty[] = {FOURCC_RIFF, FOURCC_DLS, 0};
|
|
FOURCC inam[] =
|
|
{
|
|
FOURCC_RIFF, FOURCC_DLS, FOURCC_LIST, DMUS_FOURCC_UNFO_LIST,
|
|
mmioFOURCC('I','N','A','M'), 0, 0
|
|
};
|
|
|
|
hr = CoCreateInstance(&CLSID_DirectMusicCollection, NULL, CLSCTX_INPROC_SERVER,
|
|
&IID_IDirectMusicObject, (void **)&dmo);
|
|
ok(hr == S_OK, "DirectMusicCollection create failed: %#lx, expected S_OK\n", hr);
|
|
|
|
/* Nothing loaded */
|
|
hr = IDirectMusicObject_GetDescriptor(dmo, &desc);
|
|
ok(hr == S_OK, "GetDescriptor failed: %#lx, expected S_OK\n", hr);
|
|
ok(desc.dwValidData == DMUS_OBJ_CLASS, "Got valid data %#lx, expected DMUS_OBJ_OBJECT\n",
|
|
desc.dwValidData);
|
|
ok(IsEqualGUID(&desc.guidClass, &CLSID_DirectMusicCollection),
|
|
"Got class guid %s, expected CLSID_DirectMusicCollection\n",
|
|
wine_dbgstr_guid(&desc.guidClass));
|
|
|
|
/* Empty RIFF stream */
|
|
stream = gen_riff_stream(empty);
|
|
memset(&desc, 0, sizeof(desc));
|
|
hr = IDirectMusicObject_ParseDescriptor(dmo, stream, &desc);
|
|
ok(hr == S_OK, "ParseDescriptor failed: %#lx, expected S_OK\n", hr);
|
|
ok(desc.dwValidData == DMUS_OBJ_CLASS, "Got valid data %#lx, expected DMUS_OBJ_CLASS\n",
|
|
desc.dwValidData);
|
|
ok(IsEqualGUID(&desc.guidClass, &CLSID_DirectMusicCollection),
|
|
"Got class guid %s, expected CLSID_DirectMusicCollection\n",
|
|
wine_dbgstr_guid(&desc.guidClass));
|
|
IStream_Release(stream);
|
|
|
|
/* NULL pointers */
|
|
memset(&desc, 0, sizeof(desc));
|
|
hr = IDirectMusicObject_ParseDescriptor(dmo, NULL, &desc);
|
|
ok(hr == E_POINTER, "ParseDescriptor failed: %#lx, expected E_POINTER\n", hr);
|
|
hr = IDirectMusicObject_ParseDescriptor(dmo, stream, NULL);
|
|
ok(hr == E_POINTER, "ParseDescriptor failed: %#lx, expected E_POINTER\n", hr);
|
|
|
|
/* Wrong form */
|
|
empty[1] = DMUS_FOURCC_CONTAINER_FORM;
|
|
stream = gen_riff_stream(empty);
|
|
hr = IDirectMusicObject_ParseDescriptor(dmo, stream, &desc);
|
|
ok(hr == DMUS_E_NOTADLSCOL, "ParseDescriptor failed: %#lx, expected DMUS_E_NOTADLSCOL\n", hr);
|
|
IStream_Release(stream);
|
|
|
|
/* All desc chunks */
|
|
stream = gen_riff_stream(alldesc);
|
|
memset(&desc, 0, sizeof(desc));
|
|
hr = IDirectMusicObject_ParseDescriptor(dmo, stream, &desc);
|
|
ok(hr == S_OK, "ParseDescriptor failed: %#lx, expected S_OK\n", hr);
|
|
ok(desc.dwValidData == (DMUS_OBJ_CLASS | DMUS_OBJ_VERSION),
|
|
"Got valid data %#lx, expected DMUS_OBJ_CLASS | DMUS_OBJ_VERSION\n", desc.dwValidData);
|
|
ok(IsEqualGUID(&desc.guidClass, &CLSID_DirectMusicCollection),
|
|
"Got class guid %s, expected CLSID_DirectMusicCollection\n",
|
|
wine_dbgstr_guid(&desc.guidClass));
|
|
ok(IsEqualGUID(&desc.guidObject, &GUID_NULL), "Got object guid %s, expected GUID_NULL\n",
|
|
wine_dbgstr_guid(&desc.guidClass));
|
|
ok(desc.vVersion.dwVersionMS == 5 && desc.vVersion.dwVersionLS == 8,
|
|
"Got version %lu.%lu, expected 5.8\n", desc.vVersion.dwVersionMS,
|
|
desc.vVersion.dwVersionLS);
|
|
IStream_Release(stream);
|
|
|
|
/* UNFO list with INAM */
|
|
inam[3] = DMUS_FOURCC_UNFO_LIST;
|
|
stream = gen_riff_stream(inam);
|
|
memset(&desc, 0, sizeof(desc));
|
|
hr = IDirectMusicObject_ParseDescriptor(dmo, stream, &desc);
|
|
ok(hr == S_OK, "ParseDescriptor failed: %#lx, expected S_OK\n", hr);
|
|
ok(desc.dwValidData == DMUS_OBJ_CLASS, "Got valid data %#lx, expected DMUS_OBJ_CLASS\n",
|
|
desc.dwValidData);
|
|
IStream_Release(stream);
|
|
|
|
/* INFO list with INAM */
|
|
inam[3] = DMUS_FOURCC_INFO_LIST;
|
|
stream = gen_riff_stream(inam);
|
|
memset(&desc, 0, sizeof(desc));
|
|
hr = IDirectMusicObject_ParseDescriptor(dmo, stream, &desc);
|
|
ok(hr == S_OK, "ParseDescriptor failed: %#lx, expected S_OK\n", hr);
|
|
ok(desc.dwValidData == (DMUS_OBJ_CLASS | DMUS_OBJ_NAME),
|
|
"Got valid data %#lx, expected DMUS_OBJ_CLASS | DMUS_OBJ_NAME\n", desc.dwValidData);
|
|
ok(!lstrcmpW(desc.wszName, L"INAM"), "Got name '%s', expected 'INAM'\n",
|
|
wine_dbgstr_w(desc.wszName));
|
|
IStream_Release(stream);
|
|
|
|
/* Duplicated chunks */
|
|
stream = gen_riff_stream(dupes);
|
|
memset(&desc, 0, sizeof(desc));
|
|
hr = IDirectMusicObject_ParseDescriptor(dmo, stream, &desc);
|
|
ok(hr == S_OK, "ParseDescriptor failed: %#lx, expected S_OK\n", hr);
|
|
ok(desc.dwValidData == (DMUS_OBJ_CLASS | DMUS_OBJ_NAME | DMUS_OBJ_VERSION),
|
|
"Got valid data %#lx, expected DMUS_OBJ_CLASS | DMUS_OBJ_NAME | DMUS_OBJ_VERSION\n",
|
|
desc.dwValidData);
|
|
ok(!lstrcmpW(desc.wszName, L"INAM"), "Got name '%s', expected 'INAM'\n",
|
|
wine_dbgstr_w(desc.wszName));
|
|
IStream_Release(stream);
|
|
|
|
IDirectMusicObject_Release(dmo);
|
|
}
|
|
|
|
static void test_master_clock(void)
|
|
{
|
|
static const GUID guid_system_clock = {0x58d58419, 0x71b4, 0x11d1, {0xa7, 0x4c, 0x00, 0x00, 0xf8, 0x75, 0xac, 0x12}};
|
|
static const GUID guid_dsound_clock = {0x58d58420, 0x71b4, 0x11d1, {0xa7, 0x4c, 0x00, 0x00, 0xf8, 0x75, 0xac, 0x12}};
|
|
IReferenceClock *clock, *clock2;
|
|
REFERENCE_TIME time1, time2;
|
|
LARGE_INTEGER counter, freq;
|
|
DMUS_CLOCKINFO clock_info;
|
|
IDirectMusic *dmusic;
|
|
DWORD_PTR cookie;
|
|
HRESULT hr;
|
|
ULONG ref;
|
|
GUID guid;
|
|
|
|
hr = CoCreateInstance(&CLSID_DirectMusic, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectMusic, (void **)&dmusic);
|
|
ok(hr == S_OK, "Got hr %#lx.\n", hr);
|
|
|
|
hr = IDirectMusic_GetMasterClock(dmusic, NULL, NULL);
|
|
ok(hr == S_OK, "Got hr %#lx.\n", hr);
|
|
|
|
memset(&guid, 0xcc, sizeof(guid));
|
|
hr = IDirectMusic_GetMasterClock(dmusic, &guid, NULL);
|
|
ok(hr == S_OK, "Got hr %#lx.\n", hr);
|
|
todo_wine ok(IsEqualGUID(&guid, &guid_system_clock), "Got guid %s.\n", wine_dbgstr_guid(&guid));
|
|
|
|
clock = (IReferenceClock *)0xdeadbeef;
|
|
hr = IDirectMusic_GetMasterClock(dmusic, NULL, &clock);
|
|
ok(hr == S_OK, "Got hr %#lx.\n", hr);
|
|
ok(clock && clock != (IReferenceClock *)0xdeadbeef, "Got clock %p.\n", clock);
|
|
|
|
hr = IDirectMusic_GetMasterClock(dmusic, NULL, &clock2);
|
|
ok(hr == S_OK, "Got hr %#lx.\n", hr);
|
|
ok(clock2 == clock, "Clocks didn't match.\n");
|
|
IReferenceClock_Release(clock2);
|
|
|
|
memset(&guid, 0xcc, sizeof(guid));
|
|
hr = IDirectMusic_GetMasterClock(dmusic, &guid, &clock2);
|
|
ok(hr == S_OK, "Got hr %#lx.\n", hr);
|
|
todo_wine ok(IsEqualGUID(&guid, &guid_system_clock), "Got guid %s.\n", wine_dbgstr_guid(&guid));
|
|
ok(clock2 == clock, "Clocks didn't match.\n");
|
|
IReferenceClock_Release(clock2);
|
|
|
|
QueryPerformanceFrequency(&freq);
|
|
QueryPerformanceCounter(&counter);
|
|
hr = IReferenceClock_GetTime(clock, &time1);
|
|
ok(hr == S_OK, "Got hr %#lx.\n", hr);
|
|
time2 = counter.QuadPart * 10000000.0 / freq.QuadPart;
|
|
ok(compare_time(time1, time2, 20 * 10000), "Expected about %s, got %s.\n",
|
|
wine_dbgstr_longlong(time2), wine_dbgstr_longlong(time1));
|
|
|
|
hr = IReferenceClock_GetTime(clock, &time2);
|
|
ok(hr == (time2 == time1 ? S_FALSE : S_OK), "Got hr %#lx.\n", hr);
|
|
|
|
Sleep(100);
|
|
hr = IReferenceClock_GetTime(clock, &time2);
|
|
ok(hr == S_OK, "Got hr %#lx.\n", hr);
|
|
ok(time2 - time1 > 80 * 10000, "Expected about %s, but got %s.\n",
|
|
wine_dbgstr_longlong(time1 + 100 * 10000), wine_dbgstr_longlong(time2));
|
|
|
|
hr = IReferenceClock_AdviseTime(clock, 0, 0, 0, &cookie);
|
|
ok(hr == E_NOTIMPL, "Got hr %#lx.\n", hr);
|
|
|
|
hr = IReferenceClock_AdvisePeriodic(clock, 0, 0, 0, &cookie);
|
|
ok(hr == E_NOTIMPL, "Got hr %#lx.\n", hr);
|
|
|
|
hr = IReferenceClock_Unadvise(clock, 0);
|
|
ok(hr == E_NOTIMPL, "Got hr %#lx.\n", hr);
|
|
|
|
IReferenceClock_Release(clock);
|
|
|
|
hr = IDirectMusic_EnumMasterClock(dmusic, 0, NULL);
|
|
todo_wine ok(hr == E_INVALIDARG, "Got hr %#lx.\n", hr);
|
|
|
|
memset(&clock_info, 0xcc, sizeof(DMUS_CLOCKINFO));
|
|
clock_info.dwSize = sizeof(DMUS_CLOCKINFO7);
|
|
hr = IDirectMusic_EnumMasterClock(dmusic, 0, &clock_info);
|
|
ok(hr == S_OK, "Got hr %#lx.\n", hr);
|
|
ok(clock_info.ctType == DMUS_CLOCK_SYSTEM, "Got type %#x.\n", clock_info.ctType);
|
|
ok(IsEqualGUID(&clock_info.guidClock, &guid_system_clock), "Got guid %s.\n",
|
|
wine_dbgstr_guid(&clock_info.guidClock));
|
|
ok(clock_info.dwFlags == 0xcccccccc, "Got flags %#lx.\n", clock_info.dwFlags);
|
|
|
|
memset(&clock_info, 0xcc, sizeof(DMUS_CLOCKINFO));
|
|
clock_info.dwSize = sizeof(DMUS_CLOCKINFO7);
|
|
hr = IDirectMusic_EnumMasterClock(dmusic, 1, &clock_info);
|
|
ok(hr == S_OK, "Got hr %#lx.\n", hr);
|
|
ok(clock_info.ctType == DMUS_CLOCK_SYSTEM, "Got type %#x.\n", clock_info.ctType);
|
|
ok(IsEqualGUID(&clock_info.guidClock, &guid_dsound_clock), "Got guid %s.\n",
|
|
wine_dbgstr_guid(&clock_info.guidClock));
|
|
ok(clock_info.dwFlags == 0xcccccccc, "Got flags %#lx.\n", clock_info.dwFlags);
|
|
|
|
memset(&clock_info, 0xcc, sizeof(DMUS_CLOCKINFO));
|
|
clock_info.dwSize = sizeof(DMUS_CLOCKINFO7);
|
|
hr = IDirectMusic_EnumMasterClock(dmusic, 2, &clock_info);
|
|
ok(hr == S_FALSE, "Got hr %#lx.\n", hr);
|
|
|
|
ref = IDirectMusic_Release(dmusic);
|
|
ok(!ref, "Got outstanding refcount %ld.\n", ref);
|
|
}
|
|
|
|
static void test_synthport(void)
|
|
{
|
|
IDirectMusic *dmusic;
|
|
IDirectMusicBuffer *buf;
|
|
IDirectMusicPort *port;
|
|
DMUS_BUFFERDESC desc;
|
|
DMUS_PORTCAPS caps;
|
|
WAVEFORMATEX fmt;
|
|
DWORD fmtsize, bufsize;
|
|
|
|
HRESULT hr;
|
|
|
|
port = create_synth_port(&dmusic);
|
|
|
|
/* Create a IDirectMusicPortBuffer */
|
|
desc.dwSize = sizeof(DMUS_BUFFERDESC);
|
|
desc.dwFlags = 0;
|
|
desc.cbBuffer = 1023;
|
|
memcpy(&desc.guidBufferFormat, &GUID_NULL, sizeof(GUID));
|
|
hr = IDirectMusic_CreateMusicBuffer(dmusic, &desc, &buf, NULL);
|
|
ok(hr == S_OK, "IDirectMusic_CreateMusicBuffer failed: %#lx\n", hr);
|
|
|
|
/* Unsupported methods */
|
|
hr = IDirectMusicPort_Read(port, NULL);
|
|
todo_wine ok(hr == E_POINTER, "Read returned: %#lx\n", hr);
|
|
hr = IDirectMusicPort_Read(port, buf);
|
|
ok(hr == E_NOTIMPL, "Read returned: %#lx\n", hr);
|
|
hr = IDirectMusicPort_SetReadNotificationHandle(port, NULL);
|
|
ok(hr == E_NOTIMPL, "SetReadNotificationHandle returned: %#lx\n", hr);
|
|
hr = IDirectMusicPort_Compact(port);
|
|
ok(hr == E_NOTIMPL, "Compact returned: %#lx\n", hr);
|
|
|
|
/* GetCaps */
|
|
hr = IDirectMusicPort_GetCaps(port, NULL);
|
|
ok(hr == E_INVALIDARG, "GetCaps failed: %#lx\n", hr);
|
|
memset(&caps, 0, sizeof(caps));
|
|
hr = IDirectMusicPort_GetCaps(port, &caps);
|
|
ok(hr == E_INVALIDARG, "GetCaps failed: %#lx\n", hr);
|
|
caps.dwSize = sizeof(caps);
|
|
hr = IDirectMusicPort_GetCaps(port, &caps);
|
|
ok(hr == S_OK, "GetCaps failed: %#lx\n", hr);
|
|
ok(caps.dwSize == sizeof(caps), "dwSize was modified to %ld\n", caps.dwSize);
|
|
ok(IsEqualGUID(&caps.guidPort, &CLSID_DirectMusicSynth), "Expected port guid CLSID_DirectMusicSynth, got %s\n",
|
|
wine_dbgstr_guid(&caps.guidPort));
|
|
ok(caps.dwClass == DMUS_PC_OUTPUTCLASS, "Got wrong dwClass: %#lx\n", caps.dwClass);
|
|
ok(caps.dwType == DMUS_PORT_USER_MODE_SYNTH, "Got wrong dwType: %#lx\n", caps.dwType);
|
|
ok(caps.dwFlags == (DMUS_PC_AUDIOPATH|DMUS_PC_DIRECTSOUND|DMUS_PC_DLS|DMUS_PC_DLS2|DMUS_PC_SOFTWARESYNTH|
|
|
DMUS_PC_WAVE), "Unexpected dwFlags returned: %#lx\n", caps.dwFlags);
|
|
ok(caps.dwMemorySize == DMUS_PC_SYSTEMMEMORY, "Got dwMemorySize: %#lx\n", caps.dwMemorySize);
|
|
ok(caps.dwMaxChannelGroups == 1000, "Got dwMaxChannelGroups: %ld\n", caps.dwMaxChannelGroups);
|
|
ok(caps.dwMaxVoices == 1000, "Got dwMaxVoices: %ld\n", caps.dwMaxVoices);
|
|
ok(caps.dwMaxAudioChannels == 2, "Got dwMaxAudioChannels: %#lx\n", caps.dwMaxAudioChannels);
|
|
ok(caps.dwEffectFlags == DMUS_EFFECT_REVERB, "Unexpected dwEffectFlags returned: %#lx\n", caps.dwEffectFlags);
|
|
trace("Port wszDescription: %s\n", wine_dbgstr_w(caps.wszDescription));
|
|
|
|
/* GetFormat */
|
|
hr = IDirectMusicPort_GetFormat(port, NULL, NULL, NULL);
|
|
ok(hr == E_POINTER, "GetFormat failed: %#lx\n", hr);
|
|
hr = IDirectMusicPort_GetFormat(port, NULL, &fmtsize, NULL);
|
|
ok(hr == S_OK, "GetFormat failed: %#lx\n", hr);
|
|
ok(fmtsize == sizeof(fmt), "format size; %ld\n", fmtsize);
|
|
fmtsize = 0;
|
|
hr = IDirectMusicPort_GetFormat(port, &fmt, &fmtsize, NULL);
|
|
ok(hr == S_OK, "GetFormat failed: %#lx\n", hr);
|
|
ok(fmtsize == sizeof(fmt), "format size; %ld\n", fmtsize);
|
|
hr = IDirectMusicPort_GetFormat(port, NULL, NULL, &bufsize);
|
|
ok(hr == E_POINTER, "GetFormat failed: %#lx\n", hr);
|
|
hr = IDirectMusicPort_GetFormat(port, NULL, &fmtsize, &bufsize);
|
|
ok(hr == S_OK, "GetFormat failed: %#lx\n", hr);
|
|
hr = IDirectMusicPort_GetFormat(port, &fmt, &fmtsize, &bufsize);
|
|
ok(hr == S_OK, "GetFormat failed: %#lx\n", hr);
|
|
ok(bufsize == fmt.nSamplesPerSec * fmt.nChannels * 4, "buffer size: %ld\n", bufsize);
|
|
|
|
IDirectMusicPort_Release(port);
|
|
IDirectMusic_Release(dmusic);
|
|
}
|
|
|
|
static void test_port_download(void)
|
|
{
|
|
struct wave_download
|
|
{
|
|
DMUS_DOWNLOADINFO info;
|
|
ULONG offsets[2];
|
|
DMUS_WAVE wave;
|
|
DMUS_WAVEDATA wave_data;
|
|
};
|
|
|
|
static void *invalid_ptr = (void *)0xdeadbeef;
|
|
IDirectMusicDownload *download, *tmp_download;
|
|
struct wave_download *wave_download;
|
|
IDirectMusicPortDownload *port;
|
|
IDirectMusicPort *tmp_port;
|
|
DWORD ids[4], append, size;
|
|
IDirectMusic *dmusic;
|
|
void *buffer;
|
|
HRESULT hr;
|
|
|
|
tmp_port = create_synth_port(&dmusic);
|
|
hr = IDirectMusicPort_QueryInterface(tmp_port, &IID_IDirectMusicPortDownload, (void **)&port);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
IDirectMusicPort_Release(tmp_port);
|
|
|
|
/* GetBuffer only works with pre-allocated DLId */
|
|
hr = IDirectMusicPortDownload_GetBuffer(port, 0, NULL);
|
|
ok(hr == E_POINTER, "got %#lx\n", hr);
|
|
hr = IDirectMusicPortDownload_GetBuffer(port, 0, &download);
|
|
ok(hr == DMUS_E_INVALID_DOWNLOADID, "got %#lx\n", hr);
|
|
hr = IDirectMusicPortDownload_GetBuffer(port, 0xdeadbeef, &download);
|
|
ok(hr == DMUS_E_INVALID_DOWNLOADID, "got %#lx\n", hr);
|
|
|
|
/* AllocateBuffer use the exact requested size */
|
|
hr = IDirectMusicPortDownload_AllocateBuffer(port, 0, NULL);
|
|
ok(hr == E_POINTER, "got %#lx\n", hr);
|
|
hr = IDirectMusicPortDownload_AllocateBuffer(port, 0, &download);
|
|
ok(hr == E_INVALIDARG, "got %#lx\n", hr);
|
|
|
|
hr = IDirectMusicPortDownload_AllocateBuffer(port, 1, &download);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
size = 0xdeadbeef;
|
|
buffer = invalid_ptr;
|
|
hr = IDirectMusicDownload_GetBuffer(download, &buffer, &size);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
ok(size == 1, "got %#lx\n", size);
|
|
ok(buffer != invalid_ptr, "got %p\n", buffer);
|
|
IDirectMusicDownload_Release(download);
|
|
|
|
/* GetDLId allocates the given number of slots and returns only the first */
|
|
hr = IDirectMusicPortDownload_GetDLId(port, NULL, 0);
|
|
ok(hr == E_POINTER, "got %#lx\n", hr);
|
|
hr = IDirectMusicPortDownload_GetDLId(port, ids, 0);
|
|
ok(hr == E_INVALIDARG, "got %#lx\n", hr);
|
|
|
|
memset(ids, 0xcc, sizeof(ids));
|
|
hr = IDirectMusicPortDownload_GetDLId(port, ids, 4);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
ok(ids[0] == 0, "got %#lx\n", ids[0]);
|
|
ok(ids[1] == 0xcccccccc, "got %#lx\n", ids[1]);
|
|
|
|
/* GetBuffer looks up allocated ids to find downloaded buffers */
|
|
hr = IDirectMusicPortDownload_GetBuffer(port, 2, &download);
|
|
ok(hr == DMUS_E_NOT_DOWNLOADED_TO_PORT, "got %#lx\n", hr);
|
|
|
|
hr = IDirectMusicPortDownload_GetAppend(port, NULL);
|
|
todo_wine ok(hr == E_POINTER, "got %#lx\n", hr);
|
|
append = 0xdeadbeef;
|
|
hr = IDirectMusicPortDownload_GetAppend(port, &append);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
todo_wine ok(append == 2, "got %#lx\n", append);
|
|
|
|
/* test Download / Unload on invalid and valid buffers */
|
|
|
|
download = invalid_ptr;
|
|
hr = IDirectMusicPortDownload_AllocateBuffer(port, sizeof(struct wave_download), &download);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
ok(download != invalid_ptr, "got %p\n", download);
|
|
size = 0xdeadbeef;
|
|
wave_download = invalid_ptr;
|
|
hr = IDirectMusicDownload_GetBuffer(download, (void **)&wave_download, &size);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
ok(size == sizeof(struct wave_download), "got %#lx\n", size);
|
|
ok(wave_download != invalid_ptr, "got %p\n", wave_download);
|
|
wave_download->info.cbSize = sizeof(struct wave_download);
|
|
wave_download->info.dwDLId = 2;
|
|
wave_download->info.dwDLType = 0;
|
|
wave_download->info.dwNumOffsetTableEntries = 0;
|
|
hr = IDirectMusicPortDownload_GetBuffer(port, 2, &tmp_download);
|
|
ok(hr == DMUS_E_NOT_DOWNLOADED_TO_PORT, "got %#lx\n", hr);
|
|
|
|
hr = IDirectMusicPortDownload_Download(port, NULL);
|
|
ok(hr == E_POINTER, "got %#lx\n", hr);
|
|
hr = IDirectMusicPortDownload_Download(port, download);
|
|
todo_wine ok(hr == DMUS_E_UNKNOWNDOWNLOAD, "got %#lx\n", hr);
|
|
|
|
wave_download->info.dwDLType = DMUS_DOWNLOADINFO_WAVE;
|
|
wave_download->info.dwNumOffsetTableEntries = 2;
|
|
wave_download->offsets[0] = offsetof(struct wave_download, wave);
|
|
wave_download->offsets[1] = offsetof(struct wave_download, wave_data);
|
|
wave_download->wave.WaveformatEx.wFormatTag = WAVE_FORMAT_PCM;
|
|
wave_download->wave.WaveformatEx.nChannels = 1;
|
|
wave_download->wave.WaveformatEx.nSamplesPerSec = 44100;
|
|
wave_download->wave.WaveformatEx.nAvgBytesPerSec = 44100;
|
|
wave_download->wave.WaveformatEx.nBlockAlign = 1;
|
|
wave_download->wave.WaveformatEx.wBitsPerSample = 8;
|
|
wave_download->wave.WaveformatEx.cbSize = 0;
|
|
wave_download->wave.ulWaveDataIdx = 1;
|
|
wave_download->wave.ulCopyrightIdx = 0;
|
|
wave_download->wave.ulFirstExtCkIdx = 0;
|
|
wave_download->wave_data.cbSize = 1;
|
|
|
|
hr = IDirectMusicPortDownload_Download(port, download);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
hr = IDirectMusicPortDownload_Download(port, download);
|
|
ok(hr == DMUS_E_ALREADY_DOWNLOADED, "got %#lx\n", hr);
|
|
|
|
tmp_download = invalid_ptr;
|
|
hr = IDirectMusicPortDownload_GetBuffer(port, 2, &tmp_download);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
ok(tmp_download == download, "got %p\n", tmp_download);
|
|
IDirectMusicDownload_Release(tmp_download);
|
|
|
|
hr = IDirectMusicPortDownload_Unload(port, NULL);
|
|
ok(hr == E_POINTER, "got %#lx\n", hr);
|
|
hr = IDirectMusicPortDownload_Unload(port, download);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
|
|
hr = IDirectMusicPortDownload_GetBuffer(port, 2, &tmp_download);
|
|
ok(hr == DMUS_E_NOT_DOWNLOADED_TO_PORT, "got %#lx\n", hr);
|
|
|
|
hr = IDirectMusicPortDownload_Unload(port, download);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
|
|
/* DLIds are never released */
|
|
hr = IDirectMusicPortDownload_GetDLId(port, ids, 1);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
ok(ids[0] == 4, "got %#lx\n", ids[0]);
|
|
|
|
IDirectMusicDownload_Release(download);
|
|
|
|
IDirectMusicPortDownload_Release(port);
|
|
}
|
|
|
|
static void test_download_instrument(void)
|
|
{
|
|
static const LARGE_INTEGER zero = {0};
|
|
IDirectMusicDownloadedInstrument *downloaded;
|
|
IDirectMusicCollection *collection;
|
|
IDirectMusicInstrument *instrument, *tmp_instrument;
|
|
IPersistStream *persist;
|
|
IDirectMusicPort *port;
|
|
IDirectMusic *dmusic;
|
|
WCHAR name[MAX_PATH];
|
|
IStream *stream;
|
|
DWORD patch;
|
|
HRESULT hr;
|
|
|
|
port = create_synth_port(&dmusic);
|
|
|
|
hr = CoCreateInstance(&CLSID_DirectMusicCollection, NULL, CLSCTX_INPROC_SERVER,
|
|
&IID_IDirectMusicCollection, (void **)&collection);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
|
|
hr = IDirectMusicCollection_QueryInterface(collection, &IID_IPersistStream, (void **)&persist);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
hr = CreateStreamOnHGlobal(0, TRUE, &stream);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
|
|
CHUNK_RIFF(stream, "DLS ")
|
|
{
|
|
DLSHEADER colh = {.cInstruments = 1};
|
|
struct
|
|
{
|
|
POOLTABLE head;
|
|
POOLCUE cues[1];
|
|
} ptbl =
|
|
{
|
|
.head = {.cbSize = sizeof(POOLTABLE), .cCues = ARRAY_SIZE(ptbl.cues)},
|
|
.cues = {{.ulOffset = 0}}, /* offsets in wvpl */
|
|
};
|
|
|
|
CHUNK_DATA(stream, "colh", colh);
|
|
CHUNK_LIST(stream, "lins")
|
|
{
|
|
CHUNK_LIST(stream, "ins ")
|
|
{
|
|
INSTHEADER insh = {.cRegions = 1, .Locale = {.ulBank = 0x12, .ulInstrument = 0x34}};
|
|
|
|
CHUNK_DATA(stream, "insh", insh);
|
|
CHUNK_LIST(stream, "lrgn")
|
|
{
|
|
CHUNK_LIST(stream, "rgn ")
|
|
{
|
|
RGNHEADER rgnh =
|
|
{
|
|
.RangeKey = {.usLow = 0, .usHigh = 127},
|
|
.RangeVelocity = {.usLow = 1, .usHigh = 127},
|
|
};
|
|
WAVELINK wlnk = {.ulChannel = 1, .ulTableIndex = 0};
|
|
WSMPL wsmp = {.cbSize = sizeof(WSMPL)};
|
|
|
|
CHUNK_DATA(stream, "rgnh", rgnh);
|
|
CHUNK_DATA(stream, "wsmp", wsmp);
|
|
CHUNK_DATA(stream, "wlnk", wlnk);
|
|
}
|
|
CHUNK_END;
|
|
}
|
|
CHUNK_END;
|
|
|
|
CHUNK_LIST(stream, "lart")
|
|
{
|
|
CONNECTIONLIST connections = {.cbSize = sizeof(connections)};
|
|
CHUNK_DATA(stream, "art1", connections);
|
|
}
|
|
CHUNK_END;
|
|
}
|
|
CHUNK_END;
|
|
}
|
|
CHUNK_END;
|
|
CHUNK_DATA(stream, "ptbl", ptbl);
|
|
CHUNK_LIST(stream, "wvpl")
|
|
{
|
|
CHUNK_LIST(stream, "wave")
|
|
{
|
|
WAVEFORMATEX fmt =
|
|
{
|
|
.wFormatTag = WAVE_FORMAT_PCM,
|
|
.nChannels = 1,
|
|
.wBitsPerSample = 8,
|
|
.nSamplesPerSec = 22050,
|
|
.nAvgBytesPerSec = 22050,
|
|
.nBlockAlign = 1,
|
|
};
|
|
BYTE data[16] = {0};
|
|
|
|
/* native returns DMUS_E_INVALIDOFFSET from DownloadInstrument if data is last */
|
|
CHUNK_DATA(stream, "data", data);
|
|
CHUNK_DATA(stream, "fmt ", fmt);
|
|
}
|
|
CHUNK_END;
|
|
}
|
|
CHUNK_END;
|
|
}
|
|
CHUNK_END;
|
|
|
|
hr = IStream_Seek(stream, zero, 0, NULL);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
hr = IPersistStream_Load(persist, stream);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
IPersistStream_Release(persist);
|
|
IStream_Release(stream);
|
|
|
|
patch = 0xdeadbeef;
|
|
wcscpy(name, L"DeadBeef");
|
|
hr = IDirectMusicCollection_EnumInstrument(collection, 0, &patch, name, ARRAY_SIZE(name));
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
ok(patch == 0x1234, "got %#lx\n", patch);
|
|
ok(*name == 0, "got %s\n", debugstr_w(name));
|
|
hr = IDirectMusicCollection_EnumInstrument(collection, 1, &patch, name, ARRAY_SIZE(name));
|
|
ok(hr == S_FALSE, "got %#lx\n", hr);
|
|
|
|
hr = IDirectMusicCollection_GetInstrument(collection, 0x1234, &instrument);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
hr = IDirectMusicInstrument_GetPatch(instrument, &patch);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
ok(patch == 0x1234, "got %#lx\n", patch);
|
|
hr = IDirectMusicInstrument_SetPatch(instrument, 0x4321);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
hr = IDirectMusicInstrument_GetPatch(instrument, &patch);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
ok(patch == 0x4321, "got %#lx\n", patch);
|
|
|
|
hr = IDirectMusicCollection_GetInstrument(collection, 0x1234, &tmp_instrument);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
ok(instrument == tmp_instrument, "got %p\n", tmp_instrument);
|
|
hr = IDirectMusicInstrument_GetPatch(tmp_instrument, &patch);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
ok(patch == 0x4321, "got %#lx\n", patch);
|
|
IDirectMusicInstrument_Release(tmp_instrument);
|
|
|
|
check_interface(instrument, &IID_IDirectMusicObject, FALSE);
|
|
check_interface(instrument, &IID_IDirectMusicDownload, FALSE);
|
|
check_interface(instrument, &IID_IDirectMusicDownloadedInstrument, FALSE);
|
|
|
|
hr = IDirectMusicPort_DownloadInstrument(port, instrument, &downloaded, NULL, 0);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
|
|
check_interface(downloaded, &IID_IDirectMusicObject, FALSE);
|
|
check_interface(downloaded, &IID_IDirectMusicDownload, FALSE);
|
|
check_interface(downloaded, &IID_IDirectMusicInstrument, FALSE);
|
|
|
|
hr = IDirectMusicPort_UnloadInstrument(port, downloaded);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
IDirectMusicDownloadedInstrument_Release(downloaded);
|
|
|
|
IDirectMusicInstrument_Release(instrument);
|
|
|
|
IDirectMusicCollection_Release(collection);
|
|
IDirectMusicPort_Release(port);
|
|
IDirectMusic_Release(dmusic);
|
|
}
|
|
|
|
struct result
|
|
{
|
|
DWORD patch;
|
|
WCHAR name[DMUS_MAX_NAME];
|
|
};
|
|
|
|
static int __cdecl result_cmp(const void *a, const void *b)
|
|
{
|
|
const struct result *ra = a, *rb = b;
|
|
if (ra->patch != rb->patch) return ra->patch < rb->patch ? -1 : 1;
|
|
return wcscmp(ra->name, rb->name);
|
|
}
|
|
|
|
static void test_default_gm_collection(void)
|
|
{
|
|
DMUS_OBJECTDESC desc =
|
|
{
|
|
.dwSize = sizeof(DMUS_OBJECTDESC),
|
|
.dwValidData = DMUS_OBJ_OBJECT | DMUS_OBJ_CLASS,
|
|
.guidClass = CLSID_DirectMusicCollection,
|
|
.guidObject = GUID_DefaultGMCollection,
|
|
};
|
|
struct result expected[] =
|
|
{
|
|
{ 0, L"Piano 1 "},
|
|
{ 0x1, L"Piano 2 "},
|
|
{ 0x2, L"Piano 3 "},
|
|
{ 0x3, L"Honky-tonk "},
|
|
{ 0x4, L"E.Piano 1 "},
|
|
{ 0x5, L"E.Piano 2 "},
|
|
{ 0x6, L"Harpsichord "},
|
|
{ 0x7, L"Clav. "},
|
|
{ 0x8, L"Celesta "},
|
|
{ 0x9, L"Glockenspiel"},
|
|
{ 0xa, L"Music Box "},
|
|
{ 0xb, L"Vibraphone "},
|
|
{ 0xc, L"Marimba "},
|
|
{ 0xd, L"Xylophone "},
|
|
{ 0xe, L"Tubular-bell"},
|
|
{ 0xf, L"Santur "},
|
|
{ 0x10, L"Organ 1 "},
|
|
{ 0x11, L"Organ 2 "},
|
|
{ 0x12, L"Organ 3 "},
|
|
{ 0x13, L"Church Org.1"},
|
|
{ 0x14, L"Reed Organ "},
|
|
{ 0x15, L"Accordion Fr"},
|
|
{ 0x16, L"Harmonica "},
|
|
{ 0x17, L"Bandoneon "},
|
|
{ 0x18, L"Nylon-str.Gt"},
|
|
{ 0x19, L"Steel-str.Gt"},
|
|
{ 0x1a, L"Jazz Gt. "},
|
|
{ 0x1b, L"Clean Gt. "},
|
|
{ 0x1c, L"Muted Gt. "},
|
|
{ 0x1d, L"Overdrive Gt"},
|
|
{ 0x1e, L"DistortionGt"},
|
|
{ 0x1f, L"Gt.Harmonics"},
|
|
{ 0x20, L"Acoustic Bs."},
|
|
{ 0x21, L"Fingered Bs."},
|
|
{ 0x22, L"Picked Bs. "},
|
|
{ 0x23, L"Fretless Bs."},
|
|
{ 0x24, L"Slap Bass 1 "},
|
|
{ 0x25, L"Slap Bass 2 "},
|
|
{ 0x26, L"Synth Bass 1"},
|
|
{ 0x27, L"Synth Bass 2"},
|
|
{ 0x28, L"Violin "},
|
|
{ 0x29, L"Viola "},
|
|
{ 0x2a, L"Cello "},
|
|
{ 0x2b, L"Contrabass "},
|
|
{ 0x2c, L"Tremolo Str "},
|
|
{ 0x2d, L"PizzicatoStr"},
|
|
{ 0x2e, L"Harp "},
|
|
{ 0x2f, L"Timpani "},
|
|
{ 0x30, L"Strings "},
|
|
{ 0x31, L"Slow Strings"},
|
|
{ 0x32, L"Syn.Strings1"},
|
|
{ 0x33, L"Syn.Strings2"},
|
|
{ 0x34, L"Choir Aahs "},
|
|
{ 0x35, L"Voice Oohs "},
|
|
{ 0x36, L"SynVox "},
|
|
{ 0x37, L"OrchestraHit"},
|
|
{ 0x38, L"Trumpet "},
|
|
{ 0x39, L"Trombone "},
|
|
{ 0x3a, L"Tuba "},
|
|
{ 0x3b, L"MutedTrumpet"},
|
|
{ 0x3c, L"French Horns"},
|
|
{ 0x3d, L"Brass 1 "},
|
|
{ 0x3e, L"Synth Brass1"},
|
|
{ 0x3f, L"Synth Brass2"},
|
|
{ 0x40, L"Soprano Sax "},
|
|
{ 0x41, L"Alto Sax "},
|
|
{ 0x42, L"Tenor Sax "},
|
|
{ 0x43, L"Baritone Sax"},
|
|
{ 0x44, L"Oboe "},
|
|
{ 0x45, L"English Horn"},
|
|
{ 0x46, L"Bassoon "},
|
|
{ 0x47, L"Clarinet "},
|
|
{ 0x48, L"Piccolo "},
|
|
{ 0x49, L"Flute "},
|
|
{ 0x4a, L"Recorder "},
|
|
{ 0x4b, L"Pan Flute "},
|
|
{ 0x4c, L"Bottle Blow "},
|
|
{ 0x4d, L"Shakuhachi "},
|
|
{ 0x4e, L"Whistle "},
|
|
{ 0x4f, L"Ocarina "},
|
|
{ 0x50, L"Square Wave "},
|
|
{ 0x51, L"Saw Wave "},
|
|
{ 0x52, L"Syn.Calliope"},
|
|
{ 0x53, L"Chiffer Lead"},
|
|
{ 0x54, L"Charang "},
|
|
{ 0x55, L"Solo Vox "},
|
|
{ 0x56, L"5th Saw Wave"},
|
|
{ 0x57, L"Bass & Lead "},
|
|
{ 0x58, L"Fantasia "},
|
|
{ 0x59, L"Warm Pad "},
|
|
{ 0x5a, L"Polysynth "},
|
|
{ 0x5b, L"Space Voice "},
|
|
{ 0x5c, L"Bowed Glass "},
|
|
{ 0x5d, L"Metal Pad "},
|
|
{ 0x5e, L"Halo Pad "},
|
|
{ 0x5f, L"Sweep Pad "},
|
|
{ 0x60, L"Ice Rain "},
|
|
{ 0x61, L"Soundtrack "},
|
|
{ 0x62, L"Crystal "},
|
|
{ 0x63, L"Atmosphere "},
|
|
{ 0x64, L"Brightness "},
|
|
{ 0x65, L"Goblin "},
|
|
{ 0x66, L"Echo Drops "},
|
|
{ 0x67, L"Star Theme "},
|
|
{ 0x68, L"Sitar "},
|
|
{ 0x69, L"Banjo "},
|
|
{ 0x6a, L"Shamisen "},
|
|
{ 0x6b, L"Koto "},
|
|
{ 0x6c, L"Kalimba "},
|
|
{ 0x6d, L"Bagpipe "},
|
|
{ 0x6e, L"Fiddle "},
|
|
{ 0x6f, L"Shanai "},
|
|
{ 0x70, L"Tinkle Bell "},
|
|
{ 0x71, L"Agogo "},
|
|
{ 0x72, L"Steel Drums "},
|
|
{ 0x73, L"Woodblock "},
|
|
{ 0x74, L"Taiko "},
|
|
{ 0x75, L"Melo. Tom 1 "},
|
|
{ 0x76, L"Synth Drum "},
|
|
{ 0x77, L"Reverse Cym."},
|
|
{ 0x78, L"Gt.FretNoise"},
|
|
{ 0x79, L"Breath Noise"},
|
|
{ 0x7a, L"Seashore "},
|
|
{ 0x7b, L"Bird "},
|
|
{ 0x7c, L"Telephone 1 "},
|
|
{ 0x7d, L"Helicopter "},
|
|
{ 0x7e, L"Applause "},
|
|
{ 0x7f, L"Gun Shot "},
|
|
{ 0x10026, L"SynthBass101"},
|
|
{ 0x10039, L"Trombone 2 "},
|
|
{ 0x1003c, L"Fr.Horn 2 "},
|
|
{ 0x10050, L"Square "},
|
|
{ 0x10051, L"Saw "},
|
|
{ 0x10062, L"Syn Mallet "},
|
|
{ 0x10066, L"Echo Bell "},
|
|
{ 0x10068, L"Sitar 2 "},
|
|
{ 0x10078, L"Gt.Cut Noise"},
|
|
{ 0x10079, L"Fl.Key Click"},
|
|
{ 0x1007a, L"Rain "},
|
|
{ 0x1007b, L"Dog "},
|
|
{ 0x1007c, L"Telephone 2 "},
|
|
{ 0x1007d, L"Car-Engine "},
|
|
{ 0x1007e, L"Laughing "},
|
|
{ 0x1007f, L"Machine Gun "},
|
|
{ 0x20066, L"Echo Pan "},
|
|
{ 0x20078, L"String Slap "},
|
|
{ 0x2007a, L"Thunder "},
|
|
{ 0x2007b, L"Horse-Gallop"},
|
|
{ 0x2007c, L"DoorCreaking"},
|
|
{ 0x2007d, L"Car-Stop "},
|
|
{ 0x2007e, L"Screaming "},
|
|
{ 0x2007f, L"Lasergun "},
|
|
{ 0x3007a, L"Wind "},
|
|
{ 0x3007b, L"Bird 2 "},
|
|
{ 0x3007c, L"Door "},
|
|
{ 0x3007d, L"Car-Pass "},
|
|
{ 0x3007e, L"Punch "},
|
|
{ 0x3007f, L"Explosion "},
|
|
{ 0x4007a, L"Stream "},
|
|
{ 0x4007c, L"Scratch "},
|
|
{ 0x4007d, L"Car-Crash "},
|
|
{ 0x4007e, L"Heart Beat "},
|
|
{ 0x5007a, L"Bubble "},
|
|
{ 0x5007c, L"Wind Chimes "},
|
|
{ 0x5007d, L"Siren "},
|
|
{ 0x5007e, L"Footsteps "},
|
|
{ 0x6007d, L"Train "},
|
|
{ 0x7007d, L"Jetplane "},
|
|
{ 0x80000, L"Piano 1 "},
|
|
{ 0x80001, L"Piano 2 "},
|
|
{ 0x80002, L"Piano 3 "},
|
|
{ 0x80003, L"Honky-tonk "},
|
|
{ 0x80004, L"Detuned EP 1"},
|
|
{ 0x80005, L"Detuned EP 2"},
|
|
{ 0x80006, L"Coupled Hps."},
|
|
{ 0x8000b, L"Vibraphone "},
|
|
{ 0x8000c, L"Marimba "},
|
|
{ 0x8000e, L"Church Bell "},
|
|
{ 0x80010, L"Detuned Or.1"},
|
|
{ 0x80011, L"Detuned Or.2"},
|
|
{ 0x80013, L"Church Org.2"},
|
|
{ 0x80015, L"Accordion It"},
|
|
{ 0x80018, L"Ukulele "},
|
|
{ 0x80019, L"12-str.Gt "},
|
|
{ 0x8001a, L"Hawaiian Gt."},
|
|
{ 0x8001b, L"Chorus Gt. "},
|
|
{ 0x8001c, L"Funk Gt. "},
|
|
{ 0x8001e, L"Feedback Gt."},
|
|
{ 0x8001f, L"Gt. Feedback"},
|
|
{ 0x80026, L"Synth Bass 3"},
|
|
{ 0x80027, L"Synth Bass 4"},
|
|
{ 0x80028, L"Slow Violin "},
|
|
{ 0x80030, L"Orchestra "},
|
|
{ 0x80032, L"Syn.Strings3"},
|
|
{ 0x8003d, L"Brass 2 "},
|
|
{ 0x8003e, L"Synth Brass3"},
|
|
{ 0x8003f, L"Synth Brass4"},
|
|
{ 0x80050, L"Sine Wave "},
|
|
{ 0x80051, L"Doctor Solo "},
|
|
{ 0x8006b, L"Taisho Koto "},
|
|
{ 0x80073, L"Castanets "},
|
|
{ 0x80074, L"Concert BD "},
|
|
{ 0x80075, L"Melo. Tom 2 "},
|
|
{ 0x80076, L"808 Tom "},
|
|
{ 0x8007d, L"Starship "},
|
|
{ 0x9000e, L"Carillon "},
|
|
{ 0x90076, L"Elec Perc. "},
|
|
{ 0x9007d, L"Burst Noise "},
|
|
{ 0x100000, L"Piano 1d "},
|
|
{ 0x100004, L"E.Piano 1v "},
|
|
{ 0x100005, L"E.Piano 2v "},
|
|
{ 0x100006, L"Harpsichord "},
|
|
{ 0x100010, L"60's Organ 1"},
|
|
{ 0x100013, L"Church Org.3"},
|
|
{ 0x100018, L"Nylon Gt.o "},
|
|
{ 0x100019, L"Mandolin "},
|
|
{ 0x10001c, L"Funk Gt.2 "},
|
|
{ 0x100027, L"Rubber Bass "},
|
|
{ 0x10003e, L"AnalogBrass1"},
|
|
{ 0x10003f, L"AnalogBrass2"},
|
|
{ 0x180004, L"60's E.Piano"},
|
|
{ 0x180006, L"Harpsi.o "},
|
|
{ 0x200010, L"Organ 4 "},
|
|
{ 0x200011, L"Organ 5 "},
|
|
{ 0x200018, L"Nylon Gt.2 "},
|
|
{ 0x200034, L"Choir Aahs 2"},
|
|
{0x80000000, L"Standard "},
|
|
{0x80000008, L"Room "},
|
|
{0x80000010, L"Power "},
|
|
{0x80000018, L"Electronic "},
|
|
{0x80000019, L"TR-808 "},
|
|
{0x80000020, L"Jazz "},
|
|
{0x80000028, L"Brush "},
|
|
{0x80000030, L"Orchestra "},
|
|
{0x80000038, L"SFX "},
|
|
}, results[ARRAY_SIZE(expected) + 1];
|
|
IDirectMusicCollection *collection;
|
|
IDirectMusicLoader *loader;
|
|
HRESULT hr;
|
|
DWORD i;
|
|
|
|
hr = CoCreateInstance(&CLSID_DirectMusicLoader, NULL, CLSCTX_INPROC_SERVER,
|
|
&IID_IDirectMusicLoader, (void**)&loader);
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
|
|
hr = IDirectMusicLoader_GetObject(loader, &desc, &IID_IDirectMusicCollection, (void **)&collection);
|
|
if (hr == DMUS_E_LOADER_NOFILENAME)
|
|
{
|
|
skip("Failed to open default GM collection, skipping tests. Missing system SoundFont?\n");
|
|
goto skip_tests;
|
|
}
|
|
ok(hr == S_OK, "got %#lx\n", hr);
|
|
|
|
for (i = 0; hr == S_OK && i < ARRAY_SIZE(results); i++)
|
|
{
|
|
results[i].patch = 0xdeadbeef;
|
|
wcscpy(results[i].name, L"DeadBeef");
|
|
hr = IDirectMusicCollection_EnumInstrument(collection, i, &results[i].patch,
|
|
results[i].name, ARRAY_SIZE(results[i].name));
|
|
}
|
|
if (hr == S_FALSE) i--;
|
|
ok(hr == S_FALSE, "got %#lx\n", hr);
|
|
ok(i > 0, "got %lu\n", i);
|
|
todo_wine ok(i == ARRAY_SIZE(expected), "got %lu\n", i);
|
|
|
|
qsort(results, i, sizeof(*results), result_cmp);
|
|
|
|
while (i--)
|
|
{
|
|
winetest_push_context("%lu", i);
|
|
trace("got %#lx %s\n", results[i].patch, debugstr_w(results[i].name));
|
|
todo_wine_if(expected[i].patch >= 128)
|
|
ok(results[i].patch == expected[i].patch, "got %#lx\n", results[i].patch);
|
|
/* system soundfont names are not very predictable, let's not check them */
|
|
winetest_pop_context();
|
|
}
|
|
|
|
IDirectMusicCollection_Release(collection);
|
|
|
|
skip_tests:
|
|
IDirectMusicLoader_Release(loader);
|
|
}
|
|
|
|
START_TEST(dmusic)
|
|
{
|
|
CoInitializeEx(NULL, COINIT_MULTITHREADED);
|
|
|
|
if (missing_dmusic())
|
|
{
|
|
skip("DirectMusic not available\n");
|
|
CoUninitialize();
|
|
return;
|
|
}
|
|
test_COM();
|
|
test_COM_dmcoll();
|
|
test_COM_synthport();
|
|
test_dmusic();
|
|
test_setdsound();
|
|
test_dmbuffer();
|
|
test_dmcoll();
|
|
test_parsedescriptor();
|
|
test_master_clock();
|
|
test_synthport();
|
|
test_port_download();
|
|
test_download_instrument();
|
|
test_default_gm_collection();
|
|
|
|
CoUninitialize();
|
|
}
|