git.oblomov.eu Git - wine/blob - dlls/dmstyle/styletrack.c

   1 /* IDirectMusicStyleTrack Implementation
   2  *
   3  * Copyright (C) 2003 Rok Mandeljc
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 2 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  18  */
  19
  20 #include <stdarg.h>
  21
  22 #include "windef.h"
  23 #include "winbase.h"
  24 #include "winuser.h"
  25 #include "wingdi.h"
  26 #include "wine/debug.h"
  27
  28 #include "dmstyle_private.h"
  29
  30 WINE_DEFAULT_DEBUG_CHANNEL(dmstyle);
  31 WINE_DECLARE_DEBUG_CHANNEL(dmfile);
  32
  33 /*****************************************************************************
  34  * IDirectMusicStyleTrack implementation
  35  */
  36 /* IDirectMusicStyleTrack IUnknown part: */
  37 HRESULT WINAPI IDirectMusicStyleTrack_QueryInterface (LPDIRECTMUSICTRACK8 iface, REFIID riid, LPVOID *ppobj)
  38 {
  39         ICOM_THIS(IDirectMusicStyleTrack,iface);
  40
  41         if (IsEqualIID (riid, &IID_IUnknown) ||
  42             IsEqualIID (riid, &IID_IDirectMusicTrack) ||
  43             IsEqualIID (riid, &IID_IDirectMusicTrack8)) {
  44                 IDirectMusicStyleTrack_AddRef(iface);
  45                 *ppobj = This;
  46                 return S_OK;
  47         } else if (IsEqualIID (riid, &IID_IPersistStream)) {
  48                 IDirectMusicStyleTrackStream_AddRef ((LPPERSISTSTREAM)This->pStream);
  49                 *ppobj = This->pStream;
  50                 return S_OK;
  51         }
  52
  53         WARN("(%p)->(%s,%p),not found\n", This, debugstr_guid(riid), ppobj);
  54         return E_NOINTERFACE;
  55 }
  56
  57 ULONG WINAPI IDirectMusicStyleTrack_AddRef (LPDIRECTMUSICTRACK8 iface)
  58 {
  59         ICOM_THIS(IDirectMusicStyleTrack,iface);
  60         TRACE("(%p) : AddRef from %ld\n", This, This->ref);
  61         return ++(This->ref);
  62 }
  63
  64 ULONG WINAPI IDirectMusicStyleTrack_Release (LPDIRECTMUSICTRACK8 iface)
  65 {
  66         ICOM_THIS(IDirectMusicStyleTrack,iface);
  67         ULONG ref = --This->ref;
  68         TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
  69         if (ref == 0) {
  70                 HeapFree(GetProcessHeap(), 0, This);
  71         }
  72         return ref;
  73 }
  74
  75 /* IDirectMusicStyleTrack IDirectMusicTrack part: */
  76 HRESULT WINAPI IDirectMusicStyleTrack_Init (LPDIRECTMUSICTRACK8 iface, IDirectMusicSegment* pSegment)
  77 {
  78         ICOM_THIS(IDirectMusicStyleTrack,iface);
  79
  80         FIXME("(%p, %p): stub\n", This, pSegment);
  81
  82         return S_OK;
  83 }
  84
  85 HRESULT WINAPI IDirectMusicStyleTrack_InitPlay (LPDIRECTMUSICTRACK8 iface, IDirectMusicSegmentState* pSegmentState, IDirectMusicPerformance* pPerformance, void** ppStateData, DWORD dwVirtualTrack8ID, DWORD dwFlags)
  86 {
  87         ICOM_THIS(IDirectMusicStyleTrack,iface);
  88
  89         FIXME("(%p, %p, %p, %p, %ld, %ld): stub\n", This, pSegmentState, pPerformance, ppStateData, dwVirtualTrack8ID, dwFlags);
  90
  91         return S_OK;
  92 }
  93
  94 HRESULT WINAPI IDirectMusicStyleTrack_EndPlay (LPDIRECTMUSICTRACK8 iface, void* pStateData)
  95 {
  96         ICOM_THIS(IDirectMusicStyleTrack,iface);
  97
  98         FIXME("(%p, %p): stub\n", This, pStateData);
  99
 100         return S_OK;
 101 }
 102
 103 HRESULT WINAPI IDirectMusicStyleTrack_Play (LPDIRECTMUSICTRACK8 iface, void* pStateData, MUSIC_TIME mtStart, MUSIC_TIME mtEnd, MUSIC_TIME mtOffset, DWORD dwFlags, IDirectMusicPerformance* pPerf, IDirectMusicSegmentState* pSegSt, DWORD dwVirtualID)
 104 {
 105         ICOM_THIS(IDirectMusicStyleTrack,iface);
 106
 107         FIXME("(%p, %p, %ld, %ld, %ld, %ld, %p, %p, %ld): stub\n", This, pStateData, mtStart, mtEnd, mtOffset, dwFlags, pPerf, pSegSt, dwVirtualID);
 108
 109         return S_OK;
 110 }
 111
 112 HRESULT WINAPI IDirectMusicStyleTrack_GetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, MUSIC_TIME* pmtNext, void* pParam)
 113 {
 114         ICOM_THIS(IDirectMusicStyleTrack,iface);
 115
 116         FIXME("(%p, %s, %ld, %p, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pmtNext, pParam);
 117
 118         return S_OK;
 119 }
 120
 121 HRESULT WINAPI IDirectMusicStyleTrack_SetParam (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, MUSIC_TIME mtTime, void* pParam)
 122 {
 123         ICOM_THIS(IDirectMusicStyleTrack,iface);
 124
 125         FIXME("(%p, %s, %ld, %p): stub\n", This, debugstr_guid(rguidType), mtTime, pParam);
 126
 127         return S_OK;
 128 }
 129
 130 HRESULT WINAPI IDirectMusicStyleTrack_IsParamSupported (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType)
 131 {
 132         ICOM_THIS(IDirectMusicStyleTrack,iface);
 133
 134         TRACE("(%p, %s): ", This, debugstr_guid(rguidType));
 135         if (IsEqualGUID (rguidType, &GUID_DisableTimeSig)
 136                 || IsEqualGUID (rguidType, &GUID_EnableTimeSig)
 137                 || IsEqualGUID (rguidType, &GUID_IDirectMusicStyle)
 138                 || IsEqualGUID (rguidType, &GUID_SeedVariations)
 139                 || IsEqualGUID (rguidType, &GUID_TimeSignature)) {
 140                 TRACE("param supported\n");
 141                 return S_OK;
 142                 }
 143
 144         TRACE("param unsupported\n");
 145         return DMUS_E_TYPE_UNSUPPORTED;
 146 }
 147
 148 HRESULT WINAPI IDirectMusicStyleTrack_AddNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType)
 149 {
 150         ICOM_THIS(IDirectMusicStyleTrack,iface);
 151
 152         FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
 153
 154         return S_OK;
 155 }
 156
 157 HRESULT WINAPI IDirectMusicStyleTrack_RemoveNotificationType (LPDIRECTMUSICTRACK8 iface, REFGUID rguidNotificationType)
 158 {
 159         ICOM_THIS(IDirectMusicStyleTrack,iface);
 160
 161         FIXME("(%p, %s): stub\n", This, debugstr_guid(rguidNotificationType));
 162
 163         return S_OK;
 164 }
 165
 166 HRESULT WINAPI IDirectMusicStyleTrack_Clone (LPDIRECTMUSICTRACK8 iface, MUSIC_TIME mtStart, MUSIC_TIME mtEnd, IDirectMusicTrack** ppTrack)
 167 {
 168         ICOM_THIS(IDirectMusicStyleTrack,iface);
 169
 170         FIXME("(%p, %ld, %ld, %p): stub\n", This, mtStart, mtEnd, ppTrack);
 171
 172         return S_OK;
 173 }
 174
 175 /* IDirectMusicStyleTrack IDirectMusicTrack8 part: */
 176 HRESULT WINAPI IDirectMusicStyleTrack_PlayEx (LPDIRECTMUSICTRACK8 iface, void* pStateData, REFERENCE_TIME rtStart, REFERENCE_TIME rtEnd, REFERENCE_TIME rtOffset, DWORD dwFlags, IDirectMusicPerformance* pPerf, IDirectMusicSegmentState* pSegSt, DWORD dwVirtualID)
 177 {
 178         ICOM_THIS(IDirectMusicStyleTrack,iface);
 179
 180         FIXME("(%p, %p, %lli, %lli, %lli, %ld, %p, %p, %ld): stub\n", This, pStateData, rtStart, rtEnd, rtOffset, dwFlags, pPerf, pSegSt, dwVirtualID);
 181
 182         return S_OK;
 183 }
 184
 185 HRESULT WINAPI IDirectMusicStyleTrack_GetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, REFERENCE_TIME* prtNext, void* pParam, void* pStateData, DWORD dwFlags)
 186 {
 187         ICOM_THIS(IDirectMusicStyleTrack,iface);
 188
 189         FIXME("(%p, %s, %lli, %p, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, prtNext, pParam, pStateData, dwFlags);
 190
 191         return S_OK;
 192 }
 193
 194 HRESULT WINAPI IDirectMusicStyleTrack_SetParamEx (LPDIRECTMUSICTRACK8 iface, REFGUID rguidType, REFERENCE_TIME rtTime, void* pParam, void* pStateData, DWORD dwFlags)
 195 {
 196         ICOM_THIS(IDirectMusicStyleTrack,iface);
 197
 198         FIXME("(%p, %s, %lli, %p, %p, %ld): stub\n", This, debugstr_guid(rguidType), rtTime, pParam, pStateData, dwFlags);
 199
 200         return S_OK;
 201 }
 202
 203 HRESULT WINAPI IDirectMusicStyleTrack_Compose (LPDIRECTMUSICTRACK8 iface, IUnknown* pContext, DWORD dwTrackGroup, IDirectMusicTrack** ppResultTrack)
 204 {
 205         ICOM_THIS(IDirectMusicStyleTrack,iface);
 206
 207         FIXME("(%p, %p, %ld, %p): stub\n", This, pContext, dwTrackGroup, ppResultTrack);
 208
 209         return S_OK;
 210 }
 211
 212 HRESULT WINAPI IDirectMusicStyleTrack_Join (LPDIRECTMUSICTRACK8 iface, IDirectMusicTrack* pNewTrack, MUSIC_TIME mtJoin, IUnknown* pContext, DWORD dwTrackGroup, IDirectMusicTrack** ppResultTrack)
 213 {
 214         ICOM_THIS(IDirectMusicStyleTrack,iface);
 215
 216         FIXME("(%p, %p, %ld, %p, %ld, %p): stub\n", This, pNewTrack, mtJoin, pContext, dwTrackGroup, ppResultTrack);
 217
 218         return S_OK;
 219 }
 220
 221 ICOM_VTABLE(IDirectMusicTrack8) DirectMusicStyleTrack_Vtbl =
 222 {
 223     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 224         IDirectMusicStyleTrack_QueryInterface,
 225         IDirectMusicStyleTrack_AddRef,
 226         IDirectMusicStyleTrack_Release,
 227         IDirectMusicStyleTrack_Init,
 228         IDirectMusicStyleTrack_InitPlay,
 229         IDirectMusicStyleTrack_EndPlay,
 230         IDirectMusicStyleTrack_Play,
 231         IDirectMusicStyleTrack_GetParam,
 232         IDirectMusicStyleTrack_SetParam,
 233         IDirectMusicStyleTrack_IsParamSupported,
 234         IDirectMusicStyleTrack_AddNotificationType,
 235         IDirectMusicStyleTrack_RemoveNotificationType,
 236         IDirectMusicStyleTrack_Clone,
 237         IDirectMusicStyleTrack_PlayEx,
 238         IDirectMusicStyleTrack_GetParamEx,
 239         IDirectMusicStyleTrack_SetParamEx,
 240         IDirectMusicStyleTrack_Compose,
 241         IDirectMusicStyleTrack_Join
 242 };
 243
 244 /* for ClassFactory */
 245 HRESULT WINAPI DMUSIC_CreateDirectMusicStyleTrack (LPCGUID lpcGUID, LPDIRECTMUSICTRACK8 *ppTrack, LPUNKNOWN pUnkOuter)
 246 {
 247         IDirectMusicStyleTrack* track;
 248
 249         if (IsEqualIID (lpcGUID, &IID_IDirectMusicTrack)
 250                 || IsEqualIID (lpcGUID, &IID_IDirectMusicTrack8)) {
 251                 track = HeapAlloc (GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectMusicStyleTrack));
 252                 if (NULL == track) {
 253                         *ppTrack = (LPDIRECTMUSICTRACK8) NULL;
 254                         return E_OUTOFMEMORY;
 255                 }
 256                 track->lpVtbl = &DirectMusicStyleTrack_Vtbl;
 257                 track->ref = 1;
 258                 track->pStream = HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, sizeof(IDirectMusicStyleTrackStream));
 259                 track->pStream->lpVtbl = &DirectMusicStyleTrackStream_Vtbl;
 260                 track->pStream->ref = 1;
 261                 track->pStream->pParentTrack = track;
 262                 *ppTrack = (LPDIRECTMUSICTRACK8) track;
 263                 return S_OK;
 264         }
 265         WARN("No interface found\n");
 266
 267         return E_NOINTERFACE;
 268 }
 269
 270
 271 /*****************************************************************************
 272  * IDirectMusicStyleTrackStream implementation
 273  */
 274 /* IDirectMusicStyleTrackStream IUnknown part follow: */
 275 HRESULT WINAPI IDirectMusicStyleTrackStream_QueryInterface (LPPERSISTSTREAM iface, REFIID riid, LPVOID *ppobj)
 276 {
 277         ICOM_THIS(IDirectMusicStyleTrackStream,iface);
 278
 279         if (IsEqualIID (riid, &IID_IUnknown)
 280                 || IsEqualIID (riid, &IID_IPersistStream)) {
 281                 IDirectMusicStyleTrackStream_AddRef(iface);
 282                 *ppobj = This;
 283                 return S_OK;
 284         }
 285
 286         WARN("(%p)->(%s,%p),not found\n",This,debugstr_guid(riid),ppobj);
 287         return E_NOINTERFACE;
 288 }
 289
 290 ULONG WINAPI IDirectMusicStyleTrackStream_AddRef (LPPERSISTSTREAM iface)
 291 {
 292         ICOM_THIS(IDirectMusicStyleTrackStream,iface);
 293         TRACE("(%p) : AddRef from %ld\n", This, This->ref);
 294         return ++(This->ref);
 295 }
 296
 297 ULONG WINAPI IDirectMusicStyleTrackStream_Release (LPPERSISTSTREAM iface)
 298 {
 299         ICOM_THIS(IDirectMusicStyleTrackStream,iface);
 300         ULONG ref = --This->ref;
 301         TRACE("(%p) : ReleaseRef to %ld\n", This, This->ref);
 302         if (ref == 0) {
 303                 HeapFree(GetProcessHeap(), 0, This);
 304         }
 305         return ref;
 306 }
 307
 308 /* IDirectMusicStyleTrackStream IPersist part: */
 309 HRESULT WINAPI IDirectMusicStyleTrackStream_GetClassID (LPPERSISTSTREAM iface, CLSID* pClassID)
 310 {
 311         return E_NOTIMPL;
 312 }
 313
 314 /* IDirectMusicStyleTrackStream IPersistStream part: */
 315 HRESULT WINAPI IDirectMusicStyleTrackStream_IsDirty (LPPERSISTSTREAM iface)
 316 {
 317         return E_NOTIMPL;
 318 }
 319
 320 HRESULT WINAPI IDirectMusicStyleTrackStream_Load (LPPERSISTSTREAM iface, IStream* pStm)
 321 {
 322         ICOM_THIS(IDirectMusicStyleTrackStream,iface);
 323         FOURCC chunkID;
 324         DWORD chunkSize, ListSize[3], ListCount[3];
 325         LARGE_INTEGER liMove; /* used when skipping chunks */
 326         DMUS_IO_REFERENCE tempReferenceHeader;
 327         DMUS_OBJECTDESC ObjDesc;
 328         IDirectMusicStyleTrack* pTrack = This->pParentTrack; /* that's where we load data to */
 329         LPDIRECTMUSICLOADER pLoader;
 330         LPDIRECTMUSICGETLOADER pGetLoader;
 331
 332         IStream_Read (pStm, &chunkID, sizeof(FOURCC), NULL);
 333         IStream_Read (pStm, &chunkSize, sizeof(DWORD), NULL);
 334         TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (chunkID), chunkSize);
 335         switch (chunkID) {
 336                 case FOURCC_LIST: {
 337                         IStream_Read (pStm, &chunkID, sizeof(FOURCC), NULL);
 338                         TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(chunkID));
 339                         ListSize[0] = chunkSize - sizeof(FOURCC);
 340                         ListCount[0] = 0;
 341                         switch (chunkID) {
 342                                 case DMUS_FOURCC_STYLE_TRACK_LIST: {
 343                                         TRACE_(dmfile)(": style track list\n");
 344                                         do {
 345                                                 IStream_Read (pStm, &chunkID, sizeof(FOURCC), NULL);
 346                                                 IStream_Read (pStm, &chunkSize, sizeof(FOURCC), NULL);
 347                                                 ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + chunkSize;
 348                                                 TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (chunkID), chunkSize);
 349                                                 switch (chunkID) {
 350                                                         case FOURCC_LIST: {
 351                                                                 IStream_Read (pStm, &chunkID, sizeof(FOURCC), NULL);
 352                                                                 TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(chunkID));
 353                                                                 ListSize[1] = chunkSize - sizeof(FOURCC);
 354                                                                 ListCount[1] = 0;
 355                                                                 switch (chunkID) {
 356                                                                         case DMUS_FOURCC_STYLE_REF_LIST: {
 357                                                                                 TRACE_(dmfile)(": style reference list\n");
 358                                                                                 do {
 359                                                                                         IStream_Read (pStm, &chunkID, sizeof(FOURCC), NULL);
 360                                                                                         IStream_Read (pStm, &chunkSize, sizeof(FOURCC), NULL);
 361                                                                                         ListCount[1] += sizeof(FOURCC) + sizeof(DWORD) + chunkSize;
 362                                                                                         TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (chunkID), chunkSize);
 363                                                                                         switch (chunkID) {
 364                                                                                                 case DMUS_FOURCC_TIME_STAMP_CHUNK: {
 365                                                                                                         TRACE_(dmfile)(": time stamp chunk\n");
 366                                                                                                         IStream_Read (pStm, &pTrack->pStampTimes[pTrack->dwStyles], sizeof(DWORD), NULL);
 367                                                                                                         TRACE_(dmfile)(": (READ): time stamp = %ld\n", pTrack->pStampTimes[pTrack->dwStyles]);
 368                                                                                                         break;
 369                                                                                                 }
 370                                                                                                 case FOURCC_LIST: {
 371                                                                                                         IStream_Read (pStm, &chunkID, sizeof(FOURCC), NULL);
 372                                                                                                         TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(chunkID));
 373                                                                                                         ListSize[2] = chunkSize - sizeof(FOURCC);
 374                                                                                                         ListCount[2] = 0;
 375                                                                                                         switch (chunkID) {
 376                                                                                                                 case DMUS_FOURCC_REF_LIST: {
 377                                                                                                                         TRACE_(dmfile)(": reference list\n");
 378                                                                                                                         ZeroMemory ((LPVOID)&ObjDesc, sizeof(DMUS_OBJECTDESC));
 379                                                                                                                         do {
 380                                                                                                                                 IStream_Read (pStm, &chunkID, sizeof(FOURCC), NULL);
 381                                                                                                                                 IStream_Read (pStm, &chunkSize, sizeof(FOURCC), NULL);
 382                                                                                                                                 ListCount[2] += sizeof(FOURCC) + sizeof(DWORD) + chunkSize;
 383                                                                                                                                 TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (chunkID), chunkSize);
 384                                                                                                                                 switch (chunkID) {
 385                                                                                                                                         case DMUS_FOURCC_REF_CHUNK: {
 386                                                                                                                                                 TRACE_(dmfile)(": reference header chunk\n");
 387                                                                                                                                                 IStream_Read (pStm, &tempReferenceHeader, chunkSize, NULL);
 388                                                                                                                                                 /* copy retrieved data to DMUS_OBJECTDESC */
 389                                                                                                                                                 ObjDesc.dwSize = sizeof(DMUS_OBJECTDESC);
 390                                                                                                                                                 ObjDesc.guidClass = tempReferenceHeader.guidClassID;
 391                                                                                                                                                 ObjDesc.dwValidData = tempReferenceHeader.dwValidData;
 392                                                                                                                                                 break;
 393                                                                                                                                         }
 394                                                                                                                                         case DMUS_FOURCC_GUID_CHUNK: {
 395                                                                                                                                                 TRACE_(dmfile)(": guid chunk\n");
 396                                                                                                                                                 IStream_Read (pStm, &ObjDesc.guidObject, chunkSize, NULL);
 397                                                                                                                                                 break;
 398                                                                                                                                         }
 399                                                                                                                                         case DMUS_FOURCC_DATE_CHUNK: {
 400                                                                                                                                                 TRACE_(dmfile)(": file date chunk\n");
 401                                                                                                                                                 IStream_Read (pStm, &ObjDesc.ftDate, chunkSize, NULL);
 402                                                                                                                                                 break;
 403                                                                                                                                         }
 404                                                                                                                                         case DMUS_FOURCC_NAME_CHUNK: {
 405                                                                                                                                                 TRACE_(dmfile)(": name chunk\n");
 406                                                                                                                                                 IStream_Read (pStm, &ObjDesc.wszName, chunkSize, NULL);
 407                                                                                                                                                 break;
 408                                                                                                                                         }
 409                                                                                                                                         case DMUS_FOURCC_FILE_CHUNK: {
 410                                                                                                                                                 TRACE_(dmfile)(": file name chunk\n");
 411                                                                                                                                                 IStream_Read (pStm, &ObjDesc.wszFileName, chunkSize, NULL);
 412                                                                                                                                                 break;
 413                                                                                                                                         }
 414                                                                                                                                         case DMUS_FOURCC_CATEGORY_CHUNK: {
 415                                                                                                                                                 TRACE_(dmfile)(": category chunk\n");
 416                                                                                                                                                 IStream_Read (pStm, &ObjDesc.wszCategory, chunkSize, NULL);
 417                                                                                                                                                 break;
 418                                                                                                                                         }
 419                                                                                                                                         case DMUS_FOURCC_VERSION_CHUNK: {
 420                                                                                                                                                 TRACE_(dmfile)(": version chunk\n");
 421                                                                                                                                                 IStream_Read (pStm, &ObjDesc.vVersion, chunkSize, NULL);
 422                                                                                                                                                 break;
 423                                                                                                                                         }
 424                                                                                                                                         default: {
 425                                                                                                                                                 TRACE_(dmfile)(": unknown chunk (skipping)\n");
 426                                                                                                                                                 liMove.QuadPart = chunkSize;
 427                                                                                                                                                 IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); /* skip this chunk */
 428                                                                                                                                                 break;
 429                                                                                                                                         }
 430                                                                                                                                 }
 431                                                                                                                                 TRACE_(dmfile)(": ListCount[2] = %ld < ListSize[2] = %ld\n", ListCount[2], ListSize[2]);
 432                                                                                                                         } while (ListCount[2] < ListSize[2]);
 433                                                                                                                         break;
 434                                                                                                                 }
 435                                                                                                                 default: {
 436                                                                                                                         TRACE_(dmfile)(": unexpected chunk; loading failed)\n");
 437                                                                                                                         return E_FAIL;
 438                                                                                                                 }
 439                                                                                                         }
 440                                                                                                         break;
 441                                                                                                 }
 442                                                                                                 default: {
 443                                                                                                         TRACE_(dmfile)(": unknown chunk (skipping)\n");
 444                                                                                                         liMove.QuadPart = chunkSize;
 445                                                                                                         IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); /* skip this chunk */
 446                                                                                                         break;
 447                                                                                                 }
 448                                                                                         }
 449                                                                                         TRACE_(dmfile)(": ListCount[1] = %ld < ListSize[1] = %ld\n", ListCount[1], ListSize[1]);
 450                                                                                 } while (ListCount[1] < ListSize[1]);
 451                                                                                 /* let's see what we have */
 452                                                                                 TRACE_(dmfile)(": (READ): reference: dwSize = %ld; dwValidData = %ld; guidObject = %s; guidClass = %s; \
 453 vVersion = %08lx,%08lx; wszName = %s; wszCategory = %s; wszFileName = %s\n", ObjDesc.dwSize, ObjDesc.dwValidData, debugstr_guid(&ObjDesc.guidObject), debugstr_guid(&ObjDesc.guidClass), \
 454 ObjDesc.vVersion.dwVersionMS, ObjDesc.vVersion.dwVersionLS, debugstr_w(ObjDesc.wszName), debugstr_w(ObjDesc.wszCategory), debugstr_w(ObjDesc.wszFileName));
 455                                                                                 /* now, let's convience loader to load reference */
 456                                                                                 if (IStream_QueryInterface (pStm, &IID_IDirectMusicGetLoader, (LPVOID*)&pGetLoader) == S_OK) {
 457                                                                                         if (IDirectMusicGetLoader_GetLoader (pGetLoader, &pLoader) == S_OK) {
 458                                                                                                 /* load referenced object */
 459                                                                                                 IDirectMusicObject* pObject;
 460                                                                                                 IDirectMusicLoader_GetObject (pLoader, &ObjDesc, &IID_IDirectMusicObject, (LPVOID*)&pObject);
 461                                                                                                 /* acquire style from loaded referenced object */
 462                                                                                                 IDirectMusicObject_QueryInterface (pObject, &IID_IDirectMusicStyle8, (LPVOID*)&pTrack->ppStyles[pTrack->dwStyles]);
 463                                                                                                 IDirectMusicLoader_Release (pLoader);
 464                                                                                         }
 465                                                                                         IDirectMusicGetLoader_Release (pGetLoader);
 466                                                                                 } else {
 467                                                                                         ERR("Could not get IDirectMusicGetLoader... reference will not be loaded :(\n");
 468                                                                                         /* E_FAIL */
 469                                                                                 }
 470                                                                                 pTrack->dwStyles++; /* add reference count */
 471                                                                                 break;
 472                                                                         }
 473                                                                         default: {
 474                                                                                 TRACE_(dmfile)(": unexpected chunk; loading failed)\n");
 475                                                                                 return E_FAIL;
 476                                                                         }
 477                                                                 }
 478                                                                 break;
 479                                                         }
 480                                                         default: {
 481                                                                 TRACE_(dmfile)(": unknown chunk (skipping)\n");
 482                                                                 liMove.QuadPart = chunkSize;
 483                                                                 IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); /* skip this chunk */
 484                                                                 break;
 485                                                         }
 486                                                 }
 487                                                 TRACE_(dmfile)(": ListCount[0] = %ld < ListSize[0] = %ld\n", ListCount[0], ListSize[0]);
 488                                         } while (ListCount[0] < ListSize[0]);
 489                                         break;
 490                                 }
 491                                 default: {
 492                                         TRACE_(dmfile)(": unexpected chunk; loading failed)\n");
 493                                         liMove.QuadPart = ListSize[0];
 494                                         IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); /* skip the rest of the chunk */
 495                                         return E_FAIL;
 496                                 }
 497                         }
 498                         TRACE_(dmfile)(": reading finished\n");
 499                         break;
 500                 }
 501                 default: {
 502                         TRACE_(dmfile)(": unexpected chunk; loading failed)\n");
 503                         liMove.QuadPart = chunkSize;
 504                         IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); /* skip the rest of the chunk */
 505                         return E_FAIL;
 506                 }
 507         }
 508
 509         return S_OK;
 510 }
 511
 512 HRESULT WINAPI IDirectMusicStyleTrackStream_Save (LPPERSISTSTREAM iface, IStream* pStm, BOOL fClearDirty)
 513 {
 514         return E_NOTIMPL;
 515 }
 516
 517 HRESULT WINAPI IDirectMusicStyleTrackStream_GetSizeMax (LPPERSISTSTREAM iface, ULARGE_INTEGER* pcbSize)
 518 {
 519         return E_NOTIMPL;
 520 }
 521
 522 ICOM_VTABLE(IPersistStream) DirectMusicStyleTrackStream_Vtbl =
 523 {
 524     ICOM_MSVTABLE_COMPAT_DummyRTTIVALUE
 525         IDirectMusicStyleTrackStream_QueryInterface,
 526         IDirectMusicStyleTrackStream_AddRef,
 527         IDirectMusicStyleTrackStream_Release,
 528         IDirectMusicStyleTrackStream_GetClassID,
 529         IDirectMusicStyleTrackStream_IsDirty,
 530         IDirectMusicStyleTrackStream_Load,
 531         IDirectMusicStyleTrackStream_Save,
 532         IDirectMusicStyleTrackStream_GetSizeMax
 533 };