dlls/dmstyle/style.c

   1 /* IDirectMusicStyle8 Implementation
   2  *
   3  * Copyright (C) 2003-2004 Rok Mandeljc
   4  * Copyright (C) 2003-2004 Raphael Junqueira
   5  *
   6  * This program is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This program is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this program; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "dmstyle_private.h"
  22 #include "dmobject.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(dmstyle);
  25 WINE_DECLARE_DEBUG_CHANNEL(dmfile);
  26
  27 /*****************************************************************************
  28  * IDirectMusicStyleImpl implementation
  29  */
  30 typedef struct IDirectMusicStyle8Impl {
  31     IDirectMusicStyle8 IDirectMusicStyle8_iface;
  32     struct dmobject dmobj;
  33     LONG ref;
  34     DMUS_IO_STYLE style;
  35     struct list Motifs;
  36     struct list Bands;
  37 } IDirectMusicStyle8Impl;
  38
  39 static inline IDirectMusicStyle8Impl *impl_from_IDirectMusicStyle8(IDirectMusicStyle8 *iface)
  40 {
  41     return CONTAINING_RECORD(iface, IDirectMusicStyle8Impl, IDirectMusicStyle8_iface);
  42 }
  43
  44 /* DirectMusicStyle8Impl IDirectMusicStyle8 part: */
  45 static HRESULT WINAPI IDirectMusicStyle8Impl_QueryInterface(IDirectMusicStyle8 *iface, REFIID riid,
  46         void **ret_iface)
  47 {
  48     IDirectMusicStyle8Impl *This = impl_from_IDirectMusicStyle8(iface);
  49
  50     TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ret_iface);
  51
  52     *ret_iface = NULL;
  53
  54     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDirectMusicStyle) ||
  55             IsEqualIID(riid, &IID_IDirectMusicStyle8))
  56         *ret_iface = iface;
  57     else if (IsEqualIID(riid, &IID_IDirectMusicObject))
  58         *ret_iface = &This->dmobj.IDirectMusicObject_iface;
  59     else if (IsEqualIID(riid, &IID_IPersistStream))
  60         *ret_iface = &This->dmobj.IPersistStream_iface;
  61     else {
  62         WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ret_iface);
  63         return E_NOINTERFACE;
  64     }
  65
  66     IUnknown_AddRef((IUnknown*)*ret_iface);
  67     return S_OK;
  68 }
  69
  70 static ULONG WINAPI IDirectMusicStyle8Impl_AddRef(IDirectMusicStyle8 *iface)
  71 {
  72     IDirectMusicStyle8Impl *This = impl_from_IDirectMusicStyle8(iface);
  73     LONG ref = InterlockedIncrement(&This->ref);
  74
  75     TRACE("(%p) ref=%d\n", This, ref);
  76
  77     return ref;
  78 }
  79
  80 static ULONG WINAPI IDirectMusicStyle8Impl_Release(IDirectMusicStyle8 *iface)
  81 {
  82     IDirectMusicStyle8Impl *This = impl_from_IDirectMusicStyle8(iface);
  83     LONG ref = InterlockedDecrement(&This->ref);
  84
  85     TRACE("(%p) ref=%d\n", This, ref);
  86
  87     if (!ref) {
  88         HeapFree(GetProcessHeap(), 0, This);
  89         DMSTYLE_UnlockModule();
  90     }
  91
  92     return ref;
  93 }
  94
  95 /* IDirectMusicStyle8Impl IDirectMusicStyle(8) part: */
  96 static HRESULT WINAPI IDirectMusicStyle8Impl_GetBand(IDirectMusicStyle8 *iface, WCHAR *pwszName,
  97         IDirectMusicBand **ppBand)
  98 {
  99         IDirectMusicStyle8Impl *This = impl_from_IDirectMusicStyle8(iface);
 100         FIXME("(%p, %p, %p): stub\n", This, pwszName, ppBand);
 101         return S_OK;
 102 }
 103
 104 static HRESULT WINAPI IDirectMusicStyle8Impl_EnumBand(IDirectMusicStyle8 *iface, DWORD dwIndex,
 105         WCHAR *pwszName)
 106 {
 107         IDirectMusicStyle8Impl *This = impl_from_IDirectMusicStyle8(iface);
 108         FIXME("(%p, %d, %p): stub\n", This, dwIndex, pwszName);
 109         return S_OK;
 110 }
 111
 112 static HRESULT WINAPI IDirectMusicStyle8Impl_GetDefaultBand(IDirectMusicStyle8 *iface,
 113         IDirectMusicBand **ppBand)
 114 {
 115         IDirectMusicStyle8Impl *This = impl_from_IDirectMusicStyle8(iface);
 116         FIXME("(%p, %p): stub\n", This, ppBand);
 117         return S_OK;
 118 }
 119
 120 static HRESULT WINAPI IDirectMusicStyle8Impl_EnumMotif(IDirectMusicStyle8 *iface, DWORD dwIndex,
 121         WCHAR *pwszName)
 122 {
 123         IDirectMusicStyle8Impl *This = impl_from_IDirectMusicStyle8(iface);
 124         FIXME("(%p, %d, %p): stub\n", This, dwIndex, pwszName);
 125         return S_OK;
 126 }
 127
 128 static HRESULT WINAPI IDirectMusicStyle8Impl_GetMotif(IDirectMusicStyle8 *iface, WCHAR *pwszName,
 129         IDirectMusicSegment **ppSegment)
 130 {
 131         IDirectMusicStyle8Impl *This = impl_from_IDirectMusicStyle8(iface);
 132         FIXME("(%p, %p, %p): stub\n", This, pwszName, ppSegment);
 133         return S_OK;
 134 }
 135
 136 static HRESULT WINAPI IDirectMusicStyle8Impl_GetDefaultChordMap(IDirectMusicStyle8 *iface,
 137         IDirectMusicChordMap **ppChordMap)
 138 {
 139         IDirectMusicStyle8Impl *This = impl_from_IDirectMusicStyle8(iface);
 140         FIXME("(%p, %p): stub\n", This, ppChordMap);
 141         return S_OK;
 142 }
 143
 144 static HRESULT WINAPI IDirectMusicStyle8Impl_EnumChordMap(IDirectMusicStyle8 *iface, DWORD dwIndex,
 145         WCHAR *pwszName)
 146 {
 147         IDirectMusicStyle8Impl *This = impl_from_IDirectMusicStyle8(iface);
 148         FIXME("(%p, %d, %p): stub\n", This, dwIndex, pwszName);
 149         return S_OK;
 150 }
 151
 152 static HRESULT WINAPI IDirectMusicStyle8Impl_GetChordMap(IDirectMusicStyle8 *iface, WCHAR *pwszName,
 153         IDirectMusicChordMap **ppChordMap)
 154 {
 155         IDirectMusicStyle8Impl *This = impl_from_IDirectMusicStyle8(iface);
 156         FIXME("(%p, %p, %p): stub\n", This, pwszName, ppChordMap);
 157         return S_OK;
 158 }
 159
 160 static HRESULT WINAPI IDirectMusicStyle8Impl_GetTimeSignature(IDirectMusicStyle8 *iface,
 161         DMUS_TIMESIGNATURE *pTimeSig)
 162 {
 163         IDirectMusicStyle8Impl *This = impl_from_IDirectMusicStyle8(iface);
 164         FIXME("(%p, %p): stub\n", This, pTimeSig);
 165         return S_OK;
 166 }
 167
 168 static HRESULT WINAPI IDirectMusicStyle8Impl_GetEmbellishmentLength(IDirectMusicStyle8 *iface,
 169         DWORD dwType, DWORD dwLevel, DWORD *pdwMin, DWORD *pdwMax)
 170 {
 171         IDirectMusicStyle8Impl *This = impl_from_IDirectMusicStyle8(iface);
 172         FIXME("(%p, %d, %d, %p, %p): stub\n", This, dwType, dwLevel, pdwMin, pdwMax);
 173         return S_OK;
 174 }
 175
 176 static HRESULT WINAPI IDirectMusicStyle8Impl_GetTempo(IDirectMusicStyle8 *iface, double *pTempo)
 177 {
 178         IDirectMusicStyle8Impl *This = impl_from_IDirectMusicStyle8(iface);
 179         FIXME("(%p, %p): stub\n", This, pTempo);
 180         return S_OK;
 181 }
 182
 183 static HRESULT WINAPI IDirectMusicStyle8Impl_EnumPattern(IDirectMusicStyle8 *iface, DWORD dwIndex,
 184         DWORD dwPatternType, WCHAR *pwszName)
 185 {
 186         IDirectMusicStyle8Impl *This = impl_from_IDirectMusicStyle8(iface);
 187         FIXME("(%p, %d, %d, %p): stub\n", This, dwIndex, dwPatternType, pwszName);
 188         return S_OK;
 189 }
 190
 191 static const IDirectMusicStyle8Vtbl dmstyle8_vtbl = {
 192     IDirectMusicStyle8Impl_QueryInterface,
 193     IDirectMusicStyle8Impl_AddRef,
 194     IDirectMusicStyle8Impl_Release,
 195     IDirectMusicStyle8Impl_GetBand,
 196     IDirectMusicStyle8Impl_EnumBand,
 197     IDirectMusicStyle8Impl_GetDefaultBand,
 198     IDirectMusicStyle8Impl_EnumMotif,
 199     IDirectMusicStyle8Impl_GetMotif,
 200     IDirectMusicStyle8Impl_GetDefaultChordMap,
 201     IDirectMusicStyle8Impl_EnumChordMap,
 202     IDirectMusicStyle8Impl_GetChordMap,
 203     IDirectMusicStyle8Impl_GetTimeSignature,
 204     IDirectMusicStyle8Impl_GetEmbellishmentLength,
 205     IDirectMusicStyle8Impl_GetTempo,
 206     IDirectMusicStyle8Impl_EnumPattern
 207 };
 208
 209 /* IDirectMusicStyle8Impl IDirectMusicObject part: */
 210 static HRESULT WINAPI style_IDirectMusicObject_ParseDescriptor(IDirectMusicObject *iface,
 211         IStream *stream, DMUS_OBJECTDESC *desc)
 212 {
 213     struct chunk_entry riff = {0};
 214     HRESULT hr;
 215
 216     TRACE("(%p, %p, %p)\n", iface, stream, desc);
 217
 218     if (!stream || !desc)
 219         return E_POINTER;
 220
 221     if ((hr = stream_get_chunk(stream, &riff)) != S_OK)
 222         return hr;
 223     if (riff.id != FOURCC_RIFF || riff.type != DMUS_FOURCC_STYLE_FORM) {
 224         TRACE("loading failed: unexpected %s\n", debugstr_chunk(&riff));
 225         stream_skip_chunk(stream, &riff);
 226         return DMUS_E_CHUNKNOTFOUND;
 227     }
 228
 229     hr = dmobj_parsedescriptor(stream, &riff, desc,
 230             DMUS_OBJ_OBJECT|DMUS_OBJ_NAME|DMUS_OBJ_NAME_INAM|DMUS_OBJ_VERSION);
 231     if (FAILED(hr))
 232         return hr;
 233
 234     desc->guidClass = CLSID_DirectMusicStyle;
 235     desc->dwValidData |= DMUS_OBJ_CLASS;
 236
 237     TRACE("returning descriptor:\n%s\n", debugstr_DMUS_OBJECTDESC (desc));
 238     return S_OK;
 239 }
 240
 241 static const IDirectMusicObjectVtbl dmobject_vtbl = {
 242     dmobj_IDirectMusicObject_QueryInterface,
 243     dmobj_IDirectMusicObject_AddRef,
 244     dmobj_IDirectMusicObject_Release,
 245     dmobj_IDirectMusicObject_GetDescriptor,
 246     dmobj_IDirectMusicObject_SetDescriptor,
 247     style_IDirectMusicObject_ParseDescriptor
 248 };
 249
 250 /* IDirectMusicStyle8Impl IPersistStream part: */
 251 static inline IDirectMusicStyle8Impl *impl_from_IPersistStream(IPersistStream *iface)
 252 {
 253     return CONTAINING_RECORD(iface, IDirectMusicStyle8Impl, dmobj.IPersistStream_iface);
 254 }
 255
 256 static HRESULT load_band(IStream *pClonedStream, IDirectMusicBand **ppBand)
 257 {
 258   HRESULT hr = E_FAIL;
 259   IPersistStream* pPersistStream = NULL;
 260
 261   hr = CoCreateInstance (&CLSID_DirectMusicBand, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectMusicBand, (LPVOID*) ppBand);
 262   if (FAILED(hr)) {
 263     ERR(": could not create object\n");
 264     return hr;
 265   }
 266   /* acquire PersistStream interface */
 267   hr = IDirectMusicBand_QueryInterface (*ppBand, &IID_IPersistStream, (LPVOID*) &pPersistStream);
 268   if (FAILED(hr)) {
 269     ERR(": could not acquire IPersistStream\n");
 270     return hr;
 271   }
 272   /* load */
 273   hr = IPersistStream_Load (pPersistStream, pClonedStream);
 274   if (FAILED(hr)) {
 275     ERR(": failed to load object\n");
 276     return hr;
 277   }
 278
 279   /* release all loading-related stuff */
 280   IPersistStream_Release (pPersistStream);
 281
 282   return S_OK;
 283 }
 284
 285 static HRESULT parse_part_ref_list(DMUS_PRIVATE_CHUNK *pChunk, IStream *pStm,
 286         DMUS_PRIVATE_STYLE_MOTIF *pNewMotif)
 287 {
 288   HRESULT hr = E_FAIL;
 289   DMUS_PRIVATE_CHUNK Chunk;
 290   DWORD ListSize[3], ListCount[3];
 291   LARGE_INTEGER liMove; /* used when skipping chunks */
 292
 293   LPDMUS_PRIVATE_STYLE_PARTREF_ITEM pNewItem = NULL;
 294
 295
 296   if (pChunk->fccID != DMUS_FOURCC_PARTREF_LIST) {
 297     ERR_(dmfile)(": %s chunk should be a PARTREF list\n", debugstr_fourcc (pChunk->fccID));
 298     return E_FAIL;
 299   }
 300
 301   ListSize[0] = pChunk->dwSize - sizeof(FOURCC);
 302   ListCount[0] = 0;
 303
 304   do {
 305     IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
 306     ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
 307     TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
 308     switch (Chunk.fccID) {
 309     case DMUS_FOURCC_PARTREF_CHUNK: {
 310       TRACE_(dmfile)(": PartRef chunk\n");
 311       pNewItem = HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, sizeof(DMUS_PRIVATE_STYLE_PARTREF_ITEM));
 312       if (!pNewItem) {
 313         ERR(": no more memory\n");
 314         return E_OUTOFMEMORY;
 315       }
 316       hr = IStream_Read (pStm, &pNewItem->part_ref, sizeof(DMUS_IO_PARTREF), NULL);
 317       /*TRACE_(dmfile)(" - sizeof %lu\n",  sizeof(DMUS_IO_PARTREF));*/
 318       list_add_tail (&pNewMotif->Items, &pNewItem->entry);
 319       pNewItem->desc.dwSize = sizeof(pNewItem->desc);
 320       break;
 321     }
 322     case FOURCC_LIST: {
 323       IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL);
 324       TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(Chunk.fccID));
 325       ListSize[1] = Chunk.dwSize - sizeof(FOURCC);
 326       ListCount[1] = 0;
 327       switch (Chunk.fccID) {
 328       case DMUS_FOURCC_UNFO_LIST: {
 329         TRACE_(dmfile)(": UNFO list\n");
 330         do {
 331           IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
 332           ListCount[1] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
 333           TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
 334
 335           if (!pNewItem) {
 336             ERR(": pNewItem not yet allocated, chunk order bad?\n");
 337             return E_OUTOFMEMORY;
 338           }
 339           hr = IDirectMusicUtils_IPersistStream_ParseUNFOGeneric(&Chunk, pStm, &pNewItem->desc);
 340           if (FAILED(hr)) return hr;
 341
 342           if (hr == S_FALSE) {
 343             switch (Chunk.fccID) {
 344             default: {
 345               TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
 346               liMove.QuadPart = Chunk.dwSize;
 347               IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 348               break;
 349             }
 350             }
 351           }
 352           TRACE_(dmfile)(": ListCount[1] = %d < ListSize[1] = %d\n", ListCount[1], ListSize[1]);
 353         } while (ListCount[1] < ListSize[1]);
 354         break;
 355       }
 356       default: {
 357         TRACE_(dmfile)(": unknown chunk (skipping)\n");
 358         liMove.QuadPart = Chunk.dwSize - sizeof(FOURCC);
 359         IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 360         break;
 361       }
 362       }
 363       break;
 364     }
 365     default: {
 366       TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
 367       liMove.QuadPart = Chunk.dwSize;
 368       IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 369       break;
 370     }
 371     }
 372     TRACE_(dmfile)(": ListCount[0] = %d < ListSize[0] = %d\n", ListCount[0], ListSize[0]);
 373   } while (ListCount[0] < ListSize[0]);
 374
 375   return S_OK;
 376 }
 377
 378 static HRESULT parse_part_list(DMUS_PRIVATE_CHUNK *pChunk, IStream *pStm)
 379 {
 380   HRESULT hr = E_FAIL;
 381   DMUS_PRIVATE_CHUNK Chunk;
 382   DWORD ListSize[3], ListCount[3];
 383   LARGE_INTEGER liMove; /* used when skipping chunks */
 384
 385   DMUS_OBJECTDESC desc;
 386   DWORD dwSize = 0;
 387   DWORD cnt = 0;
 388
 389   if (pChunk->fccID != DMUS_FOURCC_PART_LIST) {
 390     ERR_(dmfile)(": %s chunk should be a PART list\n", debugstr_fourcc (pChunk->fccID));
 391     return E_FAIL;
 392   }
 393
 394   ListSize[0] = pChunk->dwSize - sizeof(FOURCC);
 395   ListCount[0] = 0;
 396
 397   do {
 398     IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
 399     ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
 400     TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
 401     switch (Chunk.fccID) {
 402     case DMUS_FOURCC_PART_CHUNK: {
 403       TRACE_(dmfile)(": Part chunk (skipping for now)\n" );
 404       liMove.QuadPart = Chunk.dwSize;
 405       IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 406       break;
 407     }
 408     case DMUS_FOURCC_NOTE_CHUNK: {
 409       TRACE_(dmfile)(": Note chunk (skipping for now)\n");
 410       IStream_Read (pStm, &dwSize, sizeof(DWORD), NULL);
 411       cnt = (Chunk.dwSize - sizeof(DWORD));
 412       TRACE_(dmfile)(" - dwSize: %u\n", dwSize);
 413       TRACE_(dmfile)(" - cnt: %u (%u / %u)\n", cnt / dwSize, (DWORD)(Chunk.dwSize - sizeof(DWORD)), dwSize);
 414       if (cnt % dwSize != 0) {
 415         ERR("Invalid Array Size\n");
 416         return E_FAIL;
 417       }
 418       cnt /= dwSize;
 419       /** skip for now */
 420       liMove.QuadPart = cnt * dwSize;
 421       IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 422       break;
 423     }
 424     case DMUS_FOURCC_CURVE_CHUNK: {
 425       TRACE_(dmfile)(": Curve chunk (skipping for now)\n");
 426       IStream_Read (pStm, &dwSize, sizeof(DWORD), NULL);
 427       cnt = (Chunk.dwSize - sizeof(DWORD));
 428       TRACE_(dmfile)(" - dwSize: %u\n", dwSize);
 429       TRACE_(dmfile)(" - cnt: %u (%u / %u)\n", cnt / dwSize, (DWORD)(Chunk.dwSize - sizeof(DWORD)), dwSize);
 430       if (cnt % dwSize != 0) {
 431         ERR("Invalid Array Size\n");
 432         return E_FAIL;
 433       }
 434       cnt /= dwSize;
 435       /** skip for now */
 436       liMove.QuadPart = cnt * dwSize;
 437       IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 438       break;
 439     }
 440     case DMUS_FOURCC_MARKER_CHUNK: {
 441       TRACE_(dmfile)(": Marker chunk (skipping for now)\n");
 442       liMove.QuadPart = Chunk.dwSize;
 443       IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 444       break;
 445     }
 446     case DMUS_FOURCC_RESOLUTION_CHUNK: {
 447       TRACE_(dmfile)(": Resolution chunk (skipping for now)\n");
 448       liMove.QuadPart = Chunk.dwSize;
 449       IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 450       break;
 451     }
 452     case DMUS_FOURCC_ANTICIPATION_CHUNK: {
 453       TRACE_(dmfile)(": Anticipation chunk (skipping for now)\n");
 454       liMove.QuadPart = Chunk.dwSize;
 455       IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 456       break;
 457     }
 458     case FOURCC_LIST: {
 459       IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL);
 460       TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(Chunk.fccID));
 461       ListSize[1] = Chunk.dwSize - sizeof(FOURCC);
 462       ListCount[1] = 0;
 463       switch (Chunk.fccID) {
 464       case DMUS_FOURCC_UNFO_LIST: {
 465         TRACE_(dmfile)(": UNFO list\n");
 466         do {
 467           IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
 468           ListCount[1] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
 469           TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
 470
 471           hr = IDirectMusicUtils_IPersistStream_ParseUNFOGeneric(&Chunk, pStm, &desc);
 472           if (FAILED(hr)) return hr;
 473
 474           if (hr == S_FALSE) {
 475             switch (Chunk.fccID) {
 476             default: {
 477               TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
 478               liMove.QuadPart = Chunk.dwSize;
 479               IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 480               break;
 481             }
 482             }
 483           }
 484           TRACE_(dmfile)(": ListCount[1] = %d < ListSize[1] = %d\n", ListCount[1], ListSize[1]);
 485         } while (ListCount[1] < ListSize[1]);
 486         break;
 487       }
 488       default: {
 489         TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
 490         liMove.QuadPart = Chunk.dwSize;
 491         IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 492         break;
 493       }
 494       }
 495     break;
 496     }
 497     default: {
 498       TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
 499       liMove.QuadPart = Chunk.dwSize;
 500       IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 501       break;
 502     }
 503     }
 504     TRACE_(dmfile)(": ListCount[0] = %d < ListSize[0] = %d\n", ListCount[0], ListSize[0]);
 505   } while (ListCount[0] < ListSize[0]);
 506
 507   return S_OK;
 508 }
 509
 510 static HRESULT parse_pattern_list(IDirectMusicStyle8Impl *This, DMUS_PRIVATE_CHUNK *pChunk,
 511         IStream *pStm)
 512 {
 513   HRESULT hr = E_FAIL;
 514   DMUS_PRIVATE_CHUNK Chunk;
 515   DWORD ListSize[3], ListCount[3];
 516   LARGE_INTEGER liMove; /* used when skipping chunks */
 517
 518   IDirectMusicBand* pBand = NULL;
 519   LPDMUS_PRIVATE_STYLE_MOTIF pNewMotif = NULL;
 520
 521   if (pChunk->fccID != DMUS_FOURCC_PATTERN_LIST) {
 522     ERR_(dmfile)(": %s chunk should be a PATTERN list\n", debugstr_fourcc (pChunk->fccID));
 523     return E_FAIL;
 524   }
 525
 526   ListSize[0] = pChunk->dwSize - sizeof(FOURCC);
 527   ListCount[0] = 0;
 528
 529   do {
 530     IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
 531     ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
 532     TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
 533     switch (Chunk.fccID) {
 534     case DMUS_FOURCC_PATTERN_CHUNK: {
 535       TRACE_(dmfile)(": Pattern chunk\n");
 536       /** alloc new motif entry */
 537       pNewMotif = HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, sizeof(DMUS_PRIVATE_STYLE_MOTIF));
 538       if (NULL == pNewMotif) {
 539         ERR(": no more memory\n");
 540         return  E_OUTOFMEMORY;
 541       }
 542       list_add_tail (&This->Motifs, &pNewMotif->entry);
 543
 544       IStream_Read (pStm, &pNewMotif->pattern, Chunk.dwSize, NULL);
 545       /** TODO trace pattern */
 546
 547       /** reset all data, as a new pattern begin */
 548       pNewMotif->desc.dwSize = sizeof(pNewMotif->desc);
 549       list_init (&pNewMotif->Items);
 550       break;
 551     }
 552     case DMUS_FOURCC_RHYTHM_CHUNK: {
 553       TRACE_(dmfile)(": Rhythm chunk\n");
 554       IStream_Read (pStm, &pNewMotif->dwRhythm, sizeof(DWORD), NULL);
 555       TRACE_(dmfile)(" - dwRhythm: %u\n", pNewMotif->dwRhythm);
 556       /** TODO understand why some Chunks have size > 4 */
 557       liMove.QuadPart = Chunk.dwSize - sizeof(DWORD);
 558       IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 559       break;
 560     }
 561     case DMUS_FOURCC_MOTIFSETTINGS_CHUNK: {
 562       TRACE_(dmfile)(": MotifSettings chunk (skipping for now)\n");
 563       IStream_Read (pStm, &pNewMotif->settings, Chunk.dwSize, NULL);
 564       /** TODO trace settings */
 565       break;
 566     }
 567     case FOURCC_RIFF: {
 568       /**
 569        * should be embedded Bands into pattern
 570        */
 571       IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL);
 572       TRACE_(dmfile)(": RIFF chunk of type %s", debugstr_fourcc(Chunk.fccID));
 573       ListSize[1] = Chunk.dwSize - sizeof(FOURCC);
 574       ListCount[1] = 0;
 575       switch (Chunk.fccID) {
 576       case DMUS_FOURCC_BAND_FORM: {
 577         LPSTREAM pClonedStream = NULL;
 578
 579         TRACE_(dmfile)(": BAND RIFF\n");
 580
 581         IStream_Clone (pStm, &pClonedStream);
 582
 583         liMove.QuadPart = 0;
 584         liMove.QuadPart -= sizeof(FOURCC) + (sizeof(FOURCC)+sizeof(DWORD));
 585         IStream_Seek (pClonedStream, liMove, STREAM_SEEK_CUR, NULL);
 586
 587         hr = load_band(pClonedStream, &pBand);
 588         if (FAILED(hr)) {
 589           ERR(": could not load track\n");
 590           return hr;
 591         }
 592         IStream_Release (pClonedStream);
 593
 594         pNewMotif->pBand = pBand;
 595         IDirectMusicBand_AddRef(pBand);
 596
 597         IDirectMusicTrack_Release(pBand); pBand = NULL;  /* now we can release it as it's inserted */
 598
 599         /** now safe move the cursor */
 600         liMove.QuadPart = ListSize[1];
 601         IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 602
 603         break;
 604       }
 605       default: {
 606         TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
 607         liMove.QuadPart = ListSize[1];
 608         IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 609         break;
 610       }
 611       }
 612       break;
 613     }
 614     case FOURCC_LIST: {
 615       IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL);
 616       TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(Chunk.fccID));
 617       ListSize[1] = Chunk.dwSize - sizeof(FOURCC);
 618       ListCount[1] = 0;
 619       switch (Chunk.fccID) {
 620       case DMUS_FOURCC_UNFO_LIST: {
 621         TRACE_(dmfile)(": UNFO list\n");
 622         do {
 623           IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
 624           ListCount[1] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
 625           TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
 626
 627           hr = IDirectMusicUtils_IPersistStream_ParseUNFOGeneric(&Chunk, pStm, &pNewMotif->desc);
 628           if (FAILED(hr)) return hr;
 629
 630           if (hr == S_FALSE) {
 631             switch (Chunk.fccID) {
 632             default: {
 633               TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
 634               liMove.QuadPart = Chunk.dwSize;
 635               IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 636               break;
 637             }
 638             }
 639           }
 640           TRACE_(dmfile)(": ListCount[1] = %d < ListSize[1] = %d\n", ListCount[1], ListSize[1]);
 641         } while (ListCount[1] < ListSize[1]);
 642         break;
 643       }
 644       case DMUS_FOURCC_PARTREF_LIST: {
 645         TRACE_(dmfile)(": PartRef list\n");
 646         hr = parse_part_ref_list(&Chunk, pStm, pNewMotif);
 647         if (FAILED(hr)) return hr;
 648         break;
 649       }
 650       default: {
 651         TRACE_(dmfile)(": unknown (skipping)\n");
 652         liMove.QuadPart = Chunk.dwSize - sizeof(FOURCC);
 653         IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 654         break;
 655       }
 656       }
 657       break;
 658     }
 659     default: {
 660       TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
 661       liMove.QuadPart = Chunk.dwSize;
 662       IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 663       break;
 664     }
 665     }
 666     TRACE_(dmfile)(": ListCount[0] = %d < ListSize[0] = %d\n", ListCount[0], ListSize[0]);
 667   } while (ListCount[0] < ListSize[0]);
 668
 669   return S_OK;
 670 }
 671
 672 static HRESULT parse_style_form(IDirectMusicStyle8Impl *This, DMUS_PRIVATE_CHUNK *pChunk,
 673         IStream *pStm)
 674 {
 675   HRESULT hr = E_FAIL;
 676   DMUS_PRIVATE_CHUNK Chunk;
 677   DWORD StreamSize, StreamCount, ListSize[3], ListCount[3];
 678   LARGE_INTEGER liMove; /* used when skipping chunks */
 679
 680   IDirectMusicBand* pBand = NULL;
 681
 682   if (pChunk->fccID != DMUS_FOURCC_STYLE_FORM) {
 683     ERR_(dmfile)(": %s chunk should be a STYLE form\n", debugstr_fourcc (pChunk->fccID));
 684     return E_FAIL;
 685   }
 686
 687   StreamSize = pChunk->dwSize - sizeof(FOURCC);
 688   StreamCount = 0;
 689
 690   do {
 691     IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
 692     StreamCount += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
 693     TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
 694
 695     hr = IDirectMusicUtils_IPersistStream_ParseDescGeneric(&Chunk, pStm, &This->dmobj.desc);
 696     if (FAILED(hr)) return hr;
 697
 698     if (hr == S_FALSE) {
 699       switch (Chunk.fccID) {
 700       case DMUS_FOURCC_STYLE_CHUNK: {
 701         TRACE_(dmfile)(": Style chunk\n");
 702         IStream_Read (pStm, &This->style, sizeof(DMUS_IO_STYLE), NULL);
 703         /** TODO dump DMUS_IO_TIMESIG style.timeSig */
 704         TRACE_(dmfile)(" - dblTempo: %g\n", This->style.dblTempo);
 705         break;
 706       }
 707       case FOURCC_RIFF: {
 708         /**
 709          * should be embedded Bands into style
 710          */
 711         IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL);
 712         TRACE_(dmfile)(": RIFF chunk of type %s", debugstr_fourcc(Chunk.fccID));
 713         ListSize[0] = Chunk.dwSize - sizeof(FOURCC);
 714         ListCount[0] = 0;
 715         switch (Chunk.fccID) {
 716         case DMUS_FOURCC_BAND_FORM: {
 717           LPSTREAM pClonedStream = NULL;
 718           LPDMUS_PRIVATE_STYLE_BAND pNewBand;
 719
 720           TRACE_(dmfile)(": BAND RIFF\n");
 721
 722           IStream_Clone (pStm, &pClonedStream);
 723
 724           liMove.QuadPart = 0;
 725           liMove.QuadPart -= sizeof(FOURCC) + (sizeof(FOURCC)+sizeof(DWORD));
 726           IStream_Seek (pClonedStream, liMove, STREAM_SEEK_CUR, NULL);
 727
 728           hr = load_band(pClonedStream, &pBand);
 729           if (FAILED(hr)) {
 730             ERR(": could not load track\n");
 731             return hr;
 732           }
 733           IStream_Release (pClonedStream);
 734
 735           pNewBand = HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, sizeof(DMUS_PRIVATE_STYLE_BAND));
 736           if (NULL == pNewBand) {
 737             ERR(": no more memory\n");
 738             return  E_OUTOFMEMORY;
 739           }
 740           pNewBand->pBand = pBand;
 741           IDirectMusicBand_AddRef(pBand);
 742           list_add_tail (&This->Bands, &pNewBand->entry);
 743
 744           IDirectMusicTrack_Release(pBand); pBand = NULL;  /* now we can release it as it's inserted */
 745
 746           /** now safely move the cursor */
 747           liMove.QuadPart = ListSize[0];
 748           IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 749
 750           break;
 751         }
 752         default: {
 753           TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
 754           liMove.QuadPart = ListSize[0];
 755           IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 756           break;
 757         }
 758         }
 759         break;
 760       }
 761       case FOURCC_LIST: {
 762         IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL);
 763         TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(Chunk.fccID));
 764         ListSize[0] = Chunk.dwSize - sizeof(FOURCC);
 765         ListCount[0] = 0;
 766         switch (Chunk.fccID) {
 767         case DMUS_FOURCC_UNFO_LIST: {
 768           TRACE_(dmfile)(": UNFO list\n");
 769           do {
 770             IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
 771             ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
 772             TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
 773
 774             hr = IDirectMusicUtils_IPersistStream_ParseUNFOGeneric(&Chunk, pStm, &This->dmobj.desc);
 775             if (FAILED(hr)) return hr;
 776
 777             if (hr == S_FALSE) {
 778               switch (Chunk.fccID) {
 779               default: {
 780                 TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
 781                 liMove.QuadPart = Chunk.dwSize;
 782                 IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 783                 break;
 784               }
 785               }
 786             }
 787             TRACE_(dmfile)(": ListCount[0] = %d < ListSize[0] = %d\n", ListCount[0], ListSize[0]);
 788           } while (ListCount[0] < ListSize[0]);
 789           break;
 790         }
 791         case DMUS_FOURCC_PART_LIST: {
 792           TRACE_(dmfile)(": PART list\n");
 793           hr = parse_part_list(&Chunk, pStm);
 794           if (FAILED(hr)) return hr;
 795           break;
 796         }
 797         case  DMUS_FOURCC_PATTERN_LIST: {
 798           TRACE_(dmfile)(": PATTERN list\n");
 799           hr = parse_pattern_list(This, &Chunk, pStm);
 800           if (FAILED(hr)) return hr;
 801           break;
 802         }
 803         default: {
 804           TRACE_(dmfile)(": unknown (skipping)\n");
 805           liMove.QuadPart = Chunk.dwSize - sizeof(FOURCC);
 806           IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 807           break;
 808         }
 809         }
 810         break;
 811       }
 812       default: {
 813         TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
 814         liMove.QuadPart = Chunk.dwSize;
 815         IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 816         break;
 817       }
 818       }
 819     }
 820     TRACE_(dmfile)(": StreamCount[0] = %d < StreamSize[0] = %d\n", StreamCount, StreamSize);
 821   } while (StreamCount < StreamSize);
 822
 823   return S_OK;
 824 }
 825
 826 static HRESULT WINAPI IPersistStreamImpl_Load(IPersistStream *iface, IStream *pStm)
 827 {
 828   IDirectMusicStyle8Impl *This = impl_from_IPersistStream(iface);
 829   DMUS_PRIVATE_CHUNK Chunk;
 830   LARGE_INTEGER liMove; /* used when skipping chunks */
 831   HRESULT hr;
 832
 833   FIXME("(%p, %p): Loading\n", This, pStm);
 834
 835   IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
 836   TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
 837   switch (Chunk.fccID) {
 838   case FOURCC_RIFF: {
 839     IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL);
 840     TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
 841     switch (Chunk.fccID) {
 842     case DMUS_FOURCC_STYLE_FORM: {
 843       TRACE_(dmfile)(": Style form\n");
 844       hr = parse_style_form(This, &Chunk, pStm);
 845       if (FAILED(hr)) return hr;
 846       break;
 847     }
 848     default: {
 849       TRACE_(dmfile)(": unexpected chunk; loading failed)\n");
 850       liMove.QuadPart = Chunk.dwSize;
 851       IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); /* skip the rest of the chunk */
 852       return E_FAIL;
 853     }
 854     }
 855     TRACE_(dmfile)(": reading finished\n");
 856     break;
 857   }
 858   default: {
 859     TRACE_(dmfile)(": unexpected chunk; loading failed)\n");
 860     liMove.QuadPart = Chunk.dwSize;
 861     IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); /* skip the rest of the chunk */
 862     return E_FAIL;
 863   }
 864   }
 865
 866   return S_OK;
 867 }
 868
 869 static const IPersistStreamVtbl persiststream_vtbl = {
 870     dmobj_IPersistStream_QueryInterface,
 871     dmobj_IPersistStream_AddRef,
 872     dmobj_IPersistStream_Release,
 873     dmobj_IPersistStream_GetClassID,
 874     unimpl_IPersistStream_IsDirty,
 875     IPersistStreamImpl_Load,
 876     unimpl_IPersistStream_Save,
 877     unimpl_IPersistStream_GetSizeMax
 878 };
 879
 880 /* for ClassFactory */
 881 HRESULT WINAPI create_dmstyle(REFIID lpcGUID, void **ppobj)
 882 {
 883   IDirectMusicStyle8Impl* obj;
 884   HRESULT hr;
 885
 886   obj = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectMusicStyle8Impl));
 887   if (NULL == obj) {
 888     *ppobj = NULL;
 889     return E_OUTOFMEMORY;
 890   }
 891   obj->IDirectMusicStyle8_iface.lpVtbl = &dmstyle8_vtbl;
 892   obj->ref = 1;
 893   dmobject_init(&obj->dmobj, &CLSID_DirectMusicStyle, (IUnknown *)&obj->IDirectMusicStyle8_iface);
 894   obj->dmobj.IDirectMusicObject_iface.lpVtbl = &dmobject_vtbl;
 895   obj->dmobj.IPersistStream_iface.lpVtbl = &persiststream_vtbl;
 896   list_init (&obj->Bands);
 897   list_init (&obj->Motifs);
 898
 899   DMSTYLE_LockModule();
 900   hr = IDirectMusicStyle8_QueryInterface(&obj->IDirectMusicStyle8_iface, lpcGUID, ppobj);
 901   IDirectMusicStyle8_Release(&obj->IDirectMusicStyle8_iface);
 902
 903   return hr;
 904 }