Added name resolving for CLSIDs, IIDs, GUIDs and return codes.

dlls/dmband/band.c

@@ -31,7 +31,7 @@ const GUID IID_IDirectMusicBandPRIVATE = {0xda54db81,0x837d,0x11d1,{0x86,0xbc,0x
 HRESULT WINAPI IDirectMusicBandImpl_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS_MULTI(IDirectMusicBandImpl, UnknownVtbl, iface);
 	
-	TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppobj);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 	if (IsEqualIID (riid, &IID_IUnknown)) {
 		*ppobj = (LPVOID)&This->UnknownVtbl;
 		IDirectMusicBandImpl_IUnknown_AddRef ((LPUNKNOWN)&This->UnknownVtbl);
@@ -50,7 +50,7 @@ HRESULT WINAPI IDirectMusicBandImpl_IUnknown_QueryInterface (LPUNKNOWN iface, RE
 		return S_OK;
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -147,10 +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);
-	if (TRACE_ON(dmband)) {
-		DMUSIC_dump_DMUS_OBJECTDESC (pDesc);
-	}
+	TRACE("(%p, %p): setting descriptor:\n%s\n", This, pDesc, debugstr_DMUS_OBJECTDESC (pDesc));
 	
 	/* According to MSDN, we should copy only given values, not whole struct */	
 	if (pDesc->dwValidData & DMUS_OBJ_OBJECT)
@@ -325,10 +322,7 @@ HRESULT WINAPI IDirectMusicBandImpl_IDirectMusicObject_ParseDescriptor (LPDIRECT
 		}
 	}	
 	
-	TRACE(": returning descriptor:\n");
-	if (TRACE_ON(dmband)) {
-		DMUSIC_dump_DMUS_OBJECTDESC (pDesc);
-	}
+	TRACE(": returning descriptor:\n%s\n", debugstr_DMUS_OBJECTDESC (pDesc));
 	
 	return S_OK;
 }

dlls/dmband/bandtrack.c

@@ -28,6 +28,7 @@ WINE_DECLARE_DEBUG_CHANNEL(dmfile);
 /* IDirectMusicBandTrack IUnknown part: */
 HRESULT WINAPI IDirectMusicBandTrack_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS_MULTI(IDirectMusicBandTrack, UnknownVtbl, iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 
 	if (IsEqualIID (riid, &IID_IUnknown)) {
 		*ppobj = (LPUNKNOWN)&This->UnknownVtbl;
@@ -44,7 +45,7 @@ HRESULT WINAPI IDirectMusicBandTrack_IUnknown_QueryInterface (LPUNKNOWN iface, R
 		return S_OK;
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s,%p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -121,20 +122,20 @@ HRESULT WINAPI IDirectMusicBandTrack_IDirectMusicTrack_Play (LPDIRECTMUSICTRACK8
 
 HRESULT WINAPI IDirectMusicBandTrack_IDirectMusicTrack_GetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, MUSIC_TIME* pmtNext, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicBandTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pmtNext, pParam);
+	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pmtNext, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicBandTrack_IDirectMusicTrack_SetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicBandTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pParam);
+	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicBandTrack_IDirectMusicTrack_IsParamSupported (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType) {
 	ICOM_THIS_MULTI(IDirectMusicBandTrack, TrackVtbl, iface);
 
-	TRACE("(%p, %s): ", This, debugstr_guid(rguidType));
+	TRACE("(%p, %s): ", This, debugstr_dmguid(rguidType));
 	if (IsEqualGUID (rguidType, &GUID_BandParam)
 		|| IsEqualGUID (rguidType, &GUID_Clear_All_Bands)
 		|| IsEqualGUID (rguidType, &GUID_ConnectToDLSCollection)
@@ -156,13 +157,13 @@ HRESULT WINAPI IDirectMusicBandTrack_IDirectMusicTrack_IsParamSupported (LPDIREC
 
 HRESULT WINAPI IDirectMusicBandTrack_IDirectMusicTrack_AddNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicBandTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicBandTrack_IDirectMusicTrack_RemoveNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicBandTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
@@ -180,13 +181,13 @@ HRESULT WINAPI IDirectMusicBandTrack_IDirectMusicTrack_PlayEx (LPDIRECTMUSICTRAC
 
 HRESULT WINAPI IDirectMusicBandTrack_IDirectMusicTrack_GetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, REFERENCE_TIME* prtNext, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicBandTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicBandTrack_IDirectMusicTrack_SetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicBandTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 

dlls/dmband/dmband_main.c

@@ -33,8 +33,7 @@ typedef struct {
  
 static HRESULT WINAPI BandCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n",This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -51,13 +50,13 @@ static ULONG WINAPI BandCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI BandCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicBandImpl (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI BandCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -80,7 +79,7 @@ static IClassFactoryImpl Band_CF = {&BandCF_Vtbl, 1 };
 static HRESULT WINAPI BandTrackCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
 
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -97,13 +96,13 @@ static ULONG WINAPI BandTrackCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI BandTrackCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicBandTrack (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI BandTrackCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -152,7 +151,7 @@ HRESULT WINAPI DMBAND_DllCanUnloadNow(void) {
  *
  */
 HRESULT WINAPI DMBAND_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv) {
-    TRACE("(%p,%p,%p)\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
+    TRACE("(%s, %s, %p)\n", debugstr_dmguid(rclsid), debugstr_dmguid(riid), ppv);
 
 	if (IsEqualCLSID (rclsid, &CLSID_DirectMusicBand) && IsEqualIID (riid, &IID_IClassFactory)) {
 		*ppv = (LPVOID) &Band_CF;
@@ -164,6 +163,415 @@ HRESULT WINAPI DMBAND_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *pp
 		return S_OK;	
 	}
 	
-    WARN("(%p,%p,%p): no interface found.\n", debugstr_guid(rclsid), debugstr_guid(riid), 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) {
+		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)");
+	}
+}

dlls/dmband/dmband_private.h

@@ -20,7 +20,9 @@
 #ifndef __WINE_DMBAND_PRIVATE_H
 #define __WINE_DMBAND_PRIVATE_H
 
+#include <stdio.h>
 #include <stdarg.h>
+#include <string.h>
 
 #include "windef.h"
 #include "winbase.h"
@@ -197,26 +199,16 @@ typedef struct _DMUS_PRIVATE_CHUNK {
 	DWORD dwSize; /* size of the chunk */
 } DMUS_PRIVATE_CHUNK, *LPDMUS_PRIVATE_CHUNK;
 
-/* check whether the given DWORD is even (return 0) or odd (return 1) */
-static inline int even_or_odd (DWORD number) {
-	return (number & 0x1); /* basically, check if bit 0 is set ;) */
-}
+/* used for generic dumping (copied from ddraw) */
+typedef struct {
+    DWORD val;
+    const char* name;
+} flag_info;
 
-/* FOURCC to string conversion for debug messages */
-static inline 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 */
-static inline 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));
-}
+typedef struct {
+    const GUID *guid;
+    const char* name;
+} guid_info;
 
 /* used for initialising structs (primarily for DMUS_OBJECTDESC) */
 #define DM_STRUCT_INIT(x) 				\
@@ -225,65 +217,23 @@ static inline const char *debugstr_dmversion (LPDMUS_VERSION version) {
 		(x)->dwSize = sizeof(*x);		\
 	} while (0)
 
-
-/* used for generic dumping (copied from ddraw) */
-typedef struct {
-    DWORD val;
-    const char* name;
-} flag_info;
-
-/* generic dump function */
-static inline void DMUSIC_dump_flags_ (DWORD flags, const flag_info* names, size_t num_names, int newline) {
-	unsigned int i;
-	
-	for (i=0; i < num_names; i++) {
-		if ((flags & names[i].val) ||      /* standard flag value */
-		((!flags) && (!names[i].val))) /* zero value only */
-	    	DPRINTF("%s ", names[i].name);
-	}
-	
-    if (newline) DPRINTF("\n");
-}
-
 #define FE(x) { x, #x }
-#define DMUSIC_dump_flags(flags,names,num_names) DMUSIC_dump_flags_(flags, names, num_names, 1)
+#define GE(x) { &x, #x }
 
-static inline void DMUSIC_dump_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)
-	};
-    DMUSIC_dump_flags(flagmask, flags, sizeof(flags)/sizeof(flags[0]));
-}
-
-static inline void DMUSIC_dump_DMUS_OBJECTDESC (LPDMUS_OBJECTDESC pDesc) {
-	if (pDesc) {
-		DPRINTF("DMUS_OBJECTDESC (%p)\n", pDesc);
-		DPRINTF("  - dwSize = %ld\n", pDesc->dwSize);
-		DPRINTF("  - dwValidData = ");
-		DMUSIC_dump_DMUS_OBJ_FLAGS (pDesc->dwValidData);
-		if (pDesc->dwValidData & DMUS_OBJ_CLASS) DPRINTF("  - guidClass = %s\n", debugstr_guid(&pDesc->guidClass));
-		if (pDesc->dwValidData & DMUS_OBJ_OBJECT) DPRINTF("  - guidObject = %s\n", debugstr_guid(&pDesc->guidObject));
-		if (pDesc->dwValidData & DMUS_OBJ_DATE) DPRINTF("  - ftDate = FIXME\n");
-		if (pDesc->dwValidData & DMUS_OBJ_VERSION) DPRINTF("  - vVersion = %s\n", debugstr_dmversion(&pDesc->vVersion));
-		if (pDesc->dwValidData & DMUS_OBJ_NAME) DPRINTF("  - wszName = %s\n", debugstr_w(pDesc->wszName));
-		if (pDesc->dwValidData & DMUS_OBJ_CATEGORY) DPRINTF("  - wszCategory = %s\n", debugstr_w(pDesc->wszCategory));
-		if (pDesc->dwValidData & DMUS_OBJ_FILENAME) DPRINTF("  - wszFileName = %s\n", debugstr_w(pDesc->wszFileName));
-		if (pDesc->dwValidData & DMUS_OBJ_MEMORY) DPRINTF("  - llMemLength = %lli\n  - pbMemData = %p\n", pDesc->llMemLength, pDesc->pbMemData);
-		if (pDesc->dwValidData & DMUS_OBJ_STREAM) DPRINTF("  - pStream = %p\n", pDesc->pStream);		
-	} else {
-		DPRINTF("(NULL)\n");
-	}
-}
+/* 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);
 
 #endif	/* __WINE_DMBAND_PRIVATE_H */

dlls/dmcompos/chordmap.c

@@ -28,6 +28,7 @@ WINE_DECLARE_DEBUG_CHANNEL(dmfile);
 /* IDirectMusicChordMapImpl IUnknown part: */
 HRESULT WINAPI IDirectMusicChordMapImpl_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS_MULTI(IDirectMusicChordMapImpl, UnknownVtbl, iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 	
 	if (IsEqualIID (riid, &IID_IUnknown)) {
 		*ppobj = (LPVOID)&This->UnknownVtbl;
@@ -47,20 +48,20 @@ HRESULT WINAPI IDirectMusicChordMapImpl_IUnknown_QueryInterface (LPUNKNOWN iface
 		return S_OK;
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicChordMapImpl_IUnknown_AddRef (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicChordMapImpl, UnknownVtbl, iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicChordMapImpl_IUnknown_Release (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicChordMapImpl, UnknownVtbl, iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}
@@ -130,10 +131,7 @@ HRESULT WINAPI IDirectMusicChordMapImpl_IDirectMusicObject_GetDescriptor (LPDIRE
 
 HRESULT WINAPI IDirectMusicChordMapImpl_IDirectMusicObject_SetDescriptor (LPDIRECTMUSICOBJECT iface, LPDMUS_OBJECTDESC pDesc) {
 	ICOM_THIS_MULTI(IDirectMusicChordMapImpl, ObjectVtbl, iface);
-	TRACE("(%p, %p): setting descriptor:\n", This, pDesc);
-	if (TRACE_ON(dmcompos)) {
-		DMUSIC_dump_DMUS_OBJECTDESC (pDesc);
-	}
+	TRACE("(%p, %p): setting descriptor:\n%s\n", This, pDesc, debugstr_DMUS_OBJECTDESC (pDesc));
 	
 	/* According to MSDN, we should copy only given values, not whole struct */	
 	if (pDesc->dwValidData & DMUS_OBJ_OBJECT)
@@ -308,10 +306,7 @@ HRESULT WINAPI IDirectMusicChordMapImpl_IDirectMusicObject_ParseDescriptor (LPDI
 		}
 	}	
 	
-	TRACE(": returning descriptor:\n");
-	if (TRACE_ON(dmcompos)) {
-		DMUSIC_dump_DMUS_OBJECTDESC (pDesc);
-	}
+	TRACE(": returning descriptor:\n%s\n", debugstr_DMUS_OBJECTDESC (pDesc));
 	
 	return S_OK;
 }

dlls/dmcompos/chordmaptrack.c

@@ -28,6 +28,7 @@ WINE_DECLARE_DEBUG_CHANNEL(dmfile);
 /* IDirectMusicChordMapTrack IUnknown part: */
 HRESULT WINAPI IDirectMusicChordMapTrack_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS_MULTI(IDirectMusicChordMapTrack, UnknownVtbl, iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 
 	if (IsEqualIID (riid, &IID_IUnknown)) {
 		*ppobj = (LPUNKNOWN)&This->UnknownVtbl;
@@ -44,20 +45,20 @@ HRESULT WINAPI IDirectMusicChordMapTrack_IUnknown_QueryInterface (LPUNKNOWN ifac
 		return S_OK;
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicChordMapTrack_IUnknown_AddRef (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicChordMapTrack, UnknownVtbl, iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicChordMapTrack_IUnknown_Release (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicChordMapTrack, UnknownVtbl, iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}
@@ -113,19 +114,19 @@ HRESULT WINAPI IDirectMusicChordMapTrack_IDirectMusicTrack_Play (LPDIRECTMUSICTR
 
 HRESULT WINAPI IDirectMusicChordMapTrack_IDirectMusicTrack_GetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, MUSIC_TIME* pmtNext, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicChordMapTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pmtNext, pParam);
+	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pmtNext, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicChordMapTrack_IDirectMusicTrack_SetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicChordMapTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pParam);
+	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicChordMapTrack_IDirectMusicTrack_IsParamSupported (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType) {
 	ICOM_THIS_MULTI(IDirectMusicChordMapTrack, TrackVtbl, iface);
-	TRACE("(%p, %s): ", This, debugstr_guid(rguidType));
+	TRACE("(%p, %s): ", This, debugstr_dmguid(rguidType));
 	if (IsEqualGUID (rguidType, &GUID_IDirectMusicChordMap)) {
 		TRACE("param supported\n");
 		return S_OK;
@@ -136,13 +137,13 @@ HRESULT WINAPI IDirectMusicChordMapTrack_IDirectMusicTrack_IsParamSupported (LPD
 
 HRESULT WINAPI IDirectMusicChordMapTrack_IDirectMusicTrack_AddNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicChordMapTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicChordMapTrack_IDirectMusicTrack_RemoveNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicChordMapTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
@@ -160,13 +161,13 @@ HRESULT WINAPI IDirectMusicChordMapTrack_IDirectMusicTrack_PlayEx (LPDIRECTMUSIC
 
 HRESULT WINAPI IDirectMusicChordMapTrack_IDirectMusicTrack_GetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, REFERENCE_TIME* prtNext, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicChordMapTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicChordMapTrack_IDirectMusicTrack_SetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicChordMapTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 

dlls/dmcompos/composer.c

@@ -24,6 +24,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(dmcompos);
 /* IDirectMusicComposerImpl IUnknown part: */
 HRESULT WINAPI IDirectMusicComposerImpl_QueryInterface (LPDIRECTMUSICCOMPOSER iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IDirectMusicComposerImpl,iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 
 	if (IsEqualIID (riid, &IID_IUnknown) || 
 	    IsEqualIID (riid, &IID_IDirectMusicComposer)) {
@@ -31,20 +32,20 @@ HRESULT WINAPI IDirectMusicComposerImpl_QueryInterface (LPDIRECTMUSICCOMPOSER if
 		*ppobj = This;
 		return S_OK;
 	}
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicComposerImpl_AddRef (LPDIRECTMUSICCOMPOSER iface) {
 	ICOM_THIS(IDirectMusicComposerImpl,iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicComposerImpl_Release (LPDIRECTMUSICCOMPOSER iface) {
 	ICOM_THIS(IDirectMusicComposerImpl,iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}

dlls/dmcompos/dmcompos_main.c

@@ -32,7 +32,7 @@ typedef struct {
  */
 static HRESULT WINAPI ChordMapCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -49,13 +49,13 @@ static ULONG WINAPI ChordMapCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI ChordMapCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicChordMapImpl (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI ChordMapCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -75,7 +75,7 @@ static IClassFactoryImpl ChordMap_CF = {&ChordMapCF_Vtbl, 1 };
  */
 static HRESULT WINAPI ComposerCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n",This,debugstr_dmguid(riid),ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -92,13 +92,13 @@ static ULONG WINAPI ComposerCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI ComposerCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicComposerImpl (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI ComposerCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -118,7 +118,7 @@ static IClassFactoryImpl Composer_CF = {&ComposerCF_Vtbl, 1 };
  */
 static HRESULT WINAPI ChordMapTrackCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n",This,debugstr_dmguid(riid),ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -135,13 +135,13 @@ static ULONG WINAPI ChordMapTrackCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI ChordMapTrackCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicChordMapTrack (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI ChordMapTrackCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -161,7 +161,7 @@ static IClassFactoryImpl ChordMapTrack_CF = {&ChordMapTrackCF_Vtbl, 1 };
  */
 static HRESULT WINAPI TemplateCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -178,15 +178,15 @@ static ULONG WINAPI TemplateCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI TemplateCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	/* nothing yet */
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s,%p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 static HRESULT WINAPI TemplateCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -206,7 +206,7 @@ static IClassFactoryImpl Template_CF = {&TemplateCF_Vtbl, 1 };
  */
 static HRESULT WINAPI SignPostTrackCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n",This,debugstr_dmguid(riid),ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -223,13 +223,13 @@ static ULONG WINAPI SignPostTrackCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI SignPostTrackCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicSignPostTrack (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI SignPostTrackCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -279,7 +279,7 @@ HRESULT WINAPI DMCOMPOS_DllCanUnloadNow(void) {
  *
  */
 HRESULT WINAPI DMCOMPOS_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv) {
-    TRACE("(%p,%p,%p)\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
+    TRACE("(%s, %s, %p)\n", debugstr_dmguid(rclsid), debugstr_dmguid(riid), ppv);
     if (IsEqualCLSID (rclsid, &CLSID_DirectMusicChordMap) && IsEqualIID (riid, &IID_IClassFactory)) {
 		*ppv = (LPVOID) &ChordMap_CF;
 		IClassFactory_AddRef((IClassFactory*)*ppv);
@@ -302,6 +302,415 @@ HRESULT WINAPI DMCOMPOS_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *
 		return S_OK;
 	}
 
-    WARN("(%p,%p,%p): no interface found.\n", debugstr_guid(rclsid), debugstr_guid(riid), 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) {
+		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)");
+	}
+}

dlls/dmcompos/dmcompos_private.h

@@ -20,7 +20,9 @@
 #ifndef __WINE_DMCOMPOS_PRIVATE_H
 #define __WINE_DMCOMPOS_PRIVATE_H
 
+#include <stdio.h>
 #include <stdarg.h>
+#include <string.h>
 
 #include "windef.h"
 #include "winbase.h"
@@ -242,26 +244,16 @@ typedef struct _DMUS_PRIVATE_CHUNK {
 	DWORD dwSize; /* size of the chunk */
 } DMUS_PRIVATE_CHUNK, *LPDMUS_PRIVATE_CHUNK;
 
-/* check whether the given DWORD is even (return 0) or odd (return 1) */
-static inline int even_or_odd (DWORD number) {
-	return (number & 0x1); /* basically, check if bit 0 is set ;) */
-}
+/* used for generic dumping (copied from ddraw) */
+typedef struct {
+    DWORD val;
+    const char* name;
+} flag_info;
 
-/* FOURCC to string conversion for debug messages */
-static inline 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 */
-static inline 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));
-}
+typedef struct {
+    const GUID *guid;
+    const char* name;
+} guid_info;
 
 /* used for initialising structs (primarily for DMUS_OBJECTDESC) */
 #define DM_STRUCT_INIT(x) 				\
@@ -270,65 +262,23 @@ static inline const char *debugstr_dmversion (LPDMUS_VERSION version) {
 		(x)->dwSize = sizeof(*x);		\
 	} while (0)
 
+#define FE(x) { x, #x }	
+#define GE(x) { &x, #x }
 
-/* used for generic dumping (copied from ddraw) */
-typedef struct {
-    DWORD val;
-    const char* name;
-} flag_info;
-
-/* generic dump function */
-static inline void DMUSIC_dump_flags_ (DWORD flags, const flag_info* names, size_t num_names, int newline) {
-	unsigned int i;
-	
-	for (i=0; i < num_names; i++) {
-		if ((flags & names[i].val) ||      /* standard flag value */
-		((!flags) && (!names[i].val))) /* zero value only */
-	    	DPRINTF("%s ", names[i].name);
-	}
-	
-    if (newline) DPRINTF("\n");
-}
-
-#define FE(x) { x, #x }
-#define DMUSIC_dump_flags(flags,names,num_names) DMUSIC_dump_flags_(flags, names, num_names, 1)
-
-static inline void DMUSIC_dump_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)
-	};
-    DMUSIC_dump_flags(flagmask, flags, sizeof(flags)/sizeof(flags[0]));
-}
-
-static inline void DMUSIC_dump_DMUS_OBJECTDESC (LPDMUS_OBJECTDESC pDesc) {
-	if (pDesc) {
-		DPRINTF("DMUS_OBJECTDESC (%p)\n", pDesc);
-		DPRINTF("  - dwSize = %ld\n", pDesc->dwSize);
-		DPRINTF("  - dwValidData = ");
-		DMUSIC_dump_DMUS_OBJ_FLAGS (pDesc->dwValidData);
-		if (pDesc->dwValidData & DMUS_OBJ_CLASS) DPRINTF("  - guidClass = %s\n", debugstr_guid(&pDesc->guidClass));
-		if (pDesc->dwValidData & DMUS_OBJ_OBJECT) DPRINTF("  - guidObject = %s\n", debugstr_guid(&pDesc->guidObject));
-		if (pDesc->dwValidData & DMUS_OBJ_DATE) DPRINTF("  - ftDate = FIXME\n");
-		if (pDesc->dwValidData & DMUS_OBJ_VERSION) DPRINTF("  - vVersion = %s\n", debugstr_dmversion(&pDesc->vVersion));
-		if (pDesc->dwValidData & DMUS_OBJ_NAME) DPRINTF("  - wszName = %s\n", debugstr_w(pDesc->wszName));
-		if (pDesc->dwValidData & DMUS_OBJ_CATEGORY) DPRINTF("  - wszCategory = %s\n", debugstr_w(pDesc->wszCategory));
-		if (pDesc->dwValidData & DMUS_OBJ_FILENAME) DPRINTF("  - wszFileName = %s\n", debugstr_w(pDesc->wszFileName));
-		if (pDesc->dwValidData & DMUS_OBJ_MEMORY) DPRINTF("  - llMemLength = %lli\n  - pbMemData = %p\n", pDesc->llMemLength, pDesc->pbMemData);
-		if (pDesc->dwValidData & DMUS_OBJ_STREAM) DPRINTF("  - pStream = %p\n", pDesc->pStream);		
-	} else {
-		DPRINTF("(NULL)\n");
-	}
-}
+/* 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);
 
 #endif	/* __WINE_DMCOMPOS_PRIVATE_H */

dlls/dmcompos/signposttrack.c

@@ -28,6 +28,7 @@ WINE_DECLARE_DEBUG_CHANNEL(dmfile);
 /* IDirectMusicSignPostTrack IUnknown part: */
 HRESULT WINAPI IDirectMusicSignPostTrack_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS_MULTI(IDirectMusicSignPostTrack, UnknownVtbl, iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 
 	if (IsEqualIID (riid, &IID_IUnknown)) {
 		*ppobj = (LPUNKNOWN)&This->UnknownVtbl;
@@ -44,20 +45,20 @@ HRESULT WINAPI IDirectMusicSignPostTrack_IUnknown_QueryInterface (LPUNKNOWN ifac
 		return S_OK;
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicSignPostTrack_IUnknown_AddRef (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicSignPostTrack, UnknownVtbl, iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicSignPostTrack_IUnknown_Release (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicSignPostTrack, UnknownVtbl, iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}
@@ -113,19 +114,19 @@ HRESULT WINAPI IDirectMusicSignPostTrack_IDirectMusicTrack_Play (LPDIRECTMUSICTR
 
 HRESULT WINAPI IDirectMusicSignPostTrack_IDirectMusicTrack_GetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, MUSIC_TIME* pmtNext, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicSignPostTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pmtNext, pParam);
+	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pmtNext, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicSignPostTrack_IDirectMusicTrack_SetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicSignPostTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pParam);
+	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicSignPostTrack_IDirectMusicTrack_IsParamSupported (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType) {
 	ICOM_THIS_MULTI(IDirectMusicSignPostTrack, TrackVtbl, iface);
-	TRACE("(%p, %s): ", This, debugstr_guid(rguidType));
+	TRACE("(%p, %s): ", This, debugstr_dmguid(rguidType));
 	/* didn't find any params */
 	TRACE("param unsupported\n");
 	return DMUS_E_TYPE_UNSUPPORTED;
@@ -133,13 +134,13 @@ HRESULT WINAPI IDirectMusicSignPostTrack_IDirectMusicTrack_IsParamSupported (LPD
 
 HRESULT WINAPI IDirectMusicSignPostTrack_IDirectMusicTrack_AddNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicSignPostTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicSignPostTrack_IDirectMusicTrack_RemoveNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicSignPostTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
@@ -157,13 +158,13 @@ HRESULT WINAPI IDirectMusicSignPostTrack_IDirectMusicTrack_PlayEx (LPDIRECTMUSIC
 
 HRESULT WINAPI IDirectMusicSignPostTrack_IDirectMusicTrack_GetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, REFERENCE_TIME* prtNext, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicSignPostTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicSignPostTrack_IDirectMusicTrack_SetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicSignPostTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 

dlls/dmime/audiopath.c

@@ -28,6 +28,7 @@ WINE_DECLARE_DEBUG_CHANNEL(dmfile);
 /* IDirectMusicAudioPath IUnknown part: */
 HRESULT WINAPI IDirectMusicAudioPathImpl_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS_MULTI(IDirectMusicAudioPathImpl, UnknownVtbl, iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 	
 	if (IsEqualIID (riid, &IID_IUnknown)) {
 		*ppobj = (LPVOID)&This->UnknownVtbl;
@@ -47,20 +48,20 @@ HRESULT WINAPI IDirectMusicAudioPathImpl_IUnknown_QueryInterface (LPUNKNOWN ifac
 		return S_OK;
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicAudioPathImpl_IUnknown_AddRef (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicAudioPathImpl, UnknownVtbl, iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicAudioPathImpl_IUnknown_Release (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicAudioPathImpl, UnknownVtbl, iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}
@@ -93,7 +94,7 @@ ULONG WINAPI IDirectMusicAudioPathImpl_IDirectMusicAudioPath_Release (LPDIRECTMU
 HRESULT WINAPI IDirectMusicAudioPathImpl_IDirectMusicAudioPath_GetObjectInPath (LPDIRECTMUSICAUDIOPATH iface, DWORD dwPChannel, DWORD dwStage, DWORD dwBuffer, REFGUID guidObject, WORD dwIndex, REFGUID iidInterface, void** ppObject) {
 	ICOM_THIS_MULTI(IDirectMusicAudioPathImpl, AudioPathVtbl, iface);
 
-	FIXME("(%p, %ld, %ld, %ld, %s, %d, %s, %p): stub\n", This, dwPChannel, dwStage, dwBuffer, debugstr_guid(guidObject), dwIndex, debugstr_guid(iidInterface), ppObject);
+	FIXME("(%p, %ld, %ld, %ld, %s, %d, %s, %p): stub\n", This, dwPChannel, dwStage, dwBuffer, debugstr_dmguid(guidObject), dwIndex, debugstr_dmguid(iidInterface), ppObject);
 
 	switch (dwStage) {
 	case DMUS_PATH_BUFFER:
@@ -233,10 +234,7 @@ HRESULT WINAPI IDirectMusicAudioPathImpl_IDirectMusicObject_GetDescriptor (LPDIR
 
 HRESULT WINAPI IDirectMusicAudioPathImpl_IDirectMusicObject_SetDescriptor (LPDIRECTMUSICOBJECT iface, LPDMUS_OBJECTDESC pDesc) {
 	ICOM_THIS_MULTI(IDirectMusicAudioPathImpl, ObjectVtbl, iface);
-	TRACE("(%p, %p): setting descriptor:\n", This, pDesc);
-	if (TRACE_ON(dmime)) {
-		DMUSIC_dump_DMUS_OBJECTDESC (pDesc);
-	}
+	TRACE("(%p, %p): setting descriptor:\n%s\n", This, pDesc, debugstr_DMUS_OBJECTDESC (pDesc));
 	
 	/* According to MSDN, we should copy only given values, not whole struct */	
 	if (pDesc->dwValidData & DMUS_OBJ_OBJECT)
@@ -412,10 +410,7 @@ HRESULT WINAPI IDirectMusicAudioPathImpl_IDirectMusicObject_ParseDescriptor (LPD
 		}
 	}	
 	
-	TRACE(": returning descriptor:\n");
-	if (TRACE_ON(dmime)) {
-		DMUSIC_dump_DMUS_OBJECTDESC (pDesc);
-	}
+	TRACE(": returning descriptor:\n%s\n", debugstr_DMUS_OBJECTDESC (pDesc));
 	
 	return S_OK;
 }

dlls/dmime/dmime_main.c

@@ -32,7 +32,7 @@ typedef struct {
  */
 static HRESULT WINAPI PerformanceCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -49,13 +49,13 @@ static ULONG WINAPI PerformanceCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI PerformanceCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicPerformanceImpl (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI PerformanceCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -75,7 +75,7 @@ static IClassFactoryImpl Performance_CF = {&PerformanceCF_Vtbl, 1 };
  */
 static HRESULT WINAPI SegmentCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -92,13 +92,13 @@ static ULONG WINAPI SegmentCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI SegmentCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicSegmentImpl (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI SegmentCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -118,7 +118,7 @@ static IClassFactoryImpl Segment_CF = {&SegmentCF_Vtbl, 1 };
  */
 static HRESULT WINAPI SegmentStateCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -135,13 +135,13 @@ static ULONG WINAPI SegmentStateCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI SegmentStateCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicSegmentStateImpl (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI SegmentStateCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -161,7 +161,7 @@ static IClassFactoryImpl SegmentState_CF = {&SegmentStateCF_Vtbl, 1 };
  */
 static HRESULT WINAPI GraphCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -178,13 +178,13 @@ static ULONG WINAPI GraphCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI GraphCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicGraphImpl (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI GraphCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -204,7 +204,7 @@ static IClassFactoryImpl Graph_CF = {&GraphCF_Vtbl, 1 };
  */
 static HRESULT WINAPI TempoTrackCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -221,13 +221,13 @@ static ULONG WINAPI TempoTrackCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI TempoTrackCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicTempoTrack (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI TempoTrackCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -247,7 +247,7 @@ static IClassFactoryImpl TempoTrack_CF = {&TempoTrackCF_Vtbl, 1 };
  */
 static HRESULT WINAPI SeqTrackCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -264,13 +264,13 @@ static ULONG WINAPI SeqTrackCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI SeqTrackCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicSeqTrack (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI SeqTrackCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -290,7 +290,7 @@ static IClassFactoryImpl SeqTrack_CF = {&SeqTrackCF_Vtbl, 1 };
  */
 static HRESULT WINAPI SysExTrackCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -307,13 +307,13 @@ static ULONG WINAPI SysExTrackCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI SysExTrackCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicSysExTrack (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI SysExTrackCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -333,7 +333,7 @@ static IClassFactoryImpl SysExTrack_CF = {&SysExTrackCF_Vtbl, 1 };
  */
 static HRESULT WINAPI TimeSigTrackCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -350,13 +350,13 @@ static ULONG WINAPI TimeSigTrackCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI TimeSigTrackCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicTimeSigTrack (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI TimeSigTrackCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -376,7 +376,7 @@ static IClassFactoryImpl TimeSigTrack_CF = {&TimeSigTrackCF_Vtbl, 1 };
  */
 static HRESULT WINAPI ParamControlTrackCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -393,13 +393,13 @@ static ULONG WINAPI ParamControlTrackCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI ParamControlTrackCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicParamControlTrack (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI ParamControlTrackCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -419,7 +419,7 @@ static IClassFactoryImpl ParamControlTrack_CF = {&ParamControlTrackCF_Vtbl, 1 };
  */
 static HRESULT WINAPI MarkerTrackCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -436,13 +436,13 @@ static ULONG WINAPI MarkerTrackCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI MarkerTrackCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicMarkerTrack (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI MarkerTrackCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -462,7 +462,7 @@ static IClassFactoryImpl MarkerTrack_CF = {&MarkerTrackCF_Vtbl, 1 };
  */
 static HRESULT WINAPI LyricsTrackCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -479,13 +479,13 @@ static ULONG WINAPI LyricsTrackCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI LyricsTrackCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicLyricsTrack (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI LyricsTrackCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -506,7 +506,7 @@ static IClassFactoryImpl LyricsTrack_CF = {&LyricsTrackCF_Vtbl, 1 };
  */
 static HRESULT WINAPI SegTriggerTrackCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -523,13 +523,13 @@ static ULONG WINAPI SegTriggerTrackCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI SegTriggerTrackCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicSegTriggerTrack (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI SegTriggerTrackCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -549,7 +549,7 @@ static IClassFactoryImpl SegTriggerTrack_CF = {&SegTriggerTrackCF_Vtbl, 1 };
  */
 static HRESULT WINAPI AudioPathCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -566,13 +566,13 @@ static ULONG WINAPI AudioPathCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI AudioPathCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicAudioPathImpl (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI AudioPathCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -592,7 +592,7 @@ static IClassFactoryImpl AudioPath_CF = {&AudioPathCF_Vtbl, 1 };
  */
 static HRESULT WINAPI WaveTrackCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -609,13 +609,13 @@ static ULONG WINAPI WaveTrackCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI WaveTrackCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicWaveTrack (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI WaveTrackCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -666,7 +666,7 @@ HRESULT WINAPI DMIME_DllCanUnloadNow(void) {
  */
 HRESULT WINAPI DMIME_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv)
 {
-    TRACE("(%p,%p,%p)\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
+    TRACE("(%s, %s, %p)\n", debugstr_dmguid(rclsid), debugstr_dmguid(riid), ppv);
     if (IsEqualCLSID (rclsid, &CLSID_DirectMusicPerformance) && IsEqualIID (riid, &IID_IClassFactory)) {
 		*ppv = (LPVOID) &Performance_CF;
 		IClassFactory_AddRef((IClassFactory*)*ppv);
@@ -725,6 +725,415 @@ HRESULT WINAPI DMIME_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv
 		return S_OK;
 	} 
 	
-    WARN("(%p,%p,%p): no interface found.\n", debugstr_guid(rclsid), debugstr_guid(riid), 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) {
+		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)");
+	}
+}

dlls/dmime/dmime_private.h

@@ -20,7 +20,9 @@
 #ifndef __WINE_DMIME_PRIVATE_H
 #define __WINE_DMIME_PRIVATE_H
 
+#include <stdio.h>
 #include <stdarg.h>
+#include <string.h>
 
 #include "windef.h"
 #include "winbase.h"
@@ -904,26 +906,16 @@ typedef struct _DMUS_PRIVATE_CHUNK {
 	DWORD dwSize; /* size of the chunk */
 } DMUS_PRIVATE_CHUNK, *LPDMUS_PRIVATE_CHUNK;
 
-/* check whether the given DWORD is even (return 0) or odd (return 1) */
-static inline int even_or_odd (DWORD number) {
-	return (number & 0x1); /* basically, check if bit 0 is set ;) */
-}
+/* used for generic dumping (copied from ddraw) */
+typedef struct {
+    DWORD val;
+    const char* name;
+} flag_info;
 
-/* FOURCC to string conversion for debug messages */
-static inline 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 */
-static inline 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));
-}
+typedef struct {
+    const GUID *guid;
+    const char* name;
+} guid_info;
 
 /* used for initialising structs (primarily for DMUS_OBJECTDESC) */
 #define DM_STRUCT_INIT(x) 				\
@@ -932,65 +924,23 @@ static inline const char *debugstr_dmversion (LPDMUS_VERSION version) {
 		(x)->dwSize = sizeof(*x);		\
 	} while (0)
 
+#define FE(x) { x, #x }	
+#define GE(x) { &x, #x }
 
-/* used for generic dumping (copied from ddraw) */
-typedef struct {
-    DWORD val;
-    const char* name;
-} flag_info;
-
-/* generic dump function */
-static inline void DMUSIC_dump_flags_ (DWORD flags, const flag_info* names, size_t num_names, int newline) {
-	unsigned int i;
-	
-	for (i=0; i < num_names; i++) {
-		if ((flags & names[i].val) ||      /* standard flag value */
-		((!flags) && (!names[i].val))) /* zero value only */
-	    	DPRINTF("%s ", names[i].name);
-	}
-	
-    if (newline) DPRINTF("\n");
-}
-
-#define FE(x) { x, #x }
-#define DMUSIC_dump_flags(flags,names,num_names) DMUSIC_dump_flags_(flags, names, num_names, 1)
-
-static inline void DMUSIC_dump_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)
-	};
-    DMUSIC_dump_flags(flagmask, flags, sizeof(flags)/sizeof(flags[0]));
-}
-
-static inline void DMUSIC_dump_DMUS_OBJECTDESC (LPDMUS_OBJECTDESC pDesc) {
-	if (pDesc) {
-		DPRINTF("DMUS_OBJECTDESC (%p)\n", pDesc);
-		DPRINTF("  - dwSize = %ld\n", pDesc->dwSize);
-		DPRINTF("  - dwValidData = ");
-		DMUSIC_dump_DMUS_OBJ_FLAGS (pDesc->dwValidData);
-		if (pDesc->dwValidData & DMUS_OBJ_CLASS) DPRINTF("  - guidClass = %s\n", debugstr_guid(&pDesc->guidClass));
-		if (pDesc->dwValidData & DMUS_OBJ_OBJECT) DPRINTF("  - guidObject = %s\n", debugstr_guid(&pDesc->guidObject));
-		if (pDesc->dwValidData & DMUS_OBJ_DATE) DPRINTF("  - ftDate = FIXME\n");
-		if (pDesc->dwValidData & DMUS_OBJ_VERSION) DPRINTF("  - vVersion = %s\n", debugstr_dmversion(&pDesc->vVersion));
-		if (pDesc->dwValidData & DMUS_OBJ_NAME) DPRINTF("  - wszName = %s\n", debugstr_w(pDesc->wszName));
-		if (pDesc->dwValidData & DMUS_OBJ_CATEGORY) DPRINTF("  - wszCategory = %s\n", debugstr_w(pDesc->wszCategory));
-		if (pDesc->dwValidData & DMUS_OBJ_FILENAME) DPRINTF("  - wszFileName = %s\n", debugstr_w(pDesc->wszFileName));
-		if (pDesc->dwValidData & DMUS_OBJ_MEMORY) DPRINTF("  - llMemLength = %lli\n  - pbMemData = %p\n", pDesc->llMemLength, pDesc->pbMemData);
-		if (pDesc->dwValidData & DMUS_OBJ_STREAM) DPRINTF("  - pStream = %p\n", pDesc->pStream);		
-	} else {
-		DPRINTF("(NULL)\n");
-	}
-}
+/* 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);
 
 #endif	/* __WINE_DMIME_PRIVATE_H */

dlls/dmime/graph.c

@@ -28,6 +28,7 @@ WINE_DECLARE_DEBUG_CHANNEL(dmfile);
 /* IDirectMusicGraphImpl IUnknown part: */
 HRESULT WINAPI IDirectMusicGraphImpl_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS_MULTI(IDirectMusicGraphImpl, UnknownVtbl, iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppobj);
 	
 	if (IsEqualIID (riid, &IID_IUnknown)) {
 		*ppobj = (LPVOID)&This->UnknownVtbl;
@@ -47,20 +48,20 @@ HRESULT WINAPI IDirectMusicGraphImpl_IUnknown_QueryInterface (LPUNKNOWN iface, R
 		return S_OK;
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_guid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicGraphImpl_IUnknown_AddRef (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicGraphImpl, UnknownVtbl, iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicGraphImpl_IUnknown_Release (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicGraphImpl, UnknownVtbl, iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}
@@ -202,10 +203,7 @@ HRESULT WINAPI IDirectMusicGraphImpl_IDirectMusicObject_GetDescriptor (LPDIRECTM
 
 HRESULT WINAPI IDirectMusicGraphImpl_IDirectMusicObject_SetDescriptor (LPDIRECTMUSICOBJECT iface, LPDMUS_OBJECTDESC pDesc) {
 	ICOM_THIS_MULTI(IDirectMusicGraphImpl, ObjectVtbl, iface);
-	TRACE("(%p, %p): setting descriptor:\n", This, pDesc);
-	if (TRACE_ON(dmime)) {
-		DMUSIC_dump_DMUS_OBJECTDESC (pDesc);
-	}
+	TRACE("(%p, %p): setting descriptor:\n%s\n", This, pDesc, debugstr_DMUS_OBJECTDESC (pDesc));
 	
 	/* According to MSDN, we should copy only given values, not whole struct */	
 	if (pDesc->dwValidData & DMUS_OBJ_OBJECT)
@@ -381,10 +379,7 @@ HRESULT WINAPI IDirectMusicGraphImpl_IDirectMusicObject_ParseDescriptor (LPDIREC
 		}
 	}	
 	
-	TRACE(": returning descriptor:\n");
-	if (TRACE_ON(dmime)) {
-		DMUSIC_dump_DMUS_OBJECTDESC (pDesc);
-	}
+	TRACE(": returning descriptor:\n%s\n", debugstr_DMUS_OBJECTDESC (pDesc));
 	
 	return S_OK;
 }

dlls/dmime/lyricstrack.c

@@ -28,6 +28,7 @@ WINE_DECLARE_DEBUG_CHANNEL(dmfile);
 /* IDirectMusicLyricsTrack IUnknown part: */
 HRESULT WINAPI IDirectMusicLyricsTrack_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS_MULTI(IDirectMusicLyricsTrack, UnknownVtbl, iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 
 	if (IsEqualIID (riid, &IID_IUnknown)) {
 		*ppobj = (LPUNKNOWN)&This->UnknownVtbl;
@@ -44,20 +45,20 @@ HRESULT WINAPI IDirectMusicLyricsTrack_IUnknown_QueryInterface (LPUNKNOWN iface,
 		return S_OK;
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicLyricsTrack_IUnknown_AddRef (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicLyricsTrack, UnknownVtbl, iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicLyricsTrack_IUnknown_Release (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicLyricsTrack, UnknownVtbl, iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}
@@ -117,20 +118,20 @@ HRESULT WINAPI IDirectMusicLyricsTrack_IDirectMusicTrack_Play (LPDIRECTMUSICTRAC
 
 HRESULT WINAPI IDirectMusicLyricsTrack_IDirectMusicTrack_GetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, MUSIC_TIME* pmtNext, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicLyricsTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pmtNext, pParam);
+	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pmtNext, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicLyricsTrack_IDirectMusicTrack_SetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicLyricsTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pParam);
+	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicLyricsTrack_IDirectMusicTrack_IsParamSupported (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType) {
 	ICOM_THIS_MULTI(IDirectMusicLyricsTrack, TrackVtbl, iface);
 
-	TRACE("(%p, %s): ", This, debugstr_guid(rguidType));
+	TRACE("(%p, %s): ", This, debugstr_dmguid(rguidType));
 	/* didn't find any params */
 	TRACE("param unsupported\n");
 	return DMUS_E_TYPE_UNSUPPORTED;
@@ -138,13 +139,13 @@ HRESULT WINAPI IDirectMusicLyricsTrack_IDirectMusicTrack_IsParamSupported (LPDIR
 
 HRESULT WINAPI IDirectMusicLyricsTrack_IDirectMusicTrack_AddNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicLyricsTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicLyricsTrack_IDirectMusicTrack_RemoveNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicLyricsTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
@@ -162,13 +163,13 @@ HRESULT WINAPI IDirectMusicLyricsTrack_IDirectMusicTrack_PlayEx (LPDIRECTMUSICTR
 
 HRESULT WINAPI IDirectMusicLyricsTrack_IDirectMusicTrack_GetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, REFERENCE_TIME* prtNext, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicLyricsTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicLyricsTrack_IDirectMusicTrack_SetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicLyricsTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 

dlls/dmime/markertrack.c

@@ -28,6 +28,7 @@ WINE_DECLARE_DEBUG_CHANNEL(dmfile);
 /* IDirectMusicMarkerTrack IUnknown part: */
 HRESULT WINAPI IDirectMusicMarkerTrack_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS_MULTI(IDirectMusicMarkerTrack, UnknownVtbl, iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 
 	if (IsEqualIID (riid, &IID_IUnknown)) {
 		*ppobj = (LPUNKNOWN)&This->UnknownVtbl;
@@ -44,20 +45,20 @@ HRESULT WINAPI IDirectMusicMarkerTrack_IUnknown_QueryInterface (LPUNKNOWN iface,
 		return S_OK;
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicMarkerTrack_IUnknown_AddRef (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicMarkerTrack, UnknownVtbl, iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicMarkerTrack_IUnknown_Release (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicMarkerTrack, UnknownVtbl, iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}
@@ -113,20 +114,20 @@ HRESULT WINAPI IDirectMusicMarkerTrack_IDirectMusicTrack_Play (LPDIRECTMUSICTRAC
 
 HRESULT WINAPI IDirectMusicMarkerTrack_IDirectMusicTrack_GetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, MUSIC_TIME* pmtNext, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicMarkerTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pmtNext, pParam);
+	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pmtNext, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicMarkerTrack_IDirectMusicTrack_SetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicMarkerTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pParam);
+	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicMarkerTrack_IDirectMusicTrack_IsParamSupported (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType) {
 	ICOM_THIS_MULTI(IDirectMusicMarkerTrack, TrackVtbl, iface);
 
-	TRACE("(%p, %s): ", This, debugstr_guid(rguidType));
+	TRACE("(%p, %s): ", This, debugstr_dmguid(rguidType));
 	if (IsEqualGUID (rguidType, &GUID_Play_Marker)
 		|| IsEqualGUID (rguidType, &GUID_Valid_Start_Time)) {
 		TRACE("param supported\n");
@@ -138,13 +139,13 @@ HRESULT WINAPI IDirectMusicMarkerTrack_IDirectMusicTrack_IsParamSupported (LPDIR
 
 HRESULT WINAPI IDirectMusicMarkerTrack_IDirectMusicTrack_AddNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicMarkerTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicMarkerTrack_IDirectMusicTrack_RemoveNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicMarkerTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
@@ -162,13 +163,13 @@ HRESULT WINAPI IDirectMusicMarkerTrack_IDirectMusicTrack_PlayEx (LPDIRECTMUSICTR
 
 HRESULT WINAPI IDirectMusicMarkerTrack_IDirectMusicTrack_GetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, REFERENCE_TIME* prtNext, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicMarkerTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicMarkerTrack_IDirectMusicTrack_SetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicMarkerTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 

dlls/dmime/paramcontroltrack.c

@@ -28,6 +28,7 @@ WINE_DECLARE_DEBUG_CHANNEL(dmfile);
 /* IDirectMusicParamControlTrack IUnknown part: */
 HRESULT WINAPI IDirectMusicParamControlTrack_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS_MULTI(IDirectMusicParamControlTrack, UnknownVtbl, iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 
 	if (IsEqualIID (riid, &IID_IUnknown)) {
 		*ppobj = (LPUNKNOWN)&This->UnknownVtbl;
@@ -44,20 +45,20 @@ HRESULT WINAPI IDirectMusicParamControlTrack_IUnknown_QueryInterface (LPUNKNOWN
 		return S_OK;
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicParamControlTrack_IUnknown_AddRef (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicParamControlTrack, UnknownVtbl, iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicParamControlTrack_IUnknown_Release (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicParamControlTrack, UnknownVtbl, iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}
@@ -117,20 +118,20 @@ HRESULT WINAPI IDirectMusicParamControlTrack_IDirectMusicTrack_Play (LPDIRECTMUS
 
 HRESULT WINAPI IDirectMusicParamControlTrack_IDirectMusicTrack_GetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, MUSIC_TIME* pmtNext, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicParamControlTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pmtNext, pParam);
+	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pmtNext, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicParamControlTrack_IDirectMusicTrack_SetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicParamControlTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pParam);
+	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicParamControlTrack_IDirectMusicTrack_IsParamSupported (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType) {
 	ICOM_THIS_MULTI(IDirectMusicParamControlTrack, TrackVtbl, iface);
 
-	TRACE("(%p, %s): ", This, debugstr_guid(rguidType));
+	TRACE("(%p, %s): ", This, debugstr_dmguid(rguidType));
 	/* didn't find any params */
 	TRACE("param unsupported\n");
 	return DMUS_E_TYPE_UNSUPPORTED;
@@ -138,13 +139,13 @@ HRESULT WINAPI IDirectMusicParamControlTrack_IDirectMusicTrack_IsParamSupported
 
 HRESULT WINAPI IDirectMusicParamControlTrack_IDirectMusicTrack_AddNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicParamControlTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicParamControlTrack_IDirectMusicTrack_RemoveNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicParamControlTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
@@ -162,13 +163,13 @@ HRESULT WINAPI IDirectMusicParamControlTrack_IDirectMusicTrack_PlayEx (LPDIRECTM
 
 HRESULT WINAPI IDirectMusicParamControlTrack_IDirectMusicTrack_GetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, REFERENCE_TIME* prtNext, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicParamControlTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicParamControlTrack_IDirectMusicTrack_SetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicParamControlTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 

dlls/dmime/patterntrack.c

@@ -24,6 +24,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(dmime);
 /* IDirectMusicPatternTrack IUnknown parts follow: */
 HRESULT WINAPI IDirectMusicPatternTrackImpl_QueryInterface (LPDIRECTMUSICPATTERNTRACK iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IDirectMusicPatternTrackImpl,iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 
 	if (IsEqualIID (riid, &IID_IUnknown) || 
 	    IsEqualIID (riid, &IID_IDirectMusicPatternTrack)) {
@@ -32,20 +33,20 @@ HRESULT WINAPI IDirectMusicPatternTrackImpl_QueryInterface (LPDIRECTMUSICPATTERN
 		return S_OK;
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicPatternTrackImpl_AddRef (LPDIRECTMUSICPATTERNTRACK iface) {
 	ICOM_THIS(IDirectMusicPatternTrackImpl,iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicPatternTrackImpl_Release (LPDIRECTMUSICPATTERNTRACK iface) {
 	ICOM_THIS(IDirectMusicPatternTrackImpl,iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}

dlls/dmime/performance.c

@@ -24,6 +24,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(dmime);
 /* IDirectMusicPerformance8 IUnknown part: */
 HRESULT WINAPI IDirectMusicPerformance8Impl_QueryInterface (LPDIRECTMUSICPERFORMANCE8 iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IDirectMusicPerformance8Impl,iface);
+	TRACE("(%p, %s,%p)\n", This, debugstr_dmguid(riid), ppobj);
 
 	if (IsEqualIID (riid, &IID_IUnknown) || 
 	    IsEqualIID (riid, &IID_IDirectMusicPerformance) ||
@@ -33,20 +34,20 @@ HRESULT WINAPI IDirectMusicPerformance8Impl_QueryInterface (LPDIRECTMUSICPERFORM
 		return S_OK;
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s,%p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicPerformance8Impl_AddRef (LPDIRECTMUSICPERFORMANCE8 iface) {
 	ICOM_THIS(IDirectMusicPerformance8Impl,iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicPerformance8Impl_Release (LPDIRECTMUSICPERFORMANCE8 iface) {
 	ICOM_THIS(IDirectMusicPerformance8Impl,iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}
@@ -221,13 +222,13 @@ HRESULT WINAPI IDirectMusicPerformance8Impl_GetNotificationPMsg (LPDIRECTMUSICPE
 
 HRESULT WINAPI IDirectMusicPerformance8Impl_AddNotificationType (LPDIRECTMUSICPERFORMANCE8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS(IDirectMusicPerformance8Impl,iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicPerformance8Impl_RemoveNotificationType (LPDIRECTMUSICPERFORMANCE8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS(IDirectMusicPerformance8Impl,iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
@@ -295,20 +296,20 @@ HRESULT WINAPI IDirectMusicPerformance8Impl_Invalidate (LPDIRECTMUSICPERFORMANCE
 
 HRESULT WINAPI IDirectMusicPerformance8Impl_GetParam (LPDIRECTMUSICPERFORMANCE8 iface, REFGUID rguidType, DWORD dwGroupBits, DWORD dwIndex, MUSIC_TIME mtTime, MUSIC_TIME* pmtNext, void* pParam) {
 	ICOM_THIS(IDirectMusicPerformance8Impl,iface);
-	FIXME("(%p, %s, %ld, %ld, %ld, %p, %p): stub\n", This, debugstr_guid(rguidType), dwGroupBits, dwIndex, mtTime, pmtNext, pParam);
+	FIXME("(%p, %s, %ld, %ld, %ld, %p, %p): stub\n", This, debugstr_dmguid(rguidType), dwGroupBits, dwIndex, mtTime, pmtNext, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicPerformance8Impl_SetParam (LPDIRECTMUSICPERFORMANCE8 iface, REFGUID rguidType, DWORD dwGroupBits, DWORD dwIndex, MUSIC_TIME mtTime, void* pParam) {
 	ICOM_THIS(IDirectMusicPerformance8Impl,iface);
-	FIXME("(%p, %s, %ld, %ld, %ld, %p): stub\n", This, debugstr_guid(rguidType), dwGroupBits, dwIndex, mtTime, pParam);
+	FIXME("(%p, %s, %ld, %ld, %ld, %p): stub\n", This, debugstr_dmguid(rguidType), dwGroupBits, dwIndex, mtTime, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicPerformance8Impl_GetGlobalParam (LPDIRECTMUSICPERFORMANCE8 iface, REFGUID rguidType, void* pParam, DWORD dwSize) {
 	ICOM_THIS(IDirectMusicPerformance8Impl,iface);
 
-	TRACE("(%p, %s, %p, %ld): stub\n", This, debugstr_guid(rguidType), pParam, dwSize);
+	TRACE("(%p, %s, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), pParam, dwSize);
 	
 	if (IsEqualGUID (rguidType, &GUID_PerfAutoDownload))
 		memcpy(pParam, &This->fAutoDownload, sizeof(&This->fAutoDownload));
@@ -325,7 +326,7 @@ HRESULT WINAPI IDirectMusicPerformance8Impl_GetGlobalParam (LPDIRECTMUSICPERFORM
 HRESULT WINAPI IDirectMusicPerformance8Impl_SetGlobalParam (LPDIRECTMUSICPERFORMANCE8 iface, REFGUID rguidType, void* pParam, DWORD dwSize) {
 	ICOM_THIS(IDirectMusicPerformance8Impl,iface);
 
-	TRACE("(%p, %s, %p, %ld)\n", This, debugstr_guid(rguidType), pParam, dwSize);
+	TRACE("(%p, %s, %p, %ld)\n", This, debugstr_dmguid(rguidType), pParam, dwSize);
 	
 	if (IsEqualGUID (rguidType, &GUID_PerfAutoDownload)) {
 		memcpy(&This->fAutoDownload, pParam, dwSize);
@@ -606,7 +607,7 @@ HRESULT WINAPI IDirectMusicPerformance8ImplGetDefaultAudioPath (LPDIRECTMUSICPER
 HRESULT WINAPI IDirectMusicPerformance8ImplGetParamEx (LPDIRECTMUSICPERFORMANCE8 iface, REFGUID rguidType, DWORD dwTrackID, DWORD dwGroupBits, DWORD dwIndex, MUSIC_TIME mtTime, MUSIC_TIME* pmtNext, void* pParam) {
 	ICOM_THIS(IDirectMusicPerformance8Impl,iface);
 
-	FIXME("(%p, %s, %ld, %ld, %ld, %ld, %p, %p): stub\n", This, debugstr_guid(rguidType), dwTrackID, dwGroupBits, dwIndex, mtTime, pmtNext, pParam);
+	FIXME("(%p, %s, %ld, %ld, %ld, %ld, %p, %p): stub\n", This, debugstr_dmguid(rguidType), dwTrackID, dwGroupBits, dwIndex, mtTime, pmtNext, pParam);
 
 	return S_OK;
 }

dlls/dmime/segment.c

@@ -28,6 +28,7 @@ WINE_DECLARE_DEBUG_CHANNEL(dmfile);
 /* IDirectMusicSegment IUnknown part: */
 HRESULT WINAPI IDirectMusicSegment8Impl_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS_MULTI(IDirectMusicSegment8Impl, UnknownVtbl, iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 	
 	if (IsEqualIID (riid, &IID_IUnknown)) {
 		*ppobj = (LPVOID)&This->UnknownVtbl;
@@ -49,20 +50,20 @@ HRESULT WINAPI IDirectMusicSegment8Impl_IUnknown_QueryInterface (LPUNKNOWN iface
 		return S_OK;
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicSegment8Impl_IUnknown_AddRef (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicSegment8Impl, UnknownVtbl, iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicSegment8Impl_IUnknown_Release (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicSegment8Impl, UnknownVtbl, iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}
@@ -130,7 +131,7 @@ HRESULT WINAPI IDirectMusicSegment8Impl_IDirectMusicSegment8_SetDefaultResolutio
 
 HRESULT WINAPI IDirectMusicSegment8Impl_IDirectMusicSegment8_GetTrack (LPDIRECTMUSICSEGMENT8 iface, REFGUID rguidType, DWORD dwGroupBits, DWORD dwIndex, IDirectMusicTrack** ppTrack) {
 	ICOM_THIS_MULTI(IDirectMusicSegment8Impl, SegmentVtbl, iface);
-	FIXME("(%p, %s, %ld, %ld, %p): stub\n", This, debugstr_guid(rguidType), dwGroupBits, dwIndex, ppTrack);
+	FIXME("(%p, %s, %ld, %ld, %p): stub\n", This, debugstr_dmguid(rguidType), dwGroupBits, dwIndex, ppTrack);
 	return S_OK;
 }
 
@@ -172,25 +173,25 @@ HRESULT WINAPI IDirectMusicSegment8Impl_IDirectMusicSegment8_SetGraph (LPDIRECTM
 
 HRESULT WINAPI IDirectMusicSegment8Impl_IDirectMusicSegment8_AddNotificationType (LPDIRECTMUSICSEGMENT8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicSegment8Impl, SegmentVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicSegment8Impl_IDirectMusicSegment8_RemoveNotificationType (LPDIRECTMUSICSEGMENT8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicSegment8Impl, SegmentVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicSegment8Impl_IDirectMusicSegment8_GetParam (LPDIRECTMUSICSEGMENT8 iface, REFGUID rguidType, DWORD dwGroupBits, DWORD dwIndex, MUSIC_TIME mtTime, MUSIC_TIME* pmtNext, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicSegment8Impl, SegmentVtbl, iface);
-	FIXME("(%p, %s, %ld, %ld, %ld, %p, %p): stub\n", This, debugstr_guid(rguidType), dwGroupBits, dwIndex, mtTime, pmtNext, pParam);
+	FIXME("(%p, %s, %ld, %ld, %ld, %p, %p): stub\n", This, debugstr_dmguid(rguidType), dwGroupBits, dwIndex, mtTime, pmtNext, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicSegment8Impl_IDirectMusicSegment8_SetParam (LPDIRECTMUSICSEGMENT8 iface, REFGUID rguidType, DWORD dwGroupBits, DWORD dwIndex, MUSIC_TIME mtTime, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicSegment8Impl, SegmentVtbl, iface);
-	FIXME("(%p, %s, %ld, %ld, %ld, %p): stub\n", This, debugstr_guid(rguidType), dwGroupBits, dwIndex, mtTime, pParam);
+	FIXME("(%p, %s, %ld, %ld, %ld, %p): stub\n", This, debugstr_dmguid(rguidType), dwGroupBits, dwIndex, mtTime, pParam);
 	return S_OK;
 }
 
@@ -232,7 +233,7 @@ HRESULT WINAPI IDirectMusicSegment8Impl_IDirectMusicSegment8_SetPChannelsUsed (L
 
 HRESULT WINAPI IDirectMusicSegment8Impl_IDirectMusicSegment8_SetTrackConfig (LPDIRECTMUSICSEGMENT8 iface, REFGUID rguidTrackClassID, DWORD dwGroupBits, DWORD dwIndex, DWORD dwFlagsOn, DWORD dwFlagsOff) {
 	ICOM_THIS_MULTI(IDirectMusicSegment8Impl, SegmentVtbl, iface);
-	FIXME("(%p, %s, %ld, %ld, %ld, %ld): stub\n", This, debugstr_guid(rguidTrackClassID), dwGroupBits, dwIndex, dwFlagsOn, dwFlagsOff);
+	FIXME("(%p, %s, %ld, %ld, %ld, %ld): stub\n", This, debugstr_dmguid(rguidTrackClassID), dwGroupBits, dwIndex, dwFlagsOn, dwFlagsOff);
 	return S_OK;
 }
 
@@ -260,8 +261,7 @@ HRESULT WINAPI IDirectMusicSegment8Impl_IDirectMusicSegment8_Unload (LPDIRECTMUS
 	return S_OK;
 }
 
-ICOM_VTABLE(IDirectMusicSegment8) DirectMusicSegment8_Segment_Vtbl =
-{
+ICOM_VTABLE(IDirectMusicSegment8) DirectMusicSegment8_Segment_Vtbl = {
     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 	IDirectMusicSegment8Impl_IDirectMusicSegment8_QueryInterface,
 	IDirectMusicSegment8Impl_IDirectMusicSegment8_AddRef,
@@ -322,10 +322,7 @@ HRESULT WINAPI IDirectMusicSegment8Impl_IDirectMusicObject_GetDescriptor (LPDIRE
 
 HRESULT WINAPI IDirectMusicSegment8Impl_IDirectMusicObject_SetDescriptor (LPDIRECTMUSICOBJECT iface, LPDMUS_OBJECTDESC pDesc) {
 	ICOM_THIS_MULTI(IDirectMusicSegment8Impl, ObjectVtbl, iface);
-	TRACE("(%p, %p): setting descriptor:\n", This, pDesc);
-	if (TRACE_ON(dmime)) {
-		DMUSIC_dump_DMUS_OBJECTDESC (pDesc);
-	}
+	TRACE("(%p, %p): setting descriptor:\n%s\n", This, pDesc, debugstr_DMUS_OBJECTDESC (pDesc));
 	
 	/* According to MSDN, we should copy only given values, not whole struct */	
 	if (pDesc->dwValidData & DMUS_OBJ_OBJECT)
@@ -501,10 +498,7 @@ HRESULT WINAPI IDirectMusicSegment8Impl_IDirectMusicObject_ParseDescriptor (LPDI
 		}
 	}	
 	
-	TRACE(": returning descriptor:\n");
-	if (TRACE_ON(dmime)) {
-		DMUSIC_dump_DMUS_OBJECTDESC (pDesc);
-	}
+	TRACE(": returning descriptor:\n%s\n", debugstr_DMUS_OBJECTDESC (pDesc));
 	
 	return S_OK;
 }

dlls/dmime/segmentstate.c

@@ -24,6 +24,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(dmime);
 /* IDirectMusicSegmentState8Impl IUnknown part: */
 HRESULT WINAPI IDirectMusicSegmentState8Impl_QueryInterface (LPDIRECTMUSICSEGMENTSTATE8 iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IDirectMusicSegmentState8Impl,iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 
 	if (IsEqualIID(riid, &IID_IUnknown) || 
 	    IsEqualIID(riid, &IID_IDirectMusicSegmentState) ||
@@ -32,20 +33,20 @@ HRESULT WINAPI IDirectMusicSegmentState8Impl_QueryInterface (LPDIRECTMUSICSEGMEN
 		*ppobj = This;
 		return S_OK;
 	}
-	WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicSegmentState8Impl_AddRef (LPDIRECTMUSICSEGMENTSTATE8 iface) {
 	ICOM_THIS(IDirectMusicSegmentState8Impl,iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicSegmentState8Impl_Release (LPDIRECTMUSICSEGMENTSTATE8 iface) {
 	ICOM_THIS(IDirectMusicSegmentState8Impl,iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}
@@ -86,13 +87,13 @@ HRESULT WINAPI IDirectMusicSegmentState8Impl_GetStartPoint (LPDIRECTMUSICSEGMENT
 /* IDirectMusicSegmentState8Impl IDirectMusicSegmentState8 part: */
 HRESULT WINAPI IDirectMusicSegmentState8Impl_SetTrackConfig (LPDIRECTMUSICSEGMENTSTATE8 iface, REFGUID rguidTrackClassID, DWORD dwGroupBits, DWORD dwIndex, DWORD dwFlagsOn, DWORD dwFlagsOff) {
 	ICOM_THIS(IDirectMusicSegmentState8Impl,iface);
-	FIXME("(%p, %s, %ld, %ld, %ld, %ld): stub\n", This, debugstr_guid(rguidTrackClassID), dwGroupBits, dwIndex, dwFlagsOn, dwFlagsOff);
+	FIXME("(%p, %s, %ld, %ld, %ld, %ld): stub\n", This, debugstr_dmguid(rguidTrackClassID), dwGroupBits, dwIndex, dwFlagsOn, dwFlagsOff);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicSegmentState8Impl_GetObjectInPath (LPDIRECTMUSICSEGMENTSTATE8 iface, DWORD dwPChannel, DWORD dwStage, DWORD dwBuffer, REFGUID guidObject, DWORD dwIndex, REFGUID iidInterface, void** ppObject) {
 	ICOM_THIS(IDirectMusicSegmentState8Impl,iface);
-	FIXME("(%p, %ld, %ld, %ld, %s, %ld, %s, %p): stub\n", This, dwPChannel, dwStage, dwBuffer, debugstr_guid(guidObject), dwIndex, debugstr_guid(iidInterface), ppObject);
+	FIXME("(%p, %ld, %ld, %ld, %s, %ld, %s, %p): stub\n", This, dwPChannel, dwStage, dwBuffer, debugstr_dmguid(guidObject), dwIndex, debugstr_dmguid(iidInterface), ppObject);
 	return S_OK;
 }
 

dlls/dmime/segtriggertrack.c

@@ -28,6 +28,7 @@ WINE_DECLARE_DEBUG_CHANNEL(dmfile);
 /* IDirectMusicSegTriggerTrack IUnknown part: */
 HRESULT WINAPI IDirectMusicSegTriggerTrack_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS_MULTI(IDirectMusicSegTriggerTrack, UnknownVtbl, iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 
 	if (IsEqualIID (riid, &IID_IUnknown)) {
 		*ppobj = (LPUNKNOWN)&This->UnknownVtbl;
@@ -44,20 +45,20 @@ HRESULT WINAPI IDirectMusicSegTriggerTrack_IUnknown_QueryInterface (LPUNKNOWN if
 		return S_OK;
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicSegTriggerTrack_IUnknown_AddRef (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicSegTriggerTrack, UnknownVtbl, iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicSegTriggerTrack_IUnknown_Release (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicSegTriggerTrack, UnknownVtbl, iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}
@@ -117,20 +118,20 @@ HRESULT WINAPI IDirectMusicSegTriggerTrack_IDirectMusicTrack_Play (LPDIRECTMUSIC
 
 HRESULT WINAPI IDirectMusicSegTriggerTrack_IDirectMusicTrack_GetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, MUSIC_TIME* pmtNext, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicSegTriggerTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pmtNext, pParam);
+	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pmtNext, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicSegTriggerTrack_IDirectMusicTrack_SetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicSegTriggerTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pParam);
+	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicSegTriggerTrack_IDirectMusicTrack_IsParamSupported (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType) {
 	ICOM_THIS_MULTI(IDirectMusicSegTriggerTrack, TrackVtbl, iface);
 
-	TRACE("(%p, %s): ", This, debugstr_guid(rguidType));
+	TRACE("(%p, %s): ", This, debugstr_dmguid(rguidType));
 	/* didn't find any params */
 	TRACE("param unsupported\n");
 	return DMUS_E_TYPE_UNSUPPORTED;
@@ -138,13 +139,13 @@ HRESULT WINAPI IDirectMusicSegTriggerTrack_IDirectMusicTrack_IsParamSupported (L
 
 HRESULT WINAPI IDirectMusicSegTriggerTrack_IDirectMusicTrack_AddNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicSegTriggerTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicSegTriggerTrack_IDirectMusicTrack_RemoveNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicSegTriggerTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
@@ -162,13 +163,13 @@ HRESULT WINAPI IDirectMusicSegTriggerTrack_IDirectMusicTrack_PlayEx (LPDIRECTMUS
 
 HRESULT WINAPI IDirectMusicSegTriggerTrack_IDirectMusicTrack_GetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, REFERENCE_TIME* prtNext, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicSegTriggerTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicSegTriggerTrack_IDirectMusicTrack_SetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicSegTriggerTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 

dlls/dmime/seqtrack.c

@@ -29,6 +29,7 @@ WINE_DECLARE_DEBUG_CHANNEL(dmfile);
 HRESULT WINAPI IDirectMusicSeqTrack_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS_MULTI(IDirectMusicSeqTrack, UnknownVtbl, iface);
 
+	TRACE("(%p, %s,%p)\n", This, debugstr_dmguid(riid), ppobj);
 	if (IsEqualIID (riid, &IID_IUnknown)) {
 		*ppobj = (LPUNKNOWN)&This->UnknownVtbl;
 		IDirectMusicSeqTrack_IUnknown_AddRef ((LPUNKNOWN)&This->UnknownVtbl);
@@ -44,20 +45,20 @@ HRESULT WINAPI IDirectMusicSeqTrack_IUnknown_QueryInterface (LPUNKNOWN iface, RE
 		return S_OK;
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s,%p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicSeqTrack_IUnknown_AddRef (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicSeqTrack, UnknownVtbl, iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicSeqTrack_IUnknown_Release (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicSeqTrack, UnknownVtbl, iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}
@@ -117,20 +118,20 @@ HRESULT WINAPI IDirectMusicSeqTrack_IDirectMusicTrack_Play (LPDIRECTMUSICTRACK8
 
 HRESULT WINAPI IDirectMusicSeqTrack_IDirectMusicTrack_GetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, MUSIC_TIME* pmtNext, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicSeqTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pmtNext, pParam);
+	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pmtNext, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicSeqTrack_IDirectMusicTrack_SetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicSeqTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pParam);
+	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicSeqTrack_IDirectMusicTrack_IsParamSupported (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType) {
 	ICOM_THIS_MULTI(IDirectMusicSeqTrack, TrackVtbl, iface);
 
-	TRACE("(%p, %s): ", This, debugstr_guid(rguidType));
+	TRACE("(%p, %s): ", This, debugstr_dmguid(rguidType));
 	/* didn't find any params */
 	TRACE("param unsupported\n");
 	return DMUS_E_TYPE_UNSUPPORTED;
@@ -138,13 +139,13 @@ HRESULT WINAPI IDirectMusicSeqTrack_IDirectMusicTrack_IsParamSupported (LPDIRECT
 
 HRESULT WINAPI IDirectMusicSeqTrack_IDirectMusicTrack_AddNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicSeqTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicSeqTrack_IDirectMusicTrack_RemoveNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicSeqTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
@@ -162,13 +163,13 @@ HRESULT WINAPI IDirectMusicSeqTrack_IDirectMusicTrack_PlayEx (LPDIRECTMUSICTRACK
 
 HRESULT WINAPI IDirectMusicSeqTrack_IDirectMusicTrack_GetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, REFERENCE_TIME* prtNext, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicSeqTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicSeqTrack_IDirectMusicTrack_SetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicSeqTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 

dlls/dmime/sysextrack.c

@@ -28,6 +28,7 @@ WINE_DECLARE_DEBUG_CHANNEL(dmfile);
 /* IDirectMusicSysExTrack IUnknown part: */
 HRESULT WINAPI IDirectMusicSysExTrack_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS_MULTI(IDirectMusicSysExTrack, UnknownVtbl, iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppobj);
 
 	if (IsEqualIID (riid, &IID_IUnknown)) {
 		*ppobj = (LPUNKNOWN)&This->UnknownVtbl;
@@ -44,20 +45,20 @@ HRESULT WINAPI IDirectMusicSysExTrack_IUnknown_QueryInterface (LPUNKNOWN iface,
 		return S_OK;
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_guid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicSysExTrack_IUnknown_AddRef (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicSysExTrack, UnknownVtbl, iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicSysExTrack_IUnknown_Release (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicSysExTrack, UnknownVtbl, iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}

dlls/dmime/tempotrack.c

@@ -28,6 +28,7 @@ WINE_DECLARE_DEBUG_CHANNEL(dmfile);
 /* IDirectMusicTempoTrack IUnknown part: */
 HRESULT WINAPI IDirectMusicTempoTrack_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS_MULTI(IDirectMusicTempoTrack, UnknownVtbl, iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 
 	if (IsEqualIID (riid, &IID_IUnknown)) {
 		*ppobj = (LPUNKNOWN)&This->UnknownVtbl;
@@ -44,20 +45,20 @@ HRESULT WINAPI IDirectMusicTempoTrack_IUnknown_QueryInterface (LPUNKNOWN iface,
 		return S_OK;
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicTempoTrack_IUnknown_AddRef (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicTempoTrack, UnknownVtbl, iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicTempoTrack_IUnknown_Release (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicTempoTrack, UnknownVtbl, iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}
@@ -117,20 +118,20 @@ HRESULT WINAPI IDirectMusicTempoTrack_IDirectMusicTrack_Play (LPDIRECTMUSICTRACK
 
 HRESULT WINAPI IDirectMusicTempoTrack_IDirectMusicTrack_GetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, MUSIC_TIME* pmtNext, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicTempoTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pmtNext, pParam);
+	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pmtNext, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicTempoTrack_IDirectMusicTrack_SetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicTempoTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pParam);
+	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicTempoTrack_IDirectMusicTrack_IsParamSupported (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType) {
 	ICOM_THIS_MULTI(IDirectMusicTempoTrack, TrackVtbl, iface);
 
-	TRACE("(%p, %s): ", This, debugstr_guid(rguidType));
+	TRACE("(%p, %s): ", This, debugstr_dmguid(rguidType));
 	if (IsEqualGUID (rguidType, &GUID_DisableTempo)
 		|| IsEqualGUID (rguidType, &GUID_EnableTempo)
 		|| IsEqualGUID (rguidType, &GUID_TempoParam)) {
@@ -143,13 +144,13 @@ HRESULT WINAPI IDirectMusicTempoTrack_IDirectMusicTrack_IsParamSupported (LPDIRE
 
 HRESULT WINAPI IDirectMusicTempoTrack_IDirectMusicTrack_AddNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicTempoTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicTempoTrack_IDirectMusicTrack_RemoveNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicTempoTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
@@ -167,13 +168,13 @@ HRESULT WINAPI IDirectMusicTempoTrack_IDirectMusicTrack_PlayEx (LPDIRECTMUSICTRA
 
 HRESULT WINAPI IDirectMusicTempoTrack_IDirectMusicTrack_GetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, REFERENCE_TIME* prtNext, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicTempoTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicTempoTrack_IDirectMusicTrack_SetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicTempoTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 

dlls/dmime/timesigtrack.c

@@ -28,6 +28,7 @@ WINE_DECLARE_DEBUG_CHANNEL(dmfile);
 /* IDirectMusicTimeSigTrack IUnknown part: */
 HRESULT WINAPI IDirectMusicTimeSigTrack_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS_MULTI(IDirectMusicTimeSigTrack, UnknownVtbl, iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 
 	if (IsEqualIID (riid, &IID_IUnknown)) {
 		*ppobj = (LPUNKNOWN)&This->UnknownVtbl;
@@ -44,20 +45,20 @@ HRESULT WINAPI IDirectMusicTimeSigTrack_IUnknown_QueryInterface (LPUNKNOWN iface
 		return S_OK;
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicTimeSigTrack_IUnknown_AddRef (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicTimeSigTrack, UnknownVtbl, iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicTimeSigTrack_IUnknown_Release (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicTimeSigTrack, UnknownVtbl, iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}
@@ -117,20 +118,20 @@ HRESULT WINAPI IDirectMusicTimeSigTrack_IDirectMusicTrack_Play (LPDIRECTMUSICTRA
 
 HRESULT WINAPI IDirectMusicTimeSigTrack_IDirectMusicTrack_GetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, MUSIC_TIME* pmtNext, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicTimeSigTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pmtNext, pParam);
+	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pmtNext, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicTimeSigTrack_IDirectMusicTrack_SetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicTimeSigTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pParam);
+	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicTimeSigTrack_IDirectMusicTrack_IsParamSupported (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType) {
 	ICOM_THIS_MULTI(IDirectMusicTimeSigTrack, TrackVtbl, iface);
 
-	TRACE("(%p, %s): ", This, debugstr_guid(rguidType));
+	TRACE("(%p, %s): ", This, debugstr_dmguid(rguidType));
 	if (IsEqualGUID (rguidType, &GUID_DisableTimeSig)
 		|| IsEqualGUID (rguidType, &GUID_EnableTimeSig)
 		|| IsEqualGUID (rguidType, &GUID_TimeSignature)) {
@@ -143,13 +144,13 @@ HRESULT WINAPI IDirectMusicTimeSigTrack_IDirectMusicTrack_IsParamSupported (LPDI
 
 HRESULT WINAPI IDirectMusicTimeSigTrack_IDirectMusicTrack_AddNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicTimeSigTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicTimeSigTrack_IDirectMusicTrack_RemoveNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicTimeSigTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
@@ -167,13 +168,13 @@ HRESULT WINAPI IDirectMusicTimeSigTrack_IDirectMusicTrack_PlayEx (LPDIRECTMUSICT
 
 HRESULT WINAPI IDirectMusicTimeSigTrack_IDirectMusicTrack_GetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, REFERENCE_TIME* prtNext, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicTimeSigTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicTimeSigTrack_IDirectMusicTrack_SetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicTimeSigTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 

dlls/dmime/tool.c

@@ -24,6 +24,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(dmime);
 /* IDirectMusicTool8Impl IUnknown part: */
 HRESULT WINAPI IDirectMusicTool8Impl_QueryInterface (LPDIRECTMUSICTOOL8 iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IDirectMusicTool8Impl,iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 	if (IsEqualIID (riid, &IID_IUnknown) || 
 	    IsEqualIID (riid, &IID_IDirectMusicTool) ||
 	    IsEqualIID (riid, &IID_IDirectMusicTool8)) {
@@ -31,7 +32,7 @@ HRESULT WINAPI IDirectMusicTool8Impl_QueryInterface (LPDIRECTMUSICTOOL8 iface, R
 		*ppobj = This;
 		return S_OK;
 	}
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 

dlls/dmime/wavetrack.c

@@ -28,6 +28,7 @@ WINE_DECLARE_DEBUG_CHANNEL(dmfile);
 /* IDirectMusicWaveTrack IUnknown part: */
 HRESULT WINAPI IDirectMusicWaveTrack_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS_MULTI(IDirectMusicWaveTrack, UnknownVtbl, iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 
 	if (IsEqualIID (riid, &IID_IUnknown)) {
 		*ppobj = (LPUNKNOWN)&This->UnknownVtbl;
@@ -44,7 +45,7 @@ HRESULT WINAPI IDirectMusicWaveTrack_IUnknown_QueryInterface (LPUNKNOWN iface, R
 		return S_OK;
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -117,20 +118,20 @@ HRESULT WINAPI IDirectMusicWaveTrack_IDirectMusicTrack_Play (LPDIRECTMUSICTRACK8
 
 HRESULT WINAPI IDirectMusicWaveTrack_IDirectMusicTrack_GetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, MUSIC_TIME* pmtNext, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicWaveTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pmtNext, pParam);
+	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pmtNext, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicWaveTrack_IDirectMusicTrack_SetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicWaveTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pParam);
+	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicWaveTrack_IDirectMusicTrack_IsParamSupported (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType) {
 	ICOM_THIS_MULTI(IDirectMusicWaveTrack, TrackVtbl, iface);
 
-	TRACE("(%p, %s): ", This, debugstr_guid(rguidType));
+	TRACE("(%p, %s): ", This, debugstr_dmguid(rguidType));
 	if (IsEqualGUID (rguidType, &GUID_Disable_Auto_Download)
 		|| IsEqualGUID (rguidType, &GUID_Download)
 		|| IsEqualGUID (rguidType, &GUID_DownloadToAudioPath)
@@ -144,13 +145,13 @@ HRESULT WINAPI IDirectMusicWaveTrack_IDirectMusicTrack_IsParamSupported (LPDIREC
 
 HRESULT WINAPI IDirectMusicWaveTrack_IDirectMusicTrack_AddNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicWaveTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicWaveTrack_IDirectMusicTrack_RemoveNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicWaveTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
@@ -168,13 +169,13 @@ HRESULT WINAPI IDirectMusicWaveTrack_IDirectMusicTrack_PlayEx (LPDIRECTMUSICTRAC
 
 HRESULT WINAPI IDirectMusicWaveTrack_IDirectMusicTrack_GetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, REFERENCE_TIME* prtNext, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicWaveTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicWaveTrack_IDirectMusicTrack_SetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicWaveTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 

dlls/dmloader/container.c

@@ -29,7 +29,7 @@ WINE_DECLARE_DEBUG_CHANNEL(dmfile);
 HRESULT WINAPI IDirectMusicContainerImpl_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS_MULTI(IDirectMusicContainerImpl, UnknownVtbl, iface);
 	
-	TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppobj);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 	if (IsEqualIID (riid, &IID_IUnknown)) {
 		*ppobj = (LPVOID)&This->UnknownVtbl;
 		IDirectMusicContainerImpl_IUnknown_AddRef ((LPUNKNOWN)&This->UnknownVtbl);
@@ -48,20 +48,20 @@ HRESULT WINAPI IDirectMusicContainerImpl_IUnknown_QueryInterface (LPUNKNOWN ifac
 		return S_OK;
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicContainerImpl_IUnknown_AddRef (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicContainerImpl, UnknownVtbl, iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicContainerImpl_IUnknown_Release (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicContainerImpl, UnknownVtbl, iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}
@@ -97,7 +97,7 @@ HRESULT WINAPI IDirectMusicContainerImpl_IDirectMusicContainer_EnumObject (LPDIR
 	struct list *listEntry;
 	LPDMUS_PRIVATE_CONTAINED_OBJECT_ENTRY objectEntry;
 
-	TRACE("(%p, %s, %ld, %p, %p)\n", This, debugstr_guid(rguidClass), dwIndex, pDesc, pwszAlias);
+	TRACE("(%p, %s, %ld, %p, %p)\n", This, debugstr_dmguid(rguidClass), dwIndex, pDesc, pwszAlias);
 	LIST_FOR_EACH (listEntry, &This->ObjectsList) {
 		objectEntry = LIST_ENTRY(listEntry, DMUS_PRIVATE_CONTAINED_OBJECT_ENTRY, entry);	
 		if (IsEqualGUID(rguidClass, &GUID_DirectMusicAllTypes)) i++;
@@ -153,10 +153,7 @@ HRESULT WINAPI IDirectMusicContainerImpl_IDirectMusicObject_GetDescriptor (LPDIR
 
 HRESULT WINAPI IDirectMusicContainerImpl_IDirectMusicObject_SetDescriptor (LPDIRECTMUSICOBJECT iface, LPDMUS_OBJECTDESC pDesc) {
 	ICOM_THIS_MULTI(IDirectMusicContainerImpl, ObjectVtbl, iface);
-	TRACE("(%p, %p): setting descriptor:\n", This, pDesc);
-	if (TRACE_ON(dmloader)) {
-		DMUSIC_dump_DMUS_OBJECTDESC (pDesc);
-	}
+	TRACE("(%p, %p): setting descriptor:\n%s\n", This, pDesc, debugstr_DMUS_OBJECTDESC (pDesc));
 	
 	/* According to MSDN, we should copy only given values, not whole struct */	
 	if (pDesc->dwValidData & DMUS_OBJ_OBJECT)
@@ -332,10 +329,7 @@ HRESULT WINAPI IDirectMusicContainerImpl_IDirectMusicObject_ParseDescriptor (LPD
 		}
 	}	
 	
-	TRACE(": returning descriptor:\n");
-	if (TRACE_ON(dmloader)) {
-		DMUSIC_dump_DMUS_OBJECTDESC (pDesc);
-	}
+	TRACE(": returning descriptor:\n%s\n", debugstr_DMUS_OBJECTDESC (pDesc));
 	
 	return S_OK;	
 }
@@ -749,11 +743,9 @@ HRESULT WINAPI IDirectMusicContainerImpl_IPersistStream_Load (LPPERSISTSTREAM if
 		struct list *listEntry;
 
 		TRACE("*** IDirectMusicContainer (%p) ***\n", This->ContainerVtbl);
-		TRACE(" - Object descriptor:\n");
-		DMUSIC_dump_DMUS_OBJECTDESC (This->pDesc);
+		TRACE(" - Object descriptor:\n%s\n", debugstr_DMUS_OBJECTDESC (This->pDesc));
 		TRACE(" - Header:\n");
-		TRACE("    - dwFlags: ");
-		DMUSIC_dump_DMUS_CONTAINER_FLAGS (This->pHeader->dwFlags);
+		TRACE("    - dwFlags: %s", debugstr_DMUS_CONTAINER_FLAGS (This->pHeader->dwFlags));
 
 		TRACE(" - Objects:\n");
 		
@@ -761,8 +753,7 @@ HRESULT WINAPI IDirectMusicContainerImpl_IPersistStream_Load (LPPERSISTSTREAM if
 			tmpEntry = LIST_ENTRY( listEntry, DMUS_PRIVATE_CONTAINED_OBJECT_ENTRY, entry );
 			TRACE("    - Object[%i]:\n", r);
 			TRACE("       - wszAlias: %s\n", debugstr_w(tmpEntry->wszAlias));
-			TRACE("       - Object descriptor:\n");
-			DMUSIC_dump_DMUS_OBJECTDESC(tmpEntry->pDesc);
+			TRACE("       - Object descriptor:\n%s\n", debugstr_DMUS_OBJECTDESC(tmpEntry->pDesc));
 			r++;
 		}
 	}

dlls/dmloader/dmloader_main.c

@@ -32,7 +32,7 @@ typedef struct {
  */
 static HRESULT WINAPI LoaderCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -49,13 +49,13 @@ static ULONG WINAPI LoaderCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI LoaderCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicLoaderImpl (riid, (LPVOID*) ppobj, pOuter);
 }
 
 static HRESULT WINAPI LoaderCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -75,7 +75,7 @@ static IClassFactoryImpl Loader_CF = {&LoaderCF_Vtbl, 1 };
  */
 static HRESULT WINAPI ContainerCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -92,13 +92,13 @@ static ULONG WINAPI ContainerCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI ContainerCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicContainerImpl (riid, (LPVOID*) ppobj, pOuter);
 }
 
 static HRESULT WINAPI ContainerCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub!\n", This, dolock);
 	return S_OK;
 }
 
@@ -147,7 +147,7 @@ HRESULT WINAPI DMLOADER_DllCanUnloadNow(void) {
  *
  */
 HRESULT WINAPI DMLOADER_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv) {
-    TRACE("(%p,%p,%p)\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
+    TRACE("(%s, %s, %p)\n", debugstr_dmguid(rclsid), debugstr_dmguid(riid), ppv);
     if (IsEqualCLSID (rclsid, &CLSID_DirectMusicLoader) && IsEqualIID (riid, &IID_IClassFactory)) {
 		*ppv = (LPVOID) &Loader_CF;
 		IClassFactory_AddRef((IClassFactory*)*ppv);
@@ -158,6 +158,437 @@ HRESULT WINAPI DMLOADER_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *
 		return S_OK;
 	}
 	
-    WARN("(%p,%p,%p): no interface found.\n", debugstr_guid(rclsid), debugstr_guid(riid), 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 ;) */
+}
+
+/* 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\'",
+		(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) {
+		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)");
+	}
+}
+
+/* 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;
+}

dlls/dmloader/dmloader_private.h

@@ -20,7 +20,9 @@
 #ifndef __WINE_DMLOADER_PRIVATE_H
 #define __WINE_DMLOADER_PRIVATE_H
 
+#include <stdio.h>
 #include <stdarg.h>
+#include <string.h>
 
 #include "windef.h"
 #include "winbase.h"
@@ -225,40 +227,16 @@ typedef struct _DMUS_PRIVATE_CHUNK {
 	DWORD dwSize; /* size of the chunk */
 } DMUS_PRIVATE_CHUNK, *LPDMUS_PRIVATE_CHUNK;
 
-/* check whether the given DWORD is even (return 0) or odd (return 1) */
-static inline int even_or_odd (DWORD number) {
-	return (number & 0x1); /* basically, check if bit 0 is set ;) */
-}
+/* used for generic dumping (copied from ddraw) */
+typedef struct {
+    DWORD val;
+    const char* name;
+} flag_info;
 
-/* translate STREAM_SEEK flag to string */
-static inline 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 */
-static inline 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 */
-static inline 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));
-}
+typedef struct {
+    const GUID *guid;
+    const char* name;
+} guid_info;
 
 /* used for initialising structs (primarily for DMUS_OBJECTDESC) */
 #define DM_STRUCT_INIT(x) 				\
@@ -267,81 +245,27 @@ static inline const char *debugstr_dmversion (LPDMUS_VERSION version) {
 		(x)->dwSize = sizeof(*x);		\
 	} while (0)
 
+#define FE(x) { x, #x }	
+#define GE(x) { &x, #x }
 
-/* used for generic dumping (copied from ddraw) */
-typedef struct {
-    DWORD val;
-    const char* name;
-} flag_info;
-
-#define FE(x) { x, #x }
-#define DMUSIC_dump_flags(flags,names,num_names) DMUSIC_dump_flags_(flags, names, num_names, 1)
-
-/* generic dump function */
-static inline void DMUSIC_dump_flags_ (DWORD flags, const flag_info* names, size_t num_names, int newline) {
-	unsigned int i;
-	
-	for (i=0; i < num_names; i++) {
-		if ((flags & names[i].val) ||      /* standard flag value */
-		((!flags) && (!names[i].val))) /* zero value only */
-	    	DPRINTF("%s ", names[i].name);
-	}
-	
-    if (newline) DPRINTF("\n");
-}
-
-static inline void DMUSIC_dump_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)
-	};
-    DMUSIC_dump_flags(flagmask, flags, sizeof(flags)/sizeof(flags[0]));
-}
-
-static inline void DMUSIC_dump_DMUS_CONTAINER_FLAGS (DWORD flagmask) {
-    static const flag_info flags[] = {
-	    FE(DMUS_CONTAINER_NOLOADS)
-	};
-    DMUSIC_dump_flags(flagmask, flags, sizeof(flags)/sizeof(flags[0]));
-}
-
-static inline void DMUSIC_dump_DMUS_OBJECTDESC (LPDMUS_OBJECTDESC pDesc) {
-	if (pDesc) {
-		DPRINTF("DMUS_OBJECTDESC (%p)\n", pDesc);
-		DPRINTF("  - dwSize = %ld\n", pDesc->dwSize);
-		DPRINTF("  - dwValidData = ");
-		DMUSIC_dump_DMUS_OBJ_FLAGS (pDesc->dwValidData);
-		if (pDesc->dwValidData & DMUS_OBJ_CLASS) DPRINTF("  - guidClass = %s\n", debugstr_guid(&pDesc->guidClass));
-		if (pDesc->dwValidData & DMUS_OBJ_OBJECT) DPRINTF("  - guidObject = %s\n", debugstr_guid(&pDesc->guidObject));
-		if (pDesc->dwValidData & DMUS_OBJ_DATE) DPRINTF("  - ftDate = FIXME\n");
-		if (pDesc->dwValidData & DMUS_OBJ_VERSION) DPRINTF("  - vVersion = %s\n", debugstr_dmversion(&pDesc->vVersion));
-		if (pDesc->dwValidData & DMUS_OBJ_NAME) DPRINTF("  - wszName = %s\n", debugstr_w(pDesc->wszName));
-		if (pDesc->dwValidData & DMUS_OBJ_CATEGORY) DPRINTF("  - wszCategory = %s\n", debugstr_w(pDesc->wszCategory));
-		if (pDesc->dwValidData & DMUS_OBJ_FILENAME) DPRINTF("  - wszFileName = %s\n", debugstr_w(pDesc->wszFileName));
-		if (pDesc->dwValidData & DMUS_OBJ_MEMORY) DPRINTF("  - llMemLength = %lli\n  - pbMemData = %p\n", pDesc->llMemLength, pDesc->pbMemData);
-		if (pDesc->dwValidData & DMUS_OBJ_STREAM) DPRINTF("  - pStream = %p\n", pDesc->pStream);		
-	} else {
-		DPRINTF("(NULL)\n");
-	}
-}
-
+/* check whether the given DWORD is even (return 0) or odd (return 1) */
+extern int even_or_odd (DWORD number);
+/* 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);
+/* 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);
 /* check whether chunkID is valid dmobject form chunk */
-static inline BOOL IS_VALID_DMFORM(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;
-}
+extern BOOL IS_VALID_DMFORM (FOURCC chunkID);
 
 #endif	/* __WINE_DMLOADER_PRIVATE_H */

dlls/dmloader/loader.c

@@ -27,6 +27,7 @@ HRESULT WINAPI DMUSIC_GetDefaultGMPath (WCHAR wszPath[MAX_PATH]);
 HRESULT WINAPI IDirectMusicLoader8Impl_QueryInterface (LPDIRECTMUSICLOADER8 iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IDirectMusicLoader8Impl,iface);
 
+	TRACE("(%p, %s, %p)\n",This, debugstr_dmguid(riid), ppobj);
 	if (IsEqualIID (riid, &IID_IUnknown) || 
 	    IsEqualIID (riid, &IID_IDirectMusicLoader) ||
 	    IsEqualIID (riid, &IID_IDirectMusicLoader8)) {
@@ -35,20 +36,20 @@ HRESULT WINAPI IDirectMusicLoader8Impl_QueryInterface (LPDIRECTMUSICLOADER8 ifac
 		return S_OK;
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicLoader8Impl_AddRef (LPDIRECTMUSICLOADER8 iface) {
 	ICOM_THIS(IDirectMusicLoader8Impl,iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicLoader8Impl_Release (LPDIRECTMUSICLOADER8 iface) {
 	ICOM_THIS(IDirectMusicLoader8Impl,iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}
@@ -66,9 +67,7 @@ HRESULT WINAPI IDirectMusicLoader8Impl_GetObject (LPDIRECTMUSICLOADER8 iface, LP
 	IDirectMusicObject* pObject;
 	LPDMUS_PRIVATE_CACHE_ENTRY newEntry;
 
-	TRACE("(%p, %p, %s, %p): pDesc:\n", This, pDesc, debugstr_guid(riid), ppv);
-	if (TRACE_ON(dmloader))
-		DMUSIC_dump_DMUS_OBJECTDESC(pDesc);
+	TRACE("(%p, %p, %s, %p): pDesc:\n%s\n", This, pDesc, debugstr_dmguid(riid), ppv, debugstr_DMUS_OBJECTDESC(pDesc));
 	
 	/* if I understand correctly, SetObject makes sort of aliases for entries in cache;
 		therefore I created alias list, which is similiar to cache list, and is used as resolver
@@ -79,7 +78,7 @@ HRESULT WINAPI IDirectMusicLoader8Impl_GetObject (LPDIRECTMUSICLOADER8 iface, LP
 		/* for the time being, we support only GUID/name mapping */
 		if ((aliasEntry->pDesc->dwValidData & DMUS_OBJ_OBJECT) && (pDesc->dwValidData & DMUS_OBJ_OBJECT)
 			&& IsEqualGUID (&aliasEntry->pDesc->guidObject, &pDesc->guidObject)) {
-			TRACE(": found alias by GUID (%s)... mapping:\n", debugstr_guid(&aliasEntry->pDesc->guidObject));
+			TRACE(": found alias by GUID (%s)... mapping:\n", debugstr_dmguid(&aliasEntry->pDesc->guidObject));
 			if ((aliasEntry->pDesc->dwValidData & DMUS_OBJ_FILENAME) && !(pDesc->dwValidData & DMUS_OBJ_FILENAME)) {
 				TRACE(":     - to filename (%s)\n", debugstr_w(aliasEntry->pDesc->wszFileName));
 				pDesc->dwValidData |= DMUS_OBJ_FILENAME;
@@ -114,7 +113,7 @@ HRESULT WINAPI IDirectMusicLoader8Impl_GetObject (LPDIRECTMUSICLOADER8 iface, LP
 				strncpyW (pDesc->wszFileName, aliasEntry->pDesc->wszFileName, DMUS_MAX_FILENAME);
 			}
 			if ((aliasEntry->pDesc->dwValidData & DMUS_OBJ_OBJECT) && !(pDesc->dwValidData & DMUS_OBJ_OBJECT)) {
-				TRACE(":     - to object GUID (%s)\n", debugstr_guid(&aliasEntry->pDesc->guidObject));
+				TRACE(":     - to object GUID (%s)\n", debugstr_dmguid(&aliasEntry->pDesc->guidObject));
 				pDesc->dwValidData |= DMUS_OBJ_OBJECT;
 				memcpy (&pDesc->guidObject, &aliasEntry->pDesc->guidObject, sizeof(GUID));
 			}
@@ -476,9 +475,9 @@ HRESULT WINAPI IDirectMusicLoader8Impl_GetObject (LPDIRECTMUSICLOADER8 iface, LP
 		if (cacheEntry->bIsFaultyDLS == FALSE) {
 			DM_STRUCT_INIT(&CacheDesc); /* prepare desc for reuse */
 			IDirectMusicObject_GetDescriptor (cacheEntry->pObject, &CacheDesc);
-			DMUSIC_dump_DMUS_OBJECTDESC(&CacheDesc);
+			TRACE(": %s\n", debugstr_DMUS_OBJECTDESC(&CacheDesc));
 		} else {
-			DPRINTF("faulty DLS collection\n");
+			TRACE(": faulty DLS collection\n");
 		}
 	}
 #endif
@@ -491,9 +490,7 @@ HRESULT WINAPI IDirectMusicLoader8Impl_SetObject (LPDIRECTMUSICLOADER8 iface, LP
 	DMUS_PRIVATE_ALIAS_ENTRY *newEntry;
 	DMUS_OBJECTDESC Desc;
 	
-	TRACE("(%p, %p): pDesc:\n", This, pDesc);
-	if (TRACE_ON(dmloader))
-		DMUSIC_dump_DMUS_OBJECTDESC(pDesc);
+	TRACE("(%p, %p): pDesc:\n%s\n", This, pDesc, debugstr_DMUS_OBJECTDESC(pDesc));
 	
 	/* create stream and load additional info from it */
 	if (pDesc->dwValidData & DMUS_OBJ_FILENAME) {
@@ -562,9 +559,7 @@ HRESULT WINAPI IDirectMusicLoader8Impl_SetObject (LPDIRECTMUSICLOADER8 iface, LP
 	pDesc->dwValidData |= Desc.dwValidData; /* add new flags */
 	
 	/* add new entry */
-	TRACE(": adding alias entry with following info:\n");
-	if (TRACE_ON(dmloader))
-		DMUSIC_dump_DMUS_OBJECTDESC(pDesc);
+	TRACE(": adding alias entry with following info: \n%s\n", debugstr_DMUS_OBJECTDESC(pDesc));
 	newEntry = HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, sizeof(DMUS_PRIVATE_ALIAS_ENTRY));
 	newEntry->pDesc = HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, sizeof(DMUS_OBJECTDESC));
 	memcpy (newEntry->pDesc, pDesc, sizeof(DMUS_OBJECTDESC));
@@ -575,7 +570,7 @@ HRESULT WINAPI IDirectMusicLoader8Impl_SetObject (LPDIRECTMUSICLOADER8 iface, LP
 
 HRESULT WINAPI IDirectMusicLoader8Impl_SetSearchDirectory (LPDIRECTMUSICLOADER8 iface, REFGUID rguidClass, WCHAR* pwzPath, BOOL fClear) {
 	ICOM_THIS(IDirectMusicLoader8Impl,iface);
-	TRACE("(%p, %s, %s, %d)\n", This, debugstr_guid(rguidClass), debugstr_w(pwzPath), fClear);
+	TRACE("(%p, %s, %s, %d)\n", This, debugstr_dmguid(rguidClass), debugstr_w(pwzPath), fClear);
 	if (0 == strncmpW(This->wzSearchPath, pwzPath, MAX_PATH)) {
 	  return S_FALSE;
 	} 
@@ -585,7 +580,7 @@ HRESULT WINAPI IDirectMusicLoader8Impl_SetSearchDirectory (LPDIRECTMUSICLOADER8
 
 HRESULT WINAPI IDirectMusicLoader8Impl_ScanDirectory (LPDIRECTMUSICLOADER8 iface, REFGUID rguidClass, WCHAR* pwzFileExtension, WCHAR* pwzScanFileName) {
 	ICOM_THIS(IDirectMusicLoader8Impl,iface);
-	FIXME("(%p, %s, %p, %p): stub\n", This, debugstr_guid(rguidClass), pwzFileExtension, pwzScanFileName);
+	FIXME("(%p, %s, %p, %p): stub\n", This, debugstr_dmguid(rguidClass), pwzFileExtension, pwzScanFileName);
 	return S_OK;
 }
 
@@ -603,20 +598,20 @@ HRESULT WINAPI IDirectMusicLoader8Impl_ReleaseObject (LPDIRECTMUSICLOADER8 iface
 
 HRESULT WINAPI IDirectMusicLoader8Impl_ClearCache (LPDIRECTMUSICLOADER8 iface, REFGUID rguidClass) {
 	ICOM_THIS(IDirectMusicLoader8Impl,iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidClass));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidClass));
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicLoader8Impl_EnableCache (LPDIRECTMUSICLOADER8 iface, REFGUID rguidClass, BOOL fEnable) {
 	ICOM_THIS(IDirectMusicLoader8Impl,iface);
-	FIXME("(%p, %s, %d): stub\n", This, debugstr_guid(rguidClass), fEnable);
+	FIXME("(%p, %s, %d): stub\n", This, debugstr_dmguid(rguidClass), fEnable);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicLoader8Impl_EnumObject (LPDIRECTMUSICLOADER8 iface, REFGUID rguidClass, DWORD dwIndex, LPDMUS_OBJECTDESC pDesc) {
 	ICOM_THIS(IDirectMusicLoader8Impl,iface);
-	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_guid(rguidClass), dwIndex, pDesc);
-	return S_OK;
+	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_dmguid(rguidClass), dwIndex, pDesc);
+	return S_FALSE;
 }
 
 /* IDirectMusicLoader8 Interface part follow: */
@@ -639,7 +634,7 @@ HRESULT WINAPI IDirectMusicLoader8Impl_LoadObjectFromFile (LPDIRECTMUSICLOADER8
 	ICOM_THIS(IDirectMusicLoader8Impl,iface);
 	DMUS_OBJECTDESC ObjDesc;
 	
-	TRACE("(%p, %s, %s, %s, %p): wrapping to IDirectMusicLoader8Impl_GetObject\n", This, debugstr_guid(rguidClassID), debugstr_guid(iidInterfaceID), debugstr_w(pwzFilePath), ppObject);
+	TRACE("(%p, %s, %s, %s, %p): wrapping to IDirectMusicLoader8Impl_GetObject\n", This, debugstr_dmguid(rguidClassID), debugstr_dmguid(iidInterfaceID), debugstr_w(pwzFilePath), ppObject);
 	
 	ObjDesc.dwSize = sizeof(DMUS_OBJECTDESC);
 	ObjDesc.dwValidData = DMUS_OBJ_FILENAME | DMUS_OBJ_FULLPATH | DMUS_OBJ_CLASS; /* I believe I've read somewhere in MSDN that this function requires either full path or relative path */

dlls/dmloader/loaderstream.c

@@ -59,7 +59,7 @@ void WINAPI ILoaderStream_Detach (LPSTREAM iface) {
 HRESULT WINAPI ILoaderStream_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, void** ppobj) {
 	ICOM_THIS_MULTI(ILoaderStream, UnknownVtbl, iface);
 	
-	TRACE("(%p, %s, %p)\n", This, debugstr_guid(riid), ppobj);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 	if (IsEqualIID (riid, &IID_IUnknown)) {
 		*ppobj = (LPVOID)&This->UnknownVtbl;
 		ILoaderStream_IUnknown_AddRef ((LPUNKNOWN)&This->UnknownVtbl);
@@ -74,20 +74,20 @@ HRESULT WINAPI ILoaderStream_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID ri
 		return S_OK;
 	}
 
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s,%p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI ILoaderStream_IUnknown_AddRef (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(ILoaderStream, UnknownVtbl, iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI ILoaderStream_IUnknown_Release (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(ILoaderStream, UnknownVtbl, iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}

dlls/dmscript/dmscript_main.c

@@ -32,7 +32,7 @@ typedef struct {
  */
 static HRESULT WINAPI ScriptAutoImplSegmentCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -49,15 +49,15 @@ static ULONG WINAPI ScriptAutoImplSegmentCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI ScriptAutoImplSegmentCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	/* nothing here yet */	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 static HRESULT WINAPI ScriptAutoImplSegmentCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -77,7 +77,7 @@ static IClassFactoryImpl ScriptAutoImplSegment_CF = {&ScriptAutoImplSegmentCF_Vt
  */
 static HRESULT WINAPI ScriptTrackCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -94,13 +94,13 @@ static ULONG WINAPI ScriptTrackCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI ScriptTrackCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicScriptTrack (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI ScriptTrackCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -120,7 +120,7 @@ static IClassFactoryImpl ScriptTrack_CF = {&ScriptTrackCF_Vtbl, 1 };
  */
 static HRESULT WINAPI AudioVBScriptCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -137,15 +137,15 @@ static ULONG WINAPI AudioVBScriptCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI AudioVBScriptCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	/* nothing here yet */
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 static HRESULT WINAPI AudioVBScriptCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -165,7 +165,7 @@ static IClassFactoryImpl AudioVBScript_CF = {&AudioVBScriptCF_Vtbl, 1 };
  */
 static HRESULT WINAPI ScriptCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -182,13 +182,13 @@ static ULONG WINAPI ScriptCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI ScriptCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicScriptImpl (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI ScriptCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -208,7 +208,7 @@ static IClassFactoryImpl Script_CF = {&ScriptCF_Vtbl, 1 };
  */
 static HRESULT WINAPI ScriptAutoImplPerformanceCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -225,15 +225,15 @@ static ULONG WINAPI ScriptAutoImplPerformanceCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI ScriptAutoImplPerformanceCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	/* nothing here yet */
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 static HRESULT WINAPI ScriptAutoImplPerformanceCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -253,7 +253,7 @@ static IClassFactoryImpl ScriptAutoImplPerformance_CF = {&ScriptAutoImplPerforma
  */
 static HRESULT WINAPI ScriptSourceCodeLoaderCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -270,15 +270,15 @@ static ULONG WINAPI ScriptSourceCodeLoaderCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI ScriptSourceCodeLoaderCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	/* nothing here yet */
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 static HRESULT WINAPI ScriptSourceCodeLoaderCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -298,7 +298,7 @@ static IClassFactoryImpl ScriptSourceCodeLoader_CF = {&ScriptSourceCodeLoaderCF_
  */
 static HRESULT WINAPI ScriptAutoImplSegmentStateCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -315,15 +315,15 @@ static ULONG WINAPI ScriptAutoImplSegmentStateCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI ScriptAutoImplSegmentStateCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	/* nothing here yet */
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 static HRESULT WINAPI ScriptAutoImplSegmentStateCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -343,7 +343,7 @@ static IClassFactoryImpl ScriptAutoImplSegmentState_CF = {&ScriptAutoImplSegment
  */
 static HRESULT WINAPI ScriptAutoImplAudioPathConfigCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -360,15 +360,15 @@ static ULONG WINAPI ScriptAutoImplAudioPathConfigCF_Release(LPCLASSFACTORY iface
 
 static HRESULT WINAPI ScriptAutoImplAudioPathConfigCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	/* nothing here yet */
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 static HRESULT WINAPI ScriptAutoImplAudioPathConfigCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -388,7 +388,7 @@ static IClassFactoryImpl ScriptAutoImplAudioPathConfig_CF = {&ScriptAutoImplAudi
  */
 static HRESULT WINAPI ScriptAutoImplAudioPathCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -405,15 +405,15 @@ static ULONG WINAPI ScriptAutoImplAudioPathCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI ScriptAutoImplAudioPathCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	/* nothing here yet */
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 static HRESULT WINAPI ScriptAutoImplAudioPathCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -433,7 +433,7 @@ static IClassFactoryImpl ScriptAutoImplAudioPath_CF = {&ScriptAutoImplAudioPathC
  */
 static HRESULT WINAPI ScriptAutoImplSongCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -450,15 +450,15 @@ static ULONG WINAPI ScriptAutoImplSongCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI ScriptAutoImplSongCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	/* nothing here yet */
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 static HRESULT WINAPI ScriptAutoImplSongCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -507,7 +507,7 @@ HRESULT WINAPI DMSCRIPT_DllCanUnloadNow(void) {
  *
  */
 HRESULT WINAPI DMSCRIPT_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv) {
-    TRACE("(%p,%p,%p)\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
+    TRACE("(%s, %s, %p)\n", debugstr_dmguid(rclsid), debugstr_dmguid(riid), ppv);
     if (IsEqualCLSID (rclsid, &CLSID_DirectMusicScriptAutoImpSegment) && IsEqualIID (riid, &IID_IClassFactory)) {
       *ppv = (LPVOID) &ScriptAutoImplSegment_CF;
       IClassFactory_AddRef((IClassFactory*)*ppv);
@@ -528,7 +528,7 @@ HRESULT WINAPI DMSCRIPT_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *
       *ppv = (LPVOID) &ScriptAutoImplPerformance_CF;
       IClassFactory_AddRef((IClassFactory*)*ppv);
       return S_OK;
-	} else if (IsEqualCLSID (rclsid, &CLSID_DirectMusicScripSourceCodeLoader) && IsEqualIID (riid, &IID_IClassFactory)) {
+	} else if (IsEqualCLSID (rclsid, &CLSID_DirectMusicScriptSourceCodeLoader) && IsEqualIID (riid, &IID_IClassFactory)) {
       *ppv = (LPVOID) &ScriptSourceCodeLoader_CF;
       IClassFactory_AddRef((IClassFactory*)*ppv);
       return S_OK;
@@ -550,6 +550,415 @@ HRESULT WINAPI DMSCRIPT_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *
       return S_OK;
 	}		
 
-    WARN("(%p,%p,%p): no interface found.\n", debugstr_guid(rclsid), debugstr_guid(riid), 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) {
+		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)");
+	}
+}

dlls/dmscript/dmscript_private.h

@@ -20,7 +20,9 @@
 #ifndef __WINE_DMSCRIPT_PRIVATE_H
 #define __WINE_DMSCRIPT_PRIVATE_H
 
+#include <stdio.h>
 #include <stdarg.h>
+#include <string.h>
 
 #include "windef.h"
 #include "winbase.h"
@@ -170,26 +172,16 @@ typedef struct _DMUS_PRIVATE_CHUNK {
 	DWORD dwSize; /* size of the chunk */
 } DMUS_PRIVATE_CHUNK, *LPDMUS_PRIVATE_CHUNK;
 
-/* check whether the given DWORD is even (return 0) or odd (return 1) */
-static inline int even_or_odd (DWORD number) {
-	return (number & 0x1); /* basically, check if bit 0 is set ;) */
-}
+/* used for generic dumping (copied from ddraw) */
+typedef struct {
+    DWORD val;
+    const char* name;
+} flag_info;
 
-/* FOURCC to string conversion for debug messages */
-static inline 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 */
-static inline 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));
-}
+typedef struct {
+    const GUID *guid;
+    const char* name;
+} guid_info;
 
 /* used for initialising structs (primarily for DMUS_OBJECTDESC) */
 #define DM_STRUCT_INIT(x) 				\
@@ -198,65 +190,23 @@ static inline const char *debugstr_dmversion (LPDMUS_VERSION version) {
 		(x)->dwSize = sizeof(*x);		\
 	} while (0)
 
+#define FE(x) { x, #x }	
+#define GE(x) { &x, #x }
 
-/* used for generic dumping (copied from ddraw) */
-typedef struct {
-    DWORD val;
-    const char* name;
-} flag_info;
-
-#define FE(x) { x, #x }
-#define DMUSIC_dump_flags(flags,names,num_names) DMUSIC_dump_flags_(flags, names, num_names, 1)
-
-/* generic dump function */
-static inline void DMUSIC_dump_flags_ (DWORD flags, const flag_info* names, size_t num_names, int newline) {
-	unsigned int i;
-	
-	for (i=0; i < num_names; i++) {
-		if ((flags & names[i].val) ||      /* standard flag value */
-		((!flags) && (!names[i].val))) /* zero value only */
-	    	DPRINTF("%s ", names[i].name);
-	}
-	
-    if (newline) DPRINTF("\n");
-}
-
-static inline void DMUSIC_dump_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)
-	};
-    DMUSIC_dump_flags(flagmask, flags, sizeof(flags)/sizeof(flags[0]));
-}
-
-static inline void DMUSIC_dump_DMUS_OBJECTDESC (LPDMUS_OBJECTDESC pDesc) {
-	if (pDesc) {
-		DPRINTF("DMUS_OBJECTDESC (%p)\n", pDesc);
-		DPRINTF("  - dwSize = %ld\n", pDesc->dwSize);
-		DPRINTF("  - dwValidData = ");
-		DMUSIC_dump_DMUS_OBJ_FLAGS (pDesc->dwValidData);
-		if (pDesc->dwValidData & DMUS_OBJ_CLASS) DPRINTF("  - guidClass = %s\n", debugstr_guid(&pDesc->guidClass));
-		if (pDesc->dwValidData & DMUS_OBJ_OBJECT) DPRINTF("  - guidObject = %s\n", debugstr_guid(&pDesc->guidObject));
-		if (pDesc->dwValidData & DMUS_OBJ_DATE) DPRINTF("  - ftDate = FIXME\n");
-		if (pDesc->dwValidData & DMUS_OBJ_VERSION) DPRINTF("  - vVersion = %s\n", debugstr_dmversion(&pDesc->vVersion));
-		if (pDesc->dwValidData & DMUS_OBJ_NAME) DPRINTF("  - wszName = %s\n", debugstr_w(pDesc->wszName));
-		if (pDesc->dwValidData & DMUS_OBJ_CATEGORY) DPRINTF("  - wszCategory = %s\n", debugstr_w(pDesc->wszCategory));
-		if (pDesc->dwValidData & DMUS_OBJ_FILENAME) DPRINTF("  - wszFileName = %s\n", debugstr_w(pDesc->wszFileName));
-		if (pDesc->dwValidData & DMUS_OBJ_MEMORY) DPRINTF("  - llMemLength = %lli\n  - pbMemData = %p\n", pDesc->llMemLength, pDesc->pbMemData);
-		if (pDesc->dwValidData & DMUS_OBJ_STREAM) DPRINTF("  - pStream = %p\n", pDesc->pStream);		
-	} else {
-		DPRINTF("(NULL)\n");
-	}
-}
+/* 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);
 
 #endif	/* __WINE_DMSCRIPT_PRIVATE_H */

dlls/dmscript/regsvr.c

@@ -518,7 +518,7 @@ static struct regsvr_coclass const coclass_list[] = {
 	"Microsoft.DirectMusicScriptAutoImpPerformance.1",
 	"Microsoft.DirectMusicScriptAutoImpPerformance"
     },
-    {   &CLSID_DirectMusicScripSourceCodeLoader,
+    {   &CLSID_DirectMusicScriptSourceCodeLoader,
         "DirectMusic Script Source Code Loader",
 	NULL,
 	"dmscript.dll",

dlls/dmscript/script.c

@@ -28,6 +28,7 @@ WINE_DECLARE_DEBUG_CHANNEL(dmfile);
 /* IDirectMusicScriptImpl IUnknown part: */
 HRESULT WINAPI IDirectMusicScriptImpl_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS_MULTI(IDirectMusicScriptImpl, UnknownVtbl, iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 	
 	if (IsEqualIID (riid, &IID_IUnknown)) {
 		*ppobj = (LPVOID)&This->UnknownVtbl;
@@ -47,20 +48,20 @@ HRESULT WINAPI IDirectMusicScriptImpl_IUnknown_QueryInterface (LPUNKNOWN iface,
 		return S_OK;
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicScriptImpl_IUnknown_AddRef (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicScriptImpl, UnknownVtbl, iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicScriptImpl_IUnknown_Release (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicScriptImpl, UnknownVtbl, iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}
@@ -134,7 +135,7 @@ HRESULT WINAPI IDirectMusicScriptImpl_IDirectMusicScript_SetVariableObject (LPDI
 
 HRESULT WINAPI IDirectMusicScriptImpl_IDirectMusicScript_GetVariableObject (LPDIRECTMUSICSCRIPT iface, WCHAR* pwszVariableName, REFIID riid, LPVOID* ppv, DMUS_SCRIPT_ERRORINFO* pErrorInfo) {
 	ICOM_THIS_MULTI(IDirectMusicScriptImpl, ScriptVtbl, iface);
-	FIXME("(%p, %p, %s, %p, %p): stub\n", This, pwszVariableName, debugstr_guid(riid), ppv, pErrorInfo);
+	FIXME("(%p, %p, %s, %p, %p): stub\n", This, pwszVariableName, debugstr_dmguid(riid), ppv, pErrorInfo);
 	return S_OK;
 }
 
@@ -193,10 +194,7 @@ HRESULT WINAPI IDirectMusicScriptImpl_IDirectMusicObject_GetDescriptor (LPDIRECT
 
 HRESULT WINAPI IDirectMusicScriptImpl_IDirectMusicObject_SetDescriptor (LPDIRECTMUSICOBJECT iface, LPDMUS_OBJECTDESC pDesc) {
 	ICOM_THIS_MULTI(IDirectMusicScriptImpl, ObjectVtbl, iface);
-	TRACE("(%p, %p): setting descriptor:\n", This, pDesc);
-	if (TRACE_ON(dmscript)) {
-		DMUSIC_dump_DMUS_OBJECTDESC (pDesc);
-	}
+	TRACE("(%p, %p): setting descriptor:\n%s\n", This, pDesc, debugstr_DMUS_OBJECTDESC (pDesc));
 	
 	/* According to MSDN, we should copy only given values, not whole struct */	
 	if (pDesc->dwValidData & DMUS_OBJ_OBJECT)
@@ -372,10 +370,7 @@ HRESULT WINAPI IDirectMusicScriptImpl_IDirectMusicObject_ParseDescriptor (LPDIRE
 		}
 	}	
 	
-	TRACE(": returning descriptor:\n");
-	if (TRACE_ON(dmscript)) {
-		DMUSIC_dump_DMUS_OBJECTDESC (pDesc);
-	}
+	TRACE(": returning descriptor:\n%s\n", debugstr_DMUS_OBJECTDESC (pDesc));
 	
 	return S_OK;
 }

dlls/dmscript/scripttrack.c

@@ -29,6 +29,7 @@ WINE_DECLARE_DEBUG_CHANNEL(dmfile);
 HRESULT WINAPI IDirectMusicScriptTrack_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS_MULTI(IDirectMusicScriptTrack, UnknownVtbl, iface);
 
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 	if (IsEqualIID (riid, &IID_IUnknown)) {
 		*ppobj = (LPUNKNOWN)&This->UnknownVtbl;
 		IDirectMusicScriptTrack_IUnknown_AddRef ((LPUNKNOWN)&This->UnknownVtbl);
@@ -44,20 +45,20 @@ HRESULT WINAPI IDirectMusicScriptTrack_IUnknown_QueryInterface (LPUNKNOWN iface,
 		return S_OK;
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicScriptTrack_IUnknown_AddRef (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicScriptTrack, UnknownVtbl, iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicScriptTrack_IUnknown_Release (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicScriptTrack, UnknownVtbl, iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}
@@ -117,20 +118,20 @@ HRESULT WINAPI IDirectMusicScriptTrack_IDirectMusicTrack_Play (LPDIRECTMUSICTRAC
 
 HRESULT WINAPI IDirectMusicScriptTrack_IDirectMusicTrack_GetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, MUSIC_TIME* pmtNext, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicScriptTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pmtNext, pParam);
+	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pmtNext, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicScriptTrack_IDirectMusicTrack_SetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicScriptTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pParam);
+	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicScriptTrack_IDirectMusicTrack_IsParamSupported (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType) {
 	ICOM_THIS_MULTI(IDirectMusicScriptTrack, TrackVtbl, iface);
 
-	TRACE("(%p, %s): ", This, debugstr_guid(rguidType));
+	TRACE("(%p, %s): ", This, debugstr_dmguid(rguidType));
 	/* didn't find any params */
 	TRACE("param unsupported\n");
 	return DMUS_E_TYPE_UNSUPPORTED;
@@ -138,13 +139,13 @@ HRESULT WINAPI IDirectMusicScriptTrack_IDirectMusicTrack_IsParamSupported (LPDIR
 
 HRESULT WINAPI IDirectMusicScriptTrack_IDirectMusicTrack_AddNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicScriptTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicScriptTrack_IDirectMusicTrack_RemoveNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicScriptTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
@@ -162,13 +163,13 @@ HRESULT WINAPI IDirectMusicScriptTrack_IDirectMusicTrack_PlayEx (LPDIRECTMUSICTR
 
 HRESULT WINAPI IDirectMusicScriptTrack_IDirectMusicTrack_GetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, REFERENCE_TIME* prtNext, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicScriptTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicScriptTrack_IDirectMusicTrack_SetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicScriptTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 

dlls/dmstyle/auditiontrack.c

@@ -28,6 +28,7 @@ WINE_DECLARE_DEBUG_CHANNEL(dmfile);
 /* IDirectMusicAuditionTrack IUnknown part: */
 HRESULT WINAPI IDirectMusicAuditionTrack_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS_MULTI(IDirectMusicAuditionTrack, UnknownVtbl, iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 
 	if (IsEqualIID (riid, &IID_IUnknown)) {
 		*ppobj = (LPUNKNOWN)&This->UnknownVtbl;
@@ -44,20 +45,20 @@ HRESULT WINAPI IDirectMusicAuditionTrack_IUnknown_QueryInterface (LPUNKNOWN ifac
 		return S_OK;
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicAuditionTrack_IUnknown_AddRef (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicAuditionTrack, UnknownVtbl, iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicAuditionTrack_IUnknown_Release (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicAuditionTrack, UnknownVtbl, iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}
@@ -117,20 +118,20 @@ HRESULT WINAPI IDirectMusicAuditionTrack_IDirectMusicTrack_Play (LPDIRECTMUSICTR
 
 HRESULT WINAPI IDirectMusicAuditionTrack_IDirectMusicTrack_GetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, MUSIC_TIME* pmtNext, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicAuditionTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pmtNext, pParam);
+	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pmtNext, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicAuditionTrack_IDirectMusicTrack_SetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicAuditionTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pParam);
+	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicAuditionTrack_IDirectMusicTrack_IsParamSupported (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType) {
 	ICOM_THIS_MULTI(IDirectMusicAuditionTrack, TrackVtbl, iface);
 
-	TRACE("(%p, %s): ", This, debugstr_guid(rguidType));
+	TRACE("(%p, %s): ", This, debugstr_dmguid(rguidType));
 	/* didn't find any params */
 	TRACE("param unsupported\n");
 	return DMUS_E_TYPE_UNSUPPORTED;
@@ -138,13 +139,13 @@ HRESULT WINAPI IDirectMusicAuditionTrack_IDirectMusicTrack_IsParamSupported (LPD
 
 HRESULT WINAPI IDirectMusicAuditionTrack_IDirectMusicTrack_AddNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicAuditionTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicAuditionTrack_IDirectMusicTrack_RemoveNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicAuditionTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
@@ -162,13 +163,13 @@ HRESULT WINAPI IDirectMusicAuditionTrack_IDirectMusicTrack_PlayEx (LPDIRECTMUSIC
 
 HRESULT WINAPI IDirectMusicAuditionTrack_IDirectMusicTrack_GetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, REFERENCE_TIME* prtNext, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicAuditionTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicAuditionTrack_IDirectMusicTrack_SetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicAuditionTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 

dlls/dmstyle/chordtrack.c

@@ -28,6 +28,7 @@ WINE_DECLARE_DEBUG_CHANNEL(dmfile);
 /* IDirectMusicChordTrack IUnknown part: */
 HRESULT WINAPI IDirectMusicChordTrack_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS_MULTI(IDirectMusicChordTrack, UnknownVtbl, iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 
 	if (IsEqualIID (riid, &IID_IUnknown)) {
 		*ppobj = (LPUNKNOWN)&This->UnknownVtbl;
@@ -44,20 +45,20 @@ HRESULT WINAPI IDirectMusicChordTrack_IUnknown_QueryInterface (LPUNKNOWN iface,
 		return S_OK;
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicChordTrack_IUnknown_AddRef (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicChordTrack, UnknownVtbl, iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicChordTrack_IUnknown_Release (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicChordTrack, UnknownVtbl, iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}
@@ -117,20 +118,20 @@ HRESULT WINAPI IDirectMusicChordTrack_IDirectMusicTrack_Play (LPDIRECTMUSICTRACK
 
 HRESULT WINAPI IDirectMusicChordTrack_IDirectMusicTrack_GetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, MUSIC_TIME* pmtNext, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicChordTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pmtNext, pParam);
+	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pmtNext, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicChordTrack_IDirectMusicTrack_SetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicChordTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pParam);
+	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicChordTrack_IDirectMusicTrack_IsParamSupported (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType) {
 	ICOM_THIS_MULTI(IDirectMusicChordTrack, TrackVtbl, iface);
 
-	TRACE("(%p, %s): ", This, debugstr_guid(rguidType));
+	TRACE("(%p, %s): ", This, debugstr_dmguid(rguidType));
 	if (IsEqualGUID (rguidType, &GUID_BandParam)
 		|| IsEqualGUID (rguidType, &GUID_ChordParam)
 		|| IsEqualGUID (rguidType, &GUID_RhythmParam)) {
@@ -143,13 +144,13 @@ HRESULT WINAPI IDirectMusicChordTrack_IDirectMusicTrack_IsParamSupported (LPDIRE
 
 HRESULT WINAPI IDirectMusicChordTrack_IDirectMusicTrack_AddNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicChordTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicChordTrack_IDirectMusicTrack_RemoveNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicChordTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
@@ -167,13 +168,13 @@ HRESULT WINAPI IDirectMusicChordTrack_IDirectMusicTrack_PlayEx (LPDIRECTMUSICTRA
 
 HRESULT WINAPI IDirectMusicChordTrack_IDirectMusicTrack_GetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, REFERENCE_TIME* prtNext, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicChordTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicChordTrack_IDirectMusicTrack_SetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicChordTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 

dlls/dmstyle/commandtrack.c

@@ -28,6 +28,7 @@ WINE_DECLARE_DEBUG_CHANNEL(dmfile);
 /* IDirectMusicCommandTrack IUnknown part: */
 HRESULT WINAPI IDirectMusicCommandTrack_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS_MULTI(IDirectMusicCommandTrack, UnknownVtbl, iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 
 	if (IsEqualIID (riid, &IID_IUnknown)) {
 		*ppobj = (LPUNKNOWN)&This->UnknownVtbl;
@@ -44,20 +45,20 @@ HRESULT WINAPI IDirectMusicCommandTrack_IUnknown_QueryInterface (LPUNKNOWN iface
 		return S_OK;
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicCommandTrack_IUnknown_AddRef (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicCommandTrack, UnknownVtbl, iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicCommandTrack_IUnknown_Release (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicCommandTrack, UnknownVtbl, iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}
@@ -117,20 +118,20 @@ HRESULT WINAPI IDirectMusicCommandTrack_IDirectMusicTrack_Play (LPDIRECTMUSICTRA
 
 HRESULT WINAPI IDirectMusicCommandTrack_IDirectMusicTrack_GetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, MUSIC_TIME* pmtNext, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicCommandTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pmtNext, pParam);
+	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pmtNext, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicCommandTrack_IDirectMusicTrack_SetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicCommandTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pParam);
+	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicCommandTrack_IDirectMusicTrack_IsParamSupported (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType) {
 	ICOM_THIS_MULTI(IDirectMusicCommandTrack, TrackVtbl, iface);
 
-	TRACE("(%p, %s): ", This, debugstr_guid(rguidType));
+	TRACE("(%p, %s): ", This, debugstr_dmguid(rguidType));
 	if (IsEqualGUID (rguidType, &GUID_CommandParam)
 		|| IsEqualGUID (rguidType, &GUID_CommandParam2)
 		|| IsEqualGUID (rguidType, &GUID_CommandParamNext)) {
@@ -144,13 +145,13 @@ HRESULT WINAPI IDirectMusicCommandTrack_IDirectMusicTrack_IsParamSupported (LPDI
 
 HRESULT WINAPI IDirectMusicCommandTrack_IDirectMusicTrack_AddNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicCommandTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicCommandTrack_IDirectMusicTrack_RemoveNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicCommandTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
@@ -168,13 +169,13 @@ HRESULT WINAPI IDirectMusicCommandTrack_IDirectMusicTrack_PlayEx (LPDIRECTMUSICT
 
 HRESULT WINAPI IDirectMusicCommandTrack_IDirectMusicTrack_GetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, REFERENCE_TIME* prtNext, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicCommandTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicCommandTrack_IDirectMusicTrack_SetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicCommandTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 

dlls/dmstyle/dmstyle_main.c

@@ -32,7 +32,7 @@ typedef struct {
  */
 static HRESULT WINAPI SectionCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -49,15 +49,15 @@ static ULONG WINAPI SectionCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI SectionCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	/* nothing here yet */
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 static HRESULT WINAPI SectionCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -77,7 +77,7 @@ static IClassFactoryImpl Section_CF = {&SectionCF_Vtbl, 1 };
  */
 static HRESULT WINAPI StyleCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -94,13 +94,13 @@ static ULONG WINAPI StyleCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI StyleCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicStyleImpl (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI StyleCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -120,7 +120,7 @@ static IClassFactoryImpl Style_CF = {&StyleCF_Vtbl, 1 };
  */
 static HRESULT WINAPI ChordTrackCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -137,13 +137,13 @@ static ULONG WINAPI ChordTrackCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI ChordTrackCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicChordTrack (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI ChordTrackCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -163,7 +163,7 @@ static IClassFactoryImpl ChordTrack_CF = {&ChordTrackCF_Vtbl, 1 };
  */
 static HRESULT WINAPI CommandTrackCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -180,13 +180,13 @@ static ULONG WINAPI CommandTrackCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI CommandTrackCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicCommandTrack (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI CommandTrackCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -206,7 +206,7 @@ static IClassFactoryImpl CommandTrack_CF = {&CommandTrackCF_Vtbl, 1 };
  */
 static HRESULT WINAPI StyleTrackCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -223,13 +223,13 @@ static ULONG WINAPI StyleTrackCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI StyleTrackCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicStyleTrack (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI StyleTrackCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -249,7 +249,7 @@ static IClassFactoryImpl StyleTrack_CF = {&StyleTrackCF_Vtbl, 1 };
  */
 static HRESULT WINAPI MotifTrackCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -266,13 +266,13 @@ static ULONG WINAPI MotifTrackCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI MotifTrackCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicMotifTrack (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI MotifTrackCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -292,7 +292,7 @@ static IClassFactoryImpl MotifTrack_CF = {&MotifTrackCF_Vtbl, 1 };
  */
 static HRESULT WINAPI AuditionTrackCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -309,13 +309,13 @@ static ULONG WINAPI AuditionTrackCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI AuditionTrackCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicAuditionTrack (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI AuditionTrackCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -335,7 +335,7 @@ static IClassFactoryImpl AuditionTrack_CF = {&AuditionTrackCF_Vtbl, 1 };
  */
 static HRESULT WINAPI MuteTrackCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -352,13 +352,13 @@ static ULONG WINAPI MuteTrackCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI MuteTrackCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicMuteTrack (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI MuteTrackCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -407,7 +407,7 @@ HRESULT WINAPI DMSTYLE_DllCanUnloadNow(void) {
  *
  */
 HRESULT WINAPI DMSTYLE_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv) {
-    TRACE("(%p,%p,%p)\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
+    TRACE("(%s, %s, %p)\n", debugstr_dmguid(rclsid), debugstr_dmguid(riid), ppv);
     
 	if (IsEqualCLSID (rclsid, &CLSID_DirectMusicSection) && IsEqualIID (riid, &IID_IClassFactory)) {
 		*ppv = (LPVOID) &Section_CF;
@@ -443,6 +443,414 @@ HRESULT WINAPI DMSTYLE_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *p
 		return S_OK;		
 	}
 
-    WARN("(%p,%p,%p): no interface found.\n", debugstr_guid(rclsid), debugstr_guid(riid), 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),
+		/* 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)");
+	}
+}

dlls/dmstyle/dmstyle_private.h

@@ -20,7 +20,9 @@
 #ifndef __WINE_DMSTYLE_PRIVATE_H
 #define __WINE_DMSTYLE_PRIVATE_H
 
+#include <stdio.h>
 #include <stdarg.h>
+#include <string.h>
 
 #include "windef.h"
 #include "winbase.h"
@@ -504,26 +506,16 @@ typedef struct _DMUS_PRIVATE_CHUNK {
 	DWORD dwSize; /* size of the chunk */
 } DMUS_PRIVATE_CHUNK, *LPDMUS_PRIVATE_CHUNK;
 
-/* check whether the given DWORD is even (return 0) or odd (return 1) */
-static inline int even_or_odd (DWORD number) {
-	return (number & 0x1); /* basically, check if bit 0 is set ;) */
-}
+/* used for generic dumping (copied from ddraw) */
+typedef struct {
+    DWORD val;
+    const char* name;
+} flag_info;
 
-/* FOURCC to string conversion for debug messages */
-static inline 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 */
-static inline 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));
-}
+typedef struct {
+    const GUID *guid;
+    const char* name;
+} guid_info;
 
 /* used for initialising structs (primarily for DMUS_OBJECTDESC) */
 #define DM_STRUCT_INIT(x) 				\
@@ -532,65 +524,23 @@ static inline const char *debugstr_dmversion (LPDMUS_VERSION version) {
 		(x)->dwSize = sizeof(*x);		\
 	} while (0)
 
+#define FE(x) { x, #x }	
+#define GE(x) { &x, #x }
 
-/* used for generic dumping (copied from ddraw) */
-typedef struct {
-    DWORD val;
-    const char* name;
-} flag_info;
-
-#define FE(x) { x, #x }
-#define DMUSIC_dump_flags(flags,names,num_names) DMUSIC_dump_flags_(flags, names, num_names, 1)
-
-/* generic dump function */
-static inline void DMUSIC_dump_flags_ (DWORD flags, const flag_info* names, size_t num_names, int newline) {
-	unsigned int i;
-	
-	for (i=0; i < num_names; i++) {
-		if ((flags & names[i].val) ||      /* standard flag value */
-		((!flags) && (!names[i].val))) /* zero value only */
-	    	DPRINTF("%s ", names[i].name);
-	}
-	
-    if (newline) DPRINTF("\n");
-}
-
-static inline void DMUSIC_dump_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)
-	};
-    DMUSIC_dump_flags(flagmask, flags, sizeof(flags)/sizeof(flags[0]));
-}
-
-static inline void DMUSIC_dump_DMUS_OBJECTDESC (LPDMUS_OBJECTDESC pDesc) {
-	if (pDesc) {
-		DPRINTF("DMUS_OBJECTDESC (%p)\n", pDesc);
-		DPRINTF("  - dwSize = %ld\n", pDesc->dwSize);
-		DPRINTF("  - dwValidData = ");
-		DMUSIC_dump_DMUS_OBJ_FLAGS (pDesc->dwValidData);
-		if (pDesc->dwValidData & DMUS_OBJ_CLASS) DPRINTF("  - guidClass = %s\n", debugstr_guid(&pDesc->guidClass));
-		if (pDesc->dwValidData & DMUS_OBJ_OBJECT) DPRINTF("  - guidObject = %s\n", debugstr_guid(&pDesc->guidObject));
-		if (pDesc->dwValidData & DMUS_OBJ_DATE) DPRINTF("  - ftDate = FIXME\n");
-		if (pDesc->dwValidData & DMUS_OBJ_VERSION) DPRINTF("  - vVersion = %s\n", debugstr_dmversion(&pDesc->vVersion));
-		if (pDesc->dwValidData & DMUS_OBJ_NAME) DPRINTF("  - wszName = %s\n", debugstr_w(pDesc->wszName));
-		if (pDesc->dwValidData & DMUS_OBJ_CATEGORY) DPRINTF("  - wszCategory = %s\n", debugstr_w(pDesc->wszCategory));
-		if (pDesc->dwValidData & DMUS_OBJ_FILENAME) DPRINTF("  - wszFileName = %s\n", debugstr_w(pDesc->wszFileName));
-		if (pDesc->dwValidData & DMUS_OBJ_MEMORY) DPRINTF("  - llMemLength = %lli\n  - pbMemData = %p\n", pDesc->llMemLength, pDesc->pbMemData);
-		if (pDesc->dwValidData & DMUS_OBJ_STREAM) DPRINTF("  - pStream = %p\n", pDesc->pStream);		
-	} else {
-		DPRINTF("(NULL)\n");
-	}
-}
+/* 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);
 
 #endif	/* __WINE_DMSTYLE_PRIVATE_H */

dlls/dmstyle/motiftrack.c

@@ -28,6 +28,7 @@ WINE_DECLARE_DEBUG_CHANNEL(dmfile);
 /* IDirectMusicMotifTrack IUnknown part: */
 HRESULT WINAPI IDirectMusicMotifTrack_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS_MULTI(IDirectMusicMotifTrack, UnknownVtbl, iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 
 	if (IsEqualIID (riid, &IID_IUnknown)) {
 		*ppobj = (LPUNKNOWN)&This->UnknownVtbl;
@@ -44,20 +45,20 @@ HRESULT WINAPI IDirectMusicMotifTrack_IUnknown_QueryInterface (LPUNKNOWN iface,
 		return S_OK;
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicMotifTrack_IUnknown_AddRef (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicMotifTrack, UnknownVtbl, iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicMotifTrack_IUnknown_Release (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicMotifTrack, UnknownVtbl, iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}
@@ -117,20 +118,20 @@ HRESULT WINAPI IDirectMusicMotifTrack_IDirectMusicTrack_Play (LPDIRECTMUSICTRACK
 
 HRESULT WINAPI IDirectMusicMotifTrack_IDirectMusicTrack_GetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, MUSIC_TIME* pmtNext, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicMotifTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pmtNext, pParam);
+	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pmtNext, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicMotifTrack_IDirectMusicTrack_SetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicMotifTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pParam);
+	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicMotifTrack_IDirectMusicTrack_IsParamSupported (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType) {
 	ICOM_THIS_MULTI(IDirectMusicMotifTrack, TrackVtbl, iface);
 
-	TRACE("(%p, %s): ", This, debugstr_guid(rguidType));
+	TRACE("(%p, %s): ", This, debugstr_dmguid(rguidType));
 	if (IsEqualGUID (rguidType, &GUID_DisableTimeSig)
 		|| IsEqualGUID (rguidType, &GUID_EnableTimeSig)
 		|| IsEqualGUID (rguidType, &GUID_SeedVariations)
@@ -144,13 +145,13 @@ HRESULT WINAPI IDirectMusicMotifTrack_IDirectMusicTrack_IsParamSupported (LPDIRE
 
 HRESULT WINAPI IDirectMusicMotifTrack_IDirectMusicTrack_AddNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicMotifTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicMotifTrack_IDirectMusicTrack_RemoveNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicMotifTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
@@ -168,13 +169,13 @@ HRESULT WINAPI IDirectMusicMotifTrack_IDirectMusicTrack_PlayEx (LPDIRECTMUSICTRA
 
 HRESULT WINAPI IDirectMusicMotifTrack_IDirectMusicTrack_GetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, REFERENCE_TIME* prtNext, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicMotifTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicMotifTrack_IDirectMusicTrack_SetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicMotifTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 

dlls/dmstyle/mutetrack.c

@@ -28,6 +28,7 @@ WINE_DECLARE_DEBUG_CHANNEL(dmfile);
 /* IDirectMusicMuteTrack IUnknown part: */
 HRESULT WINAPI IDirectMusicMuteTrack_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS_MULTI(IDirectMusicMuteTrack, UnknownVtbl, iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 
 	if (IsEqualIID (riid, &IID_IUnknown)) {
 		*ppobj = (LPUNKNOWN)&This->UnknownVtbl;
@@ -44,20 +45,20 @@ HRESULT WINAPI IDirectMusicMuteTrack_IUnknown_QueryInterface (LPUNKNOWN iface, R
 		return S_OK;
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicMuteTrack_IUnknown_AddRef (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicMuteTrack, UnknownVtbl, iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicMuteTrack_IUnknown_Release (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicMuteTrack, UnknownVtbl, iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}
@@ -117,20 +118,20 @@ HRESULT WINAPI IDirectMusicMuteTrack_IDirectMusicTrack_Play (LPDIRECTMUSICTRACK8
 
 HRESULT WINAPI IDirectMusicMuteTrack_IDirectMusicTrack_GetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, MUSIC_TIME* pmtNext, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicMuteTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pmtNext, pParam);
+	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pmtNext, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicMuteTrack_IDirectMusicTrack_SetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicMuteTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pParam);
+	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicMuteTrack_IDirectMusicTrack_IsParamSupported (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType) {
 	ICOM_THIS_MULTI(IDirectMusicMuteTrack, TrackVtbl, iface);
 
-	TRACE("(%p, %s): ", This, debugstr_guid(rguidType));
+	TRACE("(%p, %s): ", This, debugstr_dmguid(rguidType));
 	if (IsEqualGUID (rguidType, &GUID_MuteParam)) {
 		TRACE("param supported\n");
 		return S_OK;
@@ -141,13 +142,13 @@ HRESULT WINAPI IDirectMusicMuteTrack_IDirectMusicTrack_IsParamSupported (LPDIREC
 
 HRESULT WINAPI IDirectMusicMuteTrack_IDirectMusicTrack_AddNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicMuteTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicMuteTrack_IDirectMusicTrack_RemoveNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicMuteTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
@@ -165,13 +166,13 @@ HRESULT WINAPI IDirectMusicMuteTrack_IDirectMusicTrack_PlayEx (LPDIRECTMUSICTRAC
 
 HRESULT WINAPI IDirectMusicMuteTrack_IDirectMusicTrack_GetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, REFERENCE_TIME* prtNext, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicMuteTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicMuteTrack_IDirectMusicTrack_SetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicMuteTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 

dlls/dmstyle/style.c

@@ -28,6 +28,7 @@ WINE_DECLARE_DEBUG_CHANNEL(dmfile);
 /* IDirectMusicStyleImpl IUnknown part: */
 HRESULT WINAPI IDirectMusicStyle8Impl_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS_MULTI(IDirectMusicStyle8Impl, UnknownVtbl, iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 	
 	if (IsEqualIID (riid, &IID_IUnknown)) {
 		*ppobj = (LPVOID)&This->UnknownVtbl;
@@ -47,20 +48,20 @@ HRESULT WINAPI IDirectMusicStyle8Impl_IUnknown_QueryInterface (LPUNKNOWN iface,
 		return S_OK;
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicStyle8Impl_IUnknown_AddRef (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicStyle8Impl, UnknownVtbl, iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicStyle8Impl_IUnknown_Release (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicStyle8Impl, UnknownVtbl, iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}
@@ -208,10 +209,7 @@ HRESULT WINAPI IDirectMusicStyle8Impl_IDirectMusicObject_GetDescriptor (LPDIRECT
 
 HRESULT WINAPI IDirectMusicStyle8Impl_IDirectMusicObject_SetDescriptor (LPDIRECTMUSICOBJECT iface, LPDMUS_OBJECTDESC pDesc) {
 	ICOM_THIS_MULTI(IDirectMusicStyle8Impl, ObjectVtbl, iface);
-	TRACE("(%p, %p): setting descriptor:\n", This, pDesc);
-	if (TRACE_ON(dmstyle)) {
-		DMUSIC_dump_DMUS_OBJECTDESC (pDesc);
-	}
+	TRACE("(%p, %p): setting descriptor:\n%s\n", This, pDesc, debugstr_DMUS_OBJECTDESC (pDesc));
 	
 	/* According to MSDN, we should copy only given values, not whole struct */	
 	if (pDesc->dwValidData & DMUS_OBJ_OBJECT)
@@ -253,7 +251,7 @@ HRESULT WINAPI IDirectMusicStyle8Impl_IDirectMusicObject_ParseDescriptor (LPDIRE
 	
 	/* FIXME: should this be determined from stream? */
 	pDesc->dwValidData |= DMUS_OBJ_CLASS;
-	memcpy (&pDesc->guidClass, &CLSID_DirectMusicBand, sizeof(CLSID));
+	memcpy (&pDesc->guidClass, &CLSID_DirectMusicStyle, sizeof(CLSID));
 	
 	IStream_Read (pStream, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
 	TRACE_(dmfile)(": %s chunk (size = 0x%04lx)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
@@ -263,8 +261,8 @@ HRESULT WINAPI IDirectMusicStyle8Impl_IDirectMusicObject_ParseDescriptor (LPDIRE
 			TRACE_(dmfile)(": RIFF chunk of type %s", debugstr_fourcc(Chunk.fccID));
 			StreamSize = Chunk.dwSize - sizeof(FOURCC);
 			StreamCount = 0;
-			if (Chunk.fccID == DMUS_FOURCC_BAND_FORM) {
-				TRACE_(dmfile)(": band form\n");
+			if (Chunk.fccID == DMUS_FOURCC_STYLE_FORM) {
+				TRACE_(dmfile)(": style form\n");
 				do {
 					IStream_Read (pStream, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
 					StreamCount += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
@@ -387,10 +385,7 @@ HRESULT WINAPI IDirectMusicStyle8Impl_IDirectMusicObject_ParseDescriptor (LPDIRE
 		}
 	}	
 	
-	TRACE(": returning descriptor:\n");
-	if (TRACE_ON(dmstyle)) {
-		DMUSIC_dump_DMUS_OBJECTDESC (pDesc);
-	}
+	TRACE(": returning descriptor:\n%s\n", debugstr_DMUS_OBJECTDESC (pDesc));
 	
 	return S_OK;
 }

dlls/dmstyle/styletrack.c

@@ -28,6 +28,7 @@ WINE_DECLARE_DEBUG_CHANNEL(dmfile);
 /* IDirectMusicStyleTrack IUnknown part: */
 HRESULT WINAPI IDirectMusicStyleTrack_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS_MULTI(IDirectMusicStyleTrack, UnknownVtbl, iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 
 	if (IsEqualIID (riid, &IID_IUnknown)) {
 		*ppobj = (LPUNKNOWN)&This->UnknownVtbl;
@@ -44,20 +45,20 @@ HRESULT WINAPI IDirectMusicStyleTrack_IUnknown_QueryInterface (LPUNKNOWN iface,
 		return S_OK;
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicStyleTrack_IUnknown_AddRef (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicStyleTrack, UnknownVtbl, iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicStyleTrack_IUnknown_Release (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicStyleTrack, UnknownVtbl, iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}
@@ -117,20 +118,20 @@ HRESULT WINAPI IDirectMusicStyleTrack_IDirectMusicTrack_Play (LPDIRECTMUSICTRACK
 
 HRESULT WINAPI IDirectMusicStyleTrack_IDirectMusicTrack_GetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, MUSIC_TIME* pmtNext, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicStyleTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pmtNext, pParam);
+	FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pmtNext, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicStyleTrack_IDirectMusicTrack_SetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, void* pParam) {
 	ICOM_THIS_MULTI(IDirectMusicStyleTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pParam);
+	FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_dmguid(rguidType), mtTime, pParam);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicStyleTrack_IDirectMusicTrack_IsParamSupported (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType) {
 	ICOM_THIS_MULTI(IDirectMusicStyleTrack, TrackVtbl, iface);
 
-	TRACE("(%p, %s): ", This, debugstr_guid(rguidType));
+	TRACE("(%p, %s): ", This, debugstr_dmguid(rguidType));
 	if (IsEqualGUID (rguidType, &GUID_DisableTimeSig)
 		|| IsEqualGUID (rguidType, &GUID_EnableTimeSig)
 		|| IsEqualGUID (rguidType, &GUID_IDirectMusicStyle)
@@ -145,13 +146,13 @@ HRESULT WINAPI IDirectMusicStyleTrack_IDirectMusicTrack_IsParamSupported (LPDIRE
 
 HRESULT WINAPI IDirectMusicStyleTrack_IDirectMusicTrack_AddNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicStyleTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicStyleTrack_IDirectMusicTrack_RemoveNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType) {
 	ICOM_THIS_MULTI(IDirectMusicStyleTrack, TrackVtbl, iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 	return S_OK;
 }
 
@@ -169,13 +170,13 @@ HRESULT WINAPI IDirectMusicStyleTrack_IDirectMusicTrack_PlayEx (LPDIRECTMUSICTRA
 
 HRESULT WINAPI IDirectMusicStyleTrack_IDirectMusicTrack_GetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, REFERENCE_TIME* prtNext, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicStyleTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicStyleTrack_IDirectMusicTrack_SetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, void* pParam, void* pStateData, DWORD dwFlags) {
 	ICOM_THIS_MULTI(IDirectMusicStyleTrack, TrackVtbl, iface);
-	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, pParam, pStateData, dwFlags);
+	FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType), rtTime, pParam, pStateData, dwFlags);
 	return S_OK;
 }
 

dlls/dmsynth/dmsynth_main.c

@@ -17,6 +17,8 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  */
 
+#include <stdio.h>
+
 #include "dmsynth_private.h"
 
 WINE_DEFAULT_DEBUG_CHANNEL(dmsynth);
@@ -32,7 +34,7 @@ typedef struct {
  */
 static HRESULT WINAPI SynthCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -49,13 +51,13 @@ static ULONG WINAPI SynthCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI SynthCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicSynthImpl (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI SynthCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -75,7 +77,7 @@ static IClassFactoryImpl Synth_CF = {&SynthCF_Vtbl, 1 };
  */
 static HRESULT WINAPI SynthSinkCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -92,13 +94,13 @@ static ULONG WINAPI SynthSinkCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI SynthSinkCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicSynthSinkImpl (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI SynthSinkCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -147,7 +149,7 @@ HRESULT WINAPI DMSYNTH_DllCanUnloadNow(void) {
  *
  */
 HRESULT WINAPI DMSYNTH_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv) {
-    TRACE("(%p,%p,%p)\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
+    TRACE("(%s, %s, %p)\n", debugstr_dmguid(rclsid), debugstr_dmguid(riid), ppv);
     if (IsEqualCLSID (rclsid, &CLSID_DirectMusicSynth) && IsEqualIID (riid, &IID_IClassFactory)) {
 		*ppv = (LPVOID) &Synth_CF;
 		IClassFactory_AddRef((IClassFactory*)*ppv);
@@ -158,6 +160,367 @@ HRESULT WINAPI DMSYNTH_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *p
 		return S_OK;		
 	} 
 
-    WARN("(%p,%p,%p): no interface found.\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
+    WARN("(%s,%s,%p): no interface found.\n", debugstr_dmguid(rclsid), debugstr_dmguid(riid), ppv);
     return CLASS_E_CLASSNOTAVAILABLE;
 }
+
+/******************************************************************
+ *		Helper functions
+ *
+ *
+ */
+
+/* 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);
+}

dlls/dmsynth/dmsynth_private.h

@@ -124,4 +124,41 @@ extern HRESULT WINAPI IDirectMusicSynthSinkImpl_RefTimeToSample (LPDIRECTMUSICSY
 extern HRESULT WINAPI IDirectMusicSynthSinkImpl_SetDirectSound (LPDIRECTMUSICSYNTHSINK iface, LPDIRECTSOUND pDirectSound, LPDIRECTSOUNDBUFFER pDirectSoundBuffer);
 extern HRESULT WINAPI IDirectMusicSynthSinkImpl_GetDesiredBufferSize (LPDIRECTMUSICSYNTHSINK iface, LPDWORD pdwBufferSizeInSamples);
 
+
+/*****************************************************************************
+ * Misc.
+ */
+/* 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 }
+
+/* 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);
+
+
 #endif	/* __WINE_DMSYNTH_PRIVATE_H */

dlls/dmsynth/synth.c

@@ -24,6 +24,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(dmsynth);
 /* IDirectMusicSynth8Impl IUnknown part: */
 HRESULT WINAPI IDirectMusicSynth8Impl_QueryInterface (LPDIRECTMUSICSYNTH8 iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IDirectMusicSynth8Impl,iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 
 	if (IsEqualIID (riid, &IID_IUnknown) || 
 	    IsEqualIID (riid, &IID_IDirectMusicSynth) ||
@@ -32,20 +33,20 @@ HRESULT WINAPI IDirectMusicSynth8Impl_QueryInterface (LPDIRECTMUSICSYNTH8 iface,
 		*ppobj = This;
 		return S_OK;
 	}
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicSynth8Impl_AddRef (LPDIRECTMUSICSYNTH8 iface) {
 	ICOM_THIS(IDirectMusicSynth8Impl,iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicSynth8Impl_Release (LPDIRECTMUSICSYNTH8 iface) {
 	ICOM_THIS(IDirectMusicSynth8Impl,iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}

dlls/dmsynth/synthsink.c

@@ -24,6 +24,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(dmsynth);
 /* IDirectMusicSynthSinkImpl IUnknown part: */
 HRESULT WINAPI IDirectMusicSynthSinkImpl_QueryInterface (LPDIRECTMUSICSYNTHSINK iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IDirectMusicSynthSinkImpl,iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 
 	if (IsEqualIID (riid, &IID_IUnknown) || 
 	    IsEqualIID (riid, &IID_IDirectMusicSynthSink)) {
@@ -31,20 +32,20 @@ HRESULT WINAPI IDirectMusicSynthSinkImpl_QueryInterface (LPDIRECTMUSICSYNTHSINK
 		*ppobj = This;
 		return S_OK;
 	}
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicSynthSinkImpl_AddRef (LPDIRECTMUSICSYNTHSINK iface) {
 	ICOM_THIS(IDirectMusicSynthSinkImpl,iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicSynthSinkImpl_Release (LPDIRECTMUSICSYNTHSINK iface) {
 	ICOM_THIS(IDirectMusicSynthSinkImpl,iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}

dlls/dmusic/buffer.c

@@ -24,26 +24,27 @@ WINE_DEFAULT_DEBUG_CHANNEL(dmusic);
 /* IDirectMusicBufferImpl IUnknown part: */
 HRESULT WINAPI IDirectMusicBufferImpl_QueryInterface (LPDIRECTMUSICBUFFER iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IDirectMusicBufferImpl,iface);
+	TRACE("(%p, (%s, %p)\n",This,debugstr_dmguid(riid),ppobj);
 	if (IsEqualIID (riid, &IID_IUnknown) 
 		|| IsEqualIID (riid, &IID_IDirectMusicBuffer)) {
 		IDirectMusicBufferImpl_AddRef(iface);
 		*ppobj = This;
 		return S_OK;
 	}
-	WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj);
+	WARN("(%p, (%s, %p): not found\n",This,debugstr_dmguid(riid),ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicBufferImpl_AddRef (LPDIRECTMUSICBUFFER iface) {
 	ICOM_THIS(IDirectMusicBufferImpl,iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicBufferImpl_Release (LPDIRECTMUSICBUFFER iface) {
 	ICOM_THIS(IDirectMusicBufferImpl,iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}

dlls/dmusic/clock.c

@@ -24,6 +24,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(dmusic);
 /* IReferenceClockImpl IUnknown part: */
 HRESULT WINAPI IReferenceClockImpl_QueryInterface (IReferenceClock *iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IReferenceClockImpl,iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 
 	if (IsEqualIID (riid, &IID_IUnknown) || 
 	    IsEqualIID (riid, &IID_IReferenceClock)) {
@@ -31,20 +32,20 @@ HRESULT WINAPI IReferenceClockImpl_QueryInterface (IReferenceClock *iface, REFII
 		*ppobj = This;
 		return S_OK;
 	}
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IReferenceClockImpl_AddRef (IReferenceClock *iface) {
 	ICOM_THIS(IReferenceClockImpl,iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IReferenceClockImpl_Release (IReferenceClock *iface) {
 	ICOM_THIS(IReferenceClockImpl,iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}

dlls/dmusic/collection.c

@@ -28,7 +28,8 @@ WINE_DECLARE_DEBUG_CHANNEL(dmfile);
 /* IDirectMusicCollectionImpl IUnknown part: */
 HRESULT WINAPI IDirectMusicCollectionImpl_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS_MULTI(IDirectMusicCollectionImpl, UnknownVtbl, iface);
-	
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
+
 	if (IsEqualIID (riid, &IID_IUnknown)) {
 		*ppobj = (LPVOID)&This->UnknownVtbl;
 		IDirectMusicCollectionImpl_IUnknown_AddRef ((LPUNKNOWN)&This->UnknownVtbl);
@@ -47,20 +48,20 @@ HRESULT WINAPI IDirectMusicCollectionImpl_IUnknown_QueryInterface (LPUNKNOWN ifa
 		return S_OK;
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicCollectionImpl_IUnknown_AddRef (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicCollectionImpl, UnknownVtbl, iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicCollectionImpl_IUnknown_Release (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicCollectionImpl, UnknownVtbl, iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}
@@ -173,10 +174,7 @@ HRESULT WINAPI IDirectMusicCollectionImpl_IDirectMusicObject_GetDescriptor (LPDI
 
 HRESULT WINAPI IDirectMusicCollectionImpl_IDirectMusicObject_SetDescriptor (LPDIRECTMUSICOBJECT iface, LPDMUS_OBJECTDESC pDesc) {
 	ICOM_THIS_MULTI(IDirectMusicCollectionImpl, ObjectVtbl, iface);
-	TRACE("(%p, %p): setting descriptor:\n", This, pDesc);
-	if (TRACE_ON(dmusic)) {
-		DMUSIC_dump_DMUS_OBJECTDESC (pDesc);
-	}
+	TRACE("(%p, %p): setting descriptor:\n%s\n", This, pDesc, debugstr_DMUS_OBJECTDESC (pDesc));
 	
 	/* According to MSDN, we should copy only given values, not whole struct */	
 	if (pDesc->dwValidData & DMUS_OBJ_OBJECT)
@@ -372,10 +370,7 @@ HRESULT WINAPI IDirectMusicCollectionImpl_IDirectMusicObject_ParseDescriptor (LP
 		}
 	}	
 	
-	TRACE(": returning descriptor:\n");
-	if (TRACE_ON(dmusic)) {
-		DMUSIC_dump_DMUS_OBJECTDESC (pDesc);
-	}
+	TRACE(": returning descriptor:\n%s\n", debugstr_DMUS_OBJECTDESC (pDesc));
 	
 	return S_OK;
 }
@@ -630,7 +625,7 @@ HRESULT WINAPI IDirectMusicCollectionImpl_IPersistStream_Load (LPPERSISTSTREAM i
                                                                                                                             if (TRACE_ON(dmusic)) {
 																TRACE("*** IDirectMusicInstrument (%p) ***\n", pInstrument);
 																if (pInstrument->pInstrumentID)
-																	TRACE(" - GUID = %s\n", debugstr_guid(pInstrument->pInstrumentID));
+																	TRACE(" - GUID = %s\n", debugstr_dmguid(pInstrument->pInstrumentID));
 																
 																TRACE(" - Instrument header:\n");
 																TRACE("    - cRegions: %ld\n", pInstrument->pHeader->cRegions);
@@ -703,7 +698,7 @@ HRESULT WINAPI IDirectMusicCollectionImpl_IPersistStream_Load (LPPERSISTSTREAM i
 
 		TRACE("*** IDirectMusicCollection (%p) ***\n", This->CollectionVtbl);
 		if (This->pDesc->dwValidData & DMUS_OBJ_OBJECT)
-			TRACE(" - GUID = %s\n", debugstr_guid(&This->pDesc->guidObject));
+			TRACE(" - GUID = %s\n", debugstr_dmguid(&This->pDesc->guidObject));
 		if (This->pDesc->dwValidData & DMUS_OBJ_VERSION)
 			TRACE(" - Version = %i,%i,%i,%i\n", (This->pDesc->vVersion.dwVersionMS >> 8) && 0x0000FFFF, This->pDesc->vVersion.dwVersionMS && 0x0000FFFF, \
 				(This->pDesc->vVersion.dwVersionLS >> 8) && 0x0000FFFF, This->pDesc->vVersion.dwVersionLS && 0x0000FFFF);

dlls/dmusic/dmusic.c

@@ -23,6 +23,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(dmusic);
 /* IDirectMusic8Impl IUnknown part: */
 HRESULT WINAPI IDirectMusic8Impl_QueryInterface (LPDIRECTMUSIC8 iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IDirectMusic8Impl,iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 
 	if (IsEqualIID (riid, &IID_IUnknown) || 
 	    IsEqualIID (riid, &IID_IDirectMusic) ||
@@ -33,20 +34,20 @@ HRESULT WINAPI IDirectMusic8Impl_QueryInterface (LPDIRECTMUSIC8 iface, REFIID ri
 		return S_OK;
 	}
 
-	WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusic8Impl_AddRef (LPDIRECTMUSIC8 iface) {
 	ICOM_THIS(IDirectMusic8Impl,iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusic8Impl_Release (LPDIRECTMUSIC8 iface) {
 	ICOM_THIS(IDirectMusic8Impl,iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}
@@ -106,7 +107,7 @@ HRESULT WINAPI IDirectMusic8Impl_CreatePort (LPDIRECTMUSIC8 iface, REFCLSID rcls
 	int i/*, j*/;
 	DMUS_PORTCAPS PortCaps;
 	
-	TRACE("(%p, %s, %p, %p, %p)\n", This, debugstr_guid(rclsidPort), pPortParams, ppPort, pUnkOuter);
+	TRACE("(%p, %s, %p, %p, %p)\n", This, debugstr_dmguid(rclsidPort), pPortParams, ppPort, pUnkOuter);
 	for (i = 0; S_FALSE != IDirectMusic8Impl_EnumPort(iface, i, &PortCaps); i++) {				
 		if (IsEqualCLSID (rclsidPort, &PortCaps.guidPort)) {		
 			if(!This->ppPorts) This->ppPorts = HeapAlloc(GetProcessHeap(), 0, sizeof(LPDIRECTMUSICPORT) * This->nrofports);
@@ -177,7 +178,7 @@ HRESULT WINAPI IDirectMusic8Impl_GetMasterClock (LPDIRECTMUSIC8 iface, LPGUID pg
 
 HRESULT WINAPI IDirectMusic8Impl_SetMasterClock (LPDIRECTMUSIC8 iface, REFGUID rguidClock) {
 	ICOM_THIS(IDirectMusic8Impl,iface);
-	FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidClock));
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidClock));
 	return S_OK;
 }
 

dlls/dmusic/dmusic_main.c

@@ -17,6 +17,8 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  */
 
+#include <stdio.h>
+
 #include "dmusic_private.h"
 
 WINE_DEFAULT_DEBUG_CHANNEL(dmusic);
@@ -32,7 +34,7 @@ typedef struct {
  */
 static HRESULT WINAPI DirectMusicCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n",This,debugstr_dmguid(riid),ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -49,13 +51,13 @@ static ULONG WINAPI DirectMusicCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI DirectMusicCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicImpl (riid, (LPVOID*) ppobj, pOuter);
 }
 
 static HRESULT WINAPI DirectMusicCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -75,7 +77,7 @@ static IClassFactoryImpl DirectMusic_CF = {&DirectMusicCF_Vtbl, 1 };
  */
 static HRESULT WINAPI CollectionCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n",This,debugstr_dmguid(riid),ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -92,13 +94,13 @@ static ULONG WINAPI CollectionCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI CollectionCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicCollectionImpl (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI CollectionCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -147,7 +149,7 @@ HRESULT WINAPI DMUSIC_DllCanUnloadNow(void) {
  *
  */
 HRESULT WINAPI DMUSIC_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv) {
-	TRACE("(%p,%p,%p)\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
+	TRACE("(%s, %s, %p)\n", debugstr_dmguid(rclsid), debugstr_dmguid(riid), ppv);
 	if (IsEqualCLSID (rclsid, &CLSID_DirectMusic) && IsEqualIID (riid, &IID_IClassFactory)) {
 		*ppv = (LPVOID) &DirectMusic_CF;
 		IClassFactory_AddRef((IClassFactory*)*ppv);
@@ -158,6 +160,434 @@ HRESULT WINAPI DMUSIC_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *pp
 		return S_OK;
 	}
 	
-    WARN("(%p,%p,%p): no interface found.\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
+    WARN("(%s, %s, %p): no interface found.\n", debugstr_dmguid(rclsid), debugstr_dmguid(riid), ppv);
     return CLASS_E_CLASSNOTAVAILABLE;
 }
+
+
+/******************************************************************
+ *		Helper functions
+ *
+ *
+ */
+/* dwPatch from MIDILOCALE */
+DWORD MIDILOCALE2Patch (LPMIDILOCALE pLocale) {
+	DWORD dwPatch = 0;
+	if (!pLocale) return 0;
+	dwPatch |= (pLocale->ulBank & F_INSTRUMENT_DRUMS); /* set drum bit */
+	dwPatch |= ((pLocale->ulBank & 0x00007F7F) << 8); /* set MIDI bank location */
+	dwPatch |= (pLocale->ulInstrument & 0x0000007F); /* set PC value */
+	return dwPatch;	
+}
+
+/* MIDILOCALE from dwPatch */
+void Patch2MIDILOCALE (DWORD dwPatch, LPMIDILOCALE pLocale) {
+	memset (pLocale, 0, sizeof(MIDILOCALE));
+	
+	pLocale->ulInstrument = (dwPatch & 0x7F); /* get PC value */
+	pLocale->ulBank = ((dwPatch & 0x007F7F00) >> 8); /* get MIDI bank location */
+	pLocale->ulBank |= (dwPatch & F_INSTRUMENT_DRUMS); /* get drum bit */
+}
+
+/* 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) {
+		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)");
+	}
+}

dlls/dmusic/dmusic_private.h

@@ -419,45 +419,16 @@ typedef struct _DMUS_PRIVATE_CHUNK {
 	DWORD dwSize; /* size of the chunk */
 } DMUS_PRIVATE_CHUNK, *LPDMUS_PRIVATE_CHUNK;
 
-/* check whether the given DWORD is even (return 0) or odd (return 1) */
-static inline int even_or_odd (DWORD number) {
-	return (number & 0x1); /* basically, check if bit 0 is set ;) */
-}
+/* used for generic dumping (copied from ddraw) */
+typedef struct {
+    DWORD val;
+    const char* name;
+} flag_info;
 
-/* FOURCC to string conversion for debug messages */
-static inline 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 */
-static inline 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));
-}
-
-/* dwPatch from MIDILOCALE */
-static inline DWORD MIDILOCALE2Patch (LPMIDILOCALE pLocale) {
-	DWORD dwPatch = 0;
-	if (!pLocale) return 0;
-	dwPatch |= (pLocale->ulBank & F_INSTRUMENT_DRUMS); /* set drum bit */
-	dwPatch |= ((pLocale->ulBank & 0x00007F7F) << 8); /* set MIDI bank location */
-	dwPatch |= (pLocale->ulInstrument & 0x0000007F); /* set PC value */
-	return dwPatch;	
-}
-
-/* MIDILOCALE from dwPatch */
-static inline void Patch2MIDILOCALE (DWORD dwPatch, LPMIDILOCALE pLocale) {
-	memset (pLocale, 0, sizeof(MIDILOCALE));
-	
-	pLocale->ulInstrument = (dwPatch & 0x7F); /* get PC value */
-	pLocale->ulBank = ((dwPatch & 0x007F7F00) >> 8); /* get MIDI bank location */
-	pLocale->ulBank |= (dwPatch & F_INSTRUMENT_DRUMS); /* get drum bit */
-}
+typedef struct {
+    const GUID *guid;
+    const char* name;
+} guid_info;
 
 /* used for initialising structs (primarily for DMUS_OBJECTDESC) */
 #define DM_STRUCT_INIT(x) 				\
@@ -466,65 +437,28 @@ static inline void Patch2MIDILOCALE (DWORD dwPatch, LPMIDILOCALE pLocale) {
 		(x)->dwSize = sizeof(*x);		\
 	} while (0)
 
+#define FE(x) { x, #x }	
+#define GE(x) { &x, #x }
 
-/* used for generic dumping (copied from ddraw) */
-typedef struct {
-    DWORD val;
-    const char* name;
-} flag_info;
+/* dwPatch from MIDILOCALE */
+extern DWORD MIDILOCALE2Patch (LPMIDILOCALE pLocale);
+/* MIDILOCALE from dwPatch */
+extern void Patch2MIDILOCALE (DWORD dwPatch, LPMIDILOCALE pLocale);
 
-#define FE(x) { x, #x }
-#define DMUSIC_dump_flags(flags,names,num_names) DMUSIC_dump_flags_(flags, names, num_names, 1)
-
-/* generic dump function */
-static inline void DMUSIC_dump_flags_ (DWORD flags, const flag_info* names, size_t num_names, int newline) {
-	unsigned int i;
-	
-	for (i=0; i < num_names; i++) {
-		if ((flags & names[i].val) ||      /* standard flag value */
-		((!flags) && (!names[i].val))) /* zero value only */
-	    	DPRINTF("%s ", names[i].name);
-	}
-	
-    if (newline) DPRINTF("\n");
-}
-
-static inline void DMUSIC_dump_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)
-	};
-    DMUSIC_dump_flags(flagmask, flags, sizeof(flags)/sizeof(flags[0]));
-}
-
-static inline void DMUSIC_dump_DMUS_OBJECTDESC (LPDMUS_OBJECTDESC pDesc) {
-	if (pDesc) {
-		DPRINTF("DMUS_OBJECTDESC (%p)\n", pDesc);
-		DPRINTF("  - dwSize = %ld\n", pDesc->dwSize);
-		DPRINTF("  - dwValidData = ");
-		DMUSIC_dump_DMUS_OBJ_FLAGS (pDesc->dwValidData);
-		if (pDesc->dwValidData & DMUS_OBJ_CLASS) DPRINTF("  - guidClass = %s\n", debugstr_guid(&pDesc->guidClass));
-		if (pDesc->dwValidData & DMUS_OBJ_OBJECT) DPRINTF("  - guidObject = %s\n", debugstr_guid(&pDesc->guidObject));
-		if (pDesc->dwValidData & DMUS_OBJ_DATE) DPRINTF("  - ftDate = FIXME\n");
-		if (pDesc->dwValidData & DMUS_OBJ_VERSION) DPRINTF("  - vVersion = %s\n", debugstr_dmversion(&pDesc->vVersion));
-		if (pDesc->dwValidData & DMUS_OBJ_NAME) DPRINTF("  - wszName = %s\n", debugstr_w(pDesc->wszName));
-		if (pDesc->dwValidData & DMUS_OBJ_CATEGORY) DPRINTF("  - wszCategory = %s\n", debugstr_w(pDesc->wszCategory));
-		if (pDesc->dwValidData & DMUS_OBJ_FILENAME) DPRINTF("  - wszFileName = %s\n", debugstr_w(pDesc->wszFileName));
-		if (pDesc->dwValidData & DMUS_OBJ_MEMORY) DPRINTF("  - llMemLength = %lli\n  - pbMemData = %p\n", pDesc->llMemLength, pDesc->pbMemData);
-		if (pDesc->dwValidData & DMUS_OBJ_STREAM) DPRINTF("  - pStream = %p\n", pDesc->pStream);		
-	} else {
-		DPRINTF("(NULL)\n");
-	}
-}
+/* 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);
 
 #endif	/* __WINE_DMUSIC_PRIVATE_H */

dlls/dmusic/download.c

@@ -24,6 +24,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(dmusic);
 /* IDirectMusicDownloadImpl IUnknown part: */
 HRESULT WINAPI IDirectMusicDownloadImpl_QueryInterface (LPDIRECTMUSICDOWNLOAD iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IDirectMusicDownloadImpl,iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 
 	if (IsEqualIID (riid, &IID_IUnknown) 
 		|| IsEqualIID (riid, &IID_IDirectMusicDownload)) {
@@ -31,20 +32,20 @@ HRESULT WINAPI IDirectMusicDownloadImpl_QueryInterface (LPDIRECTMUSICDOWNLOAD if
 		*ppobj = This;
 		return S_OK;
 	}
-	WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicDownloadImpl_AddRef (LPDIRECTMUSICDOWNLOAD iface) {
 	ICOM_THIS(IDirectMusicDownloadImpl,iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicDownloadImpl_Release (LPDIRECTMUSICDOWNLOAD iface) {
 	ICOM_THIS(IDirectMusicDownloadImpl,iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}
@@ -54,7 +55,7 @@ ULONG WINAPI IDirectMusicDownloadImpl_Release (LPDIRECTMUSICDOWNLOAD iface) {
 /* IDirectMusicDownloadImpl IDirectMusicDownload part: */
 HRESULT WINAPI IDirectMusicDownloadImpl_GetBuffer (LPDIRECTMUSICDOWNLOAD iface, void** ppvBuffer, DWORD* pdwSize) {
 	ICOM_THIS(IDirectMusicDownloadImpl,iface);
-	FIXME("(%p,%p, %p): stub\n", This, ppvBuffer, pdwSize);
+	FIXME("(%p, %p, %p): stub\n", This, ppvBuffer, pdwSize);
 	return S_OK;
 }
 

dlls/dmusic/downloadedinstrument.c

@@ -24,6 +24,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(dmusic);
 /* IDirectMusicDownloadedInstrumentImpl IUnknown part: */
 HRESULT WINAPI IDirectMusicDownloadedInstrumentImpl_QueryInterface (LPDIRECTMUSICDOWNLOADEDINSTRUMENT iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IDirectMusicDownloadedInstrumentImpl,iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 
 	if (IsEqualIID (riid, &IID_IUnknown)
 		|| IsEqualIID (riid, &IID_IDirectMusicDownloadedInstrument)) {
@@ -31,20 +32,20 @@ HRESULT WINAPI IDirectMusicDownloadedInstrumentImpl_QueryInterface (LPDIRECTMUSI
 		*ppobj = This;
 		return S_OK;
 	}
-	WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicDownloadedInstrumentImpl_AddRef (LPDIRECTMUSICDOWNLOADEDINSTRUMENT iface) {
 	ICOM_THIS(IDirectMusicDownloadedInstrumentImpl,iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicDownloadedInstrumentImpl_Release (LPDIRECTMUSICDOWNLOADEDINSTRUMENT iface) {
 	ICOM_THIS(IDirectMusicDownloadedInstrumentImpl,iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}

dlls/dmusic/instrument.c

@@ -27,6 +27,7 @@ const GUID IID_IDirectMusicInstrumentPRIVATE = {0xbcb20080,0xa40c,0x11d1,{0x86,0
 /* IDirectMusicInstrument IUnknown part: */
 HRESULT WINAPI IDirectMusicInstrumentImpl_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS_MULTI(IDirectMusicInstrumentImpl, UnknownVtbl, iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 	
 	if (IsEqualIID (riid, &IID_IUnknown)) {
 		*ppobj = (LPVOID)&This->UnknownVtbl;
@@ -47,20 +48,20 @@ HRESULT WINAPI IDirectMusicInstrumentImpl_IUnknown_QueryInterface (LPUNKNOWN ifa
 		return S_OK;	
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicInstrumentImpl_IUnknown_AddRef (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicInstrumentImpl, UnknownVtbl, iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicInstrumentImpl_IUnknown_Release (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicInstrumentImpl, UnknownVtbl, iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}
@@ -403,7 +404,7 @@ HRESULT WINAPI IDirectMusicInstrumentImpl_Custom_Load (LPDIRECTMUSICINSTRUMENT i
 /*	if (TRACE_ON(dmusic)) {		
 		TRACE("*** IDirectMusicInstrument (%p) ***\n", This);
 		if (This->pInstrumentID)
-			TRACE(" - GUID = %s\n", debugstr_guid(This->pInstrumentID));
+			TRACE(" - GUID = %s\n", debugstr_dmguid(This->pInstrumentID));
 		
 		TRACE(" - Instrument header:\n");
 		TRACE("    - cRegions: %ld\n", This->pHeader->cRegions);

dlls/dmusic/port.c

@@ -24,26 +24,27 @@ WINE_DEFAULT_DEBUG_CHANNEL(dmusic);
 /* IDirectMusicPortImpl IUnknown part: */
 HRESULT WINAPI IDirectMusicPortImpl_QueryInterface (LPDIRECTMUSICPORT iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IDirectMusicPortImpl,iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 
 	if (IsEqualIID (riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IDirectMusicPort)) {
 		IDirectMusicPortImpl_AddRef(iface);
 		*ppobj = This;
 		return S_OK;
 	}
-	WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicPortImpl_AddRef (LPDIRECTMUSICPORT iface) {
 	ICOM_THIS(IDirectMusicPortImpl,iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicPortImpl_Release (LPDIRECTMUSICPORT iface) {
 	ICOM_THIS(IDirectMusicPortImpl,iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}

dlls/dmusic/portdownload.c

@@ -24,26 +24,27 @@ WINE_DEFAULT_DEBUG_CHANNEL(dmusic);
 /* IDirectMusicPortDownload IUnknown parts follow: */
 HRESULT WINAPI IDirectMusicPortDownloadImpl_QueryInterface (LPDIRECTMUSICPORTDOWNLOAD iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IDirectMusicPortDownloadImpl,iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 
 	if (IsEqualIID (riid, &IID_IUnknown) || IsEqualGUID(riid, &IID_IDirectMusicPortDownload)) {
 		IDirectMusicPortDownloadImpl_AddRef(iface);
 		*ppobj = This;
 		return S_OK;
 	}
-	WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicPortDownloadImpl_AddRef (LPDIRECTMUSICPORTDOWNLOAD iface) {
 	ICOM_THIS(IDirectMusicPortDownloadImpl,iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicPortDownloadImpl_Release (LPDIRECTMUSICPORTDOWNLOAD iface) {
 	ICOM_THIS(IDirectMusicPortDownloadImpl,iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}

dlls/dmusic/thru.c

@@ -24,6 +24,7 @@ WINE_DEFAULT_DEBUG_CHANNEL(dmusic);
 /* IDirectMusicThru IUnknown parts follow: */
 HRESULT WINAPI IDirectMusicThruImpl_QueryInterface (LPDIRECTMUSICTHRU iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IDirectMusicThruImpl,iface);
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
 
 	if (IsEqualIID (riid, &IID_IUnknown) || 
 	    IsEqualIID (riid, &IID_IDirectMusicThru)) {
@@ -31,20 +32,20 @@ HRESULT WINAPI IDirectMusicThruImpl_QueryInterface (LPDIRECTMUSICTHRU iface, REF
 		*ppobj = This;
 		return S_OK;
 	}
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicThruImpl_AddRef (LPDIRECTMUSICTHRU iface) {
 	ICOM_THIS(IDirectMusicThruImpl,iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicThruImpl_Release (LPDIRECTMUSICTHRU iface) {
 	ICOM_THIS(IDirectMusicThruImpl,iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}

dlls/dswave/dswave.c

@@ -21,6 +21,10 @@
 
 WINE_DEFAULT_DEBUG_CHANNEL(dswave);
 WINE_DECLARE_DEBUG_CHANNEL(dmfile);
+										 
+/* an interface that is, according to my tests, obtained by loader after loading object; is it acting
+   as some sort of bridge between object and loader? */
+const GUID IID_IDirectMusicWavePRIVATE = {0x69e934e4,0x97f1,0x4f1d,{0x88,0xe8,0xf2,0xac,0x88,0x67,0x13,0x27}};
 
 /*****************************************************************************
  * IDirectMusicWaveImpl implementation
@@ -29,10 +33,18 @@ WINE_DECLARE_DEBUG_CHANNEL(dmfile);
 HRESULT WINAPI IDirectMusicWaveImpl_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS_MULTI(IDirectMusicWaveImpl, UnknownVtbl, iface);
 	
+	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ppobj);
+
 	if (IsEqualIID (riid, &IID_IUnknown)) {
 		*ppobj = (LPVOID)&This->UnknownVtbl;
 		IDirectMusicWaveImpl_IUnknown_AddRef ((LPUNKNOWN)&This->UnknownVtbl);
-		return S_OK;	
+		return S_OK;
+	} else if (IsEqualIID (riid, &IID_IDirectMusicSegment)
+	|| IsEqualIID (riid, &IID_IDirectMusicSegment2)
+	|| IsEqualIID (riid, &IID_IDirectMusicSegment8)) {
+		*ppobj = (LPVOID)&This->SegmentVtbl;
+		IDirectMusicWaveImpl_IDirectMusicSegment8_AddRef ((LPDIRECTMUSICSEGMENT8)&This->SegmentVtbl);
+		return S_OK;
 	} else if (IsEqualIID (riid, &IID_IDirectMusicObject)) {
 		*ppobj = (LPVOID)&This->ObjectVtbl;
 		IDirectMusicWaveImpl_IDirectMusicObject_AddRef ((LPDIRECTMUSICOBJECT)&This->ObjectVtbl);		
@@ -41,22 +53,25 @@ HRESULT WINAPI IDirectMusicWaveImpl_IUnknown_QueryInterface (LPUNKNOWN iface, RE
 		*ppobj = (LPVOID)&This->PersistStreamVtbl;
 		IDirectMusicWaveImpl_IPersistStream_AddRef ((LPPERSISTSTREAM)&This->PersistStreamVtbl);		
 		return S_OK;
+	} else if (IsEqualIID (riid, &IID_IDirectMusicWavePRIVATE)) {
+		WARN(": requested private interface, expect crash\n");
+		return E_NOINTERFACE;
 	}
 	
-	WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
+	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
 ULONG WINAPI IDirectMusicWaveImpl_IUnknown_AddRef (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicWaveImpl, UnknownVtbl, iface);
-	TRACE("(%p) : AddRef from %ld\n", This, This->ref);
+	TRACE("(%p): AddRef from %ld\n", This, This->ref);
 	return ++(This->ref);
 }
 
 ULONG WINAPI IDirectMusicWaveImpl_IUnknown_Release (LPUNKNOWN iface) {
 	ICOM_THIS_MULTI(IDirectMusicWaveImpl, UnknownVtbl, iface);
 	ULONG ref = --This->ref;
-	TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
+	TRACE("(%p): ReleaseRef to %ld\n", This, This->ref);
 	if (ref == 0) {
 		HeapFree(GetProcessHeap(), 0, This);
 	}
@@ -70,6 +85,225 @@ ICOM_VTABLE(IUnknown) DirectMusicWave_Unknown_Vtbl = {
 	IDirectMusicWaveImpl_IUnknown_Release
 };
 
+/* IDirectMusicSegment8Impl IDirectMusicSegment part: */
+HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_QueryInterface (LPDIRECTMUSICSEGMENT8 iface, REFIID riid, LPVOID *ppobj) {
+	ICOM_THIS_MULTI(IDirectMusicWaveImpl, SegmentVtbl, iface);
+	return IDirectMusicWaveImpl_IUnknown_QueryInterface ((LPUNKNOWN)&This->UnknownVtbl, riid, ppobj);
+}
+
+ULONG WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_AddRef (LPDIRECTMUSICSEGMENT8 iface) {
+	ICOM_THIS_MULTI(IDirectMusicWaveImpl, SegmentVtbl, iface);
+	return IDirectMusicWaveImpl_IUnknown_AddRef ((LPUNKNOWN)&This->UnknownVtbl);
+}
+
+ULONG WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_Release (LPDIRECTMUSICSEGMENT8 iface) {
+	ICOM_THIS_MULTI(IDirectMusicWaveImpl, SegmentVtbl, iface);
+	return IDirectMusicWaveImpl_IUnknown_Release ((LPUNKNOWN)&This->UnknownVtbl);
+}
+
+HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_GetLength (LPDIRECTMUSICSEGMENT8 iface, MUSIC_TIME* pmtLength) {
+	ICOM_THIS_MULTI(IDirectMusicWaveImpl, SegmentVtbl, iface);
+	FIXME("(%p, %p): stub\n", This, pmtLength);
+	return S_OK;
+}
+
+HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_SetLength (LPDIRECTMUSICSEGMENT8 iface, MUSIC_TIME mtLength) {
+	ICOM_THIS_MULTI(IDirectMusicWaveImpl, SegmentVtbl, iface);
+	FIXME("(%p, %ld): stub\n", This, mtLength);
+	return S_OK;
+}
+
+HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_GetRepeats (LPDIRECTMUSICSEGMENT8 iface, DWORD* pdwRepeats) { 
+	ICOM_THIS_MULTI(IDirectMusicWaveImpl, SegmentVtbl, iface);
+	FIXME("(%p, %p): stub\n", This, pdwRepeats);
+	return S_OK;
+}
+
+HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_SetRepeats (LPDIRECTMUSICSEGMENT8 iface, DWORD dwRepeats) {
+	ICOM_THIS_MULTI(IDirectMusicWaveImpl, SegmentVtbl, iface);
+	FIXME("(%p, %ld): stub\n", This, dwRepeats);	
+	return S_OK;
+}
+
+HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_GetDefaultResolution (LPDIRECTMUSICSEGMENT8 iface, DWORD* pdwResolution) {
+	ICOM_THIS_MULTI(IDirectMusicWaveImpl, SegmentVtbl, iface);
+	FIXME("(%p, %p): stub\n", This, pdwResolution);
+	return S_OK;
+}
+
+HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_SetDefaultResolution (LPDIRECTMUSICSEGMENT8 iface, DWORD dwResolution) {
+	ICOM_THIS_MULTI(IDirectMusicWaveImpl, SegmentVtbl, iface);
+	FIXME("(%p, %ld): stub\n", This, dwResolution);
+	return S_OK;
+}
+
+HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_GetTrack (LPDIRECTMUSICSEGMENT8 iface, REFGUID rguidType, DWORD dwGroupBits, DWORD dwIndex, IDirectMusicTrack** ppTrack) {
+	ICOM_THIS_MULTI(IDirectMusicWaveImpl, SegmentVtbl, iface);
+	FIXME("(%p, %s, %ld, %ld, %p): stub\n", This, debugstr_dmguid(rguidType), dwGroupBits, dwIndex, ppTrack);
+	return S_OK;
+}
+
+HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_GetTrackGroup (LPDIRECTMUSICSEGMENT8 iface, IDirectMusicTrack* pTrack, DWORD* pdwGroupBits) {
+	ICOM_THIS_MULTI(IDirectMusicWaveImpl, SegmentVtbl, iface);
+	FIXME("(%p, %p, %p): stub\n", This, pTrack, pdwGroupBits);
+	return S_OK;
+}
+
+HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_InsertTrack (LPDIRECTMUSICSEGMENT8 iface, IDirectMusicTrack* pTrack, DWORD dwGroupBits) {
+	ICOM_THIS_MULTI(IDirectMusicWaveImpl, SegmentVtbl, iface);
+	FIXME("(%p, %p, %ld): stub\n", This, pTrack, dwGroupBits);
+	return S_OK;
+}
+
+HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_RemoveTrack (LPDIRECTMUSICSEGMENT8 iface, IDirectMusicTrack* pTrack) {
+	ICOM_THIS_MULTI(IDirectMusicWaveImpl, SegmentVtbl, iface);
+	FIXME("(%p, %p): stub\n", This, pTrack);
+	return S_OK;
+}
+
+HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_InitPlay (LPDIRECTMUSICSEGMENT8 iface, IDirectMusicSegmentState** ppSegState, IDirectMusicPerformance* pPerformance, DWORD dwFlags) {
+	ICOM_THIS_MULTI(IDirectMusicWaveImpl, SegmentVtbl, iface);
+	FIXME("(%p, %p, %p, %ld): stub\n", This, ppSegState, pPerformance, dwFlags);
+	return S_OK;
+}
+
+HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_GetGraph (LPDIRECTMUSICSEGMENT8 iface, IDirectMusicGraph** ppGraph) {
+	ICOM_THIS_MULTI(IDirectMusicWaveImpl, SegmentVtbl, iface);
+	FIXME("(%p, %p): stub\n", This, ppGraph);
+	return S_OK;
+}
+
+HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_SetGraph (LPDIRECTMUSICSEGMENT8 iface, IDirectMusicGraph* pGraph) {
+	ICOM_THIS_MULTI(IDirectMusicWaveImpl, SegmentVtbl, iface);
+	FIXME("(%p, %p): stub\n", This, pGraph);
+	return S_OK;
+}
+
+HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_AddNotificationType (LPDIRECTMUSICSEGMENT8 iface, REFGUID rguidNotificationType) {
+	ICOM_THIS_MULTI(IDirectMusicWaveImpl, SegmentVtbl, iface);
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
+	return S_OK;
+}
+
+HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_RemoveNotificationType (LPDIRECTMUSICSEGMENT8 iface, REFGUID rguidNotificationType) {
+	ICOM_THIS_MULTI(IDirectMusicWaveImpl, SegmentVtbl, iface);
+	FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
+	return S_OK;
+}
+
+HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_GetParam (LPDIRECTMUSICSEGMENT8 iface, REFGUID rguidType, DWORD dwGroupBits, DWORD dwIndex, MUSIC_TIME mtTime, MUSIC_TIME* pmtNext, void* pParam) {
+	ICOM_THIS_MULTI(IDirectMusicWaveImpl, SegmentVtbl, iface);
+	FIXME("(%p, %s, %ld, %ld, %ld, %p, %p): stub\n", This, debugstr_dmguid(rguidType), dwGroupBits, dwIndex, mtTime, pmtNext, pParam);
+	return S_OK;
+}
+
+HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_SetParam (LPDIRECTMUSICSEGMENT8 iface, REFGUID rguidType, DWORD dwGroupBits, DWORD dwIndex, MUSIC_TIME mtTime, void* pParam) {
+	ICOM_THIS_MULTI(IDirectMusicWaveImpl, SegmentVtbl, iface);
+	FIXME("(%p, %s, %ld, %ld, %ld, %p): stub\n", This, debugstr_dmguid(rguidType), dwGroupBits, dwIndex, mtTime, pParam);
+	return S_OK;
+}
+
+HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_Clone (LPDIRECTMUSICSEGMENT8 iface, MUSIC_TIME mtStart, MUSIC_TIME mtEnd, IDirectMusicSegment** ppSegment) {
+	ICOM_THIS_MULTI(IDirectMusicWaveImpl, SegmentVtbl, iface);
+	FIXME("(%p, %ld, %ld, %p): stub\n", This, mtStart, mtEnd, ppSegment);
+	return S_OK;
+}
+
+HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_SetStartPoint (LPDIRECTMUSICSEGMENT8 iface, MUSIC_TIME mtStart) {
+	ICOM_THIS_MULTI(IDirectMusicWaveImpl, SegmentVtbl, iface);
+	FIXME("(%p, %ld): stub\n", This, mtStart);
+	return S_OK;
+}
+
+HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_GetStartPoint (LPDIRECTMUSICSEGMENT8 iface, MUSIC_TIME* pmtStart) {
+	ICOM_THIS_MULTI(IDirectMusicWaveImpl, SegmentVtbl, iface);
+	FIXME("(%p, %p): stub\n", This, pmtStart);
+	return S_OK;
+}
+
+HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_SetLoopPoints (LPDIRECTMUSICSEGMENT8 iface, MUSIC_TIME mtStart, MUSIC_TIME mtEnd) {
+	ICOM_THIS_MULTI(IDirectMusicWaveImpl, SegmentVtbl, iface);
+	FIXME("(%p, %ld, %ld): stub\n", This, mtStart, mtEnd);
+	return S_OK;
+}
+
+HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_GetLoopPoints (LPDIRECTMUSICSEGMENT8 iface, MUSIC_TIME* pmtStart, MUSIC_TIME* pmtEnd) {
+	ICOM_THIS_MULTI(IDirectMusicWaveImpl, SegmentVtbl, iface);
+	FIXME("(%p, %p, %p): stub\n", This, pmtStart, pmtEnd);
+	return S_OK;
+}
+
+HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_SetPChannelsUsed (LPDIRECTMUSICSEGMENT8 iface, DWORD dwNumPChannels, DWORD* paPChannels) {
+	ICOM_THIS_MULTI(IDirectMusicWaveImpl, SegmentVtbl, iface);
+	FIXME("(%p, %ld, %p): stub\n", This, dwNumPChannels, paPChannels);	
+	return S_OK;
+}
+
+HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_SetTrackConfig (LPDIRECTMUSICSEGMENT8 iface, REFGUID rguidTrackClassID, DWORD dwGroupBits, DWORD dwIndex, DWORD dwFlagsOn, DWORD dwFlagsOff) {
+	ICOM_THIS_MULTI(IDirectMusicWaveImpl, SegmentVtbl, iface);
+	FIXME("(%p, %s, %ld, %ld, %ld, %ld): stub\n", This, debugstr_dmguid(rguidTrackClassID), dwGroupBits, dwIndex, dwFlagsOn, dwFlagsOff);
+	return S_OK;
+}
+
+HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_GetAudioPathConfig (LPDIRECTMUSICSEGMENT8 iface, IUnknown** ppAudioPathConfig){
+	ICOM_THIS_MULTI(IDirectMusicWaveImpl, SegmentVtbl, iface);
+	FIXME("(%p, %p): stub\n", This, ppAudioPathConfig);
+	return S_OK;
+}
+
+HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_Compose (LPDIRECTMUSICSEGMENT8 iface, MUSIC_TIME mtTime, IDirectMusicSegment* pFromSegment, IDirectMusicSegment* pToSegment, IDirectMusicSegment** ppComposedSegment) {
+	ICOM_THIS_MULTI(IDirectMusicWaveImpl, SegmentVtbl, iface);
+	FIXME("(%p, %ld, %p, %p, %p): stub\n", This, mtTime, pFromSegment, pToSegment, ppComposedSegment);
+	return S_OK;
+}
+
+HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_Download (LPDIRECTMUSICSEGMENT8 iface, IUnknown *pAudioPath) {
+	ICOM_THIS_MULTI(IDirectMusicWaveImpl, SegmentVtbl, iface);
+	FIXME("(%p, %p): stub\n", This, pAudioPath);
+	return S_OK;
+}
+
+HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_Unload (LPDIRECTMUSICSEGMENT8 iface, IUnknown *pAudioPath) {
+	ICOM_THIS_MULTI(IDirectMusicWaveImpl, SegmentVtbl, iface);
+	FIXME("(%p, %p): stub\n", This, pAudioPath);
+	return S_OK;
+}
+
+ICOM_VTABLE(IDirectMusicSegment8) DirectMusicSegment8_Segment_Vtbl = {
+    ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
+	IDirectMusicWaveImpl_IDirectMusicSegment8_QueryInterface,
+	IDirectMusicWaveImpl_IDirectMusicSegment8_AddRef,
+	IDirectMusicWaveImpl_IDirectMusicSegment8_Release,
+	IDirectMusicWaveImpl_IDirectMusicSegment8_GetLength,
+	IDirectMusicWaveImpl_IDirectMusicSegment8_SetLength,
+	IDirectMusicWaveImpl_IDirectMusicSegment8_GetRepeats,
+	IDirectMusicWaveImpl_IDirectMusicSegment8_SetRepeats,
+	IDirectMusicWaveImpl_IDirectMusicSegment8_GetDefaultResolution,
+	IDirectMusicWaveImpl_IDirectMusicSegment8_SetDefaultResolution,
+	IDirectMusicWaveImpl_IDirectMusicSegment8_GetTrack,
+	IDirectMusicWaveImpl_IDirectMusicSegment8_GetTrackGroup,
+	IDirectMusicWaveImpl_IDirectMusicSegment8_InsertTrack,
+	IDirectMusicWaveImpl_IDirectMusicSegment8_RemoveTrack,
+	IDirectMusicWaveImpl_IDirectMusicSegment8_InitPlay,
+	IDirectMusicWaveImpl_IDirectMusicSegment8_GetGraph,
+	IDirectMusicWaveImpl_IDirectMusicSegment8_SetGraph,
+	IDirectMusicWaveImpl_IDirectMusicSegment8_AddNotificationType,
+	IDirectMusicWaveImpl_IDirectMusicSegment8_RemoveNotificationType,
+	IDirectMusicWaveImpl_IDirectMusicSegment8_GetParam,
+	IDirectMusicWaveImpl_IDirectMusicSegment8_SetParam,
+	IDirectMusicWaveImpl_IDirectMusicSegment8_Clone,
+	IDirectMusicWaveImpl_IDirectMusicSegment8_SetStartPoint,
+	IDirectMusicWaveImpl_IDirectMusicSegment8_GetStartPoint,
+	IDirectMusicWaveImpl_IDirectMusicSegment8_SetLoopPoints,
+	IDirectMusicWaveImpl_IDirectMusicSegment8_GetLoopPoints,
+	IDirectMusicWaveImpl_IDirectMusicSegment8_SetPChannelsUsed,
+	IDirectMusicWaveImpl_IDirectMusicSegment8_SetTrackConfig,
+	IDirectMusicWaveImpl_IDirectMusicSegment8_GetAudioPathConfig,
+	IDirectMusicWaveImpl_IDirectMusicSegment8_Compose,
+	IDirectMusicWaveImpl_IDirectMusicSegment8_Download,
+	IDirectMusicWaveImpl_IDirectMusicSegment8_Unload
+};
+
 /* IDirectMusicWaveImpl IDirectMusicObject part: */
 HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicObject_QueryInterface (LPDIRECTMUSICOBJECT iface, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS_MULTI(IDirectMusicWaveImpl, ObjectVtbl, iface);
@@ -96,10 +330,7 @@ HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicObject_GetDescriptor (LPDIRECTMU
 
 HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicObject_SetDescriptor (LPDIRECTMUSICOBJECT iface, LPDMUS_OBJECTDESC pDesc) {
 	ICOM_THIS_MULTI(IDirectMusicWaveImpl, ObjectVtbl, iface);
-	TRACE("(%p, %p): setting descriptor:\n", This, pDesc);
-	if (TRACE_ON(dswave)) {
-		DMUSIC_dump_DMUS_OBJECTDESC (pDesc);
-	}
+	TRACE("(%p, %p, %s): setting descriptor:\n", This, pDesc, debugstr_DMUS_OBJECTDESC(pDesc));
 	
 	/* According to MSDN, we should copy only given values, not whole struct */	
 	if (pDesc->dwValidData & DMUS_OBJ_OBJECT)
@@ -274,10 +505,7 @@ HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicObject_ParseDescriptor (LPDIRECT
 		}
 	}	
 	
-	TRACE(": returning descriptor:\n");
-	if (TRACE_ON(dswave)) {
-		DMUSIC_dump_DMUS_OBJECTDESC (pDesc);
-	}
+	TRACE(": returning descriptor: %s\n", debugstr_DMUS_OBJECTDESC (pDesc));
 	
 	return S_OK;	
 }
@@ -318,7 +546,149 @@ HRESULT WINAPI IDirectMusicWaveImpl_IPersistStream_IsDirty (LPPERSISTSTREAM ifac
 
 HRESULT WINAPI IDirectMusicWaveImpl_IPersistStream_Load (LPPERSISTSTREAM iface, IStream* pStm) {
 	ICOM_THIS_MULTI(IDirectMusicWaveImpl, PersistStreamVtbl, iface);
-	FIXME("(%p, %p): loading not implemented yet\n", This, pStm);
+	
+	DMUS_PRIVATE_CHUNK Chunk;
+	DWORD StreamSize, StreamCount, ListSize[1], ListCount[1];
+	LARGE_INTEGER liMove; /* used when skipping chunks */
+
+	FIXME("(%p, %p): loading not implemented yet (only descriptor is loaded)\n", This, pStm);
+	
+	/* FIXME: should this be determined from stream? */
+	This->pDesc->dwValidData |= DMUS_OBJ_CLASS;
+	memcpy (&This->pDesc->guidClass, &CLSID_DirectMusicSegment, sizeof(CLSID));
+	
+	IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
+	TRACE_(dmfile)(": %s chunk (size = 0x%04lx)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
+	switch (Chunk.fccID) {	
+		case FOURCC_RIFF: {
+			IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL);				
+			TRACE_(dmfile)(": RIFF chunk of type %s", debugstr_fourcc(Chunk.fccID));
+			StreamSize = Chunk.dwSize - sizeof(FOURCC);
+			StreamCount = 0;
+			if (Chunk.fccID == mmioFOURCC('W','A','V','E')) {
+				TRACE_(dmfile)(": wave form\n");
+				do {
+					IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
+					StreamCount += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
+					TRACE_(dmfile)(": %s chunk (size = 0x%04lx)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
+					switch (Chunk.fccID) {
+						case DMUS_FOURCC_GUID_CHUNK: {
+							TRACE_(dmfile)(": GUID chunk\n");
+							This->pDesc->dwValidData |= DMUS_OBJ_OBJECT;
+							IStream_Read (pStm, &This->pDesc->guidObject, Chunk.dwSize, NULL);
+							break;
+						}
+						case DMUS_FOURCC_VERSION_CHUNK: {
+							TRACE_(dmfile)(": version chunk\n");
+							This->pDesc->dwValidData |= DMUS_OBJ_VERSION;
+							IStream_Read (pStm, &This->pDesc->vVersion, Chunk.dwSize, NULL);
+							break;
+						}
+						case DMUS_FOURCC_CATEGORY_CHUNK: {
+							TRACE_(dmfile)(": category chunk\n");
+							This->pDesc->dwValidData |= DMUS_OBJ_CATEGORY;
+							IStream_Read (pStm, This->pDesc->wszCategory, Chunk.dwSize, 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[0] = Chunk.dwSize - sizeof(FOURCC);
+							ListCount[0] = 0;
+							switch (Chunk.fccID) {
+								/* evil M$ UNFO list, which can (!?) contain INFO elements */
+								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 = 0x%04lx)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
+										switch (Chunk.fccID) {
+											/* 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, Chunk.dwSize, NULL);
+												break;
+											}
+											case mmioFOURCC('I','A','R','T'):
+											case DMUS_FOURCC_UART_CHUNK: {
+												TRACE_(dmfile)(": artist chunk (ignored)\n");
+												liMove.QuadPart = Chunk.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 = Chunk.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 = Chunk.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 = Chunk.dwSize;
+												IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
+												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]);
+									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);
+				break;
+			} else {
+				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 = Chunk.dwSize;
+			IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); /* skip the rest of the chunk */
+			return DMUS_E_INVALIDFILE;
+		}
+	}
+	
 	return S_OK;
 }
 

dlls/dswave/dswave_main.c

@@ -17,6 +17,8 @@
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  */
 
+#include <stdio.h>
+
 #include "dswave_private.h"
 
 WINE_DEFAULT_DEBUG_CHANNEL(dswave);
@@ -32,7 +34,7 @@ typedef struct {
  */
 static HRESULT WINAPI WaveCF_QueryInterface(LPCLASSFACTORY iface,REFIID riid,LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%s,%p),stub!\n",This,debugstr_guid(riid),ppobj);
+	FIXME("(%p, %s, %p): stub\n", This, debugstr_dmguid(riid), ppobj);
 	return E_NOINTERFACE;
 }
 
@@ -49,13 +51,13 @@ static ULONG WINAPI WaveCF_Release(LPCLASSFACTORY iface) {
 
 static HRESULT WINAPI WaveCF_CreateInstance(LPCLASSFACTORY iface, LPUNKNOWN pOuter, REFIID riid, LPVOID *ppobj) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	TRACE ("(%p)->(%p,%s,%p)\n", This, pOuter, debugstr_guid(riid), ppobj);
+	TRACE ("(%p, %p, %s, %p)\n", This, pOuter, debugstr_dmguid(riid), ppobj);
 	return DMUSIC_CreateDirectMusicWaveImpl (riid, ppobj, pOuter);
 }
 
 static HRESULT WINAPI WaveCF_LockServer(LPCLASSFACTORY iface,BOOL dolock) {
 	ICOM_THIS(IClassFactoryImpl,iface);
-	FIXME("(%p)->(%d),stub!\n", This, dolock);
+	FIXME("(%p, %d): stub\n", This, dolock);
 	return S_OK;
 }
 
@@ -104,13 +106,421 @@ HRESULT WINAPI DSWAVE_DllCanUnloadNow(void) {
  *
  */
 HRESULT WINAPI DSWAVE_DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID *ppv) {
-	TRACE("(%p,%p,%p)\n", debugstr_guid(rclsid), debugstr_guid(riid), ppv);
+	TRACE("(%s, %s, %p)\n", debugstr_dmguid(rclsid), debugstr_dmguid(riid), ppv);
 	if (IsEqualCLSID (rclsid, &CLSID_DirectSoundWave) && IsEqualIID (riid, &IID_IClassFactory)) {
 		*ppv = (LPVOID) &Wave_CF;
 		IClassFactory_AddRef((IClassFactory*)*ppv);
 		return S_OK;
 	}
 	
-    WARN("(%p,%p,%p): no interface found.\n", debugstr_guid(rclsid), debugstr_guid(riid), 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) {
+		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)");
+	}
+}

dlls/dswave/dswave_private.h

@@ -49,6 +49,7 @@ typedef struct IDirectMusicWaveImpl IDirectMusicWaveImpl;
 extern ICOM_VTABLE(IUnknown)               DirectMusicWave_Unknown_Vtbl;
 extern ICOM_VTABLE(IDirectMusicObject)     DirectMusicWave_Object_Vtbl;
 extern ICOM_VTABLE(IPersistStream)         DirectMusicWave_PersistStream_Vtbl;
+extern ICOM_VTABLE(IDirectMusicSegment8)   DirectMusicWave_Segment_Vtbl;
 
 
 /*****************************************************************************
@@ -63,6 +64,7 @@ extern HRESULT WINAPI DMUSIC_CreateDirectMusicWaveImpl (LPCGUID lpcGUID, LPVOID*
 struct IDirectMusicWaveImpl {
   /* IUnknown fields */
   ICOM_VTABLE(IUnknown) *UnknownVtbl;
+  ICOM_VTABLE(IDirectMusicSegment8) *SegmentVtbl;
   ICOM_VTABLE(IDirectMusicObject) *ObjectVtbl;
   ICOM_VTABLE(IPersistStream) *PersistStreamVtbl;
   DWORD          ref;
@@ -76,6 +78,38 @@ struct IDirectMusicWaveImpl {
 extern HRESULT WINAPI IDirectMusicWaveImpl_IUnknown_QueryInterface (LPUNKNOWN iface, REFIID riid, LPVOID *ppobj);
 extern ULONG WINAPI   IDirectMusicWaveImpl_IUnknown_AddRef (LPUNKNOWN iface);
 extern ULONG WINAPI   IDirectMusicWaveImpl_IUnknown_Release (LPUNKNOWN iface);
+/* IDirectMusicSegment(8): */
+extern HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_QueryInterface (LPDIRECTMUSICSEGMENT8 iface, REFIID riid, LPVOID *ppobj);
+extern ULONG WINAPI   IDirectMusicWaveImpl_IDirectMusicSegment8_AddRef (LPDIRECTMUSICSEGMENT8 iface);
+extern ULONG WINAPI   IDirectMusicWaveImpl_IDirectMusicSegment8_Release (LPDIRECTMUSICSEGMENT8 iface);
+extern HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_GetLength (LPDIRECTMUSICSEGMENT8 iface, MUSIC_TIME* pmtLength);
+extern HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_SetLength (LPDIRECTMUSICSEGMENT8 iface, MUSIC_TIME mtLength);
+extern HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_GetRepeats (LPDIRECTMUSICSEGMENT8 iface, DWORD* pdwRepeats);
+extern HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_SetRepeats (LPDIRECTMUSICSEGMENT8 iface, DWORD dwRepeats);
+extern HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_GetDefaultResolution (LPDIRECTMUSICSEGMENT8 iface, DWORD* pdwResolution);
+extern HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_SetDefaultResolution (LPDIRECTMUSICSEGMENT8 iface, DWORD dwResolution);
+extern HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_GetTrack (LPDIRECTMUSICSEGMENT8 iface, REFGUID rguidType, DWORD dwGroupBits, DWORD dwIndex, IDirectMusicTrack** ppTrack);
+extern HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_GetTrackGroup (LPDIRECTMUSICSEGMENT8 iface, IDirectMusicTrack* pTrack, DWORD* pdwGroupBits);
+extern HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_InsertTrack (LPDIRECTMUSICSEGMENT8 iface, IDirectMusicTrack* pTrack, DWORD dwGroupBits);
+extern HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_RemoveTrack (LPDIRECTMUSICSEGMENT8 iface, IDirectMusicTrack* pTrack);
+extern HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_InitPlay (LPDIRECTMUSICSEGMENT8 iface, IDirectMusicSegmentState** ppSegState, IDirectMusicPerformance* pPerformance, DWORD dwFlags);
+extern HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_GetGraph (LPDIRECTMUSICSEGMENT8 iface, IDirectMusicGraph** ppGraph);
+extern HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_SetGraph (LPDIRECTMUSICSEGMENT8 iface, IDirectMusicGraph* pGraph);
+extern HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_AddNotificationType (LPDIRECTMUSICSEGMENT8 iface, REFGUID rguidNotificationType);
+extern HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_RemoveNotificationType (LPDIRECTMUSICSEGMENT8 iface, REFGUID rguidNotificationType);
+extern HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_GetParam (LPDIRECTMUSICSEGMENT8 iface, REFGUID rguidType, DWORD dwGroupBits, DWORD dwIndex, MUSIC_TIME mtTime, MUSIC_TIME* pmtNext, void* pParam);
+extern HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_SetParam (LPDIRECTMUSICSEGMENT8 iface, REFGUID rguidType, DWORD dwGroupBits, DWORD dwIndex, MUSIC_TIME mtTime, void* pParam);
+extern HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_Clone (LPDIRECTMUSICSEGMENT8 iface, MUSIC_TIME mtStart, MUSIC_TIME mtEnd, IDirectMusicSegment** ppSegment);
+extern HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_SetStartPoint (LPDIRECTMUSICSEGMENT8 iface, MUSIC_TIME mtStart);
+extern HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_GetStartPoint (LPDIRECTMUSICSEGMENT8 iface, MUSIC_TIME* pmtStart);
+extern HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_SetLoopPoints (LPDIRECTMUSICSEGMENT8 iface, MUSIC_TIME mtStart, MUSIC_TIME mtEnd);
+extern HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_GetLoopPoints (LPDIRECTMUSICSEGMENT8 iface, MUSIC_TIME* pmtStart, MUSIC_TIME* pmtEnd);
+extern HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_SetPChannelsUsed (LPDIRECTMUSICSEGMENT8 iface, DWORD dwNumPChannels, DWORD* paPChannels);
+extern HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_SetTrackConfig (LPDIRECTMUSICSEGMENT8 iface, REFGUID rguidTrackClassID, DWORD dwGroupBits, DWORD dwIndex, DWORD dwFlagsOn, DWORD dwFlagsOff);
+extern HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_GetAudioPathConfig (LPDIRECTMUSICSEGMENT8 iface, IUnknown** ppAudioPathConfig);
+extern HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_Compose (LPDIRECTMUSICSEGMENT8 iface, MUSIC_TIME mtTime, IDirectMusicSegment* pFromSegment, IDirectMusicSegment* pToSegment, IDirectMusicSegment** ppComposedSegment);
+extern HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_Download (LPDIRECTMUSICSEGMENT8 iface, IUnknown *pAudioPath);
+extern HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicSegment8_Unload (LPDIRECTMUSICSEGMENT8 iface, IUnknown *pAudioPath);
 /* IDirectMusicObject: */
 extern HRESULT WINAPI IDirectMusicWaveImpl_IDirectMusicObject_QueryInterface (LPDIRECTMUSICOBJECT iface, REFIID riid, LPVOID *ppobj);
 extern ULONG WINAPI   IDirectMusicWaveImpl_IDirectMusicObject_AddRef (LPDIRECTMUSICOBJECT iface);
@@ -103,26 +137,16 @@ typedef struct _DMUS_PRIVATE_CHUNK {
 	DWORD dwSize; /* size of the chunk */
 } DMUS_PRIVATE_CHUNK, *LPDMUS_PRIVATE_CHUNK;
 
-/* check whether the given DWORD is even (return 0) or odd (return 1) */
-static inline int even_or_odd (DWORD number) {
-	return (number & 0x1); /* basically, check if bit 0 is set ;) */
-}
+/* used for generic dumping (copied from ddraw) */
+typedef struct {
+    DWORD val;
+    const char* name;
+} flag_info;
 
-/* FOURCC to string conversion for debug messages */
-static inline 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 */
-static inline 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));
-}
+typedef struct {
+    const GUID *guid;
+    const char* name;
+} guid_info;
 
 /* used for initialising structs (primarily for DMUS_OBJECTDESC) */
 #define DM_STRUCT_INIT(x) 				\
@@ -131,65 +155,23 @@ static inline const char *debugstr_dmversion (LPDMUS_VERSION version) {
 		(x)->dwSize = sizeof(*x);		\
 	} while (0)
 
+#define FE(x) { x, #x }	
+#define GE(x) { &x, #x }
 
-/* used for generic dumping (copied from ddraw) */
-typedef struct {
-    DWORD val;
-    const char* name;
-} flag_info;
-
-#define FE(x) { x, #x }
-#define DMUSIC_dump_flags(flags,names,num_names) DMUSIC_dump_flags_(flags, names, num_names, 1)
-
-/* generic dump function */
-static inline void DMUSIC_dump_flags_ (DWORD flags, const flag_info* names, size_t num_names, int newline) {
-	unsigned int i;
-	
-	for (i=0; i < num_names; i++) {
-		if ((flags & names[i].val) ||      /* standard flag value */
-		((!flags) && (!names[i].val))) /* zero value only */
-	    	DPRINTF("%s ", names[i].name);
-	}
-	
-    if (newline) DPRINTF("\n");
-}
-
-static inline void DMUSIC_dump_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)
-	};
-    DMUSIC_dump_flags(flagmask, flags, sizeof(flags)/sizeof(flags[0]));
-}
-
-static inline void DMUSIC_dump_DMUS_OBJECTDESC (LPDMUS_OBJECTDESC pDesc) {
-	if (pDesc) {
-		DPRINTF("DMUS_OBJECTDESC (%p)\n", pDesc);
-		DPRINTF("  - dwSize = %ld\n", pDesc->dwSize);
-		DPRINTF("  - dwValidData = ");
-		DMUSIC_dump_DMUS_OBJ_FLAGS (pDesc->dwValidData);
-		if (pDesc->dwValidData & DMUS_OBJ_CLASS) DPRINTF("  - guidClass = %s\n", debugstr_guid(&pDesc->guidClass));
-		if (pDesc->dwValidData & DMUS_OBJ_OBJECT) DPRINTF("  - guidObject = %s\n", debugstr_guid(&pDesc->guidObject));
-		if (pDesc->dwValidData & DMUS_OBJ_DATE) DPRINTF("  - ftDate = FIXME\n");
-		if (pDesc->dwValidData & DMUS_OBJ_VERSION) DPRINTF("  - vVersion = %s\n", debugstr_dmversion(&pDesc->vVersion));
-		if (pDesc->dwValidData & DMUS_OBJ_NAME) DPRINTF("  - wszName = %s\n", debugstr_w(pDesc->wszName));
-		if (pDesc->dwValidData & DMUS_OBJ_CATEGORY) DPRINTF("  - wszCategory = %s\n", debugstr_w(pDesc->wszCategory));
-		if (pDesc->dwValidData & DMUS_OBJ_FILENAME) DPRINTF("  - wszFileName = %s\n", debugstr_w(pDesc->wszFileName));
-		if (pDesc->dwValidData & DMUS_OBJ_MEMORY) DPRINTF("  - llMemLength = %lli\n  - pbMemData = %p\n", pDesc->llMemLength, pDesc->pbMemData);
-		if (pDesc->dwValidData & DMUS_OBJ_STREAM) DPRINTF("  - pStream = %p\n", pDesc->pStream);		
-	} else {
-		DPRINTF("(NULL)\n");
-	}
-}
+/* 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);
 
 #endif	/* __WINE_DSWAVE_PRIVATE_H */

include/dmusici.h

@@ -67,7 +67,7 @@ DEFINE_GUID(CLSID_DirectMusicTemplate,                     0xd30bcc65,0x60e8,0x1
 DEFINE_GUID(CLSID_DirectMusicScriptAutoImpSegment,         0x4062c116,0x0270,0x11d3,0x8b,0xcb,0x00,0x60,0x08,0x93,0xb1,0xb6);
 DEFINE_GUID(CLSID_AudioVBScript,                           0x4ee17959,0x931e,0x49e4,0xa2,0xc6,0x97,0x7e,0xcf,0x36,0x28,0xf3);
 DEFINE_GUID(CLSID_DirectMusicScriptAutoImpPerformance,     0xa861c6e2,0xfcfc,0x11d2,0x8b,0xc9,0x00,0x60,0x08,0x93,0xb1,0xb6);
-DEFINE_GUID(CLSID_DirectMusicScripSourceCodeLoader,        0xc70eb77f,0xefd4,0x4678,0xa2,0x7b,0xbf,0x16,0x48,0xf3,0x0d,0x04);
+DEFINE_GUID(CLSID_DirectMusicScriptSourceCodeLoader,       0xc70eb77f,0xefd4,0x4678,0xa2,0x7b,0xbf,0x16,0x48,0xf3,0x0d,0x04);
 DEFINE_GUID(CLSID_DirectMusicScriptAutoImpSegmentState,    0xebf2320a,0x2502,0x11d3,0x8b,0xd1,0x00,0x60,0x08,0x93,0xb1,0xb6);
 DEFINE_GUID(CLSID_DirectMusicScriptAutoImpAudioPathConfig, 0x1cebde3e,0x6b91,0x484a,0xaf,0x48,0x5e,0x4f,0x4e,0xd6,0xb1,0xe1);
 DEFINE_GUID(CLSID_DirectMusicScriptAutoImpAudioPath,       0x2c5f9b72,0x7148,0x4d97,0xbf,0xc9,0x68,0xa0,0xe0,0x76,0xbe,0xbd);