dlls/dmcompos/chordmap.c - wine - Git at Google

 /* IDirectMusicChordMap Implementation
  *
  * Copyright (C) 2003-2004 Rok Mandeljc
  *
  * This program is free software; you can redistribute it and/or
  * modify it under the terms of the GNU Lesser General Public
  * License as published by the Free Software Foundation; either
  * version 2.1 of the License, or (at your option) any later version.
  *
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  * Lesser General Public License for more details.
  *
  * You should have received a copy of the GNU Lesser General Public
  * License along with this program; if not, write to the Free Software
  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  */

 #include "dmcompos_private.h"
 #include "dmobject.h"

 WINE_DEFAULT_DEBUG_CHANNEL(dmcompos);
 WINE_DECLARE_DEBUG_CHANNEL(dmfile);

 /*****************************************************************************
  * IDirectMusicChordMapImpl implementation
  */
 typedef struct IDirectMusicChordMapImpl {
     IDirectMusicChordMap IDirectMusicChordMap_iface;
     struct dmobject dmobj;
     LONG  ref;
 } IDirectMusicChordMapImpl;

 /* IDirectMusicChordMapImpl IDirectMusicChordMap part: */
 static inline IDirectMusicChordMapImpl *impl_from_IDirectMusicChordMap(IDirectMusicChordMap *iface)
 {
     return CONTAINING_RECORD(iface, IDirectMusicChordMapImpl, IDirectMusicChordMap_iface);
 }

 static HRESULT WINAPI IDirectMusicChordMapImpl_QueryInterface(IDirectMusicChordMap *iface,
         REFIID riid, void **ret_iface)
 {
     IDirectMusicChordMapImpl *This = impl_from_IDirectMusicChordMap(iface);

     TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ret_iface);

     *ret_iface = NULL;

     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDirectMusicChordMap))
         *ret_iface = iface;
     else if (IsEqualIID(riid, &IID_IDirectMusicObject))
         *ret_iface = &This->dmobj.IDirectMusicObject_iface;
     else if (IsEqualIID(riid, &IID_IPersistStream))
         *ret_iface = &This->dmobj.IPersistStream_iface;
     else {
         WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ret_iface);
         return E_NOINTERFACE;
     }

     IUnknown_AddRef((IUnknown*)*ret_iface);
     return S_OK;
 }

 static ULONG WINAPI IDirectMusicChordMapImpl_AddRef(IDirectMusicChordMap *iface)
 {
     IDirectMusicChordMapImpl *This = impl_from_IDirectMusicChordMap(iface);
     LONG ref = InterlockedIncrement(&This->ref);

     TRACE("(%p) ref=%d\n", This, ref);

     return ref;
 }

 static ULONG WINAPI IDirectMusicChordMapImpl_Release(IDirectMusicChordMap *iface)
 {
     IDirectMusicChordMapImpl *This = impl_from_IDirectMusicChordMap(iface);
     LONG ref = InterlockedDecrement(&This->ref);

     TRACE("(%p) ref=%d\n", This, ref);

     if (!ref) {
         HeapFree(GetProcessHeap(), 0, This);
         DMCOMPOS_UnlockModule();
     }

     return ref;
 }

 static HRESULT WINAPI IDirectMusicChordMapImpl_GetScale(IDirectMusicChordMap *iface,
         DWORD *pdwScale)
 {
     IDirectMusicChordMapImpl *This = impl_from_IDirectMusicChordMap(iface);
     FIXME("(%p, %p): stub\n", This, pdwScale);
     return S_OK;
 }

 static const IDirectMusicChordMapVtbl dmchordmap_vtbl = {
     IDirectMusicChordMapImpl_QueryInterface,
     IDirectMusicChordMapImpl_AddRef,
     IDirectMusicChordMapImpl_Release,
     IDirectMusicChordMapImpl_GetScale
 };

 /* IDirectMusicChordMapImpl IDirectMusicObject part: */
 static HRESULT WINAPI IDirectMusicObjectImpl_ParseDescriptor(IDirectMusicObject *iface,
         IStream *pStream, DMUS_OBJECTDESC *pDesc)
 {
 	DMUS_PRIVATE_CHUNK Chunk;
 	DWORD StreamSize, StreamCount, ListSize[1], ListCount[1];
 	LARGE_INTEGER liMove; /* used when skipping chunks */

 	TRACE("(%p, %p)\n", pStream, pDesc);

 	/* FIXME: should this be determined from stream? */
 	pDesc->dwValidData |= DMUS_OBJ_CLASS;
 	pDesc->guidClass = CLSID_DirectMusicChordMap;

 	IStream_Read (pStream, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
 	TRACE_(dmfile)(": %s chunk (size = 0x%04x)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
 	switch (Chunk.fccID) {
 		case FOURCC_RIFF: {
 			IStream_Read (pStream, &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 == DMUS_FOURCC_CHORDMAP_FORM) {
 				TRACE_(dmfile)(": chord map form\n");
 				do {
 					IStream_Read (pStream, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
 					StreamCount += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
 					TRACE_(dmfile)(": %s chunk (size = 0x%04x)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
 					switch (Chunk.fccID) {
 						case DMUS_FOURCC_GUID_CHUNK: {
 							TRACE_(dmfile)(": GUID chunk\n");
 							pDesc->dwValidData |= DMUS_OBJ_OBJECT;
 							IStream_Read (pStream, &pDesc->guidObject, Chunk.dwSize, NULL);
 							break;
 						}
 						case DMUS_FOURCC_VERSION_CHUNK: {
 							TRACE_(dmfile)(": version chunk\n");
 							pDesc->dwValidData |= DMUS_OBJ_VERSION;
 							IStream_Read (pStream, &pDesc->vVersion, Chunk.dwSize, NULL);
 							break;
 						}
 						case DMUS_FOURCC_CATEGORY_CHUNK: {
 							TRACE_(dmfile)(": category chunk\n");
 							pDesc->dwValidData |= DMUS_OBJ_CATEGORY;
 							IStream_Read (pStream, pDesc->wszCategory, Chunk.dwSize, NULL);
 							break;
 						}
 						case FOURCC_LIST: {
 							IStream_Read (pStream, &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 (pStream, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
 										ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
 										TRACE_(dmfile)(": %s chunk (size = 0x%04x)", 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");
 												pDesc->dwValidData |= DMUS_OBJ_NAME;
 												IStream_Read (pStream, 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 (pStream, 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 (pStream, 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 (pStream, 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 (pStream, liMove, STREAM_SEEK_CUR, NULL);
 												break;
 											}
 											default: {
 												TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
 												liMove.QuadPart = Chunk.dwSize;
 												IStream_Seek (pStream, liMove, STREAM_SEEK_CUR, NULL);
 												break;
 											}
 										}
 										TRACE_(dmfile)(": ListCount[0] = %d < ListSize[0] = %d\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 (pStream, liMove, STREAM_SEEK_CUR, NULL);
 									break;
 								}
 							}
 							break;
 						}
 						default: {
 							TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
 							liMove.QuadPart = Chunk.dwSize;
 							IStream_Seek (pStream, liMove, STREAM_SEEK_CUR, NULL);
 							break;
 						}
 					}
 					TRACE_(dmfile)(": StreamCount[0] = %d < StreamSize[0] = %d\n", StreamCount, StreamSize);
 				} while (StreamCount < StreamSize);
 			} else {
 				TRACE_(dmfile)(": unexpected chunk; loading failed)\n");
 				liMove.QuadPart = StreamSize;
 				IStream_Seek (pStream, 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 (pStream, liMove, STREAM_SEEK_CUR, NULL); /* skip the rest of the chunk */
 			return DMUS_E_INVALIDFILE;
 		}
 	}

 	TRACE(": returning descriptor:\n%s\n", debugstr_DMUS_OBJECTDESC (pDesc));

 	return S_OK;
 }

 static const IDirectMusicObjectVtbl dmobject_vtbl = {
     dmobj_IDirectMusicObject_QueryInterface,
     dmobj_IDirectMusicObject_AddRef,
     dmobj_IDirectMusicObject_Release,
     dmobj_IDirectMusicObject_GetDescriptor,
     dmobj_IDirectMusicObject_SetDescriptor,
     IDirectMusicObjectImpl_ParseDescriptor
 };

 /* IDirectMusicChordMapImpl IPersistStream part: */
 static inline IDirectMusicChordMapImpl *impl_from_IPersistStream(IPersistStream *iface)
 {
     return CONTAINING_RECORD(iface, IDirectMusicChordMapImpl, dmobj.IPersistStream_iface);
 }

 static HRESULT WINAPI IPersistStreamImpl_Load(IPersistStream *iface, IStream *pStm)
 {
         IDirectMusicChordMapImpl *This = impl_from_IPersistStream(iface);
 	FOURCC chunkID;
 	DWORD chunkSize, StreamSize, StreamCount, ListSize[3], ListCount[3];
 	LARGE_INTEGER liMove; /* used when skipping chunks */

 	FIXME("(%p, %p): Loading not implemented yet\n", This, pStm);
 	IStream_Read (pStm, &chunkID, sizeof(FOURCC), NULL);
 	IStream_Read (pStm, &chunkSize, sizeof(DWORD), NULL);
 	TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (chunkID), chunkSize);
 	switch (chunkID) {
 		case FOURCC_RIFF: {
 			IStream_Read (pStm, &chunkID, sizeof(FOURCC), NULL);
 			TRACE_(dmfile)(": RIFF chunk of type %s", debugstr_fourcc(chunkID));
 			StreamSize = chunkSize - sizeof(FOURCC);
 			StreamCount = 0;
 			switch (chunkID) {
 				case DMUS_FOURCC_CHORDMAP_FORM: {
 					TRACE_(dmfile)(": chordmap form\n");
 					do {
 						IStream_Read (pStm, &chunkID, sizeof(FOURCC), NULL);
 						IStream_Read (pStm, &chunkSize, sizeof(FOURCC), NULL);
 						StreamCount += sizeof(FOURCC) + sizeof(DWORD) + chunkSize;
 						TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (chunkID), chunkSize);
 						switch (chunkID) {
 							case DMUS_FOURCC_GUID_CHUNK: {
 								TRACE_(dmfile)(": GUID chunk\n");
 								This->dmobj.desc.dwValidData |= DMUS_OBJ_OBJECT;
 								IStream_Read (pStm, &This->dmobj.desc.guidObject, chunkSize, NULL);
 								break;
 							}
 							case DMUS_FOURCC_VERSION_CHUNK: {
 								TRACE_(dmfile)(": version chunk\n");
 								This->dmobj.desc.dwValidData |= DMUS_OBJ_VERSION;
 								IStream_Read (pStm, &This->dmobj.desc.vVersion, chunkSize, NULL);
 								break;
 							}
 							case DMUS_FOURCC_CATEGORY_CHUNK: {
 								TRACE_(dmfile)(": category chunk\n");
 								This->dmobj.desc.dwValidData |= DMUS_OBJ_CATEGORY;
 								IStream_Read (pStm, This->dmobj.desc.wszCategory, chunkSize, NULL);
 								break;
 							}
 							case FOURCC_LIST: {
 								IStream_Read (pStm, &chunkID, sizeof(FOURCC), NULL);
 								TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(chunkID));
 								ListSize[0] = chunkSize - sizeof(FOURCC);
 								ListCount[0] = 0;
 								switch (chunkID) {
 									case DMUS_FOURCC_UNFO_LIST: {
 										TRACE_(dmfile)(": UNFO list\n");
 										do {
 											IStream_Read (pStm, &chunkID, sizeof(FOURCC), NULL);
 											IStream_Read (pStm, &chunkSize, sizeof(FOURCC), NULL);
 											ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + chunkSize;
 											TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (chunkID), chunkSize);
 											switch (chunkID) {
 												/* don't ask me why, but M$ puts INFO elements in UNFO list sometimes
                                               (though strings seem to be valid unicode) */
 												case mmioFOURCC('I','N','A','M'):
 												case DMUS_FOURCC_UNAM_CHUNK: {
 													TRACE_(dmfile)(": name chunk\n");
 													This->dmobj.desc.dwValidData |= DMUS_OBJ_NAME;
 													IStream_Read (pStm, This->dmobj.desc.wszName, chunkSize, NULL);
 													break;
 												}
 												case mmioFOURCC('I','A','R','T'):
 												case DMUS_FOURCC_UART_CHUNK: {
 													TRACE_(dmfile)(": artist chunk (ignored)\n");
 													liMove.QuadPart = chunkSize;
 													IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 													break;
 												}
 												case mmioFOURCC('I','C','O','P'):
 												case DMUS_FOURCC_UCOP_CHUNK: {
 													TRACE_(dmfile)(": copyright chunk (ignored)\n");
 													liMove.QuadPart = chunkSize;
 													IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 													break;
 												}
 												case mmioFOURCC('I','S','B','J'):
 												case DMUS_FOURCC_USBJ_CHUNK: {
 													TRACE_(dmfile)(": subject chunk (ignored)\n");
 													liMove.QuadPart = chunkSize;
 													IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 													break;
 												}
 												case mmioFOURCC('I','C','M','T'):
 												case DMUS_FOURCC_UCMT_CHUNK: {
 													TRACE_(dmfile)(": comment chunk (ignored)\n");
 													liMove.QuadPart = chunkSize;
 													IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 													break;
 												}
 												default: {
 													TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
 													liMove.QuadPart = chunkSize;
 													IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 													break;
 												}
 											}
 											TRACE_(dmfile)(": ListCount[0] = %d < ListSize[0] = %d\n", ListCount[0], ListSize[0]);
 										} while (ListCount[0] < ListSize[0]);
 										break;
 									}
 									default: {
 										TRACE_(dmfile)(": unknown (skipping)\n");
 										liMove.QuadPart = chunkSize - sizeof(FOURCC);
 										IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 										break;
 									}
 								}
 								break;
 							}
 							default: {
 								TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
 								liMove.QuadPart = chunkSize;
 								IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 								break;
 							}
 						}
 						TRACE_(dmfile)(": StreamCount[0] = %d < StreamSize[0] = %d\n", StreamCount, StreamSize);
 					} while (StreamCount < StreamSize);
 					break;
 				}
 				default: {
 					TRACE_(dmfile)(": unexpected chunk; loading failed)\n");
 					liMove.QuadPart = StreamSize;
 					IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); /* skip the rest of the chunk */
 					return E_FAIL;
 				}
 			}
 			TRACE_(dmfile)(": reading finished\n");
 			break;
 		}
 		default: {
 			TRACE_(dmfile)(": unexpected chunk; loading failed)\n");
 			liMove.QuadPart = chunkSize;
 			IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); /* skip the rest of the chunk */
 			return E_FAIL;
 		}
 	}

 	return S_OK;
 }

 static const IPersistStreamVtbl persiststream_vtbl = {
     dmobj_IPersistStream_QueryInterface,
     dmobj_IPersistStream_AddRef,
     dmobj_IPersistStream_Release,
     dmobj_IPersistStream_GetClassID,
     unimpl_IPersistStream_IsDirty,
     IPersistStreamImpl_Load,
     unimpl_IPersistStream_Save,
     unimpl_IPersistStream_GetSizeMax
 };

 /* for ClassFactory */
 HRESULT WINAPI create_dmchordmap(REFIID lpcGUID, void **ppobj)
 {
 	IDirectMusicChordMapImpl* obj;
         HRESULT hr;

 	obj = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectMusicChordMapImpl));
 	if (NULL == obj) {
 		*ppobj = NULL;
 		return E_OUTOFMEMORY;
 	}
         obj->IDirectMusicChordMap_iface.lpVtbl = &dmchordmap_vtbl;
         obj->ref = 1;
         dmobject_init(&obj->dmobj, &CLSID_DirectMusicChordMap,
                 (IUnknown *)&obj->IDirectMusicChordMap_iface);
         obj->dmobj.IDirectMusicObject_iface.lpVtbl = &dmobject_vtbl;
         obj->dmobj.IPersistStream_iface.lpVtbl = &persiststream_vtbl;

         DMCOMPOS_LockModule();
         hr = IDirectMusicChordMap_QueryInterface(&obj->IDirectMusicChordMap_iface, lpcGUID, ppobj);
         IDirectMusicChordMap_Release(&obj->IDirectMusicChordMap_iface);

         return hr;
 }
	/* IDirectMusicChordMap Implementation
	*
	* Copyright (C) 2003-2004 Rok Mandeljc
	*
	* This program is free software; you can redistribute it and/or
	* modify it under the terms of the GNU Lesser General Public
	* License as published by the Free Software Foundation; either
	* version 2.1 of the License, or (at your option) any later version.
	*
	* This program is distributed in the hope that it will be useful,
	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	* Lesser General Public License for more details.
	*
	* You should have received a copy of the GNU Lesser General Public
	* License along with this program; if not, write to the Free Software
	* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
	*/

	#include "dmcompos_private.h"
	#include "dmobject.h"

	WINE_DEFAULT_DEBUG_CHANNEL(dmcompos);
	WINE_DECLARE_DEBUG_CHANNEL(dmfile);

	/*****************************************************************************
	* IDirectMusicChordMapImpl implementation
	*/
	typedef struct IDirectMusicChordMapImpl {
	IDirectMusicChordMap IDirectMusicChordMap_iface;
	struct dmobject dmobj;
	LONG ref;
	} IDirectMusicChordMapImpl;

	/* IDirectMusicChordMapImpl IDirectMusicChordMap part: */
	static inline IDirectMusicChordMapImpl impl_from_IDirectMusicChordMap(IDirectMusicChordMap iface)
	{
	return CONTAINING_RECORD(iface, IDirectMusicChordMapImpl, IDirectMusicChordMap_iface);
	}

	static HRESULT WINAPI IDirectMusicChordMapImpl_QueryInterface(IDirectMusicChordMap *iface,
	REFIID riid, void **ret_iface)
	{
	IDirectMusicChordMapImpl *This = impl_from_IDirectMusicChordMap(iface);

	TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ret_iface);

	*ret_iface = NULL;

	if (IsEqualIID(riid, &IID_IUnknown) \|\| IsEqualIID(riid, &IID_IDirectMusicChordMap))
	*ret_iface = iface;
	else if (IsEqualIID(riid, &IID_IDirectMusicObject))
	*ret_iface = &This->dmobj.IDirectMusicObject_iface;
	else if (IsEqualIID(riid, &IID_IPersistStream))
	*ret_iface = &This->dmobj.IPersistStream_iface;
	else {
	WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ret_iface);
	return E_NOINTERFACE;
	}

	IUnknown_AddRef((IUnknown)ret_iface);
	return S_OK;
	}

	static ULONG WINAPI IDirectMusicChordMapImpl_AddRef(IDirectMusicChordMap *iface)
	{
	IDirectMusicChordMapImpl *This = impl_from_IDirectMusicChordMap(iface);
	LONG ref = InterlockedIncrement(&This->ref);

	TRACE("(%p) ref=%d\n", This, ref);

	return ref;
	}

	static ULONG WINAPI IDirectMusicChordMapImpl_Release(IDirectMusicChordMap *iface)
	{
	IDirectMusicChordMapImpl *This = impl_from_IDirectMusicChordMap(iface);
	LONG ref = InterlockedDecrement(&This->ref);

	TRACE("(%p) ref=%d\n", This, ref);

	if (!ref) {
	HeapFree(GetProcessHeap(), 0, This);
	DMCOMPOS_UnlockModule();
	}

	return ref;
	}

	static HRESULT WINAPI IDirectMusicChordMapImpl_GetScale(IDirectMusicChordMap *iface,
	DWORD *pdwScale)
	{
	IDirectMusicChordMapImpl *This = impl_from_IDirectMusicChordMap(iface);
	FIXME("(%p, %p): stub\n", This, pdwScale);
	return S_OK;
	}

	static const IDirectMusicChordMapVtbl dmchordmap_vtbl = {
	IDirectMusicChordMapImpl_QueryInterface,
	IDirectMusicChordMapImpl_AddRef,
	IDirectMusicChordMapImpl_Release,
	IDirectMusicChordMapImpl_GetScale
	};

	/* IDirectMusicChordMapImpl IDirectMusicObject part: */
	static HRESULT WINAPI IDirectMusicObjectImpl_ParseDescriptor(IDirectMusicObject *iface,
	IStream pStream, DMUS_OBJECTDESC pDesc)
	{
	DMUS_PRIVATE_CHUNK Chunk;
	DWORD StreamSize, StreamCount, ListSize[1], ListCount[1];
	LARGE_INTEGER liMove; /* used when skipping chunks */

	TRACE("(%p, %p)\n", pStream, pDesc);

	/* FIXME: should this be determined from stream? */
	pDesc->dwValidData \|= DMUS_OBJ_CLASS;
	pDesc->guidClass = CLSID_DirectMusicChordMap;

	IStream_Read (pStream, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
	TRACE_(dmfile)(": %s chunk (size = 0x%04x)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
	switch (Chunk.fccID) {
	case FOURCC_RIFF: {
	IStream_Read (pStream, &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 == DMUS_FOURCC_CHORDMAP_FORM) {
	TRACE_(dmfile)(": chord map form\n");
	do {
	IStream_Read (pStream, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
	StreamCount += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
	TRACE_(dmfile)(": %s chunk (size = 0x%04x)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
	switch (Chunk.fccID) {
	case DMUS_FOURCC_GUID_CHUNK: {
	TRACE_(dmfile)(": GUID chunk\n");
	pDesc->dwValidData \|= DMUS_OBJ_OBJECT;
	IStream_Read (pStream, &pDesc->guidObject, Chunk.dwSize, NULL);
	break;
	}
	case DMUS_FOURCC_VERSION_CHUNK: {
	TRACE_(dmfile)(": version chunk\n");
	pDesc->dwValidData \|= DMUS_OBJ_VERSION;
	IStream_Read (pStream, &pDesc->vVersion, Chunk.dwSize, NULL);
	break;
	}
	case DMUS_FOURCC_CATEGORY_CHUNK: {
	TRACE_(dmfile)(": category chunk\n");
	pDesc->dwValidData \|= DMUS_OBJ_CATEGORY;
	IStream_Read (pStream, pDesc->wszCategory, Chunk.dwSize, NULL);
	break;
	}
	case FOURCC_LIST: {
	IStream_Read (pStream, &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 (pStream, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
	ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
	TRACE_(dmfile)(": %s chunk (size = 0x%04x)", 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");
	pDesc->dwValidData \|= DMUS_OBJ_NAME;
	IStream_Read (pStream, 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 (pStream, 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 (pStream, 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 (pStream, 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 (pStream, liMove, STREAM_SEEK_CUR, NULL);
	break;
	}
	default: {
	TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
	liMove.QuadPart = Chunk.dwSize;
	IStream_Seek (pStream, liMove, STREAM_SEEK_CUR, NULL);
	break;
	}
	}
	TRACE_(dmfile)(": ListCount[0] = %d < ListSize[0] = %d\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 (pStream, liMove, STREAM_SEEK_CUR, NULL);
	break;
	}
	}
	break;
	}
	default: {
	TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
	liMove.QuadPart = Chunk.dwSize;
	IStream_Seek (pStream, liMove, STREAM_SEEK_CUR, NULL);
	break;
	}
	}
	TRACE_(dmfile)(": StreamCount[0] = %d < StreamSize[0] = %d\n", StreamCount, StreamSize);
	} while (StreamCount < StreamSize);
	} else {
	TRACE_(dmfile)(": unexpected chunk; loading failed)\n");
	liMove.QuadPart = StreamSize;
	IStream_Seek (pStream, 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 (pStream, liMove, STREAM_SEEK_CUR, NULL); /* skip the rest of the chunk */
	return DMUS_E_INVALIDFILE;
	}
	}

	TRACE(": returning descriptor:\n%s\n", debugstr_DMUS_OBJECTDESC (pDesc));

	return S_OK;
	}

	static const IDirectMusicObjectVtbl dmobject_vtbl = {
	dmobj_IDirectMusicObject_QueryInterface,
	dmobj_IDirectMusicObject_AddRef,
	dmobj_IDirectMusicObject_Release,
	dmobj_IDirectMusicObject_GetDescriptor,
	dmobj_IDirectMusicObject_SetDescriptor,
	IDirectMusicObjectImpl_ParseDescriptor
	};

	/* IDirectMusicChordMapImpl IPersistStream part: */
	static inline IDirectMusicChordMapImpl impl_from_IPersistStream(IPersistStream iface)
	{
	return CONTAINING_RECORD(iface, IDirectMusicChordMapImpl, dmobj.IPersistStream_iface);
	}

	static HRESULT WINAPI IPersistStreamImpl_Load(IPersistStream iface, IStream pStm)
	{
	IDirectMusicChordMapImpl *This = impl_from_IPersistStream(iface);
	FOURCC chunkID;
	DWORD chunkSize, StreamSize, StreamCount, ListSize[3], ListCount[3];
	LARGE_INTEGER liMove; /* used when skipping chunks */

	FIXME("(%p, %p): Loading not implemented yet\n", This, pStm);
	IStream_Read (pStm, &chunkID, sizeof(FOURCC), NULL);
	IStream_Read (pStm, &chunkSize, sizeof(DWORD), NULL);
	TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (chunkID), chunkSize);
	switch (chunkID) {
	case FOURCC_RIFF: {
	IStream_Read (pStm, &chunkID, sizeof(FOURCC), NULL);
	TRACE_(dmfile)(": RIFF chunk of type %s", debugstr_fourcc(chunkID));
	StreamSize = chunkSize - sizeof(FOURCC);
	StreamCount = 0;
	switch (chunkID) {
	case DMUS_FOURCC_CHORDMAP_FORM: {
	TRACE_(dmfile)(": chordmap form\n");
	do {
	IStream_Read (pStm, &chunkID, sizeof(FOURCC), NULL);
	IStream_Read (pStm, &chunkSize, sizeof(FOURCC), NULL);
	StreamCount += sizeof(FOURCC) + sizeof(DWORD) + chunkSize;
	TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (chunkID), chunkSize);
	switch (chunkID) {
	case DMUS_FOURCC_GUID_CHUNK: {
	TRACE_(dmfile)(": GUID chunk\n");
	This->dmobj.desc.dwValidData \|= DMUS_OBJ_OBJECT;
	IStream_Read (pStm, &This->dmobj.desc.guidObject, chunkSize, NULL);
	break;
	}
	case DMUS_FOURCC_VERSION_CHUNK: {
	TRACE_(dmfile)(": version chunk\n");
	This->dmobj.desc.dwValidData \|= DMUS_OBJ_VERSION;
	IStream_Read (pStm, &This->dmobj.desc.vVersion, chunkSize, NULL);
	break;
	}
	case DMUS_FOURCC_CATEGORY_CHUNK: {
	TRACE_(dmfile)(": category chunk\n");
	This->dmobj.desc.dwValidData \|= DMUS_OBJ_CATEGORY;
	IStream_Read (pStm, This->dmobj.desc.wszCategory, chunkSize, NULL);
	break;
	}
	case FOURCC_LIST: {
	IStream_Read (pStm, &chunkID, sizeof(FOURCC), NULL);
	TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(chunkID));
	ListSize[0] = chunkSize - sizeof(FOURCC);
	ListCount[0] = 0;
	switch (chunkID) {
	case DMUS_FOURCC_UNFO_LIST: {
	TRACE_(dmfile)(": UNFO list\n");
	do {
	IStream_Read (pStm, &chunkID, sizeof(FOURCC), NULL);
	IStream_Read (pStm, &chunkSize, sizeof(FOURCC), NULL);
	ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + chunkSize;
	TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (chunkID), chunkSize);
	switch (chunkID) {
	/* don't ask me why, but M$ puts INFO elements in UNFO list sometimes
	(though strings seem to be valid unicode) */
	case mmioFOURCC('I','N','A','M'):
	case DMUS_FOURCC_UNAM_CHUNK: {
	TRACE_(dmfile)(": name chunk\n");
	This->dmobj.desc.dwValidData \|= DMUS_OBJ_NAME;
	IStream_Read (pStm, This->dmobj.desc.wszName, chunkSize, NULL);
	break;
	}
	case mmioFOURCC('I','A','R','T'):
	case DMUS_FOURCC_UART_CHUNK: {
	TRACE_(dmfile)(": artist chunk (ignored)\n");
	liMove.QuadPart = chunkSize;
	IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
	break;
	}
	case mmioFOURCC('I','C','O','P'):
	case DMUS_FOURCC_UCOP_CHUNK: {
	TRACE_(dmfile)(": copyright chunk (ignored)\n");
	liMove.QuadPart = chunkSize;
	IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
	break;
	}
	case mmioFOURCC('I','S','B','J'):
	case DMUS_FOURCC_USBJ_CHUNK: {
	TRACE_(dmfile)(": subject chunk (ignored)\n");
	liMove.QuadPart = chunkSize;
	IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
	break;
	}
	case mmioFOURCC('I','C','M','T'):
	case DMUS_FOURCC_UCMT_CHUNK: {
	TRACE_(dmfile)(": comment chunk (ignored)\n");
	liMove.QuadPart = chunkSize;
	IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
	break;
	}
	default: {
	TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
	liMove.QuadPart = chunkSize;
	IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
	break;
	}
	}
	TRACE_(dmfile)(": ListCount[0] = %d < ListSize[0] = %d\n", ListCount[0], ListSize[0]);
	} while (ListCount[0] < ListSize[0]);
	break;
	}
	default: {
	TRACE_(dmfile)(": unknown (skipping)\n");
	liMove.QuadPart = chunkSize - sizeof(FOURCC);
	IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
	break;
	}
	}
	break;
	}
	default: {
	TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
	liMove.QuadPart = chunkSize;
	IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
	break;
	}
	}
	TRACE_(dmfile)(": StreamCount[0] = %d < StreamSize[0] = %d\n", StreamCount, StreamSize);
	} while (StreamCount < StreamSize);
	break;
	}
	default: {
	TRACE_(dmfile)(": unexpected chunk; loading failed)\n");
	liMove.QuadPart = StreamSize;
	IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); /* skip the rest of the chunk */
	return E_FAIL;
	}
	}
	TRACE_(dmfile)(": reading finished\n");
	break;
	}
	default: {
	TRACE_(dmfile)(": unexpected chunk; loading failed)\n");
	liMove.QuadPart = chunkSize;
	IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); /* skip the rest of the chunk */
	return E_FAIL;
	}
	}

	return S_OK;
	}

	static const IPersistStreamVtbl persiststream_vtbl = {
	dmobj_IPersistStream_QueryInterface,
	dmobj_IPersistStream_AddRef,
	dmobj_IPersistStream_Release,
	dmobj_IPersistStream_GetClassID,
	unimpl_IPersistStream_IsDirty,
	IPersistStreamImpl_Load,
	unimpl_IPersistStream_Save,
	unimpl_IPersistStream_GetSizeMax
	};

	/* for ClassFactory */
	HRESULT WINAPI create_dmchordmap(REFIID lpcGUID, void **ppobj)
	{
	IDirectMusicChordMapImpl* obj;
	HRESULT hr;

	obj = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectMusicChordMapImpl));
	if (NULL == obj) {
	*ppobj = NULL;
	return E_OUTOFMEMORY;
	}
	obj->IDirectMusicChordMap_iface.lpVtbl = &dmchordmap_vtbl;
	obj->ref = 1;
	dmobject_init(&obj->dmobj, &CLSID_DirectMusicChordMap,
	(IUnknown *)&obj->IDirectMusicChordMap_iface);
	obj->dmobj.IDirectMusicObject_iface.lpVtbl = &dmobject_vtbl;
	obj->dmobj.IPersistStream_iface.lpVtbl = &persiststream_vtbl;

	DMCOMPOS_LockModule();
	hr = IDirectMusicChordMap_QueryInterface(&obj->IDirectMusicChordMap_iface, lpcGUID, ppobj);
	IDirectMusicChordMap_Release(&obj->IDirectMusicChordMap_iface);

	return hr;
	}