diff --git a/dlls/dmband/Makefile.in b/dlls/dmband/Makefile.in index 380152cb2b9..667a7f4f0e4 100644 --- a/dlls/dmband/Makefile.in +++ b/dlls/dmband/Makefile.in @@ -9,6 +9,7 @@ EXTRALIBS = -ldxguid -luuid C_SRCS = \ band.c \ bandtrack.c \ + dmutils.c \ dmband_main.c \ regsvr.c diff --git a/dlls/dmband/band.c b/dlls/dmband/band.c index cef34450d63..bcad371f29c 100644 --- a/dlls/dmband/band.c +++ b/dlls/dmband/band.c @@ -147,7 +147,7 @@ HRESULT WINAPI IDirectMusicBandImpl_IDirectMusicObject_GetDescriptor (LPDIRECTMU HRESULT WINAPI IDirectMusicBandImpl_IDirectMusicObject_SetDescriptor (LPDIRECTMUSICOBJECT iface, LPDMUS_OBJECTDESC pDesc) { ICOM_THIS_MULTI(IDirectMusicBandImpl, ObjectVtbl, iface); - TRACE("(%p, %p): setting descriptor:\n", This, pDesc); debugstr_DMUS_OBJECTDESC (pDesc); + TRACE("(%p, %p): setting descriptor:\n", This, pDesc); debug_DMUS_OBJECTDESC (pDesc); /* According to MSDN, we should copy only given values, not whole struct */ if (pDesc->dwValidData & DMUS_OBJ_OBJECT) @@ -322,7 +322,7 @@ HRESULT WINAPI IDirectMusicBandImpl_IDirectMusicObject_ParseDescriptor (LPDIRECT } } - TRACE(": returning descriptor:\n"); debugstr_DMUS_OBJECTDESC (pDesc); + TRACE(": returning descriptor:\n"); debug_DMUS_OBJECTDESC (pDesc); return S_OK; } @@ -366,180 +366,6 @@ HRESULT WINAPI IDirectMusicBandImpl_IPersistStream_IsDirty (LPPERSISTSTREAM ifac return S_FALSE; } -HRESULT IDirectMusicUtils_IPersistStream_ParseDescGeneric (DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm, LPDMUS_OBJECTDESC pDesc) { - - switch (pChunk->fccID) { - case DMUS_FOURCC_GUID_CHUNK: { - TRACE_(dmfile)(": GUID chunk\n"); - pDesc->dwValidData |= DMUS_OBJ_OBJECT; - IStream_Read (pStm, &pDesc->guidObject, pChunk->dwSize, NULL); - break; - } - case DMUS_FOURCC_DATE_CHUNK: { - TRACE_(dmfile)(": file date chunk\n"); - pDesc->dwValidData |= DMUS_OBJ_DATE; - IStream_Read (pStm, &pDesc->ftDate, pChunk->dwSize, NULL); - break; - } - case DMUS_FOURCC_NAME_CHUNK: { - TRACE_(dmfile)(": name chunk\n"); - pDesc->dwValidData |= DMUS_OBJ_NAME; - IStream_Read (pStm, &pDesc->wszName, pChunk->dwSize, NULL); - break; - } - case DMUS_FOURCC_FILE_CHUNK: { - TRACE_(dmfile)(": file name chunk\n"); - pDesc->dwValidData |= DMUS_OBJ_FILENAME; - IStream_Read (pStm, &pDesc->wszFileName, pChunk->dwSize, NULL); - break; - } - case DMUS_FOURCC_VERSION_CHUNK: { - TRACE_(dmfile)(": version chunk\n"); - pDesc->dwValidData |= DMUS_OBJ_VERSION; - IStream_Read (pStm, &pDesc->vVersion, pChunk->dwSize, NULL); - break; - } - case DMUS_FOURCC_CATEGORY_CHUNK: { - TRACE_(dmfile)(": category chunk\n"); - pDesc->dwValidData |= DMUS_OBJ_CATEGORY; - IStream_Read (pStm, pDesc->wszCategory, pChunk->dwSize, NULL); - break; - } - default: - /* not handled */ - return S_FALSE; - } - - return S_OK; -} - -HRESULT IDirectMusicUtils_IPersistStream_ParseUNFOGeneric (DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm, LPDMUS_OBJECTDESC pDesc) { - - LARGE_INTEGER liMove; /* used when skipping chunks */ - - /** - * don't ask me why, but M$ puts INFO elements in UNFO list sometimes - * (though strings seem to be valid unicode) - */ - switch (pChunk->fccID) { - - case mmioFOURCC('I','N','A','M'): - case DMUS_FOURCC_UNAM_CHUNK: { - TRACE_(dmfile)(": name chunk\n"); - pDesc->dwValidData |= DMUS_OBJ_NAME; - IStream_Read (pStm, pDesc->wszName, pChunk->dwSize, NULL); - TRACE_(dmfile)(" - wszName: %s\n", debugstr_w(pDesc->wszName)); - break; - } - - case mmioFOURCC('I','A','R','T'): - case DMUS_FOURCC_UART_CHUNK: { - TRACE_(dmfile)(": artist chunk (ignored)\n"); - liMove.QuadPart = pChunk->dwSize; - IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); - break; - } - case mmioFOURCC('I','C','O','P'): - case DMUS_FOURCC_UCOP_CHUNK: { - TRACE_(dmfile)(": copyright chunk (ignored)\n"); - liMove.QuadPart = pChunk->dwSize; - IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); - break; - } - case mmioFOURCC('I','S','B','J'): - case DMUS_FOURCC_USBJ_CHUNK: { - TRACE_(dmfile)(": subject chunk (ignored)\n"); - liMove.QuadPart = pChunk->dwSize; - IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); - break; - } - case mmioFOURCC('I','C','M','T'): - case DMUS_FOURCC_UCMT_CHUNK: { - TRACE_(dmfile)(": comment chunk (ignored)\n"); - liMove.QuadPart = pChunk->dwSize; - IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); - break; - } - default: - /* not handled */ - return S_FALSE; - } - - return S_OK; -} - -HRESULT IDirectMusicUtils_IPersistStream_ParseReference (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm, IDirectMusicObject** ppObject) { - DMUS_PRIVATE_CHUNK Chunk; - DWORD ListSize[3], ListCount[3]; - LARGE_INTEGER liMove; /* used when skipping chunks */ - HRESULT hr; - - DMUS_IO_REFERENCE ref; - DMUS_OBJECTDESC ref_desc; - - memset(&ref, 0, sizeof(ref)); - memset(&ref_desc, 0, sizeof(ref_desc)); - - if (pChunk->fccID != DMUS_FOURCC_REF_LIST) { - ERR_(dmfile)(": %s chunk should be a REF list\n", debugstr_fourcc (pChunk->fccID)); - return E_FAIL; - } - - ListSize[0] = pChunk->dwSize - sizeof(FOURCC); - ListCount[0] = 0; - - do { - IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL); - ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize; - TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize); - - hr = IDirectMusicUtils_IPersistStream_ParseDescGeneric(&Chunk, pStm, &ref_desc); - if (FAILED(hr)) return hr; - - if (hr == S_FALSE) { - switch (Chunk.fccID) { - case DMUS_FOURCC_REF_CHUNK: { - TRACE_(dmfile)(": Reference chunk\n"); - if (Chunk.dwSize != sizeof(DMUS_IO_REFERENCE)) return E_FAIL; - IStream_Read (pStm, &ref, sizeof(DMUS_IO_REFERENCE), NULL); - TRACE_(dmfile)(" - guidClassID: %s\n", debugstr_dmguid(&ref.guidClassID)); - TRACE_(dmfile)(" - dwValidData: %lu\n", ref.dwValidData); - break; - } - default: { - TRACE_(dmfile)(": unknown chunk (irrevelant & skipping)\n"); - liMove.QuadPart = Chunk.dwSize; - IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); - break; - } - } - } - TRACE_(dmfile)(": ListCount[0] = %ld < ListSize[0] = %ld\n", ListCount[0], ListSize[0]); - } while (ListCount[0] < ListSize[0]); - - ref_desc.dwValidData |= DMUS_OBJ_CLASS; - memcpy(&ref_desc.guidClass, &ref.guidClassID, sizeof(ref.guidClassID)); - - TRACE_(dmfile)("** DM Reference Begin of Load ***\n"); - TRACE_(dmfile)("With Desc:\n"); - debugstr_DMUS_OBJECTDESC(&ref_desc); - - { - LPDIRECTMUSICGETLOADER pGetLoader = NULL; - LPDIRECTMUSICLOADER pLoader = NULL; - - IStream_QueryInterface (pStm, &IID_IDirectMusicGetLoader, (LPVOID*)&pGetLoader); - IDirectMusicGetLoader_GetLoader (pGetLoader, &pLoader); - IDirectMusicGetLoader_Release (pGetLoader); - - hr = IDirectMusicLoader_GetObject (pLoader, &ref_desc, &IID_IDirectMusicObject, (LPVOID*)ppObject); - IDirectMusicLoader_Release (pLoader); /* release loader */ - } - TRACE_(dmfile)("** DM Reference End of Load ***\n"); - - return S_OK; -} - static HRESULT IDirectMusicBandImpl_IPersistStream_ParseInstrument (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm) { ICOM_THIS_MULTI(IDirectMusicBandImpl, PersistStreamVtbl, iface); DMUS_PRIVATE_CHUNK Chunk; @@ -589,9 +415,6 @@ static HRESULT IDirectMusicBandImpl_IPersistStream_ParseInstrument (LPPERSISTSTR ListSize[1] = Chunk.dwSize - sizeof(FOURCC); ListCount[1] = 0; switch (Chunk.fccID) { - /** - * should be a DMRF (DirectMusic Reference) list @TODO - */ case DMUS_FOURCC_REF_LIST: { FIXME_(dmfile)(": DMRF (DM References) list\n"); hr = IDirectMusicUtils_IPersistStream_ParseReference (iface, &Chunk, pStm, &pObject); diff --git a/dlls/dmband/bandtrack.c b/dlls/dmband/bandtrack.c index c07ad28f8fd..83f21a4fe00 100644 --- a/dlls/dmband/bandtrack.c +++ b/dlls/dmband/bandtrack.c @@ -385,7 +385,7 @@ static HRESULT IDirectMusicBandTrack_IPersistStream_ParseBandsList (LPPERSISTSTR /** now safe move the cursor */ liMove.QuadPart = StreamSize; IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); - + break; } default: { TRACE_(dmfile)(": unknown chunk (irrevelant & skipping)\n"); @@ -394,10 +394,6 @@ static HRESULT IDirectMusicBandTrack_IPersistStream_ParseBandsList (LPPERSISTSTR break; } } - /* - liMove.QuadPart = Chunk.dwSize - sizeof(FOURCC); - IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); - */ break; } default: { @@ -448,64 +444,66 @@ static HRESULT IDirectMusicBandTrack_IPersistStream_ParseBandTrackForm (LPPERSIS hr = IDirectMusicUtils_IPersistStream_ParseDescGeneric(&Chunk, pStm, This->pDesc); if (FAILED(hr)) return hr; - switch (Chunk.fccID) { - case DMUS_FOURCC_BANDTRACK_CHUNK: { - TRACE_(dmfile)(": BandTrack chunk\n"); - IStream_Read (pStm, &This->header, sizeof(DMUS_IO_BAND_TRACK_HEADER), NULL); - TRACE_(dmfile)(" - bAutoDownload: %u\n", This->header.bAutoDownload); - break; - } - case FOURCC_LIST: { - IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL); - TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(Chunk.fccID)); - ListSize[0] = Chunk.dwSize - sizeof(FOURCC); - ListCount[0] = 0; + if (hr == S_FALSE) { switch (Chunk.fccID) { - case DMUS_FOURCC_UNFO_LIST: { - TRACE_(dmfile)(": UNFO list\n"); - do { - IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL); - ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize; - TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize); - - hr = IDirectMusicUtils_IPersistStream_ParseUNFOGeneric(&Chunk, pStm, This->pDesc); - if (FAILED(hr)) return hr; - - if (hr == S_FALSE) { - switch (Chunk.fccID) { - default: { - TRACE_(dmfile)(": unknown chunk (irrevelant & skipping)\n"); - liMove.QuadPart = Chunk.dwSize; - IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); - break; - } - } - } - TRACE_(dmfile)(": ListCount[0] = %ld < ListSize[0] = %ld\n", ListCount[0], ListSize[0]); - } while (ListCount[0] < ListSize[0]); + case DMUS_FOURCC_BANDTRACK_CHUNK: { + TRACE_(dmfile)(": BandTrack chunk\n"); + IStream_Read (pStm, &This->header, sizeof(DMUS_IO_BAND_TRACK_HEADER), NULL); + TRACE_(dmfile)(" - bAutoDownload: %u\n", This->header.bAutoDownload); break; - } - case DMUS_FOURCC_BANDS_LIST: { - TRACE_(dmfile)(": TRACK list\n"); - hr = IDirectMusicBandTrack_IPersistStream_ParseBandsList (iface, &Chunk, pStm); - if (FAILED(hr)) return hr; + } + case FOURCC_LIST: { + IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL); + TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(Chunk.fccID)); + ListSize[0] = Chunk.dwSize - sizeof(FOURCC); + ListCount[0] = 0; + switch (Chunk.fccID) { + case DMUS_FOURCC_UNFO_LIST: { + TRACE_(dmfile)(": UNFO list\n"); + do { + IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL); + ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize; + TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize); + + hr = IDirectMusicUtils_IPersistStream_ParseUNFOGeneric(&Chunk, pStm, This->pDesc); + if (FAILED(hr)) return hr; + + if (hr == S_FALSE) { + switch (Chunk.fccID) { + default: { + TRACE_(dmfile)(": unknown chunk (irrevelant & skipping)\n"); + liMove.QuadPart = Chunk.dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + } + } + TRACE_(dmfile)(": ListCount[0] = %ld < ListSize[0] = %ld\n", ListCount[0], ListSize[0]); + } while (ListCount[0] < ListSize[0]); + break; + } + case DMUS_FOURCC_BANDS_LIST: { + TRACE_(dmfile)(": TRACK list\n"); + hr = IDirectMusicBandTrack_IPersistStream_ParseBandsList (iface, &Chunk, pStm); + if (FAILED(hr)) return hr; + break; + } + default: { + TRACE_(dmfile)(": unknown (skipping)\n"); + liMove.QuadPart = Chunk.dwSize - sizeof(FOURCC); + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + } break; } default: { - TRACE_(dmfile)(": unknown (skipping)\n"); - liMove.QuadPart = Chunk.dwSize - sizeof(FOURCC); + TRACE_(dmfile)(": unknown chunk (irrevelant & skipping)\n"); + liMove.QuadPart = Chunk.dwSize; IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); break; } } - break; - } - default: { - TRACE_(dmfile)(": unknown chunk (irrevelant & skipping)\n"); - liMove.QuadPart = Chunk.dwSize; - IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); - break; - } } TRACE_(dmfile)(": StreamCount[0] = %ld < StreamSize[0] = %ld\n", StreamCount, StreamSize); } while (StreamCount < StreamSize); diff --git a/dlls/dmband/dmband_main.c b/dlls/dmband/dmband_main.c index d73cd651e92..89a523c025b 100644 --- a/dlls/dmband/dmband_main.c +++ b/dlls/dmband/dmband_main.c @@ -166,432 +166,3 @@ HRESULT WINAPI DMBAND_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *pp WARN("(%s, %s, %p): no interface found.\n", debugstr_dmguid(rclsid), debugstr_dmguid(riid), ppv); return CLASS_E_CLASSNOTAVAILABLE; } - -/****************************************************************** - * Helper functions - * - * - */ -/* check whether the given DWORD is even (return 0) or odd (return 1) */ -int even_or_odd (DWORD number) { - return (number & 0x1); /* basically, check if bit 0 is set ;) */ -} - -/* FOURCC to string conversion for debug messages */ -const char *debugstr_fourcc (DWORD fourcc) { - if (!fourcc) return "'null'"; - return wine_dbg_sprintf ("\'%c%c%c%c\'", - (char)(fourcc), (char)(fourcc >> 8), - (char)(fourcc >> 16), (char)(fourcc >> 24)); -} - -/* DMUS_VERSION struct to string conversion for debug messages */ -const char *debugstr_dmversion (LPDMUS_VERSION version) { - if (!version) return "'null'"; - return wine_dbg_sprintf ("\'%i,%i,%i,%i\'", - (int)((version->dwVersionMS && 0xFFFF0000) >> 8), (int)(version->dwVersionMS && 0x0000FFFF), - (int)((version->dwVersionLS && 0xFFFF0000) >> 8), (int)(version->dwVersionLS && 0x0000FFFF)); -} - -/* returns name of given GUID */ -const char *debugstr_dmguid (const GUID *id) { - - static const guid_info guids[] = { - /* CLSIDs */ - GE(CLSID_AudioVBScript), - GE(CLSID_DirectMusic), - GE(CLSID_DirectMusicAudioPath), - GE(CLSID_DirectMusicAudioPathConfig), - GE(CLSID_DirectMusicAuditionTrack), - GE(CLSID_DirectMusicBand), - GE(CLSID_DirectMusicBandTrack), - GE(CLSID_DirectMusicChordMapTrack), - GE(CLSID_DirectMusicChordMap), - GE(CLSID_DirectMusicChordTrack), - GE(CLSID_DirectMusicCollection), - GE(CLSID_DirectMusicCommandTrack), - GE(CLSID_DirectMusicComposer), - GE(CLSID_DirectMusicContainer), - GE(CLSID_DirectMusicGraph), - GE(CLSID_DirectMusicLoader), - GE(CLSID_DirectMusicLyricsTrack), - GE(CLSID_DirectMusicMarkerTrack), - GE(CLSID_DirectMusicMelodyFormulationTrack), - GE(CLSID_DirectMusicMotifTrack), - GE(CLSID_DirectMusicMuteTrack), - GE(CLSID_DirectMusicParamControlTrack), - GE(CLSID_DirectMusicPatternTrack), - GE(CLSID_DirectMusicPerformance), - GE(CLSID_DirectMusicScript), - GE(CLSID_DirectMusicScriptAutoImpSegment), - GE(CLSID_DirectMusicScriptAutoImpPerformance), - GE(CLSID_DirectMusicScriptAutoImpSegmentState), - GE(CLSID_DirectMusicScriptAutoImpAudioPathConfig), - GE(CLSID_DirectMusicScriptAutoImpAudioPath), - GE(CLSID_DirectMusicScriptAutoImpSong), - GE(CLSID_DirectMusicScriptSourceCodeLoader), - GE(CLSID_DirectMusicScriptTrack), - GE(CLSID_DirectMusicSection), - GE(CLSID_DirectMusicSegment), - GE(CLSID_DirectMusicSegmentState), - GE(CLSID_DirectMusicSegmentTriggerTrack), - GE(CLSID_DirectMusicSegTriggerTrack), - GE(CLSID_DirectMusicSeqTrack), - GE(CLSID_DirectMusicSignPostTrack), - GE(CLSID_DirectMusicSong), - GE(CLSID_DirectMusicStyle), - GE(CLSID_DirectMusicStyleTrack), - GE(CLSID_DirectMusicSynth), - GE(CLSID_DirectMusicSynthSink), - GE(CLSID_DirectMusicSysExTrack), - GE(CLSID_DirectMusicTemplate), - GE(CLSID_DirectMusicTempoTrack), - GE(CLSID_DirectMusicTimeSigTrack), - GE(CLSID_DirectMusicWaveTrack), - GE(CLSID_DirectSoundWave), - /* IIDs */ - GE(IID_IDirectMusic), - GE(IID_IDirectMusic2), - GE(IID_IDirectMusic8), - GE(IID_IDirectMusicAudioPath), - GE(IID_IDirectMusicBand), - GE(IID_IDirectMusicBuffer), - GE(IID_IDirectMusicChordMap), - GE(IID_IDirectMusicCollection), - GE(IID_IDirectMusicComposer), - GE(IID_IDirectMusicContainer), - GE(IID_IDirectMusicDownload), - GE(IID_IDirectMusicDownloadedInstrument), - GE(IID_IDirectMusicGetLoader), - GE(IID_IDirectMusicGraph), - GE(IID_IDirectMusicInstrument), - GE(IID_IDirectMusicLoader), - GE(IID_IDirectMusicLoader8), - GE(IID_IDirectMusicObject), - GE(IID_IDirectMusicPatternTrack), - GE(IID_IDirectMusicPerformance), - GE(IID_IDirectMusicPerformance2), - GE(IID_IDirectMusicPerformance8), - GE(IID_IDirectMusicPort), - GE(IID_IDirectMusicPortDownload), - GE(IID_IDirectMusicScript), - GE(IID_IDirectMusicSegment), - GE(IID_IDirectMusicSegment2), - GE(IID_IDirectMusicSegment8), - GE(IID_IDirectMusicSegmentState), - GE(IID_IDirectMusicSegmentState8), - GE(IID_IDirectMusicStyle), - GE(IID_IDirectMusicStyle8), - GE(IID_IDirectMusicSynth), - GE(IID_IDirectMusicSynth8), - GE(IID_IDirectMusicSynthSink), - GE(IID_IDirectMusicThru), - GE(IID_IDirectMusicTool), - GE(IID_IDirectMusicTool8), - GE(IID_IDirectMusicTrack), - GE(IID_IDirectMusicTrack8), - GE(IID_IUnknown), - GE(IID_IPersistStream), - GE(IID_IStream), - GE(IID_IClassFactory), - /* GUIDs */ - GE(GUID_DirectMusicAllTypes), - GE(GUID_NOTIFICATION_CHORD), - GE(GUID_NOTIFICATION_COMMAND), - GE(GUID_NOTIFICATION_MEASUREANDBEAT), - GE(GUID_NOTIFICATION_PERFORMANCE), - GE(GUID_NOTIFICATION_RECOMPOSE), - GE(GUID_NOTIFICATION_SEGMENT), - GE(GUID_BandParam), - GE(GUID_ChordParam), - GE(GUID_CommandParam), - GE(GUID_CommandParam2), - GE(GUID_CommandParamNext), - GE(GUID_IDirectMusicBand), - GE(GUID_IDirectMusicChordMap), - GE(GUID_IDirectMusicStyle), - GE(GUID_MuteParam), - GE(GUID_Play_Marker), - GE(GUID_RhythmParam), - GE(GUID_TempoParam), - GE(GUID_TimeSignature), - GE(GUID_Valid_Start_Time), - GE(GUID_Clear_All_Bands), - GE(GUID_ConnectToDLSCollection), - GE(GUID_Disable_Auto_Download), - GE(GUID_DisableTempo), - GE(GUID_DisableTimeSig), - GE(GUID_Download), - GE(GUID_DownloadToAudioPath), - GE(GUID_Enable_Auto_Download), - GE(GUID_EnableTempo), - GE(GUID_EnableTimeSig), - GE(GUID_IgnoreBankSelectForGM), - GE(GUID_SeedVariations), - GE(GUID_StandardMIDIFile), - GE(GUID_Unload), - GE(GUID_UnloadFromAudioPath), - GE(GUID_Variations), - GE(GUID_PerfMasterTempo), - GE(GUID_PerfMasterVolume), - GE(GUID_PerfMasterGrooveLevel), - GE(GUID_PerfAutoDownload), - GE(GUID_DefaultGMCollection), - GE(GUID_Synth_Default), - GE(GUID_Buffer_Reverb), - GE(GUID_Buffer_EnvReverb), - GE(GUID_Buffer_Stereo), - GE(GUID_Buffer_3D_Dry), - GE(GUID_Buffer_Mono), - GE(GUID_DMUS_PROP_GM_Hardware), - GE(GUID_DMUS_PROP_GS_Capable), - GE(GUID_DMUS_PROP_GS_Hardware), - GE(GUID_DMUS_PROP_DLS1), - GE(GUID_DMUS_PROP_DLS2), - GE(GUID_DMUS_PROP_Effects), - GE(GUID_DMUS_PROP_INSTRUMENT2), - GE(GUID_DMUS_PROP_LegacyCaps), - GE(GUID_DMUS_PROP_MemorySize), - GE(GUID_DMUS_PROP_SampleMemorySize), - GE(GUID_DMUS_PROP_SamplePlaybackRate), - GE(GUID_DMUS_PROP_SetSynthSink), - GE(GUID_DMUS_PROP_SinkUsesDSound), - GE(GUID_DMUS_PROP_SynthSink_DSOUND), - GE(GUID_DMUS_PROP_SynthSink_WAVE), - GE(GUID_DMUS_PROP_Volume), - GE(GUID_DMUS_PROP_WavesReverb), - GE(GUID_DMUS_PROP_WriteLatency), - GE(GUID_DMUS_PROP_WritePeriod), - GE(GUID_DMUS_PROP_XG_Capable), - GE(GUID_DMUS_PROP_XG_Hardware) - }; - - unsigned int i; - - if (!id) return "(null)"; - - for (i = 0; i < sizeof(guids)/sizeof(guids[0]); i++) { - if (IsEqualGUID(id, &guids[i].guid)) - return guids[i].name; - } - /* if we didn't find it, act like standard debugstr_guid */ - return debugstr_guid(id); -} - -/* returns name of given error code */ -const char *debugstr_dmreturn (DWORD code) { - static const flag_info codes[] = { - FE(S_OK), - FE(S_FALSE), - FE(DMUS_S_PARTIALLOAD), - FE(DMUS_S_PARTIALDOWNLOAD), - FE(DMUS_S_REQUEUE), - FE(DMUS_S_FREE), - FE(DMUS_S_END), - FE(DMUS_S_STRING_TRUNCATED), - FE(DMUS_S_LAST_TOOL), - FE(DMUS_S_OVER_CHORD), - FE(DMUS_S_UP_OCTAVE), - FE(DMUS_S_DOWN_OCTAVE), - FE(DMUS_S_NOBUFFERCONTROL), - FE(DMUS_S_GARBAGE_COLLECTED), - FE(DMUS_E_DRIVER_FAILED), - FE(DMUS_E_PORTS_OPEN), - FE(DMUS_E_DEVICE_IN_USE), - FE(DMUS_E_INSUFFICIENTBUFFER), - FE(DMUS_E_BUFFERNOTSET), - FE(DMUS_E_BUFFERNOTAVAILABLE), - FE(DMUS_E_NOTADLSCOL), - FE(DMUS_E_INVALIDOFFSET), - FE(DMUS_E_ALREADY_LOADED), - FE(DMUS_E_INVALIDPOS), - FE(DMUS_E_INVALIDPATCH), - FE(DMUS_E_CANNOTSEEK), - FE(DMUS_E_CANNOTWRITE), - FE(DMUS_E_CHUNKNOTFOUND), - FE(DMUS_E_INVALID_DOWNLOADID), - FE(DMUS_E_NOT_DOWNLOADED_TO_PORT), - FE(DMUS_E_ALREADY_DOWNLOADED), - FE(DMUS_E_UNKNOWN_PROPERTY), - FE(DMUS_E_SET_UNSUPPORTED), - FE(DMUS_E_GET_UNSUPPORTED), - FE(DMUS_E_NOTMONO), - FE(DMUS_E_BADARTICULATION), - FE(DMUS_E_BADINSTRUMENT), - FE(DMUS_E_BADWAVELINK), - FE(DMUS_E_NOARTICULATION), - FE(DMUS_E_NOTPCM), - FE(DMUS_E_BADWAVE), - FE(DMUS_E_BADOFFSETTABLE), - FE(DMUS_E_UNKNOWNDOWNLOAD), - FE(DMUS_E_NOSYNTHSINK), - FE(DMUS_E_ALREADYOPEN), - FE(DMUS_E_ALREADYCLOSED), - FE(DMUS_E_SYNTHNOTCONFIGURED), - FE(DMUS_E_SYNTHACTIVE), - FE(DMUS_E_CANNOTREAD), - FE(DMUS_E_DMUSIC_RELEASED), - FE(DMUS_E_BUFFER_EMPTY), - FE(DMUS_E_BUFFER_FULL), - FE(DMUS_E_PORT_NOT_CAPTURE), - FE(DMUS_E_PORT_NOT_RENDER), - FE(DMUS_E_DSOUND_NOT_SET), - FE(DMUS_E_ALREADY_ACTIVATED), - FE(DMUS_E_INVALIDBUFFER), - FE(DMUS_E_WAVEFORMATNOTSUPPORTED), - FE(DMUS_E_SYNTHINACTIVE), - FE(DMUS_E_DSOUND_ALREADY_SET), - FE(DMUS_E_INVALID_EVENT), - FE(DMUS_E_UNSUPPORTED_STREAM), - FE(DMUS_E_ALREADY_INITED), - FE(DMUS_E_INVALID_BAND), - FE(DMUS_E_TRACK_HDR_NOT_FIRST_CK), - FE(DMUS_E_TOOL_HDR_NOT_FIRST_CK), - FE(DMUS_E_INVALID_TRACK_HDR), - FE(DMUS_E_INVALID_TOOL_HDR), - FE(DMUS_E_ALL_TOOLS_FAILED), - FE(DMUS_E_ALL_TRACKS_FAILED), - FE(DMUS_E_NOT_FOUND), - FE(DMUS_E_NOT_INIT), - FE(DMUS_E_TYPE_DISABLED), - FE(DMUS_E_TYPE_UNSUPPORTED), - FE(DMUS_E_TIME_PAST), - FE(DMUS_E_TRACK_NOT_FOUND), - FE(DMUS_E_TRACK_NO_CLOCKTIME_SUPPORT), - FE(DMUS_E_NO_MASTER_CLOCK), - FE(DMUS_E_LOADER_NOCLASSID), - FE(DMUS_E_LOADER_BADPATH), - FE(DMUS_E_LOADER_FAILEDOPEN), - FE(DMUS_E_LOADER_FORMATNOTSUPPORTED), - FE(DMUS_E_LOADER_FAILEDCREATE), - FE(DMUS_E_LOADER_OBJECTNOTFOUND), - FE(DMUS_E_LOADER_NOFILENAME), - FE(DMUS_E_INVALIDFILE), - FE(DMUS_E_ALREADY_EXISTS), - FE(DMUS_E_OUT_OF_RANGE), - FE(DMUS_E_SEGMENT_INIT_FAILED), - FE(DMUS_E_ALREADY_SENT), - FE(DMUS_E_CANNOT_FREE), - FE(DMUS_E_CANNOT_OPEN_PORT), - FE(DMUS_E_CANNOT_CONVERT), - FE(DMUS_E_DESCEND_CHUNK_FAIL), - FE(DMUS_E_NOT_LOADED), - FE(DMUS_E_SCRIPT_LANGUAGE_INCOMPATIBLE), - FE(DMUS_E_SCRIPT_UNSUPPORTED_VARTYPE), - FE(DMUS_E_SCRIPT_ERROR_IN_SCRIPT), - FE(DMUS_E_SCRIPT_CANTLOAD_OLEAUT32), - FE(DMUS_E_SCRIPT_LOADSCRIPT_ERROR), - FE(DMUS_E_SCRIPT_INVALID_FILE), - FE(DMUS_E_INVALID_SCRIPTTRACK), - FE(DMUS_E_SCRIPT_VARIABLE_NOT_FOUND), - FE(DMUS_E_SCRIPT_ROUTINE_NOT_FOUND), - FE(DMUS_E_SCRIPT_CONTENT_READONLY), - FE(DMUS_E_SCRIPT_NOT_A_REFERENCE), - FE(DMUS_E_SCRIPT_VALUE_NOT_SUPPORTED), - FE(DMUS_E_INVALID_SEGMENTTRIGGERTRACK), - FE(DMUS_E_INVALID_LYRICSTRACK), - FE(DMUS_E_INVALID_PARAMCONTROLTRACK), - FE(DMUS_E_AUDIOVBSCRIPT_SYNTAXERROR), - FE(DMUS_E_AUDIOVBSCRIPT_RUNTIMEERROR), - FE(DMUS_E_AUDIOVBSCRIPT_OPERATIONFAILURE), - FE(DMUS_E_AUDIOPATHS_NOT_VALID), - FE(DMUS_E_AUDIOPATHS_IN_USE), - FE(DMUS_E_NO_AUDIOPATH_CONFIG), - FE(DMUS_E_AUDIOPATH_INACTIVE), - FE(DMUS_E_AUDIOPATH_NOBUFFER), - FE(DMUS_E_AUDIOPATH_NOPORT), - FE(DMUS_E_NO_AUDIOPATH), - FE(DMUS_E_INVALIDCHUNK), - FE(DMUS_E_AUDIOPATH_NOGLOBALFXBUFFER), - FE(DMUS_E_INVALID_CONTAINER_OBJECT) - }; - unsigned int i; - for (i = 0; i < sizeof(codes)/sizeof(codes[0]); i++) { - if (code == codes[i].val) - return codes[i].name; - } - /* if we didn't find it, return value */ - return wine_dbg_sprintf("0x%08lx", code); -} - -/* generic flag-dumping function */ -const char* debugstr_flags (DWORD flags, const flag_info* names, size_t num_names){ - char buffer[128] = "", *ptr = &buffer[0]; - unsigned int i, size = sizeof(buffer); - - for (i=0; i < num_names; i++) - { - if ((flags & names[i].val) || /* standard flag*/ - ((!flags) && (!names[i].val))) { /* zero value only */ - int cnt = snprintf(ptr, size, "%s ", names[i].name); - if (cnt < 0 || cnt >= size) break; - size -= cnt; - ptr += cnt; - } - } - - return wine_dbg_sprintf("%s", buffer); -} - -/* dump DMUS_OBJ flags */ -const char *debugstr_DMUS_OBJ_FLAGS (DWORD flagmask) { - static const flag_info flags[] = { - FE(DMUS_OBJ_OBJECT), - FE(DMUS_OBJ_CLASS), - FE(DMUS_OBJ_NAME), - FE(DMUS_OBJ_CATEGORY), - FE(DMUS_OBJ_FILENAME), - FE(DMUS_OBJ_FULLPATH), - FE(DMUS_OBJ_URL), - FE(DMUS_OBJ_VERSION), - FE(DMUS_OBJ_DATE), - FE(DMUS_OBJ_LOADED), - FE(DMUS_OBJ_MEMORY), - FE(DMUS_OBJ_STREAM) - }; - return debugstr_flags (flagmask, flags, sizeof(flags)/sizeof(flags[0])); -} - -/* dump whole DMUS_OBJECTDESC struct */ -void debugstr_DMUS_OBJECTDESC (LPDMUS_OBJECTDESC pDesc) { - if (pDesc) { - TRACE("DMUS_OBJECTDESC (%p):\n", pDesc); - TRACE(" - dwSize = %ld\n", pDesc->dwSize); - TRACE(" - dwValidData = %s\n", debugstr_DMUS_OBJ_FLAGS (pDesc->dwValidData)); - if (pDesc->dwValidData & DMUS_OBJ_NAME) TRACE(" - wszName = %s\n", debugstr_w(pDesc->wszName)); - if (pDesc->dwValidData & DMUS_OBJ_CLASS) TRACE(" - guidClass = %s\n", debugstr_dmguid(&pDesc->guidClass)); - if (pDesc->dwValidData & DMUS_OBJ_OBJECT) TRACE(" - guidObject = %s\n", debugstr_guid(&pDesc->guidObject)); - if (pDesc->dwValidData & DMUS_OBJ_DATE) TRACE(" - ftDate = FIXME\n"); - if (pDesc->dwValidData & DMUS_OBJ_VERSION) TRACE(" - vVersion = %s\n", debugstr_dmversion(&pDesc->vVersion)); - if (pDesc->dwValidData & DMUS_OBJ_CATEGORY) TRACE(" - wszCategory = %s\n", debugstr_w(pDesc->wszCategory)); - if (pDesc->dwValidData & DMUS_OBJ_FILENAME) TRACE(" - wszFileName = %s\n", debugstr_w(pDesc->wszFileName)); - if (pDesc->dwValidData & DMUS_OBJ_MEMORY) TRACE(" - llMemLength = %lli\n - pbMemData = %p\n", pDesc->llMemLength, pDesc->pbMemData); - if (pDesc->dwValidData & DMUS_OBJ_STREAM) TRACE(" - pStream = %p\n", pDesc->pStream); - } else { - TRACE("(NULL)\n"); - } -} -/* -const char *debugstr_DMUS_OBJECTDESC (LPDMUS_OBJECTDESC pDesc) { - if (pDesc) { - char buffer[1024] = "", *ptr = &buffer[0]; - - ptr += sprintf(ptr, "DMUS_OBJECTDESC (%p):\n", pDesc); - ptr += sprintf(ptr, " - dwSize = %ld\n", pDesc->dwSize); - ptr += sprintf(ptr, " - dwValidData = %s\n", debugstr_DMUS_OBJ_FLAGS (pDesc->dwValidData)); - if (pDesc->dwValidData & DMUS_OBJ_CLASS) ptr += sprintf(ptr, " - guidClass = %s\n", debugstr_dmguid(&pDesc->guidClass)); - if (pDesc->dwValidData & DMUS_OBJ_OBJECT) ptr += sprintf(ptr, " - guidObject = %s\n", debugstr_guid(&pDesc->guidObject)); - if (pDesc->dwValidData & DMUS_OBJ_DATE) ptr += sprintf(ptr, " - ftDate = FIXME\n"); - if (pDesc->dwValidData & DMUS_OBJ_VERSION) ptr += sprintf(ptr, " - vVersion = %s\n", debugstr_dmversion(&pDesc->vVersion)); - if (pDesc->dwValidData & DMUS_OBJ_NAME) ptr += sprintf(ptr, " - wszName = %s\n", debugstr_w(pDesc->wszName)); - if (pDesc->dwValidData & DMUS_OBJ_CATEGORY) ptr += sprintf(ptr, " - wszCategory = %s\n", debugstr_w(pDesc->wszCategory)); - if (pDesc->dwValidData & DMUS_OBJ_FILENAME) ptr += sprintf(ptr, " - wszFileName = %s\n", debugstr_w(pDesc->wszFileName)); - if (pDesc->dwValidData & DMUS_OBJ_MEMORY) ptr += sprintf(ptr, " - llMemLength = %lli\n - pbMemData = %p\n", pDesc->llMemLength, pDesc->pbMemData); - if (pDesc->dwValidData & DMUS_OBJ_STREAM) ptr += sprintf(ptr, " - pStream = %p", pDesc->pStream); - - return wine_dbg_sprintf("%s", buffer); - } else { - return wine_dbg_sprintf("(NULL)"); - } - } -*/ diff --git a/dlls/dmband/dmband_private.h b/dlls/dmband/dmband_private.h index a0ace3537b0..1a6e289a481 100644 --- a/dlls/dmband/dmband_private.h +++ b/dlls/dmband/dmband_private.h @@ -193,51 +193,7 @@ extern HRESULT WINAPI IDirectMusicBandTrack_IPersistStream_GetSizeMax (LPPERSIST /***************************************************************************** * Misc. */ -/* for simpler reading */ -typedef struct _DMUS_PRIVATE_CHUNK { - FOURCC fccID; /* FOURCC ID of the chunk */ - DWORD dwSize; /* size of the chunk */ -} DMUS_PRIVATE_CHUNK, *LPDMUS_PRIVATE_CHUNK; -/* used for generic dumping (copied from ddraw) */ -typedef struct { - DWORD val; - const char* name; -} flag_info; - -typedef struct { - const GUID *guid; - const char* name; -} guid_info; - -/* used for initialising structs (primarily for DMUS_OBJECTDESC) */ -#define DM_STRUCT_INIT(x) \ - do { \ - memset((x), 0, sizeof(*(x))); \ - (x)->dwSize = sizeof(*x); \ - } while (0) - -#define FE(x) { x, #x } -#define GE(x) { &x, #x } - -/* check whether the given DWORD is even (return 0) or odd (return 1) */ -extern int even_or_odd (DWORD number); -/* FOURCC to string conversion for debug messages */ -extern const char *debugstr_fourcc (DWORD fourcc); -/* DMUS_VERSION struct to string conversion for debug messages */ -extern const char *debugstr_dmversion (LPDMUS_VERSION version); -/* returns name of given GUID */ -extern const char *debugstr_dmguid (const GUID *id); -/* returns name of given error code */ -extern const char *debugstr_dmreturn (DWORD code); -/* generic flags-dumping function */ -extern const char *debugstr_flags (DWORD flags, const flag_info* names, size_t num_names); -extern const char *debugstr_DMUS_OBJ_FLAGS (DWORD flagmask); -/* dump whole DMUS_OBJECTDESC struct */ -extern void debugstr_DMUS_OBJECTDESC (LPDMUS_OBJECTDESC pDesc); - - -extern HRESULT IDirectMusicUtils_IPersistStream_ParseDescGeneric (DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm, LPDMUS_OBJECTDESC pDesc); -extern HRESULT IDirectMusicUtils_IPersistStream_ParseUNFOGeneric (DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm, LPDMUS_OBJECTDESC pDesc); +#include "dmutils.h" #endif /* __WINE_DMBAND_PRIVATE_H */ diff --git a/dlls/dmband/dmutils.c b/dlls/dmband/dmutils.c new file mode 100644 index 00000000000..3da649d3a05 --- /dev/null +++ b/dlls/dmband/dmutils.c @@ -0,0 +1,752 @@ +/* Debug and Helper Functions + * + * Copyright (C) 2004 Rok Mandeljc + * Copyright (C) 2004 Raphael Junqueira + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program 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 Library General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include +#include +#include + +#include "windef.h" +#include "winbase.h" +#include "winnt.h" +#include "wingdi.h" +#include "winuser.h" + +#include "wine/debug.h" +#include "wine/list.h" +#include "wine/unicode.h" +#include "winreg.h" + +#include "dmusici.h" +#include "dmusicf.h" +#include "dmusics.h" + +#include "dmutils.h" + +WINE_DEFAULT_DEBUG_CHANNEL(dmusic); +WINE_DECLARE_DEBUG_CHANNEL(dmfile); + +/* check whether the given DWORD is even (return 0) or odd (return 1) */ +int even_or_odd (DWORD number) { + return (number & 0x1); /* basically, check if bit 0 is set ;) */ +} + +/* figures out whether given FOURCC is valid DirectMusic form ID */ +BOOL IS_VALID_DMFORM (FOURCC chunkID) { + if ((chunkID == DMUS_FOURCC_AUDIOPATH_FORM) || (chunkID == DMUS_FOURCC_BAND_FORM) || (chunkID == DMUS_FOURCC_CHORDMAP_FORM) + || (chunkID == DMUS_FOURCC_CONTAINER_FORM) || (chunkID == FOURCC_DLS) || (chunkID == DMUS_FOURCC_SCRIPT_FORM) + || (chunkID == DMUS_FOURCC_SEGMENT_FORM) || (chunkID == DMUS_FOURCC_STYLE_FORM) || (chunkID == DMUS_FOURCC_TOOLGRAPH_FORM) + || (chunkID == DMUS_FOURCC_TRACK_FORM) || (chunkID == mmioFOURCC('W','A','V','E'))) return TRUE; + else return FALSE; +} + +HRESULT IDirectMusicUtils_IPersistStream_ParseDescGeneric (DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm, LPDMUS_OBJECTDESC pDesc) { + + switch (pChunk->fccID) { + case DMUS_FOURCC_GUID_CHUNK: { + TRACE_(dmfile)(": GUID chunk\n"); + pDesc->dwValidData |= DMUS_OBJ_OBJECT; + IStream_Read (pStm, &pDesc->guidObject, pChunk->dwSize, NULL); + break; + } + case DMUS_FOURCC_DATE_CHUNK: { + TRACE_(dmfile)(": file date chunk\n"); + pDesc->dwValidData |= DMUS_OBJ_DATE; + IStream_Read (pStm, &pDesc->ftDate, pChunk->dwSize, NULL); + break; + } + case DMUS_FOURCC_NAME_CHUNK: { + TRACE_(dmfile)(": name chunk\n"); + pDesc->dwValidData |= DMUS_OBJ_NAME; + IStream_Read (pStm, &pDesc->wszName, pChunk->dwSize, NULL); + break; + } + case DMUS_FOURCC_FILE_CHUNK: { + TRACE_(dmfile)(": file name chunk\n"); + pDesc->dwValidData |= DMUS_OBJ_FILENAME; + IStream_Read (pStm, &pDesc->wszFileName, pChunk->dwSize, NULL); + break; + } + case DMUS_FOURCC_VERSION_CHUNK: { + TRACE_(dmfile)(": version chunk\n"); + pDesc->dwValidData |= DMUS_OBJ_VERSION; + IStream_Read (pStm, &pDesc->vVersion, pChunk->dwSize, NULL); + break; + } + case DMUS_FOURCC_CATEGORY_CHUNK: { + TRACE_(dmfile)(": category chunk\n"); + pDesc->dwValidData |= DMUS_OBJ_CATEGORY; + IStream_Read (pStm, pDesc->wszCategory, pChunk->dwSize, NULL); + break; + } + default: + /* not handled */ + return S_FALSE; + } + + return S_OK; +} + +HRESULT IDirectMusicUtils_IPersistStream_ParseUNFOGeneric (DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm, LPDMUS_OBJECTDESC pDesc) { + + LARGE_INTEGER liMove; /* used when skipping chunks */ + + /** + * don't ask me why, but M$ puts INFO elements in UNFO list sometimes + * (though strings seem to be valid unicode) + */ + switch (pChunk->fccID) { + + case mmioFOURCC('I','N','A','M'): + case DMUS_FOURCC_UNAM_CHUNK: { + TRACE_(dmfile)(": name chunk\n"); + pDesc->dwValidData |= DMUS_OBJ_NAME; + IStream_Read (pStm, pDesc->wszName, pChunk->dwSize, NULL); + TRACE_(dmfile)(" - wszName: %s\n", debugstr_w(pDesc->wszName)); + break; + } + + case mmioFOURCC('I','A','R','T'): + case DMUS_FOURCC_UART_CHUNK: { + TRACE_(dmfile)(": artist chunk (ignored)\n"); + liMove.QuadPart = pChunk->dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + case mmioFOURCC('I','C','O','P'): + case DMUS_FOURCC_UCOP_CHUNK: { + TRACE_(dmfile)(": copyright chunk (ignored)\n"); + liMove.QuadPart = pChunk->dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + case mmioFOURCC('I','S','B','J'): + case DMUS_FOURCC_USBJ_CHUNK: { + TRACE_(dmfile)(": subject chunk (ignored)\n"); + liMove.QuadPart = pChunk->dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + case mmioFOURCC('I','C','M','T'): + case DMUS_FOURCC_UCMT_CHUNK: { + TRACE_(dmfile)(": comment chunk (ignored)\n"); + liMove.QuadPart = pChunk->dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + default: + /* not handled */ + return S_FALSE; + } + + return S_OK; +} + +HRESULT IDirectMusicUtils_IPersistStream_ParseReference (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm, IDirectMusicObject** ppObject) { + DMUS_PRIVATE_CHUNK Chunk; + DWORD ListSize[3], ListCount[3]; + LARGE_INTEGER liMove; /* used when skipping chunks */ + HRESULT hr; + + DMUS_IO_REFERENCE ref; + DMUS_OBJECTDESC ref_desc; + + memset(&ref, 0, sizeof(ref)); + memset(&ref_desc, 0, sizeof(ref_desc)); + + if (pChunk->fccID != DMUS_FOURCC_REF_LIST) { + ERR_(dmfile)(": %s chunk should be a REF list\n", debugstr_fourcc (pChunk->fccID)); + return E_FAIL; + } + + ListSize[0] = pChunk->dwSize - sizeof(FOURCC); + ListCount[0] = 0; + + do { + IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL); + ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize; + TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize); + + hr = IDirectMusicUtils_IPersistStream_ParseDescGeneric(&Chunk, pStm, &ref_desc); + if (FAILED(hr)) return hr; + + if (hr == S_FALSE) { + switch (Chunk.fccID) { + case DMUS_FOURCC_REF_CHUNK: { + TRACE_(dmfile)(": Reference chunk\n"); + if (Chunk.dwSize != sizeof(DMUS_IO_REFERENCE)) return E_FAIL; + IStream_Read (pStm, &ref, sizeof(DMUS_IO_REFERENCE), NULL); + TRACE_(dmfile)(" - guidClassID: %s\n", debugstr_dmguid(&ref.guidClassID)); + TRACE_(dmfile)(" - dwValidData: %lu\n", ref.dwValidData); + break; + } + default: { + TRACE_(dmfile)(": unknown chunk (irrevelant & skipping)\n"); + liMove.QuadPart = Chunk.dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + } + } + TRACE_(dmfile)(": ListCount[0] = %ld < ListSize[0] = %ld\n", ListCount[0], ListSize[0]); + } while (ListCount[0] < ListSize[0]); + + ref_desc.dwValidData |= DMUS_OBJ_CLASS; + memcpy(&ref_desc.guidClass, &ref.guidClassID, sizeof(ref.guidClassID)); + + TRACE_(dmfile)("** DM Reference Begin of Load ***\n"); + TRACE_(dmfile)("With Desc:\n"); + debugstr_DMUS_OBJECTDESC(&ref_desc); + + { + LPDIRECTMUSICGETLOADER pGetLoader = NULL; + LPDIRECTMUSICLOADER pLoader = NULL; + + IStream_QueryInterface (pStm, &IID_IDirectMusicGetLoader, (LPVOID*)&pGetLoader); + IDirectMusicGetLoader_GetLoader (pGetLoader, &pLoader); + IDirectMusicGetLoader_Release (pGetLoader); + + hr = IDirectMusicLoader_GetObject (pLoader, &ref_desc, &IID_IDirectMusicObject, (LPVOID*)ppObject); + IDirectMusicLoader_Release (pLoader); /* release loader */ + } + TRACE_(dmfile)("** DM Reference End of Load ***\n"); + + return S_OK; +} + +/* translate STREAM_SEEK flag to string */ +const char *resolve_STREAM_SEEK (DWORD flag) { + switch (flag) { + case STREAM_SEEK_SET: + return wine_dbg_sprintf ("STREAM_SEEK_SET"); + case STREAM_SEEK_CUR: + return wine_dbg_sprintf ("STREAM_SEEK_CUR"); + case STREAM_SEEK_END: + return wine_dbg_sprintf ("STREAM_SEEK_END"); + default: + return wine_dbg_sprintf ("()"); + } +} + +/* FOURCC to string conversion for debug messages */ +const char *debugstr_fourcc (DWORD fourcc) { + if (!fourcc) return "'null'"; + return wine_dbg_sprintf ("\'%c%c%c%c\'", + (char)(fourcc), (char)(fourcc >> 8), + (char)(fourcc >> 16), (char)(fourcc >> 24)); +} + +/* DMUS_VERSION struct to string conversion for debug messages */ +const char *debugstr_dmversion (LPDMUS_VERSION version) { + if (!version) return "'null'"; + return wine_dbg_sprintf ("\'%i,%i,%i,%i\'", + HIWORD(version->dwVersionMS),LOWORD(version->dwVersionMS), + HIWORD(version->dwVersionLS), LOWORD(version->dwVersionLS)); +} + +/* month number into month name (for debugstr_filetime) */ +const char *debugstr_month (DWORD dwMonth) { + switch (dwMonth) { + case 1: return "January"; + case 2: return "February"; + case 3: return "March"; + case 4: return "April"; + case 5: return "May"; + case 6: return "June"; + case 7: return "July"; + case 8: return "August"; + case 9: return "September"; + case 10: return "October"; + case 11: return "November"; + case 12: return "December"; + default: return "Invalid"; + } +} + +/* FILETIME struct to string conversion for debug messages */ +const char *debugstr_filetime (LPFILETIME time) { + SYSTEMTIME sysTime; + + if (!time) return "'null'"; + + FileTimeToSystemTime (time, &sysTime); + + return wine_dbg_sprintf ("\'%02i. %s %04i %02i:%02i:%02i\'", \ + sysTime.wDay, debugstr_month(sysTime.wMonth), sysTime.wYear, + sysTime.wHour, sysTime.wMinute, sysTime.wSecond); +} + +/* returns name of given GUID */ +const char *debugstr_dmguid (const GUID *id) { + static const guid_info guids[] = { + /* CLSIDs */ + GE(CLSID_AudioVBScript), + GE(CLSID_DirectMusic), + GE(CLSID_DirectMusicAudioPath), + GE(CLSID_DirectMusicAudioPathConfig), + GE(CLSID_DirectMusicAuditionTrack), + GE(CLSID_DirectMusicBand), + GE(CLSID_DirectMusicBandTrack), + GE(CLSID_DirectMusicChordMapTrack), + GE(CLSID_DirectMusicChordMap), + GE(CLSID_DirectMusicChordTrack), + GE(CLSID_DirectMusicCollection), + GE(CLSID_DirectMusicCommandTrack), + GE(CLSID_DirectMusicComposer), + GE(CLSID_DirectMusicContainer), + GE(CLSID_DirectMusicGraph), + GE(CLSID_DirectMusicLoader), + GE(CLSID_DirectMusicLyricsTrack), + GE(CLSID_DirectMusicMarkerTrack), + GE(CLSID_DirectMusicMelodyFormulationTrack), + GE(CLSID_DirectMusicMotifTrack), + GE(CLSID_DirectMusicMuteTrack), + GE(CLSID_DirectMusicParamControlTrack), + GE(CLSID_DirectMusicPatternTrack), + GE(CLSID_DirectMusicPerformance), + GE(CLSID_DirectMusicScript), + GE(CLSID_DirectMusicScriptAutoImpSegment), + GE(CLSID_DirectMusicScriptAutoImpPerformance), + GE(CLSID_DirectMusicScriptAutoImpSegmentState), + GE(CLSID_DirectMusicScriptAutoImpAudioPathConfig), + GE(CLSID_DirectMusicScriptAutoImpAudioPath), + GE(CLSID_DirectMusicScriptAutoImpSong), + GE(CLSID_DirectMusicScriptSourceCodeLoader), + GE(CLSID_DirectMusicScriptTrack), + GE(CLSID_DirectMusicSection), + GE(CLSID_DirectMusicSegment), + GE(CLSID_DirectMusicSegmentState), + GE(CLSID_DirectMusicSegmentTriggerTrack), + GE(CLSID_DirectMusicSegTriggerTrack), + GE(CLSID_DirectMusicSeqTrack), + GE(CLSID_DirectMusicSignPostTrack), + GE(CLSID_DirectMusicSong), + GE(CLSID_DirectMusicStyle), + GE(CLSID_DirectMusicStyleTrack), + GE(CLSID_DirectMusicSynth), + GE(CLSID_DirectMusicSynthSink), + GE(CLSID_DirectMusicSysExTrack), + GE(CLSID_DirectMusicTemplate), + GE(CLSID_DirectMusicTempoTrack), + GE(CLSID_DirectMusicTimeSigTrack), + GE(CLSID_DirectMusicWaveTrack), + GE(CLSID_DirectSoundWave), + /* IIDs */ + GE(IID_IDirectMusic), + GE(IID_IDirectMusic2), + GE(IID_IDirectMusic8), + GE(IID_IDirectMusicAudioPath), + GE(IID_IDirectMusicBand), + GE(IID_IDirectMusicBuffer), + GE(IID_IDirectMusicChordMap), + GE(IID_IDirectMusicCollection), + GE(IID_IDirectMusicComposer), + GE(IID_IDirectMusicContainer), + GE(IID_IDirectMusicDownload), + GE(IID_IDirectMusicDownloadedInstrument), + GE(IID_IDirectMusicGetLoader), + GE(IID_IDirectMusicGraph), + GE(IID_IDirectMusicInstrument), + GE(IID_IDirectMusicLoader), + GE(IID_IDirectMusicLoader8), + GE(IID_IDirectMusicObject), + GE(IID_IDirectMusicPatternTrack), + GE(IID_IDirectMusicPerformance), + GE(IID_IDirectMusicPerformance2), + GE(IID_IDirectMusicPerformance8), + GE(IID_IDirectMusicPort), + GE(IID_IDirectMusicPortDownload), + GE(IID_IDirectMusicScript), + GE(IID_IDirectMusicSegment), + GE(IID_IDirectMusicSegment2), + GE(IID_IDirectMusicSegment8), + GE(IID_IDirectMusicSegmentState), + GE(IID_IDirectMusicSegmentState8), + GE(IID_IDirectMusicStyle), + GE(IID_IDirectMusicStyle8), + GE(IID_IDirectMusicSynth), + GE(IID_IDirectMusicSynth8), + GE(IID_IDirectMusicSynthSink), + GE(IID_IDirectMusicThru), + GE(IID_IDirectMusicTool), + GE(IID_IDirectMusicTool8), + GE(IID_IDirectMusicTrack), + GE(IID_IDirectMusicTrack8), + GE(IID_IUnknown), + GE(IID_IPersistStream), + GE(IID_IStream), + GE(IID_IClassFactory), + /* GUIDs */ + GE(GUID_DirectMusicAllTypes), + GE(GUID_NOTIFICATION_CHORD), + GE(GUID_NOTIFICATION_COMMAND), + GE(GUID_NOTIFICATION_MEASUREANDBEAT), + GE(GUID_NOTIFICATION_PERFORMANCE), + GE(GUID_NOTIFICATION_RECOMPOSE), + GE(GUID_NOTIFICATION_SEGMENT), + GE(GUID_BandParam), + GE(GUID_ChordParam), + GE(GUID_CommandParam), + GE(GUID_CommandParam2), + GE(GUID_CommandParamNext), + GE(GUID_IDirectMusicBand), + GE(GUID_IDirectMusicChordMap), + GE(GUID_IDirectMusicStyle), + GE(GUID_MuteParam), + GE(GUID_Play_Marker), + GE(GUID_RhythmParam), + GE(GUID_TempoParam), + GE(GUID_TimeSignature), + GE(GUID_Valid_Start_Time), + GE(GUID_Clear_All_Bands), + GE(GUID_ConnectToDLSCollection), + GE(GUID_Disable_Auto_Download), + GE(GUID_DisableTempo), + GE(GUID_DisableTimeSig), + GE(GUID_Download), + GE(GUID_DownloadToAudioPath), + GE(GUID_Enable_Auto_Download), + GE(GUID_EnableTempo), + GE(GUID_EnableTimeSig), + GE(GUID_IgnoreBankSelectForGM), + GE(GUID_SeedVariations), + GE(GUID_StandardMIDIFile), + GE(GUID_Unload), + GE(GUID_UnloadFromAudioPath), + GE(GUID_Variations), + GE(GUID_PerfMasterTempo), + GE(GUID_PerfMasterVolume), + GE(GUID_PerfMasterGrooveLevel), + GE(GUID_PerfAutoDownload), + GE(GUID_DefaultGMCollection), + GE(GUID_Synth_Default), + GE(GUID_Buffer_Reverb), + GE(GUID_Buffer_EnvReverb), + GE(GUID_Buffer_Stereo), + GE(GUID_Buffer_3D_Dry), + GE(GUID_Buffer_Mono), + GE(GUID_DMUS_PROP_GM_Hardware), + GE(GUID_DMUS_PROP_GS_Capable), + GE(GUID_DMUS_PROP_GS_Hardware), + GE(GUID_DMUS_PROP_DLS1), + GE(GUID_DMUS_PROP_DLS2), + GE(GUID_DMUS_PROP_Effects), + GE(GUID_DMUS_PROP_INSTRUMENT2), + GE(GUID_DMUS_PROP_LegacyCaps), + GE(GUID_DMUS_PROP_MemorySize), + GE(GUID_DMUS_PROP_SampleMemorySize), + GE(GUID_DMUS_PROP_SamplePlaybackRate), + GE(GUID_DMUS_PROP_SetSynthSink), + GE(GUID_DMUS_PROP_SinkUsesDSound), + GE(GUID_DMUS_PROP_SynthSink_DSOUND), + GE(GUID_DMUS_PROP_SynthSink_WAVE), + GE(GUID_DMUS_PROP_Volume), + GE(GUID_DMUS_PROP_WavesReverb), + GE(GUID_DMUS_PROP_WriteLatency), + GE(GUID_DMUS_PROP_WritePeriod), + GE(GUID_DMUS_PROP_XG_Capable), + GE(GUID_DMUS_PROP_XG_Hardware) + }; + + unsigned int i; + + if (!id) return "(null)"; + for (i = 0; i < sizeof(guids)/sizeof(guids[0]); i++) { + if (IsEqualGUID(id, guids[i].guid)) + return guids[i].name; + } + + /* if we didn't find it, act like standard debugstr_guid */ + return debugstr_guid(id); +} + +/* returns name of given error code */ +const char *debugstr_dmreturn (DWORD code) { + static const flag_info codes[] = { + FE(S_OK), + FE(S_FALSE), + FE(DMUS_S_PARTIALLOAD), + FE(DMUS_S_PARTIALDOWNLOAD), + FE(DMUS_S_REQUEUE), + FE(DMUS_S_FREE), + FE(DMUS_S_END), + FE(DMUS_S_STRING_TRUNCATED), + FE(DMUS_S_LAST_TOOL), + FE(DMUS_S_OVER_CHORD), + FE(DMUS_S_UP_OCTAVE), + FE(DMUS_S_DOWN_OCTAVE), + FE(DMUS_S_NOBUFFERCONTROL), + FE(DMUS_S_GARBAGE_COLLECTED), + FE(E_NOTIMPL), + FE(E_NOINTERFACE), + FE(E_POINTER), + FE(CLASS_E_NOAGGREGATION), + FE(CLASS_E_CLASSNOTAVAILABLE), + FE(REGDB_E_CLASSNOTREG), + FE(E_OUTOFMEMORY), + FE(E_FAIL), + FE(E_INVALIDARG), + FE(DMUS_E_DRIVER_FAILED), + FE(DMUS_E_PORTS_OPEN), + FE(DMUS_E_DEVICE_IN_USE), + FE(DMUS_E_INSUFFICIENTBUFFER), + FE(DMUS_E_BUFFERNOTSET), + FE(DMUS_E_BUFFERNOTAVAILABLE), + FE(DMUS_E_NOTADLSCOL), + FE(DMUS_E_INVALIDOFFSET), + FE(DMUS_E_ALREADY_LOADED), + FE(DMUS_E_INVALIDPOS), + FE(DMUS_E_INVALIDPATCH), + FE(DMUS_E_CANNOTSEEK), + FE(DMUS_E_CANNOTWRITE), + FE(DMUS_E_CHUNKNOTFOUND), + FE(DMUS_E_INVALID_DOWNLOADID), + FE(DMUS_E_NOT_DOWNLOADED_TO_PORT), + FE(DMUS_E_ALREADY_DOWNLOADED), + FE(DMUS_E_UNKNOWN_PROPERTY), + FE(DMUS_E_SET_UNSUPPORTED), + FE(DMUS_E_GET_UNSUPPORTED), + FE(DMUS_E_NOTMONO), + FE(DMUS_E_BADARTICULATION), + FE(DMUS_E_BADINSTRUMENT), + FE(DMUS_E_BADWAVELINK), + FE(DMUS_E_NOARTICULATION), + FE(DMUS_E_NOTPCM), + FE(DMUS_E_BADWAVE), + FE(DMUS_E_BADOFFSETTABLE), + FE(DMUS_E_UNKNOWNDOWNLOAD), + FE(DMUS_E_NOSYNTHSINK), + FE(DMUS_E_ALREADYOPEN), + FE(DMUS_E_ALREADYCLOSED), + FE(DMUS_E_SYNTHNOTCONFIGURED), + FE(DMUS_E_SYNTHACTIVE), + FE(DMUS_E_CANNOTREAD), + FE(DMUS_E_DMUSIC_RELEASED), + FE(DMUS_E_BUFFER_EMPTY), + FE(DMUS_E_BUFFER_FULL), + FE(DMUS_E_PORT_NOT_CAPTURE), + FE(DMUS_E_PORT_NOT_RENDER), + FE(DMUS_E_DSOUND_NOT_SET), + FE(DMUS_E_ALREADY_ACTIVATED), + FE(DMUS_E_INVALIDBUFFER), + FE(DMUS_E_WAVEFORMATNOTSUPPORTED), + FE(DMUS_E_SYNTHINACTIVE), + FE(DMUS_E_DSOUND_ALREADY_SET), + FE(DMUS_E_INVALID_EVENT), + FE(DMUS_E_UNSUPPORTED_STREAM), + FE(DMUS_E_ALREADY_INITED), + FE(DMUS_E_INVALID_BAND), + FE(DMUS_E_TRACK_HDR_NOT_FIRST_CK), + FE(DMUS_E_TOOL_HDR_NOT_FIRST_CK), + FE(DMUS_E_INVALID_TRACK_HDR), + FE(DMUS_E_INVALID_TOOL_HDR), + FE(DMUS_E_ALL_TOOLS_FAILED), + FE(DMUS_E_ALL_TRACKS_FAILED), + FE(DMUS_E_NOT_FOUND), + FE(DMUS_E_NOT_INIT), + FE(DMUS_E_TYPE_DISABLED), + FE(DMUS_E_TYPE_UNSUPPORTED), + FE(DMUS_E_TIME_PAST), + FE(DMUS_E_TRACK_NOT_FOUND), + FE(DMUS_E_TRACK_NO_CLOCKTIME_SUPPORT), + FE(DMUS_E_NO_MASTER_CLOCK), + FE(DMUS_E_LOADER_NOCLASSID), + FE(DMUS_E_LOADER_BADPATH), + FE(DMUS_E_LOADER_FAILEDOPEN), + FE(DMUS_E_LOADER_FORMATNOTSUPPORTED), + FE(DMUS_E_LOADER_FAILEDCREATE), + FE(DMUS_E_LOADER_OBJECTNOTFOUND), + FE(DMUS_E_LOADER_NOFILENAME), + FE(DMUS_E_INVALIDFILE), + FE(DMUS_E_ALREADY_EXISTS), + FE(DMUS_E_OUT_OF_RANGE), + FE(DMUS_E_SEGMENT_INIT_FAILED), + FE(DMUS_E_ALREADY_SENT), + FE(DMUS_E_CANNOT_FREE), + FE(DMUS_E_CANNOT_OPEN_PORT), + FE(DMUS_E_CANNOT_CONVERT), + FE(DMUS_E_DESCEND_CHUNK_FAIL), + FE(DMUS_E_NOT_LOADED), + FE(DMUS_E_SCRIPT_LANGUAGE_INCOMPATIBLE), + FE(DMUS_E_SCRIPT_UNSUPPORTED_VARTYPE), + FE(DMUS_E_SCRIPT_ERROR_IN_SCRIPT), + FE(DMUS_E_SCRIPT_CANTLOAD_OLEAUT32), + FE(DMUS_E_SCRIPT_LOADSCRIPT_ERROR), + FE(DMUS_E_SCRIPT_INVALID_FILE), + FE(DMUS_E_INVALID_SCRIPTTRACK), + FE(DMUS_E_SCRIPT_VARIABLE_NOT_FOUND), + FE(DMUS_E_SCRIPT_ROUTINE_NOT_FOUND), + FE(DMUS_E_SCRIPT_CONTENT_READONLY), + FE(DMUS_E_SCRIPT_NOT_A_REFERENCE), + FE(DMUS_E_SCRIPT_VALUE_NOT_SUPPORTED), + FE(DMUS_E_INVALID_SEGMENTTRIGGERTRACK), + FE(DMUS_E_INVALID_LYRICSTRACK), + FE(DMUS_E_INVALID_PARAMCONTROLTRACK), + FE(DMUS_E_AUDIOVBSCRIPT_SYNTAXERROR), + FE(DMUS_E_AUDIOVBSCRIPT_RUNTIMEERROR), + FE(DMUS_E_AUDIOVBSCRIPT_OPERATIONFAILURE), + FE(DMUS_E_AUDIOPATHS_NOT_VALID), + FE(DMUS_E_AUDIOPATHS_IN_USE), + FE(DMUS_E_NO_AUDIOPATH_CONFIG), + FE(DMUS_E_AUDIOPATH_INACTIVE), + FE(DMUS_E_AUDIOPATH_NOBUFFER), + FE(DMUS_E_AUDIOPATH_NOPORT), + FE(DMUS_E_NO_AUDIOPATH), + FE(DMUS_E_INVALIDCHUNK), + FE(DMUS_E_AUDIOPATH_NOGLOBALFXBUFFER), + FE(DMUS_E_INVALID_CONTAINER_OBJECT) + }; + + unsigned int i; + for (i = 0; i < sizeof(codes)/sizeof(codes[0]); i++) { + if (code == codes[i].val) + return codes[i].name; + } + + /* if we didn't find it, return value */ + return wine_dbg_sprintf("0x%08lX", code); +} + + +/* generic flag-dumping function */ +const char* debugstr_flags (DWORD flags, const flag_info* names, size_t num_names){ + static char buffer[128] = "", *ptr = &buffer[0]; + unsigned int i, size = sizeof(buffer); + + for (i=0; i < num_names; i++) { + if ((flags & names[i].val)) { + int cnt = snprintf(ptr, size, "%s ", names[i].name); + if (cnt < 0 || cnt >= size) break; + size -= cnt; + ptr += cnt; + } + } + + ptr = &buffer[0]; + return ptr; +} + +/* dump DMUS_OBJ flags */ +const char *debugstr_DMUS_OBJ_FLAGS (DWORD flagmask) { + static const flag_info flags[] = { + FE(DMUS_OBJ_OBJECT), + FE(DMUS_OBJ_CLASS), + FE(DMUS_OBJ_NAME), + FE(DMUS_OBJ_CATEGORY), + FE(DMUS_OBJ_FILENAME), + FE(DMUS_OBJ_FULLPATH), + FE(DMUS_OBJ_URL), + FE(DMUS_OBJ_VERSION), + FE(DMUS_OBJ_DATE), + FE(DMUS_OBJ_LOADED), + FE(DMUS_OBJ_MEMORY), + FE(DMUS_OBJ_STREAM) + }; + return debugstr_flags (flagmask, flags, sizeof(flags)/sizeof(flags[0])); +} + +/* dump DMUS_CONTAINER flags */ +const char *debugstr_DMUS_CONTAINER_FLAGS (DWORD flagmask) { + static const flag_info flags[] = { + FE(DMUS_CONTAINER_NOLOADS) + }; + return debugstr_flags (flagmask, flags, sizeof(flags)/sizeof(flags[0])); +} + +/* dump DMUS_CONTAINED_OBJF flags */ +const char *debugstr_DMUS_CONTAINED_OBJF_FLAGS (DWORD flagmask) { + static const flag_info flags[] = { + FE(DMUS_CONTAINED_OBJF_KEEP) + }; + return debugstr_flags (flagmask, flags, sizeof(flags)/sizeof(flags[0])); +} + +const char *debugstr_DMUS_OBJECTDESC (LPDMUS_OBJECTDESC pDesc) { + if (pDesc) { + char buffer[1024] = "", *ptr = &buffer[0]; + + ptr += sprintf(ptr, "DMUS_OBJECTDESC (%p):\n", pDesc); + ptr += sprintf(ptr, " - dwSize = 0x%08lX\n", pDesc->dwSize); + ptr += sprintf(ptr, " - dwValidData = 0x%08lX ( %s)\n", pDesc->dwValidData, debugstr_DMUS_OBJ_FLAGS (pDesc->dwValidData)); + if (pDesc->dwValidData & DMUS_OBJ_CLASS) ptr += sprintf(ptr, " - guidClass = %s\n", debugstr_dmguid(&pDesc->guidClass)); + if (pDesc->dwValidData & DMUS_OBJ_OBJECT) ptr += sprintf(ptr, " - guidObject = %s\n", debugstr_guid(&pDesc->guidObject)); + if (pDesc->dwValidData & DMUS_OBJ_DATE) ptr += sprintf(ptr, " - ftDate = %s\n", debugstr_filetime (&pDesc->ftDate)); + if (pDesc->dwValidData & DMUS_OBJ_VERSION) ptr += sprintf(ptr, " - vVersion = %s\n", debugstr_dmversion(&pDesc->vVersion)); + if (pDesc->dwValidData & DMUS_OBJ_NAME) ptr += sprintf(ptr, " - wszName = %s\n", debugstr_w(pDesc->wszName)); + if (pDesc->dwValidData & DMUS_OBJ_CATEGORY) ptr += sprintf(ptr, " - wszCategory = %s\n", debugstr_w(pDesc->wszCategory)); + if (pDesc->dwValidData & DMUS_OBJ_FILENAME) ptr += sprintf(ptr, " - wszFileName = %s\n", debugstr_w(pDesc->wszFileName)); + if (pDesc->dwValidData & DMUS_OBJ_MEMORY) ptr += sprintf(ptr, " - llMemLength = %lli\n - pbMemData = %p\n", pDesc->llMemLength, pDesc->pbMemData); + if (pDesc->dwValidData & DMUS_OBJ_STREAM) ptr += sprintf(ptr, " - pStream = %p\n", pDesc->pStream); + + ptr = &buffer[0]; + return ptr; + } else { + return wine_dbg_sprintf("(NULL)"); + } +} + +void debug_DMUS_OBJECTDESC (LPDMUS_OBJECTDESC pDesc) { + if (pDesc) { + TRACE("DMUS_OBJECTDESC (%p):\n", pDesc); + TRACE(" - dwSize = %ld\n", pDesc->dwSize); + TRACE(" - dwValidData = %s\n", debugstr_DMUS_OBJ_FLAGS (pDesc->dwValidData)); + if (pDesc->dwValidData & DMUS_OBJ_NAME) TRACE(" - wszName = %s\n", debugstr_w(pDesc->wszName)); + if (pDesc->dwValidData & DMUS_OBJ_CLASS) TRACE(" - guidClass = %s\n", debugstr_dmguid(&pDesc->guidClass)); + if (pDesc->dwValidData & DMUS_OBJ_OBJECT) TRACE(" - guidObject = %s\n", debugstr_guid(&pDesc->guidObject)); + if (pDesc->dwValidData & DMUS_OBJ_DATE) TRACE(" - ftDate = FIXME\n"); + if (pDesc->dwValidData & DMUS_OBJ_VERSION) TRACE(" - vVersion = %s\n", debugstr_dmversion(&pDesc->vVersion)); + if (pDesc->dwValidData & DMUS_OBJ_CATEGORY) TRACE(" - wszCategory = %s\n", debugstr_w(pDesc->wszCategory)); + if (pDesc->dwValidData & DMUS_OBJ_FILENAME) TRACE(" - wszFileName = %s\n", debugstr_w(pDesc->wszFileName)); + if (pDesc->dwValidData & DMUS_OBJ_MEMORY) TRACE(" - llMemLength = %lli\n - pbMemData = %p\n", pDesc->llMemLength, pDesc->pbMemData); + if (pDesc->dwValidData & DMUS_OBJ_STREAM) TRACE(" - pStream = %p\n", pDesc->pStream); + } else { + TRACE("(NULL)\n"); + } +} + +const char *debugstr_DMUS_IO_CONTAINER_HEADER (LPDMUS_IO_CONTAINER_HEADER pHeader) { + if (pHeader) { + char buffer[1024] = "", *ptr = &buffer[0]; + + ptr += sprintf(ptr, "DMUS_IO_CONTAINER_HEADER (%p):\n", pHeader); + ptr += sprintf(ptr, " - dwFlags = %s\n", debugstr_DMUS_CONTAINER_FLAGS(pHeader->dwFlags)); + + ptr = &buffer[0]; + return ptr; + } else { + return wine_dbg_sprintf("(NULL)"); + } +} + +const char *debugstr_DMUS_IO_CONTAINED_OBJECT_HEADER (LPDMUS_IO_CONTAINED_OBJECT_HEADER pHeader) { + if (pHeader) { + char buffer[1024] = "", *ptr = &buffer[0]; + + ptr += sprintf(ptr, "DMUS_IO_CONTAINED_OBJECT_HEADER (%p):\n", pHeader); + ptr += sprintf(ptr, " - guidClassID = %s\n", debugstr_dmguid(&pHeader->guidClassID)); + ptr += sprintf(ptr, " - dwFlags = %s\n", debugstr_DMUS_CONTAINED_OBJF_FLAGS (pHeader->dwFlags)); + ptr += sprintf(ptr, " - ckid = %s\n", debugstr_fourcc (pHeader->ckid)); + ptr += sprintf(ptr, " - fccType = %s\n", debugstr_fourcc (pHeader->fccType)); + + ptr = &buffer[0]; + return ptr; + } else { + return wine_dbg_sprintf("(NULL)"); + } +} diff --git a/dlls/dmband/dmutils.h b/dlls/dmband/dmutils.h new file mode 100644 index 00000000000..c8651619d7b --- /dev/null +++ b/dlls/dmband/dmutils.h @@ -0,0 +1,89 @@ +/* Debug and Helper Functions + * + * Copyright (C) 2003-2004 Rok Mandeljc + * Copyright (C) 2003-2004 Raphael Junqueira + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program 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 Library General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef __WINE_DMUTILS_H +#define __WINE_DMUTILS_H + +/* for simpler reading */ +typedef struct _DMUS_PRIVATE_CHUNK { + FOURCC fccID; /* FOURCC ID of the chunk */ + DWORD dwSize; /* size of the chunk */ +} DMUS_PRIVATE_CHUNK, *LPDMUS_PRIVATE_CHUNK; + +/** + * Parsing utilities + */ +extern HRESULT IDirectMusicUtils_IPersistStream_ParseDescGeneric (DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm, LPDMUS_OBJECTDESC pDesc); +extern HRESULT IDirectMusicUtils_IPersistStream_ParseUNFOGeneric (DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm, LPDMUS_OBJECTDESC pDesc); +extern HRESULT IDirectMusicUtils_IPersistStream_ParseReference (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm, IDirectMusicObject** ppObject); + +/** + * Debug utilities + */ +/* used for generic dumping (copied from ddraw) */ +typedef struct { + DWORD val; + const char* name; +} flag_info; + +typedef struct { + const GUID *guid; + const char* name; +} guid_info; + +/* used for initialising structs */ +#define DM_STRUCT_INIT(x) \ + do { \ + memset((x), 0, sizeof(*(x))); \ + (x)->dwSize = sizeof(*x); \ + } while (0) + +#define FE(x) { x, #x } +#define GE(x) { &x, #x } + +/* check whether the given DWORD is even (return 0) or odd (return 1) */ +extern int even_or_odd (DWORD number); +/* check whether chunkID is valid dmobject form chunk */ +extern BOOL IS_VALID_DMFORM (FOURCC chunkID); +/* translate STREAM_SEEK flag to string */ +extern const char *resolve_STREAM_SEEK (DWORD flag); +/* FOURCC to string conversion for debug messages */ +extern const char *debugstr_fourcc (DWORD fourcc); +/* DMUS_VERSION struct to string conversion for debug messages */ +extern const char *debugstr_dmversion (LPDMUS_VERSION version); +/* FILETIME struct to string conversion for debug messages */ +extern const char *debugstr_filetime (LPFILETIME time); +/* returns name of given GUID */ +extern const char *debugstr_dmguid (const GUID *id); +/* returns name of given error code */ +extern const char *debugstr_dmreturn (DWORD code); +/* generic flags-dumping function */ +extern const char *debugstr_flags (DWORD flags, const flag_info* names, size_t num_names); + +extern const char *debugstr_DMUS_OBJ_FLAGS (DWORD flagmask); +extern const char *debugstr_DMUS_CONTAINER_FLAGS (DWORD flagmask); +extern const char *debugstr_DMUS_CONTAINED_OBJF_FLAGS (DWORD flagmask); +/* dump whole DMUS_OBJECTDESC struct */ +extern const char *debugstr_DMUS_OBJECTDESC (LPDMUS_OBJECTDESC pDesc); +extern void debug_DMUS_OBJECTDESC (LPDMUS_OBJECTDESC pDesc); +extern const char *debugstr_DMUS_IO_CONTAINER_HEADER (LPDMUS_IO_CONTAINER_HEADER pHeader); +extern const char *debugstr_DMUS_IO_CONTAINED_OBJECT_HEADER (LPDMUS_IO_CONTAINED_OBJECT_HEADER pHeader); + +#endif /* __WINE_DMUTILS_H */ diff --git a/dlls/dmime/Makefile.in b/dlls/dmime/Makefile.in index e9417eaf63f..1ce9ee6ec50 100644 --- a/dlls/dmime/Makefile.in +++ b/dlls/dmime/Makefile.in @@ -9,6 +9,7 @@ EXTRALIBS = -ldxguid -luuid C_SRCS = \ audiopath.c \ dmime_main.c \ + dmutils.c \ graph.c \ lyricstrack.c \ markertrack.c \ diff --git a/dlls/dmime/dmime_main.c b/dlls/dmime/dmime_main.c index 2532ed1f5f6..56521a4216e 100644 --- a/dlls/dmime/dmime_main.c +++ b/dlls/dmime/dmime_main.c @@ -730,532 +730,3 @@ HRESULT WINAPI DMIME_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv WARN("(%s, %s, %p): no interface found.\n", debugstr_dmguid(rclsid), debugstr_dmguid(riid), ppv); return CLASS_E_CLASSNOTAVAILABLE; } - - -/****************************************************************** - * Helper functions - * - * - */ -/* check whether the given DWORD is even (return 0) or odd (return 1) */ -int even_or_odd (DWORD number) { - return (number & 0x1); /* basically, check if bit 0 is set ;) */ -} - -/* FOURCC to string conversion for debug messages */ -const char *debugstr_fourcc (DWORD fourcc) { - if (!fourcc) return "'null'"; - return wine_dbg_sprintf ("\'%c%c%c%c\'", - (char)(fourcc), (char)(fourcc >> 8), - (char)(fourcc >> 16), (char)(fourcc >> 24)); -} - -/* DMUS_VERSION struct to string conversion for debug messages */ -const char *debugstr_dmversion (LPDMUS_VERSION version) { - if (!version) return "'null'"; - return wine_dbg_sprintf ("\'%i,%i,%i,%i\'", - (int)((version->dwVersionMS && 0xFFFF0000) >> 8), (int)(version->dwVersionMS && 0x0000FFFF), - (int)((version->dwVersionLS && 0xFFFF0000) >> 8), (int)(version->dwVersionLS && 0x0000FFFF)); -} - -/* returns name of given GUID */ -const char *debugstr_dmguid (const GUID *id) { - static const guid_info guids[] = { - /* CLSIDs */ - GE(CLSID_AudioVBScript), - GE(CLSID_DirectMusic), - GE(CLSID_DirectMusicAudioPath), - GE(CLSID_DirectMusicAudioPathConfig), - GE(CLSID_DirectMusicAuditionTrack), - GE(CLSID_DirectMusicBand), - GE(CLSID_DirectMusicBandTrack), - GE(CLSID_DirectMusicChordMapTrack), - GE(CLSID_DirectMusicChordMap), - GE(CLSID_DirectMusicChordTrack), - GE(CLSID_DirectMusicCollection), - GE(CLSID_DirectMusicCommandTrack), - GE(CLSID_DirectMusicComposer), - GE(CLSID_DirectMusicContainer), - GE(CLSID_DirectMusicGraph), - GE(CLSID_DirectMusicLoader), - GE(CLSID_DirectMusicLyricsTrack), - GE(CLSID_DirectMusicMarkerTrack), - GE(CLSID_DirectMusicMelodyFormulationTrack), - GE(CLSID_DirectMusicMotifTrack), - GE(CLSID_DirectMusicMuteTrack), - GE(CLSID_DirectMusicParamControlTrack), - GE(CLSID_DirectMusicPatternTrack), - GE(CLSID_DirectMusicPerformance), - GE(CLSID_DirectMusicScript), - GE(CLSID_DirectMusicScriptAutoImpSegment), - GE(CLSID_DirectMusicScriptAutoImpPerformance), - GE(CLSID_DirectMusicScriptAutoImpSegmentState), - GE(CLSID_DirectMusicScriptAutoImpAudioPathConfig), - GE(CLSID_DirectMusicScriptAutoImpAudioPath), - GE(CLSID_DirectMusicScriptAutoImpSong), - GE(CLSID_DirectMusicScriptSourceCodeLoader), - GE(CLSID_DirectMusicScriptTrack), - GE(CLSID_DirectMusicSection), - GE(CLSID_DirectMusicSegment), - GE(CLSID_DirectMusicSegmentState), - GE(CLSID_DirectMusicSegmentTriggerTrack), - GE(CLSID_DirectMusicSegTriggerTrack), - GE(CLSID_DirectMusicSeqTrack), - GE(CLSID_DirectMusicSignPostTrack), - GE(CLSID_DirectMusicSong), - GE(CLSID_DirectMusicStyle), - GE(CLSID_DirectMusicStyleTrack), - GE(CLSID_DirectMusicSynth), - GE(CLSID_DirectMusicSynthSink), - GE(CLSID_DirectMusicSysExTrack), - GE(CLSID_DirectMusicTemplate), - GE(CLSID_DirectMusicTempoTrack), - GE(CLSID_DirectMusicTimeSigTrack), - GE(CLSID_DirectMusicWaveTrack), - GE(CLSID_DirectSoundWave), - /* IIDs */ - GE(IID_IDirectMusic), - GE(IID_IDirectMusic2), - GE(IID_IDirectMusic8), - GE(IID_IDirectMusicAudioPath), - GE(IID_IDirectMusicBand), - GE(IID_IDirectMusicBuffer), - GE(IID_IDirectMusicChordMap), - GE(IID_IDirectMusicCollection), - GE(IID_IDirectMusicComposer), - GE(IID_IDirectMusicContainer), - GE(IID_IDirectMusicDownload), - GE(IID_IDirectMusicDownloadedInstrument), - GE(IID_IDirectMusicGetLoader), - GE(IID_IDirectMusicGraph), - GE(IID_IDirectMusicInstrument), - GE(IID_IDirectMusicLoader), - GE(IID_IDirectMusicLoader8), - GE(IID_IDirectMusicObject), - GE(IID_IDirectMusicPatternTrack), - GE(IID_IDirectMusicPerformance), - GE(IID_IDirectMusicPerformance2), - GE(IID_IDirectMusicPerformance8), - GE(IID_IDirectMusicPort), - GE(IID_IDirectMusicPortDownload), - GE(IID_IDirectMusicScript), - GE(IID_IDirectMusicSegment), - GE(IID_IDirectMusicSegment2), - GE(IID_IDirectMusicSegment8), - GE(IID_IDirectMusicSegmentState), - GE(IID_IDirectMusicSegmentState8), - GE(IID_IDirectMusicStyle), - GE(IID_IDirectMusicStyle8), - GE(IID_IDirectMusicSynth), - GE(IID_IDirectMusicSynth8), - GE(IID_IDirectMusicSynthSink), - GE(IID_IDirectMusicThru), - GE(IID_IDirectMusicTool), - GE(IID_IDirectMusicTool8), - GE(IID_IDirectMusicTrack), - GE(IID_IDirectMusicTrack8), - GE(IID_IUnknown), - GE(IID_IPersistStream), - GE(IID_IStream), - GE(IID_IClassFactory), - /* GUIDs */ - GE(GUID_DirectMusicAllTypes), - GE(GUID_NOTIFICATION_CHORD), - GE(GUID_NOTIFICATION_COMMAND), - GE(GUID_NOTIFICATION_MEASUREANDBEAT), - GE(GUID_NOTIFICATION_PERFORMANCE), - GE(GUID_NOTIFICATION_RECOMPOSE), - GE(GUID_NOTIFICATION_SEGMENT), - GE(GUID_BandParam), - GE(GUID_ChordParam), - GE(GUID_CommandParam), - GE(GUID_CommandParam2), - GE(GUID_CommandParamNext), - GE(GUID_IDirectMusicBand), - GE(GUID_IDirectMusicChordMap), - GE(GUID_IDirectMusicStyle), - GE(GUID_MuteParam), - GE(GUID_Play_Marker), - GE(GUID_RhythmParam), - GE(GUID_TempoParam), - GE(GUID_TimeSignature), - GE(GUID_Valid_Start_Time), - GE(GUID_Clear_All_Bands), - GE(GUID_ConnectToDLSCollection), - GE(GUID_Disable_Auto_Download), - GE(GUID_DisableTempo), - GE(GUID_DisableTimeSig), - GE(GUID_Download), - GE(GUID_DownloadToAudioPath), - GE(GUID_Enable_Auto_Download), - GE(GUID_EnableTempo), - GE(GUID_EnableTimeSig), - GE(GUID_IgnoreBankSelectForGM), - GE(GUID_SeedVariations), - GE(GUID_StandardMIDIFile), - GE(GUID_Unload), - GE(GUID_UnloadFromAudioPath), - GE(GUID_Variations), - GE(GUID_PerfMasterTempo), - GE(GUID_PerfMasterVolume), - GE(GUID_PerfMasterGrooveLevel), - GE(GUID_PerfAutoDownload), - GE(GUID_DefaultGMCollection), - GE(GUID_Synth_Default), - GE(GUID_Buffer_Reverb), - GE(GUID_Buffer_EnvReverb), - GE(GUID_Buffer_Stereo), - GE(GUID_Buffer_3D_Dry), - GE(GUID_Buffer_Mono), - GE(GUID_DMUS_PROP_GM_Hardware), - GE(GUID_DMUS_PROP_GS_Capable), - GE(GUID_DMUS_PROP_GS_Hardware), - GE(GUID_DMUS_PROP_DLS1), - GE(GUID_DMUS_PROP_DLS2), - GE(GUID_DMUS_PROP_Effects), - GE(GUID_DMUS_PROP_INSTRUMENT2), - GE(GUID_DMUS_PROP_LegacyCaps), - GE(GUID_DMUS_PROP_MemorySize), - GE(GUID_DMUS_PROP_SampleMemorySize), - GE(GUID_DMUS_PROP_SamplePlaybackRate), - GE(GUID_DMUS_PROP_SetSynthSink), - GE(GUID_DMUS_PROP_SinkUsesDSound), - GE(GUID_DMUS_PROP_SynthSink_DSOUND), - GE(GUID_DMUS_PROP_SynthSink_WAVE), - GE(GUID_DMUS_PROP_Volume), - GE(GUID_DMUS_PROP_WavesReverb), - GE(GUID_DMUS_PROP_WriteLatency), - GE(GUID_DMUS_PROP_WritePeriod), - GE(GUID_DMUS_PROP_XG_Capable), - GE(GUID_DMUS_PROP_XG_Hardware) - }; - - unsigned int i; - - if (!id) return "(null)"; - - for (i = 0; i < sizeof(guids)/sizeof(guids[0]); i++) { - if (IsEqualGUID(id, &guids[i].guid)) - return guids[i].name; - } - /* if we didn't find it, act like standard debugstr_guid */ - return debugstr_guid(id); -} - -/* returns name of given error code */ -const char *debugstr_dmreturn (DWORD code) { - static const flag_info codes[] = { - FE(S_OK), - FE(S_FALSE), - FE(DMUS_S_PARTIALLOAD), - FE(DMUS_S_PARTIALDOWNLOAD), - FE(DMUS_S_REQUEUE), - FE(DMUS_S_FREE), - FE(DMUS_S_END), - FE(DMUS_S_STRING_TRUNCATED), - FE(DMUS_S_LAST_TOOL), - FE(DMUS_S_OVER_CHORD), - FE(DMUS_S_UP_OCTAVE), - FE(DMUS_S_DOWN_OCTAVE), - FE(DMUS_S_NOBUFFERCONTROL), - FE(DMUS_S_GARBAGE_COLLECTED), - FE(DMUS_E_DRIVER_FAILED), - FE(DMUS_E_PORTS_OPEN), - FE(DMUS_E_DEVICE_IN_USE), - FE(DMUS_E_INSUFFICIENTBUFFER), - FE(DMUS_E_BUFFERNOTSET), - FE(DMUS_E_BUFFERNOTAVAILABLE), - FE(DMUS_E_NOTADLSCOL), - FE(DMUS_E_INVALIDOFFSET), - FE(DMUS_E_ALREADY_LOADED), - FE(DMUS_E_INVALIDPOS), - FE(DMUS_E_INVALIDPATCH), - FE(DMUS_E_CANNOTSEEK), - FE(DMUS_E_CANNOTWRITE), - FE(DMUS_E_CHUNKNOTFOUND), - FE(DMUS_E_INVALID_DOWNLOADID), - FE(DMUS_E_NOT_DOWNLOADED_TO_PORT), - FE(DMUS_E_ALREADY_DOWNLOADED), - FE(DMUS_E_UNKNOWN_PROPERTY), - FE(DMUS_E_SET_UNSUPPORTED), - FE(DMUS_E_GET_UNSUPPORTED), - FE(DMUS_E_NOTMONO), - FE(DMUS_E_BADARTICULATION), - FE(DMUS_E_BADINSTRUMENT), - FE(DMUS_E_BADWAVELINK), - FE(DMUS_E_NOARTICULATION), - FE(DMUS_E_NOTPCM), - FE(DMUS_E_BADWAVE), - FE(DMUS_E_BADOFFSETTABLE), - FE(DMUS_E_UNKNOWNDOWNLOAD), - FE(DMUS_E_NOSYNTHSINK), - FE(DMUS_E_ALREADYOPEN), - FE(DMUS_E_ALREADYCLOSED), - FE(DMUS_E_SYNTHNOTCONFIGURED), - FE(DMUS_E_SYNTHACTIVE), - FE(DMUS_E_CANNOTREAD), - FE(DMUS_E_DMUSIC_RELEASED), - FE(DMUS_E_BUFFER_EMPTY), - FE(DMUS_E_BUFFER_FULL), - FE(DMUS_E_PORT_NOT_CAPTURE), - FE(DMUS_E_PORT_NOT_RENDER), - FE(DMUS_E_DSOUND_NOT_SET), - FE(DMUS_E_ALREADY_ACTIVATED), - FE(DMUS_E_INVALIDBUFFER), - FE(DMUS_E_WAVEFORMATNOTSUPPORTED), - FE(DMUS_E_SYNTHINACTIVE), - FE(DMUS_E_DSOUND_ALREADY_SET), - FE(DMUS_E_INVALID_EVENT), - FE(DMUS_E_UNSUPPORTED_STREAM), - FE(DMUS_E_ALREADY_INITED), - FE(DMUS_E_INVALID_BAND), - FE(DMUS_E_TRACK_HDR_NOT_FIRST_CK), - FE(DMUS_E_TOOL_HDR_NOT_FIRST_CK), - FE(DMUS_E_INVALID_TRACK_HDR), - FE(DMUS_E_INVALID_TOOL_HDR), - FE(DMUS_E_ALL_TOOLS_FAILED), - FE(DMUS_E_ALL_TRACKS_FAILED), - FE(DMUS_E_NOT_FOUND), - FE(DMUS_E_NOT_INIT), - FE(DMUS_E_TYPE_DISABLED), - FE(DMUS_E_TYPE_UNSUPPORTED), - FE(DMUS_E_TIME_PAST), - FE(DMUS_E_TRACK_NOT_FOUND), - FE(DMUS_E_TRACK_NO_CLOCKTIME_SUPPORT), - FE(DMUS_E_NO_MASTER_CLOCK), - FE(DMUS_E_LOADER_NOCLASSID), - FE(DMUS_E_LOADER_BADPATH), - FE(DMUS_E_LOADER_FAILEDOPEN), - FE(DMUS_E_LOADER_FORMATNOTSUPPORTED), - FE(DMUS_E_LOADER_FAILEDCREATE), - FE(DMUS_E_LOADER_OBJECTNOTFOUND), - FE(DMUS_E_LOADER_NOFILENAME), - FE(DMUS_E_INVALIDFILE), - FE(DMUS_E_ALREADY_EXISTS), - FE(DMUS_E_OUT_OF_RANGE), - FE(DMUS_E_SEGMENT_INIT_FAILED), - FE(DMUS_E_ALREADY_SENT), - FE(DMUS_E_CANNOT_FREE), - FE(DMUS_E_CANNOT_OPEN_PORT), - FE(DMUS_E_CANNOT_CONVERT), - FE(DMUS_E_DESCEND_CHUNK_FAIL), - FE(DMUS_E_NOT_LOADED), - FE(DMUS_E_SCRIPT_LANGUAGE_INCOMPATIBLE), - FE(DMUS_E_SCRIPT_UNSUPPORTED_VARTYPE), - FE(DMUS_E_SCRIPT_ERROR_IN_SCRIPT), - FE(DMUS_E_SCRIPT_CANTLOAD_OLEAUT32), - FE(DMUS_E_SCRIPT_LOADSCRIPT_ERROR), - FE(DMUS_E_SCRIPT_INVALID_FILE), - FE(DMUS_E_INVALID_SCRIPTTRACK), - FE(DMUS_E_SCRIPT_VARIABLE_NOT_FOUND), - FE(DMUS_E_SCRIPT_ROUTINE_NOT_FOUND), - FE(DMUS_E_SCRIPT_CONTENT_READONLY), - FE(DMUS_E_SCRIPT_NOT_A_REFERENCE), - FE(DMUS_E_SCRIPT_VALUE_NOT_SUPPORTED), - FE(DMUS_E_INVALID_SEGMENTTRIGGERTRACK), - FE(DMUS_E_INVALID_LYRICSTRACK), - FE(DMUS_E_INVALID_PARAMCONTROLTRACK), - FE(DMUS_E_AUDIOVBSCRIPT_SYNTAXERROR), - FE(DMUS_E_AUDIOVBSCRIPT_RUNTIMEERROR), - FE(DMUS_E_AUDIOVBSCRIPT_OPERATIONFAILURE), - FE(DMUS_E_AUDIOPATHS_NOT_VALID), - FE(DMUS_E_AUDIOPATHS_IN_USE), - FE(DMUS_E_NO_AUDIOPATH_CONFIG), - FE(DMUS_E_AUDIOPATH_INACTIVE), - FE(DMUS_E_AUDIOPATH_NOBUFFER), - FE(DMUS_E_AUDIOPATH_NOPORT), - FE(DMUS_E_NO_AUDIOPATH), - FE(DMUS_E_INVALIDCHUNK), - FE(DMUS_E_AUDIOPATH_NOGLOBALFXBUFFER), - FE(DMUS_E_INVALID_CONTAINER_OBJECT) - }; - unsigned int i; - for (i = 0; i < sizeof(codes)/sizeof(codes[0]); i++) { - if (code == codes[i].val) - return codes[i].name; - } - /* if we didn't find it, return value */ - return wine_dbg_sprintf("0x%08lx", code); -} - -/* generic flag-dumping function */ -const char* debugstr_flags (DWORD flags, const flag_info* names, size_t num_names){ - char buffer[128] = "", *ptr = &buffer[0]; - unsigned int i, size = sizeof(buffer); - - for (i=0; i < num_names; i++) - { - if ((flags & names[i].val) || /* standard flag*/ - ((!flags) && (!names[i].val))) { /* zero value only */ - int cnt = snprintf(ptr, size, "%s ", names[i].name); - if (cnt < 0 || cnt >= size) break; - size -= cnt; - ptr += cnt; - } - } - - return wine_dbg_sprintf("%s", buffer); -} - -/* dump DMUS_OBJ flags */ -const char *debugstr_DMUS_OBJ_FLAGS (DWORD flagmask) { - static const flag_info flags[] = { - FE(DMUS_OBJ_OBJECT), - FE(DMUS_OBJ_CLASS), - FE(DMUS_OBJ_NAME), - FE(DMUS_OBJ_CATEGORY), - FE(DMUS_OBJ_FILENAME), - FE(DMUS_OBJ_FULLPATH), - FE(DMUS_OBJ_URL), - FE(DMUS_OBJ_VERSION), - FE(DMUS_OBJ_DATE), - FE(DMUS_OBJ_LOADED), - FE(DMUS_OBJ_MEMORY), - FE(DMUS_OBJ_STREAM) - }; - return debugstr_flags (flagmask, flags, sizeof(flags)/sizeof(flags[0])); -} - -/* dump whole DMUS_OBJECTDESC struct */ -const char *debugstr_DMUS_OBJECTDESC (LPDMUS_OBJECTDESC pDesc) { - if (pDesc) { - TRACE("DMUS_OBJECTDESC (%p):\n", pDesc); - TRACE(" - dwSize = %ld\n", pDesc->dwSize); - TRACE(" - dwValidData = %s\n", debugstr_DMUS_OBJ_FLAGS (pDesc->dwValidData)); - if (pDesc->dwValidData & DMUS_OBJ_NAME) TRACE(" - wszName = %s\n", debugstr_w(pDesc->wszName)); - if (pDesc->dwValidData & DMUS_OBJ_CLASS) TRACE(" - guidClass = %s\n", debugstr_dmguid(&pDesc->guidClass)); - if (pDesc->dwValidData & DMUS_OBJ_OBJECT) TRACE(" - guidObject = %s\n", debugstr_guid(&pDesc->guidObject)); - if (pDesc->dwValidData & DMUS_OBJ_DATE) TRACE(" - ftDate = FIXME\n"); - if (pDesc->dwValidData & DMUS_OBJ_VERSION) TRACE(" - vVersion = %s\n", debugstr_dmversion(&pDesc->vVersion)); - if (pDesc->dwValidData & DMUS_OBJ_CATEGORY) TRACE(" - wszCategory = %s\n", debugstr_w(pDesc->wszCategory)); - if (pDesc->dwValidData & DMUS_OBJ_FILENAME) TRACE(" - wszFileName = %s\n", debugstr_w(pDesc->wszFileName)); - if (pDesc->dwValidData & DMUS_OBJ_MEMORY) TRACE(" - llMemLength = %lli\n - pbMemData = %p\n", pDesc->llMemLength, pDesc->pbMemData); - if (pDesc->dwValidData & DMUS_OBJ_STREAM) TRACE(" - pStream = %p\n", pDesc->pStream); - } else { - TRACE("(NULL)\n"); - }/* - if (pDesc) { - char buffer[1024] = "", *ptr = &buffer[0]; - - ptr += sprintf(ptr, "DMUS_OBJECTDESC (%p):\n", pDesc); - ptr += sprintf(ptr, " - dwSize = %ld\n", pDesc->dwSize); - ptr += sprintf(ptr, " - dwValidData = %s\n", debugstr_DMUS_OBJ_FLAGS (pDesc->dwValidData)); - if (pDesc->dwValidData & DMUS_OBJ_CLASS) ptr += sprintf(ptr, " - guidClass = %s\n", debugstr_dmguid(&pDesc->guidClass)); - if (pDesc->dwValidData & DMUS_OBJ_OBJECT) ptr += sprintf(ptr, " - guidObject = %s\n", debugstr_guid(&pDesc->guidObject)); - if (pDesc->dwValidData & DMUS_OBJ_DATE) ptr += sprintf(ptr, " - ftDate = FIXME\n"); - if (pDesc->dwValidData & DMUS_OBJ_VERSION) ptr += sprintf(ptr, " - vVersion = %s\n", debugstr_dmversion(&pDesc->vVersion)); - if (pDesc->dwValidData & DMUS_OBJ_NAME) ptr += sprintf(ptr, " - wszName = %s\n", debugstr_w(pDesc->wszName)); - if (pDesc->dwValidData & DMUS_OBJ_CATEGORY) ptr += sprintf(ptr, " - wszCategory = %s\n", debugstr_w(pDesc->wszCategory)); - if (pDesc->dwValidData & DMUS_OBJ_FILENAME) ptr += sprintf(ptr, " - wszFileName = %s\n", debugstr_w(pDesc->wszFileName)); - if (pDesc->dwValidData & DMUS_OBJ_MEMORY) ptr += sprintf(ptr, " - llMemLength = %lli\n - pbMemData = %p\n", pDesc->llMemLength, pDesc->pbMemData); - if (pDesc->dwValidData & DMUS_OBJ_STREAM) ptr += sprintf(ptr, " - pStream = %p", pDesc->pStream); - - return wine_dbg_sprintf("%s", buffer); - } else { - return wine_dbg_sprintf("(NULL)"); - } - */ - return "X"; -} - -HRESULT IDirectMusicImpl_IPersistStream_ParseDescGeneric (DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm, LPDMUS_OBJECTDESC pDesc) { - - switch (pChunk->fccID) { - case DMUS_FOURCC_GUID_CHUNK: { - TRACE_(dmfile)(": GUID chunk\n"); - pDesc->dwValidData |= DMUS_OBJ_OBJECT; - IStream_Read (pStm, &pDesc->guidObject, pChunk->dwSize, NULL); - break; - } - case DMUS_FOURCC_DATE_CHUNK: { - TRACE_(dmfile)(": file date chunk\n"); - pDesc->dwValidData |= DMUS_OBJ_DATE; - IStream_Read (pStm, &pDesc->ftDate, pChunk->dwSize, NULL); - break; - } - case DMUS_FOURCC_NAME_CHUNK: { - TRACE_(dmfile)(": name chunk\n"); - pDesc->dwValidData |= DMUS_OBJ_NAME; - IStream_Read (pStm, &pDesc->wszName, pChunk->dwSize, NULL); - break; - } - case DMUS_FOURCC_FILE_CHUNK: { - TRACE_(dmfile)(": file name chunk\n"); - pDesc->dwValidData |= DMUS_OBJ_FILENAME; - IStream_Read (pStm, &pDesc->wszFileName, pChunk->dwSize, NULL); - break; - } - case DMUS_FOURCC_VERSION_CHUNK: { - TRACE_(dmfile)(": version chunk\n"); - pDesc->dwValidData |= DMUS_OBJ_VERSION; - IStream_Read (pStm, &pDesc->vVersion, pChunk->dwSize, NULL); - break; - } - case DMUS_FOURCC_CATEGORY_CHUNK: { - TRACE_(dmfile)(": category chunk\n"); - pDesc->dwValidData |= DMUS_OBJ_CATEGORY; - IStream_Read (pStm, pDesc->wszCategory, pChunk->dwSize, NULL); - break; - } - default: - /* not handled */ - return S_FALSE; - } - - return S_OK; -} - -HRESULT IDirectMusicImpl_IPersistStream_ParseUNFOGeneric (DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm, LPDMUS_OBJECTDESC pDesc) { - - LARGE_INTEGER liMove; /* used when skipping chunks */ - - /** - * don't ask me why, but M$ puts INFO elements in UNFO list sometimes - * (though strings seem to be valid unicode) - */ - switch (pChunk->fccID) { - - case mmioFOURCC('I','N','A','M'): - case DMUS_FOURCC_UNAM_CHUNK: { - TRACE_(dmfile)(": name chunk\n"); - pDesc->dwValidData |= DMUS_OBJ_NAME; - IStream_Read (pStm, pDesc->wszName, pChunk->dwSize, NULL); - - break; - } - - case mmioFOURCC('I','A','R','T'): - case DMUS_FOURCC_UART_CHUNK: { - TRACE_(dmfile)(": artist chunk (ignored)\n"); - liMove.QuadPart = pChunk->dwSize; - IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); - break; - } - case mmioFOURCC('I','C','O','P'): - case DMUS_FOURCC_UCOP_CHUNK: { - TRACE_(dmfile)(": copyright chunk (ignored)\n"); - liMove.QuadPart = pChunk->dwSize; - IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); - break; - } - case mmioFOURCC('I','S','B','J'): - case DMUS_FOURCC_USBJ_CHUNK: { - TRACE_(dmfile)(": subject chunk (ignored)\n"); - liMove.QuadPart = pChunk->dwSize; - IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); - break; - } - case mmioFOURCC('I','C','M','T'): - case DMUS_FOURCC_UCMT_CHUNK: { - TRACE_(dmfile)(": comment chunk (ignored)\n"); - liMove.QuadPart = pChunk->dwSize; - IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); - break; - } - default: - /* not handled */ - return S_FALSE; - } - - return S_OK; -} diff --git a/dlls/dmime/dmime_private.h b/dlls/dmime/dmime_private.h index 5a54fb84f07..f6df8ce4b5e 100644 --- a/dlls/dmime/dmime_private.h +++ b/dlls/dmime/dmime_private.h @@ -919,50 +919,7 @@ extern HRESULT WINAPI IDirectMusicWaveTrack_IPersistStream_GetSizeMax (LPPERSIST /***************************************************************************** * Misc. */ -/* for simpler reading */ -typedef struct _DMUS_PRIVATE_CHUNK { - FOURCC fccID; /* FOURCC ID of the chunk */ - DWORD dwSize; /* size of the chunk */ -} DMUS_PRIVATE_CHUNK, *LPDMUS_PRIVATE_CHUNK; -/* used for generic dumping (copied from ddraw) */ -typedef struct { - DWORD val; - const char* name; -} flag_info; - -typedef struct { - const GUID *guid; - const char* name; -} guid_info; - -/* used for initialising structs (primarily for DMUS_OBJECTDESC) */ -#define DM_STRUCT_INIT(x) \ - do { \ - memset((x), 0, sizeof(*(x))); \ - (x)->dwSize = sizeof(*x); \ - } while (0) - -#define FE(x) { x, #x } -#define GE(x) { &x, #x } - -/* check whether the given DWORD is even (return 0) or odd (return 1) */ -extern int even_or_odd (DWORD number); -/* FOURCC to string conversion for debug messages */ -extern const char *debugstr_fourcc (DWORD fourcc); -/* DMUS_VERSION struct to string conversion for debug messages */ -extern const char *debugstr_dmversion (LPDMUS_VERSION version); -/* returns name of given GUID */ -extern const char *debugstr_dmguid (const GUID *id); -/* returns name of given error code */ -extern const char *debugstr_dmreturn (DWORD code); -/* generic flags-dumping function */ -extern const char *debugstr_flags (DWORD flags, const flag_info* names, size_t num_names); -extern const char *debugstr_DMUS_OBJ_FLAGS (DWORD flagmask); -/* dump whole DMUS_OBJECTDESC struct */ -extern const char *debugstr_DMUS_OBJECTDESC (LPDMUS_OBJECTDESC pDesc); - -HRESULT IDirectMusicImpl_IPersistStream_ParseDescGeneric (DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm, LPDMUS_OBJECTDESC pDesc); -HRESULT IDirectMusicImpl_IPersistStream_ParseUNFOGeneric (DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm, LPDMUS_OBJECTDESC pDesc); +#include "dmutils.h" #endif /* __WINE_DMIME_PRIVATE_H */ diff --git a/dlls/dmime/dmutils.c b/dlls/dmime/dmutils.c new file mode 100644 index 00000000000..3da649d3a05 --- /dev/null +++ b/dlls/dmime/dmutils.c @@ -0,0 +1,752 @@ +/* Debug and Helper Functions + * + * Copyright (C) 2004 Rok Mandeljc + * Copyright (C) 2004 Raphael Junqueira + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program 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 Library General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include +#include +#include + +#include "windef.h" +#include "winbase.h" +#include "winnt.h" +#include "wingdi.h" +#include "winuser.h" + +#include "wine/debug.h" +#include "wine/list.h" +#include "wine/unicode.h" +#include "winreg.h" + +#include "dmusici.h" +#include "dmusicf.h" +#include "dmusics.h" + +#include "dmutils.h" + +WINE_DEFAULT_DEBUG_CHANNEL(dmusic); +WINE_DECLARE_DEBUG_CHANNEL(dmfile); + +/* check whether the given DWORD is even (return 0) or odd (return 1) */ +int even_or_odd (DWORD number) { + return (number & 0x1); /* basically, check if bit 0 is set ;) */ +} + +/* figures out whether given FOURCC is valid DirectMusic form ID */ +BOOL IS_VALID_DMFORM (FOURCC chunkID) { + if ((chunkID == DMUS_FOURCC_AUDIOPATH_FORM) || (chunkID == DMUS_FOURCC_BAND_FORM) || (chunkID == DMUS_FOURCC_CHORDMAP_FORM) + || (chunkID == DMUS_FOURCC_CONTAINER_FORM) || (chunkID == FOURCC_DLS) || (chunkID == DMUS_FOURCC_SCRIPT_FORM) + || (chunkID == DMUS_FOURCC_SEGMENT_FORM) || (chunkID == DMUS_FOURCC_STYLE_FORM) || (chunkID == DMUS_FOURCC_TOOLGRAPH_FORM) + || (chunkID == DMUS_FOURCC_TRACK_FORM) || (chunkID == mmioFOURCC('W','A','V','E'))) return TRUE; + else return FALSE; +} + +HRESULT IDirectMusicUtils_IPersistStream_ParseDescGeneric (DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm, LPDMUS_OBJECTDESC pDesc) { + + switch (pChunk->fccID) { + case DMUS_FOURCC_GUID_CHUNK: { + TRACE_(dmfile)(": GUID chunk\n"); + pDesc->dwValidData |= DMUS_OBJ_OBJECT; + IStream_Read (pStm, &pDesc->guidObject, pChunk->dwSize, NULL); + break; + } + case DMUS_FOURCC_DATE_CHUNK: { + TRACE_(dmfile)(": file date chunk\n"); + pDesc->dwValidData |= DMUS_OBJ_DATE; + IStream_Read (pStm, &pDesc->ftDate, pChunk->dwSize, NULL); + break; + } + case DMUS_FOURCC_NAME_CHUNK: { + TRACE_(dmfile)(": name chunk\n"); + pDesc->dwValidData |= DMUS_OBJ_NAME; + IStream_Read (pStm, &pDesc->wszName, pChunk->dwSize, NULL); + break; + } + case DMUS_FOURCC_FILE_CHUNK: { + TRACE_(dmfile)(": file name chunk\n"); + pDesc->dwValidData |= DMUS_OBJ_FILENAME; + IStream_Read (pStm, &pDesc->wszFileName, pChunk->dwSize, NULL); + break; + } + case DMUS_FOURCC_VERSION_CHUNK: { + TRACE_(dmfile)(": version chunk\n"); + pDesc->dwValidData |= DMUS_OBJ_VERSION; + IStream_Read (pStm, &pDesc->vVersion, pChunk->dwSize, NULL); + break; + } + case DMUS_FOURCC_CATEGORY_CHUNK: { + TRACE_(dmfile)(": category chunk\n"); + pDesc->dwValidData |= DMUS_OBJ_CATEGORY; + IStream_Read (pStm, pDesc->wszCategory, pChunk->dwSize, NULL); + break; + } + default: + /* not handled */ + return S_FALSE; + } + + return S_OK; +} + +HRESULT IDirectMusicUtils_IPersistStream_ParseUNFOGeneric (DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm, LPDMUS_OBJECTDESC pDesc) { + + LARGE_INTEGER liMove; /* used when skipping chunks */ + + /** + * don't ask me why, but M$ puts INFO elements in UNFO list sometimes + * (though strings seem to be valid unicode) + */ + switch (pChunk->fccID) { + + case mmioFOURCC('I','N','A','M'): + case DMUS_FOURCC_UNAM_CHUNK: { + TRACE_(dmfile)(": name chunk\n"); + pDesc->dwValidData |= DMUS_OBJ_NAME; + IStream_Read (pStm, pDesc->wszName, pChunk->dwSize, NULL); + TRACE_(dmfile)(" - wszName: %s\n", debugstr_w(pDesc->wszName)); + break; + } + + case mmioFOURCC('I','A','R','T'): + case DMUS_FOURCC_UART_CHUNK: { + TRACE_(dmfile)(": artist chunk (ignored)\n"); + liMove.QuadPart = pChunk->dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + case mmioFOURCC('I','C','O','P'): + case DMUS_FOURCC_UCOP_CHUNK: { + TRACE_(dmfile)(": copyright chunk (ignored)\n"); + liMove.QuadPart = pChunk->dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + case mmioFOURCC('I','S','B','J'): + case DMUS_FOURCC_USBJ_CHUNK: { + TRACE_(dmfile)(": subject chunk (ignored)\n"); + liMove.QuadPart = pChunk->dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + case mmioFOURCC('I','C','M','T'): + case DMUS_FOURCC_UCMT_CHUNK: { + TRACE_(dmfile)(": comment chunk (ignored)\n"); + liMove.QuadPart = pChunk->dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + default: + /* not handled */ + return S_FALSE; + } + + return S_OK; +} + +HRESULT IDirectMusicUtils_IPersistStream_ParseReference (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm, IDirectMusicObject** ppObject) { + DMUS_PRIVATE_CHUNK Chunk; + DWORD ListSize[3], ListCount[3]; + LARGE_INTEGER liMove; /* used when skipping chunks */ + HRESULT hr; + + DMUS_IO_REFERENCE ref; + DMUS_OBJECTDESC ref_desc; + + memset(&ref, 0, sizeof(ref)); + memset(&ref_desc, 0, sizeof(ref_desc)); + + if (pChunk->fccID != DMUS_FOURCC_REF_LIST) { + ERR_(dmfile)(": %s chunk should be a REF list\n", debugstr_fourcc (pChunk->fccID)); + return E_FAIL; + } + + ListSize[0] = pChunk->dwSize - sizeof(FOURCC); + ListCount[0] = 0; + + do { + IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL); + ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize; + TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize); + + hr = IDirectMusicUtils_IPersistStream_ParseDescGeneric(&Chunk, pStm, &ref_desc); + if (FAILED(hr)) return hr; + + if (hr == S_FALSE) { + switch (Chunk.fccID) { + case DMUS_FOURCC_REF_CHUNK: { + TRACE_(dmfile)(": Reference chunk\n"); + if (Chunk.dwSize != sizeof(DMUS_IO_REFERENCE)) return E_FAIL; + IStream_Read (pStm, &ref, sizeof(DMUS_IO_REFERENCE), NULL); + TRACE_(dmfile)(" - guidClassID: %s\n", debugstr_dmguid(&ref.guidClassID)); + TRACE_(dmfile)(" - dwValidData: %lu\n", ref.dwValidData); + break; + } + default: { + TRACE_(dmfile)(": unknown chunk (irrevelant & skipping)\n"); + liMove.QuadPart = Chunk.dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + } + } + TRACE_(dmfile)(": ListCount[0] = %ld < ListSize[0] = %ld\n", ListCount[0], ListSize[0]); + } while (ListCount[0] < ListSize[0]); + + ref_desc.dwValidData |= DMUS_OBJ_CLASS; + memcpy(&ref_desc.guidClass, &ref.guidClassID, sizeof(ref.guidClassID)); + + TRACE_(dmfile)("** DM Reference Begin of Load ***\n"); + TRACE_(dmfile)("With Desc:\n"); + debugstr_DMUS_OBJECTDESC(&ref_desc); + + { + LPDIRECTMUSICGETLOADER pGetLoader = NULL; + LPDIRECTMUSICLOADER pLoader = NULL; + + IStream_QueryInterface (pStm, &IID_IDirectMusicGetLoader, (LPVOID*)&pGetLoader); + IDirectMusicGetLoader_GetLoader (pGetLoader, &pLoader); + IDirectMusicGetLoader_Release (pGetLoader); + + hr = IDirectMusicLoader_GetObject (pLoader, &ref_desc, &IID_IDirectMusicObject, (LPVOID*)ppObject); + IDirectMusicLoader_Release (pLoader); /* release loader */ + } + TRACE_(dmfile)("** DM Reference End of Load ***\n"); + + return S_OK; +} + +/* translate STREAM_SEEK flag to string */ +const char *resolve_STREAM_SEEK (DWORD flag) { + switch (flag) { + case STREAM_SEEK_SET: + return wine_dbg_sprintf ("STREAM_SEEK_SET"); + case STREAM_SEEK_CUR: + return wine_dbg_sprintf ("STREAM_SEEK_CUR"); + case STREAM_SEEK_END: + return wine_dbg_sprintf ("STREAM_SEEK_END"); + default: + return wine_dbg_sprintf ("()"); + } +} + +/* FOURCC to string conversion for debug messages */ +const char *debugstr_fourcc (DWORD fourcc) { + if (!fourcc) return "'null'"; + return wine_dbg_sprintf ("\'%c%c%c%c\'", + (char)(fourcc), (char)(fourcc >> 8), + (char)(fourcc >> 16), (char)(fourcc >> 24)); +} + +/* DMUS_VERSION struct to string conversion for debug messages */ +const char *debugstr_dmversion (LPDMUS_VERSION version) { + if (!version) return "'null'"; + return wine_dbg_sprintf ("\'%i,%i,%i,%i\'", + HIWORD(version->dwVersionMS),LOWORD(version->dwVersionMS), + HIWORD(version->dwVersionLS), LOWORD(version->dwVersionLS)); +} + +/* month number into month name (for debugstr_filetime) */ +const char *debugstr_month (DWORD dwMonth) { + switch (dwMonth) { + case 1: return "January"; + case 2: return "February"; + case 3: return "March"; + case 4: return "April"; + case 5: return "May"; + case 6: return "June"; + case 7: return "July"; + case 8: return "August"; + case 9: return "September"; + case 10: return "October"; + case 11: return "November"; + case 12: return "December"; + default: return "Invalid"; + } +} + +/* FILETIME struct to string conversion for debug messages */ +const char *debugstr_filetime (LPFILETIME time) { + SYSTEMTIME sysTime; + + if (!time) return "'null'"; + + FileTimeToSystemTime (time, &sysTime); + + return wine_dbg_sprintf ("\'%02i. %s %04i %02i:%02i:%02i\'", \ + sysTime.wDay, debugstr_month(sysTime.wMonth), sysTime.wYear, + sysTime.wHour, sysTime.wMinute, sysTime.wSecond); +} + +/* returns name of given GUID */ +const char *debugstr_dmguid (const GUID *id) { + static const guid_info guids[] = { + /* CLSIDs */ + GE(CLSID_AudioVBScript), + GE(CLSID_DirectMusic), + GE(CLSID_DirectMusicAudioPath), + GE(CLSID_DirectMusicAudioPathConfig), + GE(CLSID_DirectMusicAuditionTrack), + GE(CLSID_DirectMusicBand), + GE(CLSID_DirectMusicBandTrack), + GE(CLSID_DirectMusicChordMapTrack), + GE(CLSID_DirectMusicChordMap), + GE(CLSID_DirectMusicChordTrack), + GE(CLSID_DirectMusicCollection), + GE(CLSID_DirectMusicCommandTrack), + GE(CLSID_DirectMusicComposer), + GE(CLSID_DirectMusicContainer), + GE(CLSID_DirectMusicGraph), + GE(CLSID_DirectMusicLoader), + GE(CLSID_DirectMusicLyricsTrack), + GE(CLSID_DirectMusicMarkerTrack), + GE(CLSID_DirectMusicMelodyFormulationTrack), + GE(CLSID_DirectMusicMotifTrack), + GE(CLSID_DirectMusicMuteTrack), + GE(CLSID_DirectMusicParamControlTrack), + GE(CLSID_DirectMusicPatternTrack), + GE(CLSID_DirectMusicPerformance), + GE(CLSID_DirectMusicScript), + GE(CLSID_DirectMusicScriptAutoImpSegment), + GE(CLSID_DirectMusicScriptAutoImpPerformance), + GE(CLSID_DirectMusicScriptAutoImpSegmentState), + GE(CLSID_DirectMusicScriptAutoImpAudioPathConfig), + GE(CLSID_DirectMusicScriptAutoImpAudioPath), + GE(CLSID_DirectMusicScriptAutoImpSong), + GE(CLSID_DirectMusicScriptSourceCodeLoader), + GE(CLSID_DirectMusicScriptTrack), + GE(CLSID_DirectMusicSection), + GE(CLSID_DirectMusicSegment), + GE(CLSID_DirectMusicSegmentState), + GE(CLSID_DirectMusicSegmentTriggerTrack), + GE(CLSID_DirectMusicSegTriggerTrack), + GE(CLSID_DirectMusicSeqTrack), + GE(CLSID_DirectMusicSignPostTrack), + GE(CLSID_DirectMusicSong), + GE(CLSID_DirectMusicStyle), + GE(CLSID_DirectMusicStyleTrack), + GE(CLSID_DirectMusicSynth), + GE(CLSID_DirectMusicSynthSink), + GE(CLSID_DirectMusicSysExTrack), + GE(CLSID_DirectMusicTemplate), + GE(CLSID_DirectMusicTempoTrack), + GE(CLSID_DirectMusicTimeSigTrack), + GE(CLSID_DirectMusicWaveTrack), + GE(CLSID_DirectSoundWave), + /* IIDs */ + GE(IID_IDirectMusic), + GE(IID_IDirectMusic2), + GE(IID_IDirectMusic8), + GE(IID_IDirectMusicAudioPath), + GE(IID_IDirectMusicBand), + GE(IID_IDirectMusicBuffer), + GE(IID_IDirectMusicChordMap), + GE(IID_IDirectMusicCollection), + GE(IID_IDirectMusicComposer), + GE(IID_IDirectMusicContainer), + GE(IID_IDirectMusicDownload), + GE(IID_IDirectMusicDownloadedInstrument), + GE(IID_IDirectMusicGetLoader), + GE(IID_IDirectMusicGraph), + GE(IID_IDirectMusicInstrument), + GE(IID_IDirectMusicLoader), + GE(IID_IDirectMusicLoader8), + GE(IID_IDirectMusicObject), + GE(IID_IDirectMusicPatternTrack), + GE(IID_IDirectMusicPerformance), + GE(IID_IDirectMusicPerformance2), + GE(IID_IDirectMusicPerformance8), + GE(IID_IDirectMusicPort), + GE(IID_IDirectMusicPortDownload), + GE(IID_IDirectMusicScript), + GE(IID_IDirectMusicSegment), + GE(IID_IDirectMusicSegment2), + GE(IID_IDirectMusicSegment8), + GE(IID_IDirectMusicSegmentState), + GE(IID_IDirectMusicSegmentState8), + GE(IID_IDirectMusicStyle), + GE(IID_IDirectMusicStyle8), + GE(IID_IDirectMusicSynth), + GE(IID_IDirectMusicSynth8), + GE(IID_IDirectMusicSynthSink), + GE(IID_IDirectMusicThru), + GE(IID_IDirectMusicTool), + GE(IID_IDirectMusicTool8), + GE(IID_IDirectMusicTrack), + GE(IID_IDirectMusicTrack8), + GE(IID_IUnknown), + GE(IID_IPersistStream), + GE(IID_IStream), + GE(IID_IClassFactory), + /* GUIDs */ + GE(GUID_DirectMusicAllTypes), + GE(GUID_NOTIFICATION_CHORD), + GE(GUID_NOTIFICATION_COMMAND), + GE(GUID_NOTIFICATION_MEASUREANDBEAT), + GE(GUID_NOTIFICATION_PERFORMANCE), + GE(GUID_NOTIFICATION_RECOMPOSE), + GE(GUID_NOTIFICATION_SEGMENT), + GE(GUID_BandParam), + GE(GUID_ChordParam), + GE(GUID_CommandParam), + GE(GUID_CommandParam2), + GE(GUID_CommandParamNext), + GE(GUID_IDirectMusicBand), + GE(GUID_IDirectMusicChordMap), + GE(GUID_IDirectMusicStyle), + GE(GUID_MuteParam), + GE(GUID_Play_Marker), + GE(GUID_RhythmParam), + GE(GUID_TempoParam), + GE(GUID_TimeSignature), + GE(GUID_Valid_Start_Time), + GE(GUID_Clear_All_Bands), + GE(GUID_ConnectToDLSCollection), + GE(GUID_Disable_Auto_Download), + GE(GUID_DisableTempo), + GE(GUID_DisableTimeSig), + GE(GUID_Download), + GE(GUID_DownloadToAudioPath), + GE(GUID_Enable_Auto_Download), + GE(GUID_EnableTempo), + GE(GUID_EnableTimeSig), + GE(GUID_IgnoreBankSelectForGM), + GE(GUID_SeedVariations), + GE(GUID_StandardMIDIFile), + GE(GUID_Unload), + GE(GUID_UnloadFromAudioPath), + GE(GUID_Variations), + GE(GUID_PerfMasterTempo), + GE(GUID_PerfMasterVolume), + GE(GUID_PerfMasterGrooveLevel), + GE(GUID_PerfAutoDownload), + GE(GUID_DefaultGMCollection), + GE(GUID_Synth_Default), + GE(GUID_Buffer_Reverb), + GE(GUID_Buffer_EnvReverb), + GE(GUID_Buffer_Stereo), + GE(GUID_Buffer_3D_Dry), + GE(GUID_Buffer_Mono), + GE(GUID_DMUS_PROP_GM_Hardware), + GE(GUID_DMUS_PROP_GS_Capable), + GE(GUID_DMUS_PROP_GS_Hardware), + GE(GUID_DMUS_PROP_DLS1), + GE(GUID_DMUS_PROP_DLS2), + GE(GUID_DMUS_PROP_Effects), + GE(GUID_DMUS_PROP_INSTRUMENT2), + GE(GUID_DMUS_PROP_LegacyCaps), + GE(GUID_DMUS_PROP_MemorySize), + GE(GUID_DMUS_PROP_SampleMemorySize), + GE(GUID_DMUS_PROP_SamplePlaybackRate), + GE(GUID_DMUS_PROP_SetSynthSink), + GE(GUID_DMUS_PROP_SinkUsesDSound), + GE(GUID_DMUS_PROP_SynthSink_DSOUND), + GE(GUID_DMUS_PROP_SynthSink_WAVE), + GE(GUID_DMUS_PROP_Volume), + GE(GUID_DMUS_PROP_WavesReverb), + GE(GUID_DMUS_PROP_WriteLatency), + GE(GUID_DMUS_PROP_WritePeriod), + GE(GUID_DMUS_PROP_XG_Capable), + GE(GUID_DMUS_PROP_XG_Hardware) + }; + + unsigned int i; + + if (!id) return "(null)"; + for (i = 0; i < sizeof(guids)/sizeof(guids[0]); i++) { + if (IsEqualGUID(id, guids[i].guid)) + return guids[i].name; + } + + /* if we didn't find it, act like standard debugstr_guid */ + return debugstr_guid(id); +} + +/* returns name of given error code */ +const char *debugstr_dmreturn (DWORD code) { + static const flag_info codes[] = { + FE(S_OK), + FE(S_FALSE), + FE(DMUS_S_PARTIALLOAD), + FE(DMUS_S_PARTIALDOWNLOAD), + FE(DMUS_S_REQUEUE), + FE(DMUS_S_FREE), + FE(DMUS_S_END), + FE(DMUS_S_STRING_TRUNCATED), + FE(DMUS_S_LAST_TOOL), + FE(DMUS_S_OVER_CHORD), + FE(DMUS_S_UP_OCTAVE), + FE(DMUS_S_DOWN_OCTAVE), + FE(DMUS_S_NOBUFFERCONTROL), + FE(DMUS_S_GARBAGE_COLLECTED), + FE(E_NOTIMPL), + FE(E_NOINTERFACE), + FE(E_POINTER), + FE(CLASS_E_NOAGGREGATION), + FE(CLASS_E_CLASSNOTAVAILABLE), + FE(REGDB_E_CLASSNOTREG), + FE(E_OUTOFMEMORY), + FE(E_FAIL), + FE(E_INVALIDARG), + FE(DMUS_E_DRIVER_FAILED), + FE(DMUS_E_PORTS_OPEN), + FE(DMUS_E_DEVICE_IN_USE), + FE(DMUS_E_INSUFFICIENTBUFFER), + FE(DMUS_E_BUFFERNOTSET), + FE(DMUS_E_BUFFERNOTAVAILABLE), + FE(DMUS_E_NOTADLSCOL), + FE(DMUS_E_INVALIDOFFSET), + FE(DMUS_E_ALREADY_LOADED), + FE(DMUS_E_INVALIDPOS), + FE(DMUS_E_INVALIDPATCH), + FE(DMUS_E_CANNOTSEEK), + FE(DMUS_E_CANNOTWRITE), + FE(DMUS_E_CHUNKNOTFOUND), + FE(DMUS_E_INVALID_DOWNLOADID), + FE(DMUS_E_NOT_DOWNLOADED_TO_PORT), + FE(DMUS_E_ALREADY_DOWNLOADED), + FE(DMUS_E_UNKNOWN_PROPERTY), + FE(DMUS_E_SET_UNSUPPORTED), + FE(DMUS_E_GET_UNSUPPORTED), + FE(DMUS_E_NOTMONO), + FE(DMUS_E_BADARTICULATION), + FE(DMUS_E_BADINSTRUMENT), + FE(DMUS_E_BADWAVELINK), + FE(DMUS_E_NOARTICULATION), + FE(DMUS_E_NOTPCM), + FE(DMUS_E_BADWAVE), + FE(DMUS_E_BADOFFSETTABLE), + FE(DMUS_E_UNKNOWNDOWNLOAD), + FE(DMUS_E_NOSYNTHSINK), + FE(DMUS_E_ALREADYOPEN), + FE(DMUS_E_ALREADYCLOSED), + FE(DMUS_E_SYNTHNOTCONFIGURED), + FE(DMUS_E_SYNTHACTIVE), + FE(DMUS_E_CANNOTREAD), + FE(DMUS_E_DMUSIC_RELEASED), + FE(DMUS_E_BUFFER_EMPTY), + FE(DMUS_E_BUFFER_FULL), + FE(DMUS_E_PORT_NOT_CAPTURE), + FE(DMUS_E_PORT_NOT_RENDER), + FE(DMUS_E_DSOUND_NOT_SET), + FE(DMUS_E_ALREADY_ACTIVATED), + FE(DMUS_E_INVALIDBUFFER), + FE(DMUS_E_WAVEFORMATNOTSUPPORTED), + FE(DMUS_E_SYNTHINACTIVE), + FE(DMUS_E_DSOUND_ALREADY_SET), + FE(DMUS_E_INVALID_EVENT), + FE(DMUS_E_UNSUPPORTED_STREAM), + FE(DMUS_E_ALREADY_INITED), + FE(DMUS_E_INVALID_BAND), + FE(DMUS_E_TRACK_HDR_NOT_FIRST_CK), + FE(DMUS_E_TOOL_HDR_NOT_FIRST_CK), + FE(DMUS_E_INVALID_TRACK_HDR), + FE(DMUS_E_INVALID_TOOL_HDR), + FE(DMUS_E_ALL_TOOLS_FAILED), + FE(DMUS_E_ALL_TRACKS_FAILED), + FE(DMUS_E_NOT_FOUND), + FE(DMUS_E_NOT_INIT), + FE(DMUS_E_TYPE_DISABLED), + FE(DMUS_E_TYPE_UNSUPPORTED), + FE(DMUS_E_TIME_PAST), + FE(DMUS_E_TRACK_NOT_FOUND), + FE(DMUS_E_TRACK_NO_CLOCKTIME_SUPPORT), + FE(DMUS_E_NO_MASTER_CLOCK), + FE(DMUS_E_LOADER_NOCLASSID), + FE(DMUS_E_LOADER_BADPATH), + FE(DMUS_E_LOADER_FAILEDOPEN), + FE(DMUS_E_LOADER_FORMATNOTSUPPORTED), + FE(DMUS_E_LOADER_FAILEDCREATE), + FE(DMUS_E_LOADER_OBJECTNOTFOUND), + FE(DMUS_E_LOADER_NOFILENAME), + FE(DMUS_E_INVALIDFILE), + FE(DMUS_E_ALREADY_EXISTS), + FE(DMUS_E_OUT_OF_RANGE), + FE(DMUS_E_SEGMENT_INIT_FAILED), + FE(DMUS_E_ALREADY_SENT), + FE(DMUS_E_CANNOT_FREE), + FE(DMUS_E_CANNOT_OPEN_PORT), + FE(DMUS_E_CANNOT_CONVERT), + FE(DMUS_E_DESCEND_CHUNK_FAIL), + FE(DMUS_E_NOT_LOADED), + FE(DMUS_E_SCRIPT_LANGUAGE_INCOMPATIBLE), + FE(DMUS_E_SCRIPT_UNSUPPORTED_VARTYPE), + FE(DMUS_E_SCRIPT_ERROR_IN_SCRIPT), + FE(DMUS_E_SCRIPT_CANTLOAD_OLEAUT32), + FE(DMUS_E_SCRIPT_LOADSCRIPT_ERROR), + FE(DMUS_E_SCRIPT_INVALID_FILE), + FE(DMUS_E_INVALID_SCRIPTTRACK), + FE(DMUS_E_SCRIPT_VARIABLE_NOT_FOUND), + FE(DMUS_E_SCRIPT_ROUTINE_NOT_FOUND), + FE(DMUS_E_SCRIPT_CONTENT_READONLY), + FE(DMUS_E_SCRIPT_NOT_A_REFERENCE), + FE(DMUS_E_SCRIPT_VALUE_NOT_SUPPORTED), + FE(DMUS_E_INVALID_SEGMENTTRIGGERTRACK), + FE(DMUS_E_INVALID_LYRICSTRACK), + FE(DMUS_E_INVALID_PARAMCONTROLTRACK), + FE(DMUS_E_AUDIOVBSCRIPT_SYNTAXERROR), + FE(DMUS_E_AUDIOVBSCRIPT_RUNTIMEERROR), + FE(DMUS_E_AUDIOVBSCRIPT_OPERATIONFAILURE), + FE(DMUS_E_AUDIOPATHS_NOT_VALID), + FE(DMUS_E_AUDIOPATHS_IN_USE), + FE(DMUS_E_NO_AUDIOPATH_CONFIG), + FE(DMUS_E_AUDIOPATH_INACTIVE), + FE(DMUS_E_AUDIOPATH_NOBUFFER), + FE(DMUS_E_AUDIOPATH_NOPORT), + FE(DMUS_E_NO_AUDIOPATH), + FE(DMUS_E_INVALIDCHUNK), + FE(DMUS_E_AUDIOPATH_NOGLOBALFXBUFFER), + FE(DMUS_E_INVALID_CONTAINER_OBJECT) + }; + + unsigned int i; + for (i = 0; i < sizeof(codes)/sizeof(codes[0]); i++) { + if (code == codes[i].val) + return codes[i].name; + } + + /* if we didn't find it, return value */ + return wine_dbg_sprintf("0x%08lX", code); +} + + +/* generic flag-dumping function */ +const char* debugstr_flags (DWORD flags, const flag_info* names, size_t num_names){ + static char buffer[128] = "", *ptr = &buffer[0]; + unsigned int i, size = sizeof(buffer); + + for (i=0; i < num_names; i++) { + if ((flags & names[i].val)) { + int cnt = snprintf(ptr, size, "%s ", names[i].name); + if (cnt < 0 || cnt >= size) break; + size -= cnt; + ptr += cnt; + } + } + + ptr = &buffer[0]; + return ptr; +} + +/* dump DMUS_OBJ flags */ +const char *debugstr_DMUS_OBJ_FLAGS (DWORD flagmask) { + static const flag_info flags[] = { + FE(DMUS_OBJ_OBJECT), + FE(DMUS_OBJ_CLASS), + FE(DMUS_OBJ_NAME), + FE(DMUS_OBJ_CATEGORY), + FE(DMUS_OBJ_FILENAME), + FE(DMUS_OBJ_FULLPATH), + FE(DMUS_OBJ_URL), + FE(DMUS_OBJ_VERSION), + FE(DMUS_OBJ_DATE), + FE(DMUS_OBJ_LOADED), + FE(DMUS_OBJ_MEMORY), + FE(DMUS_OBJ_STREAM) + }; + return debugstr_flags (flagmask, flags, sizeof(flags)/sizeof(flags[0])); +} + +/* dump DMUS_CONTAINER flags */ +const char *debugstr_DMUS_CONTAINER_FLAGS (DWORD flagmask) { + static const flag_info flags[] = { + FE(DMUS_CONTAINER_NOLOADS) + }; + return debugstr_flags (flagmask, flags, sizeof(flags)/sizeof(flags[0])); +} + +/* dump DMUS_CONTAINED_OBJF flags */ +const char *debugstr_DMUS_CONTAINED_OBJF_FLAGS (DWORD flagmask) { + static const flag_info flags[] = { + FE(DMUS_CONTAINED_OBJF_KEEP) + }; + return debugstr_flags (flagmask, flags, sizeof(flags)/sizeof(flags[0])); +} + +const char *debugstr_DMUS_OBJECTDESC (LPDMUS_OBJECTDESC pDesc) { + if (pDesc) { + char buffer[1024] = "", *ptr = &buffer[0]; + + ptr += sprintf(ptr, "DMUS_OBJECTDESC (%p):\n", pDesc); + ptr += sprintf(ptr, " - dwSize = 0x%08lX\n", pDesc->dwSize); + ptr += sprintf(ptr, " - dwValidData = 0x%08lX ( %s)\n", pDesc->dwValidData, debugstr_DMUS_OBJ_FLAGS (pDesc->dwValidData)); + if (pDesc->dwValidData & DMUS_OBJ_CLASS) ptr += sprintf(ptr, " - guidClass = %s\n", debugstr_dmguid(&pDesc->guidClass)); + if (pDesc->dwValidData & DMUS_OBJ_OBJECT) ptr += sprintf(ptr, " - guidObject = %s\n", debugstr_guid(&pDesc->guidObject)); + if (pDesc->dwValidData & DMUS_OBJ_DATE) ptr += sprintf(ptr, " - ftDate = %s\n", debugstr_filetime (&pDesc->ftDate)); + if (pDesc->dwValidData & DMUS_OBJ_VERSION) ptr += sprintf(ptr, " - vVersion = %s\n", debugstr_dmversion(&pDesc->vVersion)); + if (pDesc->dwValidData & DMUS_OBJ_NAME) ptr += sprintf(ptr, " - wszName = %s\n", debugstr_w(pDesc->wszName)); + if (pDesc->dwValidData & DMUS_OBJ_CATEGORY) ptr += sprintf(ptr, " - wszCategory = %s\n", debugstr_w(pDesc->wszCategory)); + if (pDesc->dwValidData & DMUS_OBJ_FILENAME) ptr += sprintf(ptr, " - wszFileName = %s\n", debugstr_w(pDesc->wszFileName)); + if (pDesc->dwValidData & DMUS_OBJ_MEMORY) ptr += sprintf(ptr, " - llMemLength = %lli\n - pbMemData = %p\n", pDesc->llMemLength, pDesc->pbMemData); + if (pDesc->dwValidData & DMUS_OBJ_STREAM) ptr += sprintf(ptr, " - pStream = %p\n", pDesc->pStream); + + ptr = &buffer[0]; + return ptr; + } else { + return wine_dbg_sprintf("(NULL)"); + } +} + +void debug_DMUS_OBJECTDESC (LPDMUS_OBJECTDESC pDesc) { + if (pDesc) { + TRACE("DMUS_OBJECTDESC (%p):\n", pDesc); + TRACE(" - dwSize = %ld\n", pDesc->dwSize); + TRACE(" - dwValidData = %s\n", debugstr_DMUS_OBJ_FLAGS (pDesc->dwValidData)); + if (pDesc->dwValidData & DMUS_OBJ_NAME) TRACE(" - wszName = %s\n", debugstr_w(pDesc->wszName)); + if (pDesc->dwValidData & DMUS_OBJ_CLASS) TRACE(" - guidClass = %s\n", debugstr_dmguid(&pDesc->guidClass)); + if (pDesc->dwValidData & DMUS_OBJ_OBJECT) TRACE(" - guidObject = %s\n", debugstr_guid(&pDesc->guidObject)); + if (pDesc->dwValidData & DMUS_OBJ_DATE) TRACE(" - ftDate = FIXME\n"); + if (pDesc->dwValidData & DMUS_OBJ_VERSION) TRACE(" - vVersion = %s\n", debugstr_dmversion(&pDesc->vVersion)); + if (pDesc->dwValidData & DMUS_OBJ_CATEGORY) TRACE(" - wszCategory = %s\n", debugstr_w(pDesc->wszCategory)); + if (pDesc->dwValidData & DMUS_OBJ_FILENAME) TRACE(" - wszFileName = %s\n", debugstr_w(pDesc->wszFileName)); + if (pDesc->dwValidData & DMUS_OBJ_MEMORY) TRACE(" - llMemLength = %lli\n - pbMemData = %p\n", pDesc->llMemLength, pDesc->pbMemData); + if (pDesc->dwValidData & DMUS_OBJ_STREAM) TRACE(" - pStream = %p\n", pDesc->pStream); + } else { + TRACE("(NULL)\n"); + } +} + +const char *debugstr_DMUS_IO_CONTAINER_HEADER (LPDMUS_IO_CONTAINER_HEADER pHeader) { + if (pHeader) { + char buffer[1024] = "", *ptr = &buffer[0]; + + ptr += sprintf(ptr, "DMUS_IO_CONTAINER_HEADER (%p):\n", pHeader); + ptr += sprintf(ptr, " - dwFlags = %s\n", debugstr_DMUS_CONTAINER_FLAGS(pHeader->dwFlags)); + + ptr = &buffer[0]; + return ptr; + } else { + return wine_dbg_sprintf("(NULL)"); + } +} + +const char *debugstr_DMUS_IO_CONTAINED_OBJECT_HEADER (LPDMUS_IO_CONTAINED_OBJECT_HEADER pHeader) { + if (pHeader) { + char buffer[1024] = "", *ptr = &buffer[0]; + + ptr += sprintf(ptr, "DMUS_IO_CONTAINED_OBJECT_HEADER (%p):\n", pHeader); + ptr += sprintf(ptr, " - guidClassID = %s\n", debugstr_dmguid(&pHeader->guidClassID)); + ptr += sprintf(ptr, " - dwFlags = %s\n", debugstr_DMUS_CONTAINED_OBJF_FLAGS (pHeader->dwFlags)); + ptr += sprintf(ptr, " - ckid = %s\n", debugstr_fourcc (pHeader->ckid)); + ptr += sprintf(ptr, " - fccType = %s\n", debugstr_fourcc (pHeader->fccType)); + + ptr = &buffer[0]; + return ptr; + } else { + return wine_dbg_sprintf("(NULL)"); + } +} diff --git a/dlls/dmime/dmutils.h b/dlls/dmime/dmutils.h new file mode 100644 index 00000000000..c8651619d7b --- /dev/null +++ b/dlls/dmime/dmutils.h @@ -0,0 +1,89 @@ +/* Debug and Helper Functions + * + * Copyright (C) 2003-2004 Rok Mandeljc + * Copyright (C) 2003-2004 Raphael Junqueira + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program 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 Library General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef __WINE_DMUTILS_H +#define __WINE_DMUTILS_H + +/* for simpler reading */ +typedef struct _DMUS_PRIVATE_CHUNK { + FOURCC fccID; /* FOURCC ID of the chunk */ + DWORD dwSize; /* size of the chunk */ +} DMUS_PRIVATE_CHUNK, *LPDMUS_PRIVATE_CHUNK; + +/** + * Parsing utilities + */ +extern HRESULT IDirectMusicUtils_IPersistStream_ParseDescGeneric (DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm, LPDMUS_OBJECTDESC pDesc); +extern HRESULT IDirectMusicUtils_IPersistStream_ParseUNFOGeneric (DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm, LPDMUS_OBJECTDESC pDesc); +extern HRESULT IDirectMusicUtils_IPersistStream_ParseReference (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm, IDirectMusicObject** ppObject); + +/** + * Debug utilities + */ +/* used for generic dumping (copied from ddraw) */ +typedef struct { + DWORD val; + const char* name; +} flag_info; + +typedef struct { + const GUID *guid; + const char* name; +} guid_info; + +/* used for initialising structs */ +#define DM_STRUCT_INIT(x) \ + do { \ + memset((x), 0, sizeof(*(x))); \ + (x)->dwSize = sizeof(*x); \ + } while (0) + +#define FE(x) { x, #x } +#define GE(x) { &x, #x } + +/* check whether the given DWORD is even (return 0) or odd (return 1) */ +extern int even_or_odd (DWORD number); +/* check whether chunkID is valid dmobject form chunk */ +extern BOOL IS_VALID_DMFORM (FOURCC chunkID); +/* translate STREAM_SEEK flag to string */ +extern const char *resolve_STREAM_SEEK (DWORD flag); +/* FOURCC to string conversion for debug messages */ +extern const char *debugstr_fourcc (DWORD fourcc); +/* DMUS_VERSION struct to string conversion for debug messages */ +extern const char *debugstr_dmversion (LPDMUS_VERSION version); +/* FILETIME struct to string conversion for debug messages */ +extern const char *debugstr_filetime (LPFILETIME time); +/* returns name of given GUID */ +extern const char *debugstr_dmguid (const GUID *id); +/* returns name of given error code */ +extern const char *debugstr_dmreturn (DWORD code); +/* generic flags-dumping function */ +extern const char *debugstr_flags (DWORD flags, const flag_info* names, size_t num_names); + +extern const char *debugstr_DMUS_OBJ_FLAGS (DWORD flagmask); +extern const char *debugstr_DMUS_CONTAINER_FLAGS (DWORD flagmask); +extern const char *debugstr_DMUS_CONTAINED_OBJF_FLAGS (DWORD flagmask); +/* dump whole DMUS_OBJECTDESC struct */ +extern const char *debugstr_DMUS_OBJECTDESC (LPDMUS_OBJECTDESC pDesc); +extern void debug_DMUS_OBJECTDESC (LPDMUS_OBJECTDESC pDesc); +extern const char *debugstr_DMUS_IO_CONTAINER_HEADER (LPDMUS_IO_CONTAINER_HEADER pHeader); +extern const char *debugstr_DMUS_IO_CONTAINED_OBJECT_HEADER (LPDMUS_IO_CONTAINED_OBJECT_HEADER pHeader); + +#endif /* __WINE_DMUTILS_H */ diff --git a/dlls/dmime/segment.c b/dlls/dmime/segment.c index 99d8a9b30ba..27f3cba0dee 100644 --- a/dlls/dmime/segment.c +++ b/dlls/dmime/segment.c @@ -899,7 +899,7 @@ static HRESULT IDirectMusicSegment8Impl_IPersistStream_ParseSegmentForm (LPPERSI StreamCount += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize; TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize); - hr = IDirectMusicImpl_IPersistStream_ParseDescGeneric(&Chunk, pStm, This->pDesc); + hr = IDirectMusicUtils_IPersistStream_ParseDescGeneric(&Chunk, pStm, This->pDesc); if (FAILED(hr)) return hr; if (hr == S_FALSE) { @@ -961,7 +961,7 @@ static HRESULT IDirectMusicSegment8Impl_IPersistStream_ParseSegmentForm (LPPERSI ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize; TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize); - hr = IDirectMusicImpl_IPersistStream_ParseUNFOGeneric(&Chunk, pStm, This->pDesc); + hr = IDirectMusicUtils_IPersistStream_ParseUNFOGeneric(&Chunk, pStm, This->pDesc); if (FAILED(hr)) return hr; if (hr == S_FALSE) { diff --git a/dlls/dmime/segtriggertrack.c b/dlls/dmime/segtriggertrack.c index ef1a88a3a1c..94a113234a0 100644 --- a/dlls/dmime/segtriggertrack.c +++ b/dlls/dmime/segtriggertrack.c @@ -242,6 +242,9 @@ static HRESULT IDirectMusicSegTriggerTrack_IPersistStream_ParseSegment (LPPERSIS DMUS_PRIVATE_CHUNK Chunk; DWORD ListSize[3], ListCount[3]; LARGE_INTEGER liMove; /* used when skipping chunks */ + HRESULT hr; + + IDirectMusicObject* pObject = NULL; if (pChunk->fccID != DMUS_FOURCC_SEGMENT_LIST) { ERR_(dmfile)(": %s chunk should be a SEGMENT list\n", debugstr_fourcc (pChunk->fccID)); @@ -277,13 +280,17 @@ static HRESULT IDirectMusicSegTriggerTrack_IPersistStream_ParseSegment (LPPERSIS ListSize[1] = Chunk.dwSize - sizeof(FOURCC); ListCount[1] = 0; switch (Chunk.fccID) { - /** - * should be a DMRF (DirectMusic Reference) list @TODO - */ case DMUS_FOURCC_REF_LIST: { - FIXME_(dmfile)(": DMRF (DM References) list, not yet handled\n"); - liMove.QuadPart = Chunk.dwSize - sizeof(FOURCC); - IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + FIXME_(dmfile)(": DMRF (DM References) list\n"); + hr = IDirectMusicUtils_IPersistStream_ParseReference (iface, &Chunk, pStm, &pObject); + if (FAILED(hr)) { + ERR(": could not load Reference\n"); + return hr; + } + /* + * TODO: what to do with the new pObject ? + * for now it leaks + */ break; } default: { diff --git a/dlls/dmstyle/Makefile.in b/dlls/dmstyle/Makefile.in index 93dd542ad00..edfc1a55062 100644 --- a/dlls/dmstyle/Makefile.in +++ b/dlls/dmstyle/Makefile.in @@ -11,6 +11,7 @@ C_SRCS = \ chordtrack.c \ commandtrack.c \ dmstyle_main.c \ + dmutils.c \ motiftrack.c \ mutetrack.c \ regsvr.c \ diff --git a/dlls/dmstyle/dmstyle_main.c b/dlls/dmstyle/dmstyle_main.c index f29b83cdddd..dfaf6982dd0 100644 --- a/dlls/dmstyle/dmstyle_main.c +++ b/dlls/dmstyle/dmstyle_main.c @@ -446,411 +446,3 @@ HRESULT WINAPI DMSTYLE_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *p WARN("(%s, %s, %p): no interface found.\n", debugstr_dmguid(rclsid), debugstr_dmguid(riid), ppv); return CLASS_E_CLASSNOTAVAILABLE; } - - -/****************************************************************** - * Helper functions - * - * - */ -/* check whether the given DWORD is even (return 0) or odd (return 1) */ -int even_or_odd (DWORD number) { - return (number & 0x1); /* basically, check if bit 0 is set ;) */ -} - -/* FOURCC to string conversion for debug messages */ -const char *debugstr_fourcc (DWORD fourcc) { - if (!fourcc) return "'null'"; - return wine_dbg_sprintf ("\'%c%c%c%c\'", - (char)(fourcc), (char)(fourcc >> 8), - (char)(fourcc >> 16), (char)(fourcc >> 24)); -} - -/* DMUS_VERSION struct to string conversion for debug messages */ -const char *debugstr_dmversion (LPDMUS_VERSION version) { - if (!version) return "'null'"; - return wine_dbg_sprintf ("\'%i,%i,%i,%i\'", - (int)((version->dwVersionMS && 0xFFFF0000) >> 8), (int)(version->dwVersionMS && 0x0000FFFF), - (int)((version->dwVersionLS && 0xFFFF0000) >> 8), (int)(version->dwVersionLS && 0x0000FFFF)); -} - -/* returns name of given GUID */ -const char *debugstr_dmguid (const GUID *id) { - static const guid_info guids[] = { - /* CLSIDs */ - GE(CLSID_AudioVBScript), - GE(CLSID_DirectMusic), - GE(CLSID_DirectMusicAudioPath), - GE(CLSID_DirectMusicAudioPathConfig), - GE(CLSID_DirectMusicAuditionTrack), - GE(CLSID_DirectMusicBand), - GE(CLSID_DirectMusicBandTrack), - GE(CLSID_DirectMusicChordMapTrack), - GE(CLSID_DirectMusicChordMap), - GE(CLSID_DirectMusicChordTrack), - GE(CLSID_DirectMusicCollection), - GE(CLSID_DirectMusicCommandTrack), - GE(CLSID_DirectMusicComposer), - GE(CLSID_DirectMusicContainer), - GE(CLSID_DirectMusicGraph), - GE(CLSID_DirectMusicLoader), - GE(CLSID_DirectMusicLyricsTrack), - GE(CLSID_DirectMusicMarkerTrack), - GE(CLSID_DirectMusicMelodyFormulationTrack), - GE(CLSID_DirectMusicMotifTrack), - GE(CLSID_DirectMusicMuteTrack), - GE(CLSID_DirectMusicParamControlTrack), - GE(CLSID_DirectMusicPatternTrack), - GE(CLSID_DirectMusicPerformance), - GE(CLSID_DirectMusicScript), - GE(CLSID_DirectMusicScriptAutoImpSegment), - GE(CLSID_DirectMusicScriptAutoImpPerformance), - GE(CLSID_DirectMusicScriptAutoImpSegmentState), - GE(CLSID_DirectMusicScriptAutoImpAudioPathConfig), - GE(CLSID_DirectMusicScriptAutoImpAudioPath), - GE(CLSID_DirectMusicScriptAutoImpSong), - GE(CLSID_DirectMusicScriptSourceCodeLoader), - GE(CLSID_DirectMusicScriptTrack), - GE(CLSID_DirectMusicSection), - GE(CLSID_DirectMusicSegment), - GE(CLSID_DirectMusicSegmentState), - GE(CLSID_DirectMusicSegmentTriggerTrack), - GE(CLSID_DirectMusicSegTriggerTrack), - GE(CLSID_DirectMusicSeqTrack), - GE(CLSID_DirectMusicSignPostTrack), - GE(CLSID_DirectMusicSong), - GE(CLSID_DirectMusicStyle), - GE(CLSID_DirectMusicStyleTrack), - GE(CLSID_DirectMusicSynth), - GE(CLSID_DirectMusicSynthSink), - GE(CLSID_DirectMusicSysExTrack), - GE(CLSID_DirectMusicTemplate), - GE(CLSID_DirectMusicTempoTrack), - GE(CLSID_DirectMusicTimeSigTrack), - GE(CLSID_DirectMusicWaveTrack), - GE(CLSID_DirectSoundWave), - /* IIDs */ - GE(IID_IDirectMusic), - GE(IID_IDirectMusic2), - GE(IID_IDirectMusic8), - GE(IID_IDirectMusicAudioPath), - GE(IID_IDirectMusicBand), - GE(IID_IDirectMusicBuffer), - GE(IID_IDirectMusicChordMap), - GE(IID_IDirectMusicCollection), - GE(IID_IDirectMusicComposer), - GE(IID_IDirectMusicContainer), - GE(IID_IDirectMusicDownload), - GE(IID_IDirectMusicDownloadedInstrument), - GE(IID_IDirectMusicGetLoader), - GE(IID_IDirectMusicGraph), - GE(IID_IDirectMusicInstrument), - GE(IID_IDirectMusicLoader), - GE(IID_IDirectMusicLoader8), - GE(IID_IDirectMusicObject), - GE(IID_IDirectMusicPatternTrack), - GE(IID_IDirectMusicPerformance), - GE(IID_IDirectMusicPerformance2), - GE(IID_IDirectMusicPerformance8), - GE(IID_IDirectMusicPort), - GE(IID_IDirectMusicPortDownload), - GE(IID_IDirectMusicScript), - GE(IID_IDirectMusicSegment), - GE(IID_IDirectMusicSegment2), - GE(IID_IDirectMusicSegment8), - GE(IID_IDirectMusicSegmentState), - GE(IID_IDirectMusicSegmentState8), - GE(IID_IDirectMusicStyle), - GE(IID_IDirectMusicStyle8), - GE(IID_IDirectMusicSynth), - GE(IID_IDirectMusicSynth8), - GE(IID_IDirectMusicSynthSink), - GE(IID_IDirectMusicThru), - GE(IID_IDirectMusicTool), - GE(IID_IDirectMusicTool8), - GE(IID_IDirectMusicTrack), - GE(IID_IDirectMusicTrack8), - GE(IID_IUnknown), - GE(IID_IPersistStream), - GE(IID_IStream), - /* GUIDs */ - GE(GUID_DirectMusicAllTypes), - GE(GUID_NOTIFICATION_CHORD), - GE(GUID_NOTIFICATION_COMMAND), - GE(GUID_NOTIFICATION_MEASUREANDBEAT), - GE(GUID_NOTIFICATION_PERFORMANCE), - GE(GUID_NOTIFICATION_RECOMPOSE), - GE(GUID_NOTIFICATION_SEGMENT), - GE(GUID_BandParam), - GE(GUID_ChordParam), - GE(GUID_CommandParam), - GE(GUID_CommandParam2), - GE(GUID_CommandParamNext), - GE(GUID_IDirectMusicBand), - GE(GUID_IDirectMusicChordMap), - GE(GUID_IDirectMusicStyle), - GE(GUID_MuteParam), - GE(GUID_Play_Marker), - GE(GUID_RhythmParam), - GE(GUID_TempoParam), - GE(GUID_TimeSignature), - GE(GUID_Valid_Start_Time), - GE(GUID_Clear_All_Bands), - GE(GUID_ConnectToDLSCollection), - GE(GUID_Disable_Auto_Download), - GE(GUID_DisableTempo), - GE(GUID_DisableTimeSig), - GE(GUID_Download), - GE(GUID_DownloadToAudioPath), - GE(GUID_Enable_Auto_Download), - GE(GUID_EnableTempo), - GE(GUID_EnableTimeSig), - GE(GUID_IgnoreBankSelectForGM), - GE(GUID_SeedVariations), - GE(GUID_StandardMIDIFile), - GE(GUID_Unload), - GE(GUID_UnloadFromAudioPath), - GE(GUID_Variations), - GE(GUID_PerfMasterTempo), - GE(GUID_PerfMasterVolume), - GE(GUID_PerfMasterGrooveLevel), - GE(GUID_PerfAutoDownload), - GE(GUID_DefaultGMCollection), - GE(GUID_Synth_Default), - GE(GUID_Buffer_Reverb), - GE(GUID_Buffer_EnvReverb), - GE(GUID_Buffer_Stereo), - GE(GUID_Buffer_3D_Dry), - GE(GUID_Buffer_Mono), - GE(GUID_DMUS_PROP_GM_Hardware), - GE(GUID_DMUS_PROP_GS_Capable), - GE(GUID_DMUS_PROP_GS_Hardware), - GE(GUID_DMUS_PROP_DLS1), - GE(GUID_DMUS_PROP_DLS2), - GE(GUID_DMUS_PROP_Effects), - GE(GUID_DMUS_PROP_INSTRUMENT2), - GE(GUID_DMUS_PROP_LegacyCaps), - GE(GUID_DMUS_PROP_MemorySize), - GE(GUID_DMUS_PROP_SampleMemorySize), - GE(GUID_DMUS_PROP_SamplePlaybackRate), - GE(GUID_DMUS_PROP_SetSynthSink), - GE(GUID_DMUS_PROP_SinkUsesDSound), - GE(GUID_DMUS_PROP_SynthSink_DSOUND), - GE(GUID_DMUS_PROP_SynthSink_WAVE), - GE(GUID_DMUS_PROP_Volume), - GE(GUID_DMUS_PROP_WavesReverb), - GE(GUID_DMUS_PROP_WriteLatency), - GE(GUID_DMUS_PROP_WritePeriod), - GE(GUID_DMUS_PROP_XG_Capable), - GE(GUID_DMUS_PROP_XG_Hardware) - }; - - unsigned int i; - - if (!id) return "(null)"; - - for (i = 0; i < sizeof(guids)/sizeof(guids[0]); i++) { - if (IsEqualGUID(id, &guids[i].guid)) - return guids[i].name; - } - /* if we didn't find it, act like standard debugstr_guid */ - return debugstr_guid(id); -} - -/* returns name of given error code */ -const char *debugstr_dmreturn (DWORD code) { - static const flag_info codes[] = { - FE(S_OK), - FE(S_FALSE), - FE(DMUS_S_PARTIALLOAD), - FE(DMUS_S_PARTIALDOWNLOAD), - FE(DMUS_S_REQUEUE), - FE(DMUS_S_FREE), - FE(DMUS_S_END), - FE(DMUS_S_STRING_TRUNCATED), - FE(DMUS_S_LAST_TOOL), - FE(DMUS_S_OVER_CHORD), - FE(DMUS_S_UP_OCTAVE), - FE(DMUS_S_DOWN_OCTAVE), - FE(DMUS_S_NOBUFFERCONTROL), - FE(DMUS_S_GARBAGE_COLLECTED), - FE(DMUS_E_DRIVER_FAILED), - FE(DMUS_E_PORTS_OPEN), - FE(DMUS_E_DEVICE_IN_USE), - FE(DMUS_E_INSUFFICIENTBUFFER), - FE(DMUS_E_BUFFERNOTSET), - FE(DMUS_E_BUFFERNOTAVAILABLE), - FE(DMUS_E_NOTADLSCOL), - FE(DMUS_E_INVALIDOFFSET), - FE(DMUS_E_ALREADY_LOADED), - FE(DMUS_E_INVALIDPOS), - FE(DMUS_E_INVALIDPATCH), - FE(DMUS_E_CANNOTSEEK), - FE(DMUS_E_CANNOTWRITE), - FE(DMUS_E_CHUNKNOTFOUND), - FE(DMUS_E_INVALID_DOWNLOADID), - FE(DMUS_E_NOT_DOWNLOADED_TO_PORT), - FE(DMUS_E_ALREADY_DOWNLOADED), - FE(DMUS_E_UNKNOWN_PROPERTY), - FE(DMUS_E_SET_UNSUPPORTED), - FE(DMUS_E_GET_UNSUPPORTED), - FE(DMUS_E_NOTMONO), - FE(DMUS_E_BADARTICULATION), - FE(DMUS_E_BADINSTRUMENT), - FE(DMUS_E_BADWAVELINK), - FE(DMUS_E_NOARTICULATION), - FE(DMUS_E_NOTPCM), - FE(DMUS_E_BADWAVE), - FE(DMUS_E_BADOFFSETTABLE), - FE(DMUS_E_UNKNOWNDOWNLOAD), - FE(DMUS_E_NOSYNTHSINK), - FE(DMUS_E_ALREADYOPEN), - FE(DMUS_E_ALREADYCLOSED), - FE(DMUS_E_SYNTHNOTCONFIGURED), - FE(DMUS_E_SYNTHACTIVE), - FE(DMUS_E_CANNOTREAD), - FE(DMUS_E_DMUSIC_RELEASED), - FE(DMUS_E_BUFFER_EMPTY), - FE(DMUS_E_BUFFER_FULL), - FE(DMUS_E_PORT_NOT_CAPTURE), - FE(DMUS_E_PORT_NOT_RENDER), - FE(DMUS_E_DSOUND_NOT_SET), - FE(DMUS_E_ALREADY_ACTIVATED), - FE(DMUS_E_INVALIDBUFFER), - FE(DMUS_E_WAVEFORMATNOTSUPPORTED), - FE(DMUS_E_SYNTHINACTIVE), - FE(DMUS_E_DSOUND_ALREADY_SET), - FE(DMUS_E_INVALID_EVENT), - FE(DMUS_E_UNSUPPORTED_STREAM), - FE(DMUS_E_ALREADY_INITED), - FE(DMUS_E_INVALID_BAND), - FE(DMUS_E_TRACK_HDR_NOT_FIRST_CK), - FE(DMUS_E_TOOL_HDR_NOT_FIRST_CK), - FE(DMUS_E_INVALID_TRACK_HDR), - FE(DMUS_E_INVALID_TOOL_HDR), - FE(DMUS_E_ALL_TOOLS_FAILED), - FE(DMUS_E_ALL_TRACKS_FAILED), - FE(DMUS_E_NOT_FOUND), - FE(DMUS_E_NOT_INIT), - FE(DMUS_E_TYPE_DISABLED), - FE(DMUS_E_TYPE_UNSUPPORTED), - FE(DMUS_E_TIME_PAST), - FE(DMUS_E_TRACK_NOT_FOUND), - FE(DMUS_E_TRACK_NO_CLOCKTIME_SUPPORT), - FE(DMUS_E_NO_MASTER_CLOCK), - FE(DMUS_E_LOADER_NOCLASSID), - FE(DMUS_E_LOADER_BADPATH), - FE(DMUS_E_LOADER_FAILEDOPEN), - FE(DMUS_E_LOADER_FORMATNOTSUPPORTED), - FE(DMUS_E_LOADER_FAILEDCREATE), - FE(DMUS_E_LOADER_OBJECTNOTFOUND), - FE(DMUS_E_LOADER_NOFILENAME), - FE(DMUS_E_INVALIDFILE), - FE(DMUS_E_ALREADY_EXISTS), - FE(DMUS_E_OUT_OF_RANGE), - FE(DMUS_E_SEGMENT_INIT_FAILED), - FE(DMUS_E_ALREADY_SENT), - FE(DMUS_E_CANNOT_FREE), - FE(DMUS_E_CANNOT_OPEN_PORT), - FE(DMUS_E_CANNOT_CONVERT), - FE(DMUS_E_DESCEND_CHUNK_FAIL), - FE(DMUS_E_NOT_LOADED), - FE(DMUS_E_SCRIPT_LANGUAGE_INCOMPATIBLE), - FE(DMUS_E_SCRIPT_UNSUPPORTED_VARTYPE), - FE(DMUS_E_SCRIPT_ERROR_IN_SCRIPT), - FE(DMUS_E_SCRIPT_CANTLOAD_OLEAUT32), - FE(DMUS_E_SCRIPT_LOADSCRIPT_ERROR), - FE(DMUS_E_SCRIPT_INVALID_FILE), - FE(DMUS_E_INVALID_SCRIPTTRACK), - FE(DMUS_E_SCRIPT_VARIABLE_NOT_FOUND), - FE(DMUS_E_SCRIPT_ROUTINE_NOT_FOUND), - FE(DMUS_E_SCRIPT_CONTENT_READONLY), - FE(DMUS_E_SCRIPT_NOT_A_REFERENCE), - FE(DMUS_E_SCRIPT_VALUE_NOT_SUPPORTED), - FE(DMUS_E_INVALID_SEGMENTTRIGGERTRACK), - FE(DMUS_E_INVALID_LYRICSTRACK), - FE(DMUS_E_INVALID_PARAMCONTROLTRACK), - FE(DMUS_E_AUDIOVBSCRIPT_SYNTAXERROR), - FE(DMUS_E_AUDIOVBSCRIPT_RUNTIMEERROR), - FE(DMUS_E_AUDIOVBSCRIPT_OPERATIONFAILURE), - FE(DMUS_E_AUDIOPATHS_NOT_VALID), - FE(DMUS_E_AUDIOPATHS_IN_USE), - FE(DMUS_E_NO_AUDIOPATH_CONFIG), - FE(DMUS_E_AUDIOPATH_INACTIVE), - FE(DMUS_E_AUDIOPATH_NOBUFFER), - FE(DMUS_E_AUDIOPATH_NOPORT), - FE(DMUS_E_NO_AUDIOPATH), - FE(DMUS_E_INVALIDCHUNK), - FE(DMUS_E_AUDIOPATH_NOGLOBALFXBUFFER), - FE(DMUS_E_INVALID_CONTAINER_OBJECT) - }; - unsigned int i; - for (i = 0; i < sizeof(codes)/sizeof(codes[0]); i++) { - if (code == codes[i].val) - return codes[i].name; - } - /* if we didn't find it, return value */ - return wine_dbg_sprintf("0x%08lx", code); -} - -/* generic flag-dumping function */ -const char* debugstr_flags (DWORD flags, const flag_info* names, size_t num_names){ - char buffer[128] = "", *ptr = &buffer[0]; - unsigned int i, size = sizeof(buffer); - - for (i=0; i < num_names; i++) - { - if ((flags & names[i].val) || /* standard flag*/ - ((!flags) && (!names[i].val))) { /* zero value only */ - int cnt = snprintf(ptr, size, "%s ", names[i].name); - if (cnt < 0 || cnt >= size) break; - size -= cnt; - ptr += cnt; - } - } - - return wine_dbg_sprintf("%s", buffer); -} - -/* dump DMUS_OBJ flags */ -const char *debugstr_DMUS_OBJ_FLAGS (DWORD flagmask) { - static const flag_info flags[] = { - FE(DMUS_OBJ_OBJECT), - FE(DMUS_OBJ_CLASS), - FE(DMUS_OBJ_NAME), - FE(DMUS_OBJ_CATEGORY), - FE(DMUS_OBJ_FILENAME), - FE(DMUS_OBJ_FULLPATH), - FE(DMUS_OBJ_URL), - FE(DMUS_OBJ_VERSION), - FE(DMUS_OBJ_DATE), - FE(DMUS_OBJ_LOADED), - FE(DMUS_OBJ_MEMORY), - FE(DMUS_OBJ_STREAM) - }; - return debugstr_flags (flagmask, flags, sizeof(flags)/sizeof(flags[0])); -} - -/* dump whole DMUS_OBJECTDESC struct */ -const char *debugstr_DMUS_OBJECTDESC (LPDMUS_OBJECTDESC pDesc) { - if (pDesc) { - char buffer[1024] = "", *ptr = &buffer[0]; - - ptr += sprintf(ptr, "DMUS_OBJECTDESC (%p):\n", pDesc); - ptr += sprintf(ptr, " - dwSize = %ld\n", pDesc->dwSize); - ptr += sprintf(ptr, " - dwValidData = %s\n", debugstr_DMUS_OBJ_FLAGS (pDesc->dwValidData)); - if (pDesc->dwValidData & DMUS_OBJ_CLASS) ptr += sprintf(ptr, " - guidClass = %s\n", debugstr_dmguid(&pDesc->guidClass)); - if (pDesc->dwValidData & DMUS_OBJ_OBJECT) ptr += sprintf(ptr, " - guidObject = %s\n", debugstr_guid(&pDesc->guidObject)); - if (pDesc->dwValidData & DMUS_OBJ_DATE) ptr += sprintf(ptr, " - ftDate = FIXME\n"); - if (pDesc->dwValidData & DMUS_OBJ_VERSION) ptr += sprintf(ptr, " - vVersion = %s\n", debugstr_dmversion(&pDesc->vVersion)); - if (pDesc->dwValidData & DMUS_OBJ_NAME) ptr += sprintf(ptr, " - wszName = %s\n", debugstr_w(pDesc->wszName)); - if (pDesc->dwValidData & DMUS_OBJ_CATEGORY) ptr += sprintf(ptr, " - wszCategory = %s\n", debugstr_w(pDesc->wszCategory)); - if (pDesc->dwValidData & DMUS_OBJ_FILENAME) ptr += sprintf(ptr, " - wszFileName = %s\n", debugstr_w(pDesc->wszFileName)); - if (pDesc->dwValidData & DMUS_OBJ_MEMORY) ptr += sprintf(ptr, " - llMemLength = %lli\n - pbMemData = %p\n", pDesc->llMemLength, pDesc->pbMemData); - if (pDesc->dwValidData & DMUS_OBJ_STREAM) ptr += sprintf(ptr, " - pStream = %p", pDesc->pStream); - - return wine_dbg_sprintf("%s", buffer); - } else { - return wine_dbg_sprintf("(NULL)"); - } -} diff --git a/dlls/dmstyle/dmstyle_private.h b/dlls/dmstyle/dmstyle_private.h index 86e784475ee..91dcc777c77 100644 --- a/dlls/dmstyle/dmstyle_private.h +++ b/dlls/dmstyle/dmstyle_private.h @@ -114,6 +114,7 @@ struct IDirectMusicStyle8Impl { /* IDirectMusicStyle8Impl fields */ LPDMUS_OBJECTDESC pDesc; + DMUS_IO_STYLE style; }; /* IUnknown: */ @@ -501,47 +502,6 @@ extern HRESULT WINAPI IDirectMusicStyleTrack_IPersistStream_GetSizeMax (LPPERSIS /***************************************************************************** * Misc. */ -/* for simpler reading */ -typedef struct _DMUS_PRIVATE_CHUNK { - FOURCC fccID; /* FOURCC ID of the chunk */ - DWORD dwSize; /* size of the chunk */ -} DMUS_PRIVATE_CHUNK, *LPDMUS_PRIVATE_CHUNK; - -/* used for generic dumping (copied from ddraw) */ -typedef struct { - DWORD val; - const char* name; -} flag_info; - -typedef struct { - const GUID *guid; - const char* name; -} guid_info; - -/* used for initialising structs (primarily for DMUS_OBJECTDESC) */ -#define DM_STRUCT_INIT(x) \ - do { \ - memset((x), 0, sizeof(*(x))); \ - (x)->dwSize = sizeof(*x); \ - } while (0) - -#define FE(x) { x, #x } -#define GE(x) { &x, #x } - -/* check whether the given DWORD is even (return 0) or odd (return 1) */ -extern int even_or_odd (DWORD number); -/* FOURCC to string conversion for debug messages */ -extern const char *debugstr_fourcc (DWORD fourcc); -/* DMUS_VERSION struct to string conversion for debug messages */ -extern const char *debugstr_dmversion (LPDMUS_VERSION version); -/* returns name of given GUID */ -extern const char *debugstr_dmguid (const GUID *id); -/* returns name of given error code */ -extern const char *debugstr_dmreturn (DWORD code); -/* generic flags-dumping function */ -extern const char *debugstr_flags (DWORD flags, const flag_info* names, size_t num_names); -extern const char *debugstr_DMUS_OBJ_FLAGS (DWORD flagmask); -/* dump whole DMUS_OBJECTDESC struct */ -extern const char *debugstr_DMUS_OBJECTDESC (LPDMUS_OBJECTDESC pDesc); +#include "dmutils.h" #endif /* __WINE_DMSTYLE_PRIVATE_H */ diff --git a/dlls/dmstyle/dmutils.c b/dlls/dmstyle/dmutils.c new file mode 100644 index 00000000000..3da649d3a05 --- /dev/null +++ b/dlls/dmstyle/dmutils.c @@ -0,0 +1,752 @@ +/* Debug and Helper Functions + * + * Copyright (C) 2004 Rok Mandeljc + * Copyright (C) 2004 Raphael Junqueira + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program 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 Library General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#include +#include +#include + +#include "windef.h" +#include "winbase.h" +#include "winnt.h" +#include "wingdi.h" +#include "winuser.h" + +#include "wine/debug.h" +#include "wine/list.h" +#include "wine/unicode.h" +#include "winreg.h" + +#include "dmusici.h" +#include "dmusicf.h" +#include "dmusics.h" + +#include "dmutils.h" + +WINE_DEFAULT_DEBUG_CHANNEL(dmusic); +WINE_DECLARE_DEBUG_CHANNEL(dmfile); + +/* check whether the given DWORD is even (return 0) or odd (return 1) */ +int even_or_odd (DWORD number) { + return (number & 0x1); /* basically, check if bit 0 is set ;) */ +} + +/* figures out whether given FOURCC is valid DirectMusic form ID */ +BOOL IS_VALID_DMFORM (FOURCC chunkID) { + if ((chunkID == DMUS_FOURCC_AUDIOPATH_FORM) || (chunkID == DMUS_FOURCC_BAND_FORM) || (chunkID == DMUS_FOURCC_CHORDMAP_FORM) + || (chunkID == DMUS_FOURCC_CONTAINER_FORM) || (chunkID == FOURCC_DLS) || (chunkID == DMUS_FOURCC_SCRIPT_FORM) + || (chunkID == DMUS_FOURCC_SEGMENT_FORM) || (chunkID == DMUS_FOURCC_STYLE_FORM) || (chunkID == DMUS_FOURCC_TOOLGRAPH_FORM) + || (chunkID == DMUS_FOURCC_TRACK_FORM) || (chunkID == mmioFOURCC('W','A','V','E'))) return TRUE; + else return FALSE; +} + +HRESULT IDirectMusicUtils_IPersistStream_ParseDescGeneric (DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm, LPDMUS_OBJECTDESC pDesc) { + + switch (pChunk->fccID) { + case DMUS_FOURCC_GUID_CHUNK: { + TRACE_(dmfile)(": GUID chunk\n"); + pDesc->dwValidData |= DMUS_OBJ_OBJECT; + IStream_Read (pStm, &pDesc->guidObject, pChunk->dwSize, NULL); + break; + } + case DMUS_FOURCC_DATE_CHUNK: { + TRACE_(dmfile)(": file date chunk\n"); + pDesc->dwValidData |= DMUS_OBJ_DATE; + IStream_Read (pStm, &pDesc->ftDate, pChunk->dwSize, NULL); + break; + } + case DMUS_FOURCC_NAME_CHUNK: { + TRACE_(dmfile)(": name chunk\n"); + pDesc->dwValidData |= DMUS_OBJ_NAME; + IStream_Read (pStm, &pDesc->wszName, pChunk->dwSize, NULL); + break; + } + case DMUS_FOURCC_FILE_CHUNK: { + TRACE_(dmfile)(": file name chunk\n"); + pDesc->dwValidData |= DMUS_OBJ_FILENAME; + IStream_Read (pStm, &pDesc->wszFileName, pChunk->dwSize, NULL); + break; + } + case DMUS_FOURCC_VERSION_CHUNK: { + TRACE_(dmfile)(": version chunk\n"); + pDesc->dwValidData |= DMUS_OBJ_VERSION; + IStream_Read (pStm, &pDesc->vVersion, pChunk->dwSize, NULL); + break; + } + case DMUS_FOURCC_CATEGORY_CHUNK: { + TRACE_(dmfile)(": category chunk\n"); + pDesc->dwValidData |= DMUS_OBJ_CATEGORY; + IStream_Read (pStm, pDesc->wszCategory, pChunk->dwSize, NULL); + break; + } + default: + /* not handled */ + return S_FALSE; + } + + return S_OK; +} + +HRESULT IDirectMusicUtils_IPersistStream_ParseUNFOGeneric (DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm, LPDMUS_OBJECTDESC pDesc) { + + LARGE_INTEGER liMove; /* used when skipping chunks */ + + /** + * don't ask me why, but M$ puts INFO elements in UNFO list sometimes + * (though strings seem to be valid unicode) + */ + switch (pChunk->fccID) { + + case mmioFOURCC('I','N','A','M'): + case DMUS_FOURCC_UNAM_CHUNK: { + TRACE_(dmfile)(": name chunk\n"); + pDesc->dwValidData |= DMUS_OBJ_NAME; + IStream_Read (pStm, pDesc->wszName, pChunk->dwSize, NULL); + TRACE_(dmfile)(" - wszName: %s\n", debugstr_w(pDesc->wszName)); + break; + } + + case mmioFOURCC('I','A','R','T'): + case DMUS_FOURCC_UART_CHUNK: { + TRACE_(dmfile)(": artist chunk (ignored)\n"); + liMove.QuadPart = pChunk->dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + case mmioFOURCC('I','C','O','P'): + case DMUS_FOURCC_UCOP_CHUNK: { + TRACE_(dmfile)(": copyright chunk (ignored)\n"); + liMove.QuadPart = pChunk->dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + case mmioFOURCC('I','S','B','J'): + case DMUS_FOURCC_USBJ_CHUNK: { + TRACE_(dmfile)(": subject chunk (ignored)\n"); + liMove.QuadPart = pChunk->dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + case mmioFOURCC('I','C','M','T'): + case DMUS_FOURCC_UCMT_CHUNK: { + TRACE_(dmfile)(": comment chunk (ignored)\n"); + liMove.QuadPart = pChunk->dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + default: + /* not handled */ + return S_FALSE; + } + + return S_OK; +} + +HRESULT IDirectMusicUtils_IPersistStream_ParseReference (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm, IDirectMusicObject** ppObject) { + DMUS_PRIVATE_CHUNK Chunk; + DWORD ListSize[3], ListCount[3]; + LARGE_INTEGER liMove; /* used when skipping chunks */ + HRESULT hr; + + DMUS_IO_REFERENCE ref; + DMUS_OBJECTDESC ref_desc; + + memset(&ref, 0, sizeof(ref)); + memset(&ref_desc, 0, sizeof(ref_desc)); + + if (pChunk->fccID != DMUS_FOURCC_REF_LIST) { + ERR_(dmfile)(": %s chunk should be a REF list\n", debugstr_fourcc (pChunk->fccID)); + return E_FAIL; + } + + ListSize[0] = pChunk->dwSize - sizeof(FOURCC); + ListCount[0] = 0; + + do { + IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL); + ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize; + TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize); + + hr = IDirectMusicUtils_IPersistStream_ParseDescGeneric(&Chunk, pStm, &ref_desc); + if (FAILED(hr)) return hr; + + if (hr == S_FALSE) { + switch (Chunk.fccID) { + case DMUS_FOURCC_REF_CHUNK: { + TRACE_(dmfile)(": Reference chunk\n"); + if (Chunk.dwSize != sizeof(DMUS_IO_REFERENCE)) return E_FAIL; + IStream_Read (pStm, &ref, sizeof(DMUS_IO_REFERENCE), NULL); + TRACE_(dmfile)(" - guidClassID: %s\n", debugstr_dmguid(&ref.guidClassID)); + TRACE_(dmfile)(" - dwValidData: %lu\n", ref.dwValidData); + break; + } + default: { + TRACE_(dmfile)(": unknown chunk (irrevelant & skipping)\n"); + liMove.QuadPart = Chunk.dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + } + } + TRACE_(dmfile)(": ListCount[0] = %ld < ListSize[0] = %ld\n", ListCount[0], ListSize[0]); + } while (ListCount[0] < ListSize[0]); + + ref_desc.dwValidData |= DMUS_OBJ_CLASS; + memcpy(&ref_desc.guidClass, &ref.guidClassID, sizeof(ref.guidClassID)); + + TRACE_(dmfile)("** DM Reference Begin of Load ***\n"); + TRACE_(dmfile)("With Desc:\n"); + debugstr_DMUS_OBJECTDESC(&ref_desc); + + { + LPDIRECTMUSICGETLOADER pGetLoader = NULL; + LPDIRECTMUSICLOADER pLoader = NULL; + + IStream_QueryInterface (pStm, &IID_IDirectMusicGetLoader, (LPVOID*)&pGetLoader); + IDirectMusicGetLoader_GetLoader (pGetLoader, &pLoader); + IDirectMusicGetLoader_Release (pGetLoader); + + hr = IDirectMusicLoader_GetObject (pLoader, &ref_desc, &IID_IDirectMusicObject, (LPVOID*)ppObject); + IDirectMusicLoader_Release (pLoader); /* release loader */ + } + TRACE_(dmfile)("** DM Reference End of Load ***\n"); + + return S_OK; +} + +/* translate STREAM_SEEK flag to string */ +const char *resolve_STREAM_SEEK (DWORD flag) { + switch (flag) { + case STREAM_SEEK_SET: + return wine_dbg_sprintf ("STREAM_SEEK_SET"); + case STREAM_SEEK_CUR: + return wine_dbg_sprintf ("STREAM_SEEK_CUR"); + case STREAM_SEEK_END: + return wine_dbg_sprintf ("STREAM_SEEK_END"); + default: + return wine_dbg_sprintf ("()"); + } +} + +/* FOURCC to string conversion for debug messages */ +const char *debugstr_fourcc (DWORD fourcc) { + if (!fourcc) return "'null'"; + return wine_dbg_sprintf ("\'%c%c%c%c\'", + (char)(fourcc), (char)(fourcc >> 8), + (char)(fourcc >> 16), (char)(fourcc >> 24)); +} + +/* DMUS_VERSION struct to string conversion for debug messages */ +const char *debugstr_dmversion (LPDMUS_VERSION version) { + if (!version) return "'null'"; + return wine_dbg_sprintf ("\'%i,%i,%i,%i\'", + HIWORD(version->dwVersionMS),LOWORD(version->dwVersionMS), + HIWORD(version->dwVersionLS), LOWORD(version->dwVersionLS)); +} + +/* month number into month name (for debugstr_filetime) */ +const char *debugstr_month (DWORD dwMonth) { + switch (dwMonth) { + case 1: return "January"; + case 2: return "February"; + case 3: return "March"; + case 4: return "April"; + case 5: return "May"; + case 6: return "June"; + case 7: return "July"; + case 8: return "August"; + case 9: return "September"; + case 10: return "October"; + case 11: return "November"; + case 12: return "December"; + default: return "Invalid"; + } +} + +/* FILETIME struct to string conversion for debug messages */ +const char *debugstr_filetime (LPFILETIME time) { + SYSTEMTIME sysTime; + + if (!time) return "'null'"; + + FileTimeToSystemTime (time, &sysTime); + + return wine_dbg_sprintf ("\'%02i. %s %04i %02i:%02i:%02i\'", \ + sysTime.wDay, debugstr_month(sysTime.wMonth), sysTime.wYear, + sysTime.wHour, sysTime.wMinute, sysTime.wSecond); +} + +/* returns name of given GUID */ +const char *debugstr_dmguid (const GUID *id) { + static const guid_info guids[] = { + /* CLSIDs */ + GE(CLSID_AudioVBScript), + GE(CLSID_DirectMusic), + GE(CLSID_DirectMusicAudioPath), + GE(CLSID_DirectMusicAudioPathConfig), + GE(CLSID_DirectMusicAuditionTrack), + GE(CLSID_DirectMusicBand), + GE(CLSID_DirectMusicBandTrack), + GE(CLSID_DirectMusicChordMapTrack), + GE(CLSID_DirectMusicChordMap), + GE(CLSID_DirectMusicChordTrack), + GE(CLSID_DirectMusicCollection), + GE(CLSID_DirectMusicCommandTrack), + GE(CLSID_DirectMusicComposer), + GE(CLSID_DirectMusicContainer), + GE(CLSID_DirectMusicGraph), + GE(CLSID_DirectMusicLoader), + GE(CLSID_DirectMusicLyricsTrack), + GE(CLSID_DirectMusicMarkerTrack), + GE(CLSID_DirectMusicMelodyFormulationTrack), + GE(CLSID_DirectMusicMotifTrack), + GE(CLSID_DirectMusicMuteTrack), + GE(CLSID_DirectMusicParamControlTrack), + GE(CLSID_DirectMusicPatternTrack), + GE(CLSID_DirectMusicPerformance), + GE(CLSID_DirectMusicScript), + GE(CLSID_DirectMusicScriptAutoImpSegment), + GE(CLSID_DirectMusicScriptAutoImpPerformance), + GE(CLSID_DirectMusicScriptAutoImpSegmentState), + GE(CLSID_DirectMusicScriptAutoImpAudioPathConfig), + GE(CLSID_DirectMusicScriptAutoImpAudioPath), + GE(CLSID_DirectMusicScriptAutoImpSong), + GE(CLSID_DirectMusicScriptSourceCodeLoader), + GE(CLSID_DirectMusicScriptTrack), + GE(CLSID_DirectMusicSection), + GE(CLSID_DirectMusicSegment), + GE(CLSID_DirectMusicSegmentState), + GE(CLSID_DirectMusicSegmentTriggerTrack), + GE(CLSID_DirectMusicSegTriggerTrack), + GE(CLSID_DirectMusicSeqTrack), + GE(CLSID_DirectMusicSignPostTrack), + GE(CLSID_DirectMusicSong), + GE(CLSID_DirectMusicStyle), + GE(CLSID_DirectMusicStyleTrack), + GE(CLSID_DirectMusicSynth), + GE(CLSID_DirectMusicSynthSink), + GE(CLSID_DirectMusicSysExTrack), + GE(CLSID_DirectMusicTemplate), + GE(CLSID_DirectMusicTempoTrack), + GE(CLSID_DirectMusicTimeSigTrack), + GE(CLSID_DirectMusicWaveTrack), + GE(CLSID_DirectSoundWave), + /* IIDs */ + GE(IID_IDirectMusic), + GE(IID_IDirectMusic2), + GE(IID_IDirectMusic8), + GE(IID_IDirectMusicAudioPath), + GE(IID_IDirectMusicBand), + GE(IID_IDirectMusicBuffer), + GE(IID_IDirectMusicChordMap), + GE(IID_IDirectMusicCollection), + GE(IID_IDirectMusicComposer), + GE(IID_IDirectMusicContainer), + GE(IID_IDirectMusicDownload), + GE(IID_IDirectMusicDownloadedInstrument), + GE(IID_IDirectMusicGetLoader), + GE(IID_IDirectMusicGraph), + GE(IID_IDirectMusicInstrument), + GE(IID_IDirectMusicLoader), + GE(IID_IDirectMusicLoader8), + GE(IID_IDirectMusicObject), + GE(IID_IDirectMusicPatternTrack), + GE(IID_IDirectMusicPerformance), + GE(IID_IDirectMusicPerformance2), + GE(IID_IDirectMusicPerformance8), + GE(IID_IDirectMusicPort), + GE(IID_IDirectMusicPortDownload), + GE(IID_IDirectMusicScript), + GE(IID_IDirectMusicSegment), + GE(IID_IDirectMusicSegment2), + GE(IID_IDirectMusicSegment8), + GE(IID_IDirectMusicSegmentState), + GE(IID_IDirectMusicSegmentState8), + GE(IID_IDirectMusicStyle), + GE(IID_IDirectMusicStyle8), + GE(IID_IDirectMusicSynth), + GE(IID_IDirectMusicSynth8), + GE(IID_IDirectMusicSynthSink), + GE(IID_IDirectMusicThru), + GE(IID_IDirectMusicTool), + GE(IID_IDirectMusicTool8), + GE(IID_IDirectMusicTrack), + GE(IID_IDirectMusicTrack8), + GE(IID_IUnknown), + GE(IID_IPersistStream), + GE(IID_IStream), + GE(IID_IClassFactory), + /* GUIDs */ + GE(GUID_DirectMusicAllTypes), + GE(GUID_NOTIFICATION_CHORD), + GE(GUID_NOTIFICATION_COMMAND), + GE(GUID_NOTIFICATION_MEASUREANDBEAT), + GE(GUID_NOTIFICATION_PERFORMANCE), + GE(GUID_NOTIFICATION_RECOMPOSE), + GE(GUID_NOTIFICATION_SEGMENT), + GE(GUID_BandParam), + GE(GUID_ChordParam), + GE(GUID_CommandParam), + GE(GUID_CommandParam2), + GE(GUID_CommandParamNext), + GE(GUID_IDirectMusicBand), + GE(GUID_IDirectMusicChordMap), + GE(GUID_IDirectMusicStyle), + GE(GUID_MuteParam), + GE(GUID_Play_Marker), + GE(GUID_RhythmParam), + GE(GUID_TempoParam), + GE(GUID_TimeSignature), + GE(GUID_Valid_Start_Time), + GE(GUID_Clear_All_Bands), + GE(GUID_ConnectToDLSCollection), + GE(GUID_Disable_Auto_Download), + GE(GUID_DisableTempo), + GE(GUID_DisableTimeSig), + GE(GUID_Download), + GE(GUID_DownloadToAudioPath), + GE(GUID_Enable_Auto_Download), + GE(GUID_EnableTempo), + GE(GUID_EnableTimeSig), + GE(GUID_IgnoreBankSelectForGM), + GE(GUID_SeedVariations), + GE(GUID_StandardMIDIFile), + GE(GUID_Unload), + GE(GUID_UnloadFromAudioPath), + GE(GUID_Variations), + GE(GUID_PerfMasterTempo), + GE(GUID_PerfMasterVolume), + GE(GUID_PerfMasterGrooveLevel), + GE(GUID_PerfAutoDownload), + GE(GUID_DefaultGMCollection), + GE(GUID_Synth_Default), + GE(GUID_Buffer_Reverb), + GE(GUID_Buffer_EnvReverb), + GE(GUID_Buffer_Stereo), + GE(GUID_Buffer_3D_Dry), + GE(GUID_Buffer_Mono), + GE(GUID_DMUS_PROP_GM_Hardware), + GE(GUID_DMUS_PROP_GS_Capable), + GE(GUID_DMUS_PROP_GS_Hardware), + GE(GUID_DMUS_PROP_DLS1), + GE(GUID_DMUS_PROP_DLS2), + GE(GUID_DMUS_PROP_Effects), + GE(GUID_DMUS_PROP_INSTRUMENT2), + GE(GUID_DMUS_PROP_LegacyCaps), + GE(GUID_DMUS_PROP_MemorySize), + GE(GUID_DMUS_PROP_SampleMemorySize), + GE(GUID_DMUS_PROP_SamplePlaybackRate), + GE(GUID_DMUS_PROP_SetSynthSink), + GE(GUID_DMUS_PROP_SinkUsesDSound), + GE(GUID_DMUS_PROP_SynthSink_DSOUND), + GE(GUID_DMUS_PROP_SynthSink_WAVE), + GE(GUID_DMUS_PROP_Volume), + GE(GUID_DMUS_PROP_WavesReverb), + GE(GUID_DMUS_PROP_WriteLatency), + GE(GUID_DMUS_PROP_WritePeriod), + GE(GUID_DMUS_PROP_XG_Capable), + GE(GUID_DMUS_PROP_XG_Hardware) + }; + + unsigned int i; + + if (!id) return "(null)"; + for (i = 0; i < sizeof(guids)/sizeof(guids[0]); i++) { + if (IsEqualGUID(id, guids[i].guid)) + return guids[i].name; + } + + /* if we didn't find it, act like standard debugstr_guid */ + return debugstr_guid(id); +} + +/* returns name of given error code */ +const char *debugstr_dmreturn (DWORD code) { + static const flag_info codes[] = { + FE(S_OK), + FE(S_FALSE), + FE(DMUS_S_PARTIALLOAD), + FE(DMUS_S_PARTIALDOWNLOAD), + FE(DMUS_S_REQUEUE), + FE(DMUS_S_FREE), + FE(DMUS_S_END), + FE(DMUS_S_STRING_TRUNCATED), + FE(DMUS_S_LAST_TOOL), + FE(DMUS_S_OVER_CHORD), + FE(DMUS_S_UP_OCTAVE), + FE(DMUS_S_DOWN_OCTAVE), + FE(DMUS_S_NOBUFFERCONTROL), + FE(DMUS_S_GARBAGE_COLLECTED), + FE(E_NOTIMPL), + FE(E_NOINTERFACE), + FE(E_POINTER), + FE(CLASS_E_NOAGGREGATION), + FE(CLASS_E_CLASSNOTAVAILABLE), + FE(REGDB_E_CLASSNOTREG), + FE(E_OUTOFMEMORY), + FE(E_FAIL), + FE(E_INVALIDARG), + FE(DMUS_E_DRIVER_FAILED), + FE(DMUS_E_PORTS_OPEN), + FE(DMUS_E_DEVICE_IN_USE), + FE(DMUS_E_INSUFFICIENTBUFFER), + FE(DMUS_E_BUFFERNOTSET), + FE(DMUS_E_BUFFERNOTAVAILABLE), + FE(DMUS_E_NOTADLSCOL), + FE(DMUS_E_INVALIDOFFSET), + FE(DMUS_E_ALREADY_LOADED), + FE(DMUS_E_INVALIDPOS), + FE(DMUS_E_INVALIDPATCH), + FE(DMUS_E_CANNOTSEEK), + FE(DMUS_E_CANNOTWRITE), + FE(DMUS_E_CHUNKNOTFOUND), + FE(DMUS_E_INVALID_DOWNLOADID), + FE(DMUS_E_NOT_DOWNLOADED_TO_PORT), + FE(DMUS_E_ALREADY_DOWNLOADED), + FE(DMUS_E_UNKNOWN_PROPERTY), + FE(DMUS_E_SET_UNSUPPORTED), + FE(DMUS_E_GET_UNSUPPORTED), + FE(DMUS_E_NOTMONO), + FE(DMUS_E_BADARTICULATION), + FE(DMUS_E_BADINSTRUMENT), + FE(DMUS_E_BADWAVELINK), + FE(DMUS_E_NOARTICULATION), + FE(DMUS_E_NOTPCM), + FE(DMUS_E_BADWAVE), + FE(DMUS_E_BADOFFSETTABLE), + FE(DMUS_E_UNKNOWNDOWNLOAD), + FE(DMUS_E_NOSYNTHSINK), + FE(DMUS_E_ALREADYOPEN), + FE(DMUS_E_ALREADYCLOSED), + FE(DMUS_E_SYNTHNOTCONFIGURED), + FE(DMUS_E_SYNTHACTIVE), + FE(DMUS_E_CANNOTREAD), + FE(DMUS_E_DMUSIC_RELEASED), + FE(DMUS_E_BUFFER_EMPTY), + FE(DMUS_E_BUFFER_FULL), + FE(DMUS_E_PORT_NOT_CAPTURE), + FE(DMUS_E_PORT_NOT_RENDER), + FE(DMUS_E_DSOUND_NOT_SET), + FE(DMUS_E_ALREADY_ACTIVATED), + FE(DMUS_E_INVALIDBUFFER), + FE(DMUS_E_WAVEFORMATNOTSUPPORTED), + FE(DMUS_E_SYNTHINACTIVE), + FE(DMUS_E_DSOUND_ALREADY_SET), + FE(DMUS_E_INVALID_EVENT), + FE(DMUS_E_UNSUPPORTED_STREAM), + FE(DMUS_E_ALREADY_INITED), + FE(DMUS_E_INVALID_BAND), + FE(DMUS_E_TRACK_HDR_NOT_FIRST_CK), + FE(DMUS_E_TOOL_HDR_NOT_FIRST_CK), + FE(DMUS_E_INVALID_TRACK_HDR), + FE(DMUS_E_INVALID_TOOL_HDR), + FE(DMUS_E_ALL_TOOLS_FAILED), + FE(DMUS_E_ALL_TRACKS_FAILED), + FE(DMUS_E_NOT_FOUND), + FE(DMUS_E_NOT_INIT), + FE(DMUS_E_TYPE_DISABLED), + FE(DMUS_E_TYPE_UNSUPPORTED), + FE(DMUS_E_TIME_PAST), + FE(DMUS_E_TRACK_NOT_FOUND), + FE(DMUS_E_TRACK_NO_CLOCKTIME_SUPPORT), + FE(DMUS_E_NO_MASTER_CLOCK), + FE(DMUS_E_LOADER_NOCLASSID), + FE(DMUS_E_LOADER_BADPATH), + FE(DMUS_E_LOADER_FAILEDOPEN), + FE(DMUS_E_LOADER_FORMATNOTSUPPORTED), + FE(DMUS_E_LOADER_FAILEDCREATE), + FE(DMUS_E_LOADER_OBJECTNOTFOUND), + FE(DMUS_E_LOADER_NOFILENAME), + FE(DMUS_E_INVALIDFILE), + FE(DMUS_E_ALREADY_EXISTS), + FE(DMUS_E_OUT_OF_RANGE), + FE(DMUS_E_SEGMENT_INIT_FAILED), + FE(DMUS_E_ALREADY_SENT), + FE(DMUS_E_CANNOT_FREE), + FE(DMUS_E_CANNOT_OPEN_PORT), + FE(DMUS_E_CANNOT_CONVERT), + FE(DMUS_E_DESCEND_CHUNK_FAIL), + FE(DMUS_E_NOT_LOADED), + FE(DMUS_E_SCRIPT_LANGUAGE_INCOMPATIBLE), + FE(DMUS_E_SCRIPT_UNSUPPORTED_VARTYPE), + FE(DMUS_E_SCRIPT_ERROR_IN_SCRIPT), + FE(DMUS_E_SCRIPT_CANTLOAD_OLEAUT32), + FE(DMUS_E_SCRIPT_LOADSCRIPT_ERROR), + FE(DMUS_E_SCRIPT_INVALID_FILE), + FE(DMUS_E_INVALID_SCRIPTTRACK), + FE(DMUS_E_SCRIPT_VARIABLE_NOT_FOUND), + FE(DMUS_E_SCRIPT_ROUTINE_NOT_FOUND), + FE(DMUS_E_SCRIPT_CONTENT_READONLY), + FE(DMUS_E_SCRIPT_NOT_A_REFERENCE), + FE(DMUS_E_SCRIPT_VALUE_NOT_SUPPORTED), + FE(DMUS_E_INVALID_SEGMENTTRIGGERTRACK), + FE(DMUS_E_INVALID_LYRICSTRACK), + FE(DMUS_E_INVALID_PARAMCONTROLTRACK), + FE(DMUS_E_AUDIOVBSCRIPT_SYNTAXERROR), + FE(DMUS_E_AUDIOVBSCRIPT_RUNTIMEERROR), + FE(DMUS_E_AUDIOVBSCRIPT_OPERATIONFAILURE), + FE(DMUS_E_AUDIOPATHS_NOT_VALID), + FE(DMUS_E_AUDIOPATHS_IN_USE), + FE(DMUS_E_NO_AUDIOPATH_CONFIG), + FE(DMUS_E_AUDIOPATH_INACTIVE), + FE(DMUS_E_AUDIOPATH_NOBUFFER), + FE(DMUS_E_AUDIOPATH_NOPORT), + FE(DMUS_E_NO_AUDIOPATH), + FE(DMUS_E_INVALIDCHUNK), + FE(DMUS_E_AUDIOPATH_NOGLOBALFXBUFFER), + FE(DMUS_E_INVALID_CONTAINER_OBJECT) + }; + + unsigned int i; + for (i = 0; i < sizeof(codes)/sizeof(codes[0]); i++) { + if (code == codes[i].val) + return codes[i].name; + } + + /* if we didn't find it, return value */ + return wine_dbg_sprintf("0x%08lX", code); +} + + +/* generic flag-dumping function */ +const char* debugstr_flags (DWORD flags, const flag_info* names, size_t num_names){ + static char buffer[128] = "", *ptr = &buffer[0]; + unsigned int i, size = sizeof(buffer); + + for (i=0; i < num_names; i++) { + if ((flags & names[i].val)) { + int cnt = snprintf(ptr, size, "%s ", names[i].name); + if (cnt < 0 || cnt >= size) break; + size -= cnt; + ptr += cnt; + } + } + + ptr = &buffer[0]; + return ptr; +} + +/* dump DMUS_OBJ flags */ +const char *debugstr_DMUS_OBJ_FLAGS (DWORD flagmask) { + static const flag_info flags[] = { + FE(DMUS_OBJ_OBJECT), + FE(DMUS_OBJ_CLASS), + FE(DMUS_OBJ_NAME), + FE(DMUS_OBJ_CATEGORY), + FE(DMUS_OBJ_FILENAME), + FE(DMUS_OBJ_FULLPATH), + FE(DMUS_OBJ_URL), + FE(DMUS_OBJ_VERSION), + FE(DMUS_OBJ_DATE), + FE(DMUS_OBJ_LOADED), + FE(DMUS_OBJ_MEMORY), + FE(DMUS_OBJ_STREAM) + }; + return debugstr_flags (flagmask, flags, sizeof(flags)/sizeof(flags[0])); +} + +/* dump DMUS_CONTAINER flags */ +const char *debugstr_DMUS_CONTAINER_FLAGS (DWORD flagmask) { + static const flag_info flags[] = { + FE(DMUS_CONTAINER_NOLOADS) + }; + return debugstr_flags (flagmask, flags, sizeof(flags)/sizeof(flags[0])); +} + +/* dump DMUS_CONTAINED_OBJF flags */ +const char *debugstr_DMUS_CONTAINED_OBJF_FLAGS (DWORD flagmask) { + static const flag_info flags[] = { + FE(DMUS_CONTAINED_OBJF_KEEP) + }; + return debugstr_flags (flagmask, flags, sizeof(flags)/sizeof(flags[0])); +} + +const char *debugstr_DMUS_OBJECTDESC (LPDMUS_OBJECTDESC pDesc) { + if (pDesc) { + char buffer[1024] = "", *ptr = &buffer[0]; + + ptr += sprintf(ptr, "DMUS_OBJECTDESC (%p):\n", pDesc); + ptr += sprintf(ptr, " - dwSize = 0x%08lX\n", pDesc->dwSize); + ptr += sprintf(ptr, " - dwValidData = 0x%08lX ( %s)\n", pDesc->dwValidData, debugstr_DMUS_OBJ_FLAGS (pDesc->dwValidData)); + if (pDesc->dwValidData & DMUS_OBJ_CLASS) ptr += sprintf(ptr, " - guidClass = %s\n", debugstr_dmguid(&pDesc->guidClass)); + if (pDesc->dwValidData & DMUS_OBJ_OBJECT) ptr += sprintf(ptr, " - guidObject = %s\n", debugstr_guid(&pDesc->guidObject)); + if (pDesc->dwValidData & DMUS_OBJ_DATE) ptr += sprintf(ptr, " - ftDate = %s\n", debugstr_filetime (&pDesc->ftDate)); + if (pDesc->dwValidData & DMUS_OBJ_VERSION) ptr += sprintf(ptr, " - vVersion = %s\n", debugstr_dmversion(&pDesc->vVersion)); + if (pDesc->dwValidData & DMUS_OBJ_NAME) ptr += sprintf(ptr, " - wszName = %s\n", debugstr_w(pDesc->wszName)); + if (pDesc->dwValidData & DMUS_OBJ_CATEGORY) ptr += sprintf(ptr, " - wszCategory = %s\n", debugstr_w(pDesc->wszCategory)); + if (pDesc->dwValidData & DMUS_OBJ_FILENAME) ptr += sprintf(ptr, " - wszFileName = %s\n", debugstr_w(pDesc->wszFileName)); + if (pDesc->dwValidData & DMUS_OBJ_MEMORY) ptr += sprintf(ptr, " - llMemLength = %lli\n - pbMemData = %p\n", pDesc->llMemLength, pDesc->pbMemData); + if (pDesc->dwValidData & DMUS_OBJ_STREAM) ptr += sprintf(ptr, " - pStream = %p\n", pDesc->pStream); + + ptr = &buffer[0]; + return ptr; + } else { + return wine_dbg_sprintf("(NULL)"); + } +} + +void debug_DMUS_OBJECTDESC (LPDMUS_OBJECTDESC pDesc) { + if (pDesc) { + TRACE("DMUS_OBJECTDESC (%p):\n", pDesc); + TRACE(" - dwSize = %ld\n", pDesc->dwSize); + TRACE(" - dwValidData = %s\n", debugstr_DMUS_OBJ_FLAGS (pDesc->dwValidData)); + if (pDesc->dwValidData & DMUS_OBJ_NAME) TRACE(" - wszName = %s\n", debugstr_w(pDesc->wszName)); + if (pDesc->dwValidData & DMUS_OBJ_CLASS) TRACE(" - guidClass = %s\n", debugstr_dmguid(&pDesc->guidClass)); + if (pDesc->dwValidData & DMUS_OBJ_OBJECT) TRACE(" - guidObject = %s\n", debugstr_guid(&pDesc->guidObject)); + if (pDesc->dwValidData & DMUS_OBJ_DATE) TRACE(" - ftDate = FIXME\n"); + if (pDesc->dwValidData & DMUS_OBJ_VERSION) TRACE(" - vVersion = %s\n", debugstr_dmversion(&pDesc->vVersion)); + if (pDesc->dwValidData & DMUS_OBJ_CATEGORY) TRACE(" - wszCategory = %s\n", debugstr_w(pDesc->wszCategory)); + if (pDesc->dwValidData & DMUS_OBJ_FILENAME) TRACE(" - wszFileName = %s\n", debugstr_w(pDesc->wszFileName)); + if (pDesc->dwValidData & DMUS_OBJ_MEMORY) TRACE(" - llMemLength = %lli\n - pbMemData = %p\n", pDesc->llMemLength, pDesc->pbMemData); + if (pDesc->dwValidData & DMUS_OBJ_STREAM) TRACE(" - pStream = %p\n", pDesc->pStream); + } else { + TRACE("(NULL)\n"); + } +} + +const char *debugstr_DMUS_IO_CONTAINER_HEADER (LPDMUS_IO_CONTAINER_HEADER pHeader) { + if (pHeader) { + char buffer[1024] = "", *ptr = &buffer[0]; + + ptr += sprintf(ptr, "DMUS_IO_CONTAINER_HEADER (%p):\n", pHeader); + ptr += sprintf(ptr, " - dwFlags = %s\n", debugstr_DMUS_CONTAINER_FLAGS(pHeader->dwFlags)); + + ptr = &buffer[0]; + return ptr; + } else { + return wine_dbg_sprintf("(NULL)"); + } +} + +const char *debugstr_DMUS_IO_CONTAINED_OBJECT_HEADER (LPDMUS_IO_CONTAINED_OBJECT_HEADER pHeader) { + if (pHeader) { + char buffer[1024] = "", *ptr = &buffer[0]; + + ptr += sprintf(ptr, "DMUS_IO_CONTAINED_OBJECT_HEADER (%p):\n", pHeader); + ptr += sprintf(ptr, " - guidClassID = %s\n", debugstr_dmguid(&pHeader->guidClassID)); + ptr += sprintf(ptr, " - dwFlags = %s\n", debugstr_DMUS_CONTAINED_OBJF_FLAGS (pHeader->dwFlags)); + ptr += sprintf(ptr, " - ckid = %s\n", debugstr_fourcc (pHeader->ckid)); + ptr += sprintf(ptr, " - fccType = %s\n", debugstr_fourcc (pHeader->fccType)); + + ptr = &buffer[0]; + return ptr; + } else { + return wine_dbg_sprintf("(NULL)"); + } +} diff --git a/dlls/dmstyle/dmutils.h b/dlls/dmstyle/dmutils.h new file mode 100644 index 00000000000..c8651619d7b --- /dev/null +++ b/dlls/dmstyle/dmutils.h @@ -0,0 +1,89 @@ +/* Debug and Helper Functions + * + * Copyright (C) 2003-2004 Rok Mandeljc + * Copyright (C) 2003-2004 Raphael Junqueira + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program 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 Library General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. + */ + +#ifndef __WINE_DMUTILS_H +#define __WINE_DMUTILS_H + +/* for simpler reading */ +typedef struct _DMUS_PRIVATE_CHUNK { + FOURCC fccID; /* FOURCC ID of the chunk */ + DWORD dwSize; /* size of the chunk */ +} DMUS_PRIVATE_CHUNK, *LPDMUS_PRIVATE_CHUNK; + +/** + * Parsing utilities + */ +extern HRESULT IDirectMusicUtils_IPersistStream_ParseDescGeneric (DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm, LPDMUS_OBJECTDESC pDesc); +extern HRESULT IDirectMusicUtils_IPersistStream_ParseUNFOGeneric (DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm, LPDMUS_OBJECTDESC pDesc); +extern HRESULT IDirectMusicUtils_IPersistStream_ParseReference (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm, IDirectMusicObject** ppObject); + +/** + * Debug utilities + */ +/* used for generic dumping (copied from ddraw) */ +typedef struct { + DWORD val; + const char* name; +} flag_info; + +typedef struct { + const GUID *guid; + const char* name; +} guid_info; + +/* used for initialising structs */ +#define DM_STRUCT_INIT(x) \ + do { \ + memset((x), 0, sizeof(*(x))); \ + (x)->dwSize = sizeof(*x); \ + } while (0) + +#define FE(x) { x, #x } +#define GE(x) { &x, #x } + +/* check whether the given DWORD is even (return 0) or odd (return 1) */ +extern int even_or_odd (DWORD number); +/* check whether chunkID is valid dmobject form chunk */ +extern BOOL IS_VALID_DMFORM (FOURCC chunkID); +/* translate STREAM_SEEK flag to string */ +extern const char *resolve_STREAM_SEEK (DWORD flag); +/* FOURCC to string conversion for debug messages */ +extern const char *debugstr_fourcc (DWORD fourcc); +/* DMUS_VERSION struct to string conversion for debug messages */ +extern const char *debugstr_dmversion (LPDMUS_VERSION version); +/* FILETIME struct to string conversion for debug messages */ +extern const char *debugstr_filetime (LPFILETIME time); +/* returns name of given GUID */ +extern const char *debugstr_dmguid (const GUID *id); +/* returns name of given error code */ +extern const char *debugstr_dmreturn (DWORD code); +/* generic flags-dumping function */ +extern const char *debugstr_flags (DWORD flags, const flag_info* names, size_t num_names); + +extern const char *debugstr_DMUS_OBJ_FLAGS (DWORD flagmask); +extern const char *debugstr_DMUS_CONTAINER_FLAGS (DWORD flagmask); +extern const char *debugstr_DMUS_CONTAINED_OBJF_FLAGS (DWORD flagmask); +/* dump whole DMUS_OBJECTDESC struct */ +extern const char *debugstr_DMUS_OBJECTDESC (LPDMUS_OBJECTDESC pDesc); +extern void debug_DMUS_OBJECTDESC (LPDMUS_OBJECTDESC pDesc); +extern const char *debugstr_DMUS_IO_CONTAINER_HEADER (LPDMUS_IO_CONTAINER_HEADER pHeader); +extern const char *debugstr_DMUS_IO_CONTAINED_OBJECT_HEADER (LPDMUS_IO_CONTAINED_OBJECT_HEADER pHeader); + +#endif /* __WINE_DMUTILS_H */ diff --git a/dlls/dmstyle/style.c b/dlls/dmstyle/style.c index 2bae932ec85..1e6aad35cb9 100644 --- a/dlls/dmstyle/style.c +++ b/dlls/dmstyle/style.c @@ -1,6 +1,7 @@ /* IDirectMusicStyle8 Implementation * * Copyright (C) 2003-2004 Rok Mandeljc + * Copyright (C) 2003-2004 Raphael Junqueira * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License as published by @@ -391,224 +392,570 @@ HRESULT WINAPI IDirectMusicStyle8Impl_IDirectMusicObject_ParseDescriptor (LPDIRE } ICOM_VTABLE(IDirectMusicObject) DirectMusicStyle8_Object_Vtbl = { - ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE - IDirectMusicStyle8Impl_IDirectMusicObject_QueryInterface, - IDirectMusicStyle8Impl_IDirectMusicObject_AddRef, - IDirectMusicStyle8Impl_IDirectMusicObject_Release, - IDirectMusicStyle8Impl_IDirectMusicObject_GetDescriptor, - IDirectMusicStyle8Impl_IDirectMusicObject_SetDescriptor, - IDirectMusicStyle8Impl_IDirectMusicObject_ParseDescriptor + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + IDirectMusicStyle8Impl_IDirectMusicObject_QueryInterface, + IDirectMusicStyle8Impl_IDirectMusicObject_AddRef, + IDirectMusicStyle8Impl_IDirectMusicObject_Release, + IDirectMusicStyle8Impl_IDirectMusicObject_GetDescriptor, + IDirectMusicStyle8Impl_IDirectMusicObject_SetDescriptor, + IDirectMusicStyle8Impl_IDirectMusicObject_ParseDescriptor }; /* IDirectMusicStyle8Impl IPersistStream part: */ HRESULT WINAPI IDirectMusicStyle8Impl_IPersistStream_QueryInterface (LPPERSISTSTREAM iface, REFIID riid, LPVOID *ppobj) { - ICOM_THIS_MULTI(IDirectMusicStyle8Impl, PersistStreamVtbl, iface); - return IDirectMusicStyle8Impl_IUnknown_QueryInterface ((LPUNKNOWN)&This->UnknownVtbl, riid, ppobj); + ICOM_THIS_MULTI(IDirectMusicStyle8Impl, PersistStreamVtbl, iface); + return IDirectMusicStyle8Impl_IUnknown_QueryInterface ((LPUNKNOWN)&This->UnknownVtbl, riid, ppobj); } ULONG WINAPI IDirectMusicStyle8Impl_IPersistStream_AddRef (LPPERSISTSTREAM iface) { - ICOM_THIS_MULTI(IDirectMusicStyle8Impl, PersistStreamVtbl, iface); - return IDirectMusicStyle8Impl_IUnknown_AddRef ((LPUNKNOWN)&This->UnknownVtbl); + ICOM_THIS_MULTI(IDirectMusicStyle8Impl, PersistStreamVtbl, iface); + return IDirectMusicStyle8Impl_IUnknown_AddRef ((LPUNKNOWN)&This->UnknownVtbl); } ULONG WINAPI IDirectMusicStyle8Impl_IPersistStream_Release (LPPERSISTSTREAM iface) { - ICOM_THIS_MULTI(IDirectMusicStyle8Impl, PersistStreamVtbl, iface); - return IDirectMusicStyle8Impl_IUnknown_Release ((LPUNKNOWN)&This->UnknownVtbl); + ICOM_THIS_MULTI(IDirectMusicStyle8Impl, PersistStreamVtbl, iface); + return IDirectMusicStyle8Impl_IUnknown_Release ((LPUNKNOWN)&This->UnknownVtbl); } HRESULT WINAPI IDirectMusicStyle8Impl_IPersistStream_GetClassID (LPPERSISTSTREAM iface, CLSID* pClassID) { - return E_NOTIMPL; + ICOM_THIS_MULTI(IDirectMusicStyle8Impl, PersistStreamVtbl, iface); + TRACE("(%p, %p)\n", This, pClassID); + memcpy(pClassID, &CLSID_DirectMusicStyle, sizeof(CLSID)); + return S_OK; } HRESULT WINAPI IDirectMusicStyle8Impl_IPersistStream_IsDirty (LPPERSISTSTREAM iface) { - return E_NOTIMPL; + ICOM_THIS_MULTI(IDirectMusicStyle8Impl, PersistStreamVtbl, iface); + FIXME("(%p): stub, always S_FALSE\n", This); + return S_FALSE; +} + +static HRESULT IDirectMusicStyle8Impl_IPersistStream_ParsePartRefList (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm) { + /*ICOM_THIS_MULTI(IDirectMusicStyle8Impl, PersistStreamVtbl, iface);*/ + HRESULT hr = E_FAIL; + DMUS_PRIVATE_CHUNK Chunk; + DWORD ListSize[3], ListCount[3]; + LARGE_INTEGER liMove; /* used when skipping chunks */ + + DMUS_OBJECTDESC desc; + + if (pChunk->fccID != DMUS_FOURCC_PARTREF_LIST) { + ERR_(dmfile)(": %s chunk should be a PARTREF list\n", debugstr_fourcc (pChunk->fccID)); + return E_FAIL; + } + + ListSize[0] = pChunk->dwSize - sizeof(FOURCC); + ListCount[0] = 0; + + do { + IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL); + ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize; + TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize); + switch (Chunk.fccID) { + case DMUS_FOURCC_PARTREF_CHUNK: { + TRACE_(dmfile)(": PartRef chunk (skipping for now)\n"); + liMove.QuadPart = Chunk.dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + case FOURCC_LIST: { + IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL); + TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(Chunk.fccID)); + ListSize[1] = Chunk.dwSize - sizeof(FOURCC); + ListCount[1] = 0; + switch (Chunk.fccID) { + case DMUS_FOURCC_UNFO_LIST: { + TRACE_(dmfile)(": UNFO list\n"); + do { + IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL); + ListCount[1] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize; + TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize); + + hr = IDirectMusicUtils_IPersistStream_ParseUNFOGeneric(&Chunk, pStm, &desc); + if (FAILED(hr)) return hr; + + if (hr == S_FALSE) { + switch (Chunk.fccID) { + default: { + TRACE_(dmfile)(": unknown chunk (irrevelant & skipping)\n"); + liMove.QuadPart = Chunk.dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + } + } + TRACE_(dmfile)(": ListCount[1] = %ld < ListSize[1] = %ld\n", ListCount[1], ListSize[1]); + } while (ListCount[1] < ListSize[1]); + break; + } + default: { + TRACE_(dmfile)(": unknown chunk (skipping)\n"); + liMove.QuadPart = Chunk.dwSize - sizeof(FOURCC); + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + } + break; + } + default: { + TRACE_(dmfile)(": unknown chunk (irrevelant & skipping)\n"); + liMove.QuadPart = Chunk.dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + } + TRACE_(dmfile)(": ListCount[0] = %ld < ListSize[0] = %ld\n", ListCount[0], ListSize[0]); + } while (ListCount[0] < ListSize[0]); + + return S_OK; +} + +static HRESULT IDirectMusicStyle8Impl_IPersistStream_ParsePartList (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm) { + + /*ICOM_THIS_MULTI(IDirectMusicStyle8Impl, PersistStreamVtbl, iface);*/ + HRESULT hr = E_FAIL; + DMUS_PRIVATE_CHUNK Chunk; + DWORD ListSize[3], ListCount[3]; + LARGE_INTEGER liMove; /* used when skipping chunks */ + + DMUS_OBJECTDESC desc; + + if (pChunk->fccID != DMUS_FOURCC_PART_LIST) { + ERR_(dmfile)(": %s chunk should be a PART list\n", debugstr_fourcc (pChunk->fccID)); + return E_FAIL; + } + + ListSize[0] = pChunk->dwSize - sizeof(FOURCC); + ListCount[0] = 0; + + do { + IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL); + ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize; + TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize); + switch (Chunk.fccID) { + case DMUS_FOURCC_PART_CHUNK: { + TRACE_(dmfile)(": Part chunk (skipping for now)\n"); + liMove.QuadPart = Chunk.dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + case DMUS_FOURCC_NOTE_CHUNK: { + TRACE_(dmfile)(": Note chunk (skipping for now)\n"); + liMove.QuadPart = Chunk.dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + case DMUS_FOURCC_CURVE_CHUNK: { + TRACE_(dmfile)(": Curve chunk (skipping for now)\n"); + liMove.QuadPart = Chunk.dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + case DMUS_FOURCC_MARKER_CHUNK: { + TRACE_(dmfile)(": Marker chunk (skipping for now)\n"); + liMove.QuadPart = Chunk.dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + case DMUS_FOURCC_RESOLUTION_CHUNK: { + TRACE_(dmfile)(": Resolution chunk (skipping for now)\n"); + liMove.QuadPart = Chunk.dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + case DMUS_FOURCC_ANTICIPATION_CHUNK: { + TRACE_(dmfile)(": Anticipation chunk (skipping for now)\n"); + liMove.QuadPart = Chunk.dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + case FOURCC_LIST: { + IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL); + TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(Chunk.fccID)); + ListSize[1] = Chunk.dwSize - sizeof(FOURCC); + ListCount[1] = 0; + switch (Chunk.fccID) { + case DMUS_FOURCC_UNFO_LIST: { + TRACE_(dmfile)(": UNFO list\n"); + do { + IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL); + ListCount[1] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize; + TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize); + + hr = IDirectMusicUtils_IPersistStream_ParseUNFOGeneric(&Chunk, pStm, &desc); + if (FAILED(hr)) return hr; + + if (hr == S_FALSE) { + switch (Chunk.fccID) { + default: { + TRACE_(dmfile)(": unknown chunk (irrevelant & skipping)\n"); + liMove.QuadPart = Chunk.dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + } + } + TRACE_(dmfile)(": ListCount[1] = %ld < ListSize[1] = %ld\n", ListCount[1], ListSize[1]); + } while (ListCount[1] < ListSize[1]); + break; + } + default: { + TRACE_(dmfile)(": unknown chunk (irrevelant & skipping)\n"); + liMove.QuadPart = Chunk.dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + } + break; + } + default: { + TRACE_(dmfile)(": unknown chunk (irrevelant & skipping)\n"); + liMove.QuadPart = Chunk.dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + } + TRACE_(dmfile)(": ListCount[0] = %ld < ListSize[0] = %ld\n", ListCount[0], ListSize[0]); + } while (ListCount[0] < ListSize[0]); + + return S_OK; +} + +static HRESULT IDirectMusicStyle8Impl_IPersistStream_ParsePatternList (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm) { + + /*ICOM_THIS_MULTI(IDirectMusicStyle8Impl, PersistStreamVtbl, iface);*/ + HRESULT hr = E_FAIL; + DMUS_PRIVATE_CHUNK Chunk; + DWORD ListSize[3], ListCount[3]; + LARGE_INTEGER liMove; /* used when skipping chunks */ + + DMUS_IO_PATTERN pattern; + DWORD dwRythm = 0; + DMUS_OBJECTDESC desc; + + memset(&pattern, 0, sizeof(pattern)); + + if (pChunk->fccID != DMUS_FOURCC_PATTERN_LIST) { + ERR_(dmfile)(": %s chunk should be a PATTERN list\n", debugstr_fourcc (pChunk->fccID)); + return E_FAIL; + } + + ListSize[0] = pChunk->dwSize - sizeof(FOURCC); + ListCount[0] = 0; + + do { + IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL); + ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize; + TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize); + switch (Chunk.fccID) { + case DMUS_FOURCC_PATTERN_CHUNK: { + TRACE_(dmfile)(": Pattern chunk\n"); + IStream_Read (pStm, &pattern, Chunk.dwSize, NULL); + /** TODO trace pattern */ + break; + } + case DMUS_FOURCC_RHYTHM_CHUNK: { + TRACE_(dmfile)(": Rythm chunk\n"); + IStream_Read (pStm, &dwRythm, sizeof(DWORD), NULL); + TRACE_(dmfile)(" - dwRythm: %lu\n", dwRythm); + /** TODO understand why some Chunks have size > 4 */ + liMove.QuadPart = Chunk.dwSize - sizeof(DWORD); + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + case DMUS_FOURCC_MOTIFSETTINGS_CHUNK: { + TRACE_(dmfile)(": MotifSettigns chunk (skipping for now)\n"); + liMove.QuadPart = Chunk.dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + case FOURCC_LIST: { + IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL); + TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(Chunk.fccID)); + ListSize[1] = Chunk.dwSize - sizeof(FOURCC); + ListCount[1] = 0; + switch (Chunk.fccID) { + case DMUS_FOURCC_UNFO_LIST: { + TRACE_(dmfile)(": UNFO list\n"); + do { + IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL); + ListCount[1] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize; + TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize); + + hr = IDirectMusicUtils_IPersistStream_ParseUNFOGeneric(&Chunk, pStm, &desc); + if (FAILED(hr)) return hr; + + if (hr == S_FALSE) { + switch (Chunk.fccID) { + default: { + TRACE_(dmfile)(": unknown chunk (irrevelant & skipping)\n"); + liMove.QuadPart = Chunk.dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + } + } + TRACE_(dmfile)(": ListCount[1] = %ld < ListSize[1] = %ld\n", ListCount[1], ListSize[1]); + } while (ListCount[1] < ListSize[1]); + break; + } + case DMUS_FOURCC_PARTREF_LIST: { + TRACE_(dmfile)(": PartRef list\n"); + hr = IDirectMusicStyle8Impl_IPersistStream_ParsePartRefList (iface, &Chunk, pStm); + if (FAILED(hr)) return hr; + break; + } + default: { + TRACE_(dmfile)(": unknown (skipping)\n"); + liMove.QuadPart = Chunk.dwSize - sizeof(FOURCC); + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + } + break; + } + default: { + TRACE_(dmfile)(": unknown chunk (irrevelant & skipping)\n"); + liMove.QuadPart = Chunk.dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + } + TRACE_(dmfile)(": ListCount[0] = %ld < ListSize[0] = %ld\n", ListCount[0], ListSize[0]); + } while (ListCount[0] < ListSize[0]); + + return S_OK; +} + +static HRESULT IDirectMusicStyle8Impl_IPersistStream_ParseStyleForm (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm) { + ICOM_THIS_MULTI(IDirectMusicStyle8Impl, PersistStreamVtbl, iface); + + HRESULT hr = E_FAIL; + DMUS_PRIVATE_CHUNK Chunk; + DWORD StreamSize, StreamCount, ListSize[3], ListCount[3]; + LARGE_INTEGER liMove; /* used when skipping chunks */ + + if (pChunk->fccID != DMUS_FOURCC_STYLE_FORM) { + ERR_(dmfile)(": %s chunk should be a STYLE form\n", debugstr_fourcc (pChunk->fccID)); + return E_FAIL; + } + + StreamSize = pChunk->dwSize - sizeof(FOURCC); + StreamCount = 0; + + do { + IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL); + StreamCount += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize; + TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize); + + hr = IDirectMusicUtils_IPersistStream_ParseDescGeneric(&Chunk, pStm, This->pDesc); + if (FAILED(hr)) return hr; + + if (hr == S_FALSE) { + switch (Chunk.fccID) { + case DMUS_FOURCC_STYLE_CHUNK: { + TRACE_(dmfile)(": Style chunk\n"); + IStream_Read (pStm, &This->style, sizeof(DMUS_IO_STYLE), NULL); + /** TODO dump DMUS_IO_TIMESIG style.timeSig */ + TRACE_(dmfile)(" - dblTempo: %g\n", This->style.dblTempo); + break; + } + case FOURCC_RIFF: { + /** + * sould be embededs Bands into style + */ + IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL); + TRACE_(dmfile)(": RIFF chunk of type %s", debugstr_fourcc(Chunk.fccID)); + ListSize[0] = Chunk.dwSize - sizeof(FOURCC); + ListCount[0] = 0; + switch (Chunk.fccID) { + case DMUS_FOURCC_BAND_FORM: { + TRACE_(dmfile)(": BAND RIFF (TODO load it)\n"); + /* + LPSTREAM pClonedStream = NULL; + TRACE_(dmfile)(": BAND RIFF\n"); + + IStream_Clone (pStm, &pClonedStream); + + liMove.QuadPart = 0; + liMove.QuadPart -= sizeof(FOURCC) + (sizeof(FOURCC)+sizeof(DWORD)); + IStream_Seek (pClonedStream, liMove, STREAM_SEEK_CUR, NULL); + + hr = IDirectMusicStyle8Impl_IPersistStream_LoadBand (iface, pClonedStream, &pBand, &header); + if (FAILED(hr)) { + ERR(": could not load track\n"); + return hr; + } + IStream_Release (pClonedStream); + + IDirectMusicTrack_Release(pBand); pBand = NULL; + */ + /** now safe move the cursor */ + liMove.QuadPart = ListSize[0]; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + + break; + } + default: { + TRACE_(dmfile)(": unknown chunk (irrevelant & skipping)\n"); + liMove.QuadPart = ListSize[0]; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + } + break; + } + case FOURCC_LIST: { + IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL); + TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(Chunk.fccID)); + ListSize[0] = Chunk.dwSize - sizeof(FOURCC); + ListCount[0] = 0; + switch (Chunk.fccID) { + case DMUS_FOURCC_UNFO_LIST: { + TRACE_(dmfile)(": UNFO list\n"); + do { + IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL); + ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize; + TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize); + + hr = IDirectMusicUtils_IPersistStream_ParseUNFOGeneric(&Chunk, pStm, This->pDesc); + if (FAILED(hr)) return hr; + + if (hr == S_FALSE) { + switch (Chunk.fccID) { + default: { + TRACE_(dmfile)(": unknown chunk (irrevelant & skipping)\n"); + liMove.QuadPart = Chunk.dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + } + } + TRACE_(dmfile)(": ListCount[0] = %ld < ListSize[0] = %ld\n", ListCount[0], ListSize[0]); + } while (ListCount[0] < ListSize[0]); + break; + } + case DMUS_FOURCC_PART_LIST: { + TRACE_(dmfile)(": PART list\n"); + hr = IDirectMusicStyle8Impl_IPersistStream_ParsePartList (iface, &Chunk, pStm); + if (FAILED(hr)) return hr; + break; + } + case DMUS_FOURCC_PATTERN_LIST: { + TRACE_(dmfile)(": PATTERN list\n"); + hr = IDirectMusicStyle8Impl_IPersistStream_ParsePatternList (iface, &Chunk, pStm); + if (FAILED(hr)) return hr; + break; + } + default: { + TRACE_(dmfile)(": unknown (skipping)\n"); + liMove.QuadPart = Chunk.dwSize - sizeof(FOURCC); + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + } + break; + } + default: { + TRACE_(dmfile)(": unknown chunk (irrevelant & skipping)\n"); + liMove.QuadPart = Chunk.dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); + break; + } + } + } + TRACE_(dmfile)(": StreamCount[0] = %ld < StreamSize[0] = %ld\n", StreamCount, StreamSize); + } while (StreamCount < StreamSize); + + return S_OK; } HRESULT WINAPI IDirectMusicStyle8Impl_IPersistStream_Load (LPPERSISTSTREAM iface, IStream* pStm) { - ICOM_THIS_MULTI(IDirectMusicStyle8Impl, PersistStreamVtbl, iface); + ICOM_THIS_MULTI(IDirectMusicStyle8Impl, PersistStreamVtbl, iface); + + DMUS_PRIVATE_CHUNK Chunk; + LARGE_INTEGER liMove; /* used when skipping chunks */ + HRESULT hr; - FOURCC chunkID; - DWORD chunkSize, StreamSize, StreamCount, ListSize[3], ListCount[3]; - LARGE_INTEGER liMove; /* used when skipping chunks */ + FIXME("(%p, %p): Loading\n", This, pStm); - FIXME("(%p, %p): Loading not implemented yet\n", This, pStm); - IStream_Read (pStm, &chunkID, sizeof(FOURCC), NULL); - IStream_Read (pStm, &chunkSize, sizeof(DWORD), NULL); - TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (chunkID), chunkSize); - switch (chunkID) { - case FOURCC_RIFF: { - IStream_Read (pStm, &chunkID, sizeof(FOURCC), NULL); - TRACE_(dmfile)(": RIFF chunk of type %s", debugstr_fourcc(chunkID)); - StreamSize = chunkSize - sizeof(FOURCC); - StreamCount = 0; - switch (chunkID) { - case DMUS_FOURCC_STYLE_FORM: { - TRACE_(dmfile)(": style form\n"); - do { - IStream_Read (pStm, &chunkID, sizeof(FOURCC), NULL); - IStream_Read (pStm, &chunkSize, sizeof(FOURCC), NULL); - StreamCount += sizeof(FOURCC) + sizeof(DWORD) + chunkSize; - TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (chunkID), chunkSize); - switch (chunkID) { - case DMUS_FOURCC_GUID_CHUNK: { - TRACE_(dmfile)(": GUID chunk\n"); - This->pDesc->dwValidData |= DMUS_OBJ_OBJECT; - IStream_Read (pStm, &This->pDesc->guidObject, chunkSize, NULL); - break; - } - case DMUS_FOURCC_VERSION_CHUNK: { - TRACE_(dmfile)(": version chunk\n"); - This->pDesc->dwValidData |= DMUS_OBJ_VERSION; - IStream_Read (pStm, &This->pDesc->vVersion, chunkSize, NULL); - break; - } - case DMUS_FOURCC_CATEGORY_CHUNK: { - TRACE_(dmfile)(": category chunk\n"); - This->pDesc->dwValidData |= DMUS_OBJ_CATEGORY; - IStream_Read (pStm, This->pDesc->wszCategory, chunkSize, NULL); - break; - } - case FOURCC_LIST: { - IStream_Read (pStm, &chunkID, sizeof(FOURCC), NULL); - TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(chunkID)); - ListSize[0] = chunkSize - sizeof(FOURCC); - ListCount[0] = 0; - switch (chunkID) { - case DMUS_FOURCC_UNFO_LIST: { - TRACE_(dmfile)(": UNFO list\n"); - do { - IStream_Read (pStm, &chunkID, sizeof(FOURCC), NULL); - IStream_Read (pStm, &chunkSize, sizeof(FOURCC), NULL); - ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + chunkSize; - TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (chunkID), chunkSize); - switch (chunkID) { - /* don't ask me why, but M$ puts INFO elements in UNFO list sometimes - (though strings seem to be valid unicode) */ - case mmioFOURCC('I','N','A','M'): - case DMUS_FOURCC_UNAM_CHUNK: { - TRACE_(dmfile)(": name chunk\n"); - This->pDesc->dwValidData |= DMUS_OBJ_NAME; - IStream_Read (pStm, This->pDesc->wszName, chunkSize, NULL); - break; - } - case mmioFOURCC('I','A','R','T'): - case DMUS_FOURCC_UART_CHUNK: { - TRACE_(dmfile)(": artist chunk (ignored)\n"); - liMove.QuadPart = chunkSize; - IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); - break; - } - case mmioFOURCC('I','C','O','P'): - case DMUS_FOURCC_UCOP_CHUNK: { - TRACE_(dmfile)(": copyright chunk (ignored)\n"); - liMove.QuadPart = chunkSize; - IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); - break; - } - case mmioFOURCC('I','S','B','J'): - case DMUS_FOURCC_USBJ_CHUNK: { - TRACE_(dmfile)(": subject chunk (ignored)\n"); - liMove.QuadPart = chunkSize; - IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); - break; - } - case mmioFOURCC('I','C','M','T'): - case DMUS_FOURCC_UCMT_CHUNK: { - TRACE_(dmfile)(": comment chunk (ignored)\n"); - liMove.QuadPart = chunkSize; - IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); - break; - } - default: { - TRACE_(dmfile)(": unknown chunk (irrevelant & skipping)\n"); - liMove.QuadPart = chunkSize; - IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); - break; - } - } - TRACE_(dmfile)(": ListCount[0] = %ld < ListSize[0] = %ld\n", ListCount[0], ListSize[0]); - } while (ListCount[0] < ListSize[0]); - break; - } - default: { - TRACE_(dmfile)(": unknown (skipping)\n"); - liMove.QuadPart = chunkSize - sizeof(FOURCC); - IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); - break; - } - } - break; - } - default: { - TRACE_(dmfile)(": unknown chunk (irrevelant & skipping)\n"); - liMove.QuadPart = chunkSize; - IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); - break; - } - } - TRACE_(dmfile)(": StreamCount[0] = %ld < StreamSize[0] = %ld\n", StreamCount, StreamSize); - } while (StreamCount < StreamSize); - break; - } - default: { - TRACE_(dmfile)(": unexpected chunk; loading failed)\n"); - liMove.QuadPart = StreamSize; - IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); /* skip the rest of the chunk */ - return E_FAIL; - } - } - TRACE_(dmfile)(": reading finished\n"); - break; - } - default: { - TRACE_(dmfile)(": unexpected chunk; loading failed)\n"); - liMove.QuadPart = chunkSize; - IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); /* skip the rest of the chunk */ - return E_FAIL; - } - } - - return S_OK; + IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL); + TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize); + switch (Chunk.fccID) { + case FOURCC_RIFF: { + IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL); + TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize); + switch (Chunk.fccID) { + case DMUS_FOURCC_STYLE_FORM: { + TRACE_(dmfile)(": Style form\n"); + hr = IDirectMusicStyle8Impl_IPersistStream_ParseStyleForm (iface, &Chunk, pStm); + if (FAILED(hr)) return hr; + break; + } + default: { + TRACE_(dmfile)(": unexpected chunk; loading failed)\n"); + liMove.QuadPart = Chunk.dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); /* skip the rest of the chunk */ + return E_FAIL; + } + } + TRACE_(dmfile)(": reading finished\n"); + break; + } + default: { + TRACE_(dmfile)(": unexpected chunk; loading failed)\n"); + liMove.QuadPart = Chunk.dwSize; + IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); /* skip the rest of the chunk */ + return E_FAIL; + } + } + + return S_OK; } HRESULT WINAPI IDirectMusicStyle8Impl_IPersistStream_Save (LPPERSISTSTREAM iface, IStream* pStm, BOOL fClearDirty) { - return E_NOTIMPL; + ICOM_THIS_MULTI(IDirectMusicStyle8Impl, PersistStreamVtbl, iface); + FIXME("(%p): Saving not implemented yet\n", This); + return E_NOTIMPL; } HRESULT WINAPI IDirectMusicStyle8Impl_IPersistStream_GetSizeMax (LPPERSISTSTREAM iface, ULARGE_INTEGER* pcbSize) { - return E_NOTIMPL; + ICOM_THIS_MULTI(IDirectMusicStyle8Impl, PersistStreamVtbl, iface); + FIXME("(%p, %p): stub\n", This, pcbSize); + return E_NOTIMPL; + } ICOM_VTABLE(IPersistStream) DirectMusicStyle8_PersistStream_Vtbl = { - ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE - IDirectMusicStyle8Impl_IPersistStream_QueryInterface, - IDirectMusicStyle8Impl_IPersistStream_AddRef, - IDirectMusicStyle8Impl_IPersistStream_Release, - IDirectMusicStyle8Impl_IPersistStream_GetClassID, - IDirectMusicStyle8Impl_IPersistStream_IsDirty, - IDirectMusicStyle8Impl_IPersistStream_Load, - IDirectMusicStyle8Impl_IPersistStream_Save, - IDirectMusicStyle8Impl_IPersistStream_GetSizeMax + ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE + IDirectMusicStyle8Impl_IPersistStream_QueryInterface, + IDirectMusicStyle8Impl_IPersistStream_AddRef, + IDirectMusicStyle8Impl_IPersistStream_Release, + IDirectMusicStyle8Impl_IPersistStream_GetClassID, + IDirectMusicStyle8Impl_IPersistStream_IsDirty, + IDirectMusicStyle8Impl_IPersistStream_Load, + IDirectMusicStyle8Impl_IPersistStream_Save, + IDirectMusicStyle8Impl_IPersistStream_GetSizeMax }; /* for ClassFactory */ HRESULT WINAPI DMUSIC_CreateDirectMusicStyleImpl (LPCGUID lpcGUID, LPVOID* ppobj, LPUNKNOWN pUnkOuter) { - IDirectMusicStyle8Impl* obj; + IDirectMusicStyle8Impl* obj; - obj = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectMusicStyle8Impl)); - if (NULL == obj) { - *ppobj = (LPVOID) NULL; - return E_OUTOFMEMORY; - } - obj->UnknownVtbl = &DirectMusicStyle8_Unknown_Vtbl; - obj->StyleVtbl = &DirectMusicStyle8_Style_Vtbl; - obj->ObjectVtbl = &DirectMusicStyle8_Object_Vtbl; - obj->PersistStreamVtbl = &DirectMusicStyle8_PersistStream_Vtbl; - obj->pDesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DMUS_OBJECTDESC)); - DM_STRUCT_INIT(obj->pDesc); - obj->pDesc->dwValidData |= DMUS_OBJ_CLASS; - memcpy (&obj->pDesc->guidClass, &CLSID_DirectMusicStyle, sizeof (CLSID)); - obj->ref = 0; /* will be inited by QueryInterface */ - - return IDirectMusicStyle8Impl_IUnknown_QueryInterface ((LPUNKNOWN)&obj->UnknownVtbl, lpcGUID, ppobj); + obj = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectMusicStyle8Impl)); + if (NULL == obj) { + *ppobj = (LPVOID) NULL; + return E_OUTOFMEMORY; + } + obj->UnknownVtbl = &DirectMusicStyle8_Unknown_Vtbl; + obj->StyleVtbl = &DirectMusicStyle8_Style_Vtbl; + obj->ObjectVtbl = &DirectMusicStyle8_Object_Vtbl; + obj->PersistStreamVtbl = &DirectMusicStyle8_PersistStream_Vtbl; + obj->pDesc = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(DMUS_OBJECTDESC)); + DM_STRUCT_INIT(obj->pDesc); + obj->pDesc->dwValidData |= DMUS_OBJ_CLASS; + memcpy (&obj->pDesc->guidClass, &CLSID_DirectMusicStyle, sizeof (CLSID)); + obj->ref = 0; /* will be inited by QueryInterface */ + + return IDirectMusicStyle8Impl_IUnknown_QueryInterface ((LPUNKNOWN)&obj->UnknownVtbl, lpcGUID, ppobj); }