- Segment loading fix (correct FOURCC_RIFF tracks handling).

dlls/dmband/bandtrack.c

@@ -242,24 +242,302 @@ ULONG WINAPI IDirectMusicBandTrack_IPersistStream_Release (LPPERSISTSTREAM iface
 }
 
 HRESULT WINAPI IDirectMusicBandTrack_IPersistStream_GetClassID (LPPERSISTSTREAM iface, CLSID* pClassID) {
-	return E_NOTIMPL;
+  ICOM_THIS_MULTI(IDirectMusicBandTrack, PersistStreamVtbl, iface);
+  TRACE("(%p, %p)\n", This, pClassID);
+  memcpy(pClassID, &CLSID_DirectMusicBandTrack, sizeof(CLSID));
+  return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicBandTrack_IPersistStream_IsDirty (LPPERSISTSTREAM iface) {
-	return E_NOTIMPL;
+  ICOM_THIS_MULTI(IDirectMusicBandTrack, PersistStreamVtbl, iface);
+  FIXME("(%p): stub, always S_FALSE\n", This);
+  return S_FALSE;
+}
+
+static HRESULT IDirectMusicBandTrack_IPersistStream_LoadBand (LPPERSISTSTREAM iface, IStream* pClonedStream, IDirectMusicBand** ppBand,
+							      DMUS_PRIVATE_BAND_ITEM_HEADER* pHeader) {
+
+  ICOM_THIS_MULTI(IDirectMusicBandTrack, PersistStreamVtbl, iface);
+  HRESULT hr = E_FAIL;
+  IPersistStream* pPersistStream = NULL;
+  
+  hr = CoCreateInstance (&CLSID_DirectMusicBand, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectMusicBand, (LPVOID*) ppBand);
+  if (FAILED(hr)) {
+    ERR(": could not create object\n");
+    return hr;
+  }
+  /* acquire PersistStream interface */
+  hr = IDirectMusicBand_QueryInterface (*ppBand, &IID_IPersistStream, (LPVOID*) &pPersistStream);
+  if (FAILED(hr)) {
+    ERR(": could not acquire IPersistStream\n");
+    return hr;
+  }
+  /* load */
+  hr = IPersistStream_Load (pPersistStream, pClonedStream);
+  if (FAILED(hr)) {
+    ERR(": failed to load object\n");
+    return hr;
+  }
+  
+  /* release all loading-related stuff */
+  IPersistStream_Release (pPersistStream);
+
+  /*
+   * @TODO insert pBand into This
+   */
+  if (SUCCEEDED(hr)) {
+    LPDMUS_PRIVATE_BAND pNewBand = HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, sizeof(DMUS_PRIVATE_BAND));
+    if (NULL == pNewBand) {
+      ERR(": no more memory\n");
+      return  E_OUTOFMEMORY;
+    }
+    memcpy(&pNewBand->pBandHeader, pHeader, sizeof(DMUS_PRIVATE_BAND_ITEM_HEADER));
+    pNewBand->ppBand = (IDirectMusicBandImpl*)((char*)(*ppBand) - offsetof(IDirectMusicBandImpl,BandVtbl));
+    IDirectMusicBandImpl_IDirectMusicBand_AddRef(*ppBand);
+    list_add_tail (&This->Bands, &pNewBand->entry);
+  }
+
+  return S_OK;
+}
+
+static HRESULT IDirectMusicBandTrack_IPersistStream_ParseBandsList (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm) {
+
+  /*ICOM_THIS_MULTI(IDirectMusicBandTrack, PersistStreamVtbl, iface);*/
+  HRESULT hr = E_FAIL;
+  DMUS_PRIVATE_CHUNK Chunk;
+  DWORD StreamSize, ListSize[3], ListCount[3];
+  LARGE_INTEGER liMove; /* used when skipping chunks */
+
+  IDirectMusicBand* pBand = NULL;
+  DMUS_PRIVATE_BAND_ITEM_HEADER header;
+
+  if (pChunk->fccID != DMUS_FOURCC_BANDS_LIST) {
+    ERR_(dmfile)(": %s chunk should be a BANDS list\n", debugstr_fourcc (pChunk->fccID));
+    return E_FAIL;
+  }  
+
+  ListSize[0] = pChunk->dwSize - sizeof(FOURCC);
+  ListCount[0] = 0;
+
+  do {
+    IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
+    ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
+    TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
+    switch (Chunk.fccID) {
+    case FOURCC_LIST: {
+      IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL);
+      TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(Chunk.fccID));
+      ListSize[1] = Chunk.dwSize - sizeof(FOURCC);
+      ListCount[1] = 0;
+      do {
+	IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
+	ListCount[1] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
+	TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
+	switch (Chunk.fccID) { 
+	case DMUS_FOURCC_BANDITEM_CHUNK: {
+	  DMUS_IO_BAND_ITEM_HEADER tmp_header;
+	  TRACE_(dmfile)(": Band Item chunk v1\n");
+	  
+	  IStream_Read (pStm, &tmp_header, sizeof(DMUS_IO_BAND_ITEM_HEADER), NULL);
+	  TRACE_(dmfile)(" - lBandTime: %lu\n", tmp_header.lBandTime);
+	  
+	  header.dwVersion = 1;
+	  header.lBandTime = tmp_header.lBandTime;
+	  break;
+	}
+	case DMUS_FOURCC_BANDITEM_CHUNK2: { 
+	  DMUS_IO_BAND_ITEM_HEADER2 tmp_header2;
+	  TRACE_(dmfile)(": Band Item chunk v2\n");
+	  
+	  IStream_Read (pStm, &tmp_header2, sizeof(DMUS_IO_BAND_ITEM_HEADER2), NULL);
+	  TRACE_(dmfile)(" - lBandTimeLogical: %lu\n", tmp_header2.lBandTimeLogical);
+	  TRACE_(dmfile)(" - lBandTimePhysical: %lu\n", tmp_header2.lBandTimePhysical);
+	  
+	  header.dwVersion = 2;
+	  header.lBandTimeLogical = tmp_header2.lBandTimeLogical;
+	  header.lBandTimePhysical = tmp_header2.lBandTimePhysical;
+	  break;
+	}
+	case FOURCC_RIFF: { 
+	  IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL);
+	  FIXME_(dmfile)(": RIFF chunk of type %s (behavior to check)\n", debugstr_fourcc(Chunk.fccID));
+	  StreamSize = Chunk.dwSize - sizeof(FOURCC);
+	  switch (Chunk.fccID) {
+	  case DMUS_FOURCC_BAND_FORM: {
+	    LPSTREAM pClonedStream = NULL;
+	    TRACE_(dmfile)(": BAND RIFF\n");
+	    
+	    IStream_Clone (pStm, &pClonedStream);
+	    
+	    liMove.QuadPart = 0;
+	    liMove.QuadPart -= sizeof(FOURCC) + (sizeof(FOURCC)+sizeof(DWORD));
+	    IStream_Seek (pClonedStream, liMove, STREAM_SEEK_CUR, NULL);
+	    
+	    hr = IDirectMusicBandTrack_IPersistStream_LoadBand (iface, pClonedStream, &pBand, &header);
+	    if (FAILED(hr)) {
+	      ERR(": could not load track\n");
+	      return hr;
+	    }
+	    IStream_Release (pClonedStream);
+	    
+	    IDirectMusicTrack_Release(pBand); pBand = NULL; /* now we can release at as it inserted */
+	    
+	    /** now safe move the cursor */
+	    liMove.QuadPart = StreamSize;
+	    IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
+	    
+	  }
+	  default: {
+	    TRACE_(dmfile)(": unknown chunk (irrevelant & skipping)\n");
+	    liMove.QuadPart = StreamSize;
+	    IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
+	    break;						
+	  }
+	  }
+	  /*
+	  liMove.QuadPart = Chunk.dwSize - sizeof(FOURCC);
+	  IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
+	  */
+	  break;
+	}
+	default: {
+	  TRACE_(dmfile)(": unknown chunk (irrevelant & skipping)\n");
+	  liMove.QuadPart = Chunk.dwSize;
+	  IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
+	  break;						
+	 }
+	}
+	TRACE_(dmfile)(": ListCount[1] = %ld < ListSize[1] = %ld\n", ListCount[1], ListSize[1]);
+      } while (ListCount[1] < ListSize[1]);
+      break;
+    }
+    default: {
+      TRACE_(dmfile)(": unknown chunk (irrevelant & skipping)\n");
+      liMove.QuadPart = Chunk.dwSize;
+      IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
+      break;						
+    }
+    }
+    TRACE_(dmfile)(": ListCount[0] = %ld < ListSize[0] = %ld\n", ListCount[0], ListSize[0]);
+  } while (ListCount[0] < ListSize[0]);
+
+  return S_OK;
+}
+
+static HRESULT IDirectMusicBandTrack_IPersistStream_ParseBandTrackForm (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm) {
+
+  ICOM_THIS_MULTI(IDirectMusicBandTrack, PersistStreamVtbl, iface);
+  HRESULT hr = E_FAIL;
+  DMUS_PRIVATE_CHUNK Chunk;
+  DWORD StreamSize, StreamCount, ListSize[3], ListCount[3];
+  LARGE_INTEGER liMove; /* used when skipping chunks */
+
+  if (pChunk->fccID != DMUS_FOURCC_BANDTRACK_FORM) {
+    ERR_(dmfile)(": %s chunk should be a BANDTRACK form\n", debugstr_fourcc (pChunk->fccID));
+    return E_FAIL;
+  }  
+
+  StreamSize = pChunk->dwSize - sizeof(FOURCC);
+  StreamCount = 0;
+
+  do {
+    IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
+    StreamCount += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
+    TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
+    switch (Chunk.fccID) {
+    case DMUS_FOURCC_BANDTRACK_CHUNK: {
+      TRACE_(dmfile)(": BandTrack chunk\n");
+      IStream_Read (pStm, &This->header, sizeof(DMUS_IO_BAND_TRACK_HEADER), NULL);
+      TRACE_(dmfile)(" - bAutoDownload: %u\n", This->header.bAutoDownload);
+      break;
+    }   
+    case FOURCC_LIST: {
+      IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL);
+      TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(Chunk.fccID));
+      ListSize[0] = Chunk.dwSize - sizeof(FOURCC);
+      ListCount[0] = 0;
+      switch (Chunk.fccID) {
+      case DMUS_FOURCC_BANDS_LIST: {
+	TRACE_(dmfile)(": TRACK list\n");
+	hr = IDirectMusicBandTrack_IPersistStream_ParseBandsList (iface, &Chunk, pStm);
+	if (FAILED(hr)) return hr;
+	break;
+      }
+      default: {
+	TRACE_(dmfile)(": unknown (skipping)\n");
+	liMove.QuadPart = Chunk.dwSize - sizeof(FOURCC);
+	IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
+	break;						
+      }
+      }
+      break;
+    }
+    default: {
+      TRACE_(dmfile)(": unknown chunk (irrevelant & skipping)\n");
+      liMove.QuadPart = Chunk.dwSize;
+      IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
+      break;						
+    }
+    }
+    TRACE_(dmfile)(": StreamCount[0] = %ld < StreamSize[0] = %ld\n", StreamCount, StreamSize);
+  } while (StreamCount < StreamSize);  
+
+  return S_OK;
 }
 
+
 HRESULT WINAPI IDirectMusicBandTrack_IPersistStream_Load (LPPERSISTSTREAM iface, IStream* pStm) {
   ICOM_THIS_MULTI(IDirectMusicBandTrack, PersistStreamVtbl, iface);
-	FIXME("(%p,%p): loading not implemented yet\n", This, pStm);
+
+  DMUS_PRIVATE_CHUNK Chunk;
+  LARGE_INTEGER liMove;
+  HRESULT hr;
+
+  FIXME("(%p, %p): loading not fully implemented yet\n", This, pStm);
+
+  IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
+  TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
+  switch (Chunk.fccID) {
+  case FOURCC_RIFF: {
+    IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL);
+    TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
+    switch (Chunk.fccID) {
+    case DMUS_FOURCC_BANDTRACK_FORM: {
+      TRACE_(dmfile)(": Band track form\n");
+      hr = IDirectMusicBandTrack_IPersistStream_ParseBandTrackForm (iface, &Chunk, pStm);
+      if (FAILED(hr)) return hr;
+      break;    
+    }
+    default: {
+      TRACE_(dmfile)(": unexpected chunk; loading failed)\n");
+      liMove.QuadPart = Chunk.dwSize;
+      IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
+      return E_FAIL;
+    }
+    }
+    TRACE_(dmfile)(": reading finished\n");
+    break;
+  }
+  default: {
+    TRACE_(dmfile)(": unexpected chunk; loading failed)\n");
+    liMove.QuadPart = Chunk.dwSize;
+    IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); /* skip the rest of the chunk */
+    return E_FAIL;
+  }
+  }
+
   return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicBandTrack_IPersistStream_Save (LPPERSISTSTREAM iface, IStream* pStm, BOOL fClearDirty) {
+  ICOM_THIS_MULTI(IDirectMusicBandTrack, PersistStreamVtbl, iface);
+  FIXME("(%p): Saving not implemented yet\n", This);
   return E_NOTIMPL;
 }
 
 HRESULT WINAPI IDirectMusicBandTrack_IPersistStream_GetSizeMax (LPPERSISTSTREAM iface, ULARGE_INTEGER* pcbSize) {
+  ICOM_THIS_MULTI(IDirectMusicBandTrack, PersistStreamVtbl, iface);
+  FIXME("(%p, %p): stub\n", This, pcbSize);
   return E_NOTIMPL;
 }
 

dlls/dmband/dmband_private.h

@@ -150,7 +150,7 @@ struct IDirectMusicBandTrack {
 
   /* IDirectMusicBandTrack fields */
   LPDMUS_OBJECTDESC pDesc;
-  DMUS_IO_BAND_TRACK_HEADER* pHeader;
+  DMUS_IO_BAND_TRACK_HEADER header;
 	
   /* data */
   struct list Bands;

dlls/dmime/segment.c

@@ -630,6 +630,7 @@ HRESULT WINAPI IDirectMusicSegment8Impl_IPersistStream_IsDirty (LPPERSISTSTREAM
 static HRESULT IDirectMusicSegment8Impl_IPersistStream_LoadTrack (LPPERSISTSTREAM iface, IStream* pClonedStream, IDirectMusicTrack** ppTrack, 
 								  DMUS_IO_TRACK_HEADER* pTrack_hdr) {
 
+  ICOM_THIS_MULTI(IDirectMusicSegment8Impl, PersistStreamVtbl, iface);
   HRESULT hr = E_FAIL;
   IPersistStream* pPersistStream = NULL;
   
@@ -654,11 +655,18 @@ static HRESULT IDirectMusicSegment8Impl_IPersistStream_LoadTrack (LPPERSISTSTREA
   /* release all loading-related stuff */
   IPersistStream_Release (pPersistStream);
 
+  hr = IDirectMusicSegment8Impl_IDirectMusicSegment8_InsertTrack ((LPDIRECTMUSICSEGMENT8)This->SegmentVtbl, *ppTrack, pTrack_hdr->dwGroup); /* at dsPosition */
+  if (FAILED(hr)) {
+    ERR(": could not insert track\n");
+    return hr;
+  }
+
   return S_OK;
 }
 
-static HRESULT IDirectMusicSegment8Impl_IPersistStream_ParseTrackForm (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm, IDirectMusicSegment8Impl* This) {
+static HRESULT IDirectMusicSegment8Impl_IPersistStream_ParseTrackForm (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm) {
 
+  /*ICOM_THIS_MULTI(IDirectMusicSegment8Impl, PersistStreamVtbl, iface);*/
   HRESULT hr = E_FAIL;
   DMUS_PRIVATE_CHUNK Chunk;
   DWORD StreamSize, StreamCount, ListSize[3], ListCount[3];
@@ -725,42 +733,13 @@ static HRESULT IDirectMusicSegment8Impl_IPersistStream_ParseTrackForm (LPPERSIST
 	  ERR(": could not load track\n");
 	  return hr;
 	}
-	
-	hr = IDirectMusicSegment8Impl_IDirectMusicSegment8_InsertTrack ((LPDIRECTMUSICSEGMENT8)This->SegmentVtbl, pTrack, track_hdr.dwGroup); /* at dsPosition */
-	if (FAILED(hr)) {
-	  ERR(": could not insert track\n");
-	  return hr;
-	}
-	IDirectMusicTrack_Release(pTrack); pTrack = NULL; /* now we can release at as it inserted */
 	IStream_Release (pClonedStream);
 	
-#if 0
-#else
-	/*
-	do {
-	  IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
-	  ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
-	  TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
-	  switch (Chunk.fccID) {
-	  default: {
-	    TRACE_(dmfile)(": unknown chunk (irrevelant & skipping)\n");
-	    liMove.QuadPart = Chunk.dwSize;
-	    IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
-	    break;						
-	  }
-	  }
-	 
-	  TRACE_(dmfile)(": ListCount[0] = %ld < ListSize[0] = %ld\n", ListCount[0], ListSize[0]);
-	} while (ListCount[0] < ListSize[0]);
-	*/
-
-#endif
+	IDirectMusicTrack_Release(pTrack); pTrack = NULL; /* now we can release at as it inserted */
 
 	liMove.QuadPart = ListSize[0];
 	IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 	
-	/*
-	*/
       } else {
 	TRACE_(dmfile)(": unknown (skipping)\n");
 	liMove.QuadPart = Chunk.dwSize;
@@ -783,7 +762,7 @@ static HRESULT IDirectMusicSegment8Impl_IPersistStream_ParseTrackForm (LPPERSIST
 	IStream_Clone (pStm, &pClonedStream);
 	
 	liMove.QuadPart = 0;
-	liMove.QuadPart -= (sizeof(FOURCC) + sizeof(DWORD));
+	liMove.QuadPart -= sizeof(FOURCC) + (sizeof(FOURCC)+sizeof(DWORD));
 	IStream_Seek (pClonedStream, liMove, STREAM_SEEK_CUR, NULL);
 	
 	hr = IDirectMusicSegment8Impl_IPersistStream_LoadTrack (iface, pClonedStream, &pTrack, &track_hdr);
@@ -791,14 +770,8 @@ static HRESULT IDirectMusicSegment8Impl_IPersistStream_ParseTrackForm (LPPERSIST
 	  ERR(": could not load track\n");
 	  return hr;
 	}
-
 	IStream_Release (pClonedStream);
 	
-	hr = IDirectMusicSegment8Impl_IDirectMusicSegment8_InsertTrack ((LPDIRECTMUSICSEGMENT8)This->SegmentVtbl, pTrack, track_hdr.dwGroup); /* at dsPosition */
-	if (FAILED(hr)) {
-	  ERR(": could not insert track\n");
-	  return hr;
-	}
 	IDirectMusicTrack_Release(pTrack); pTrack = NULL; /* now we can release at as it inserted */
 
 	/** now safe move the cursor */
@@ -830,14 +803,8 @@ static HRESULT IDirectMusicSegment8Impl_IPersistStream_ParseTrackForm (LPPERSIST
 	  ERR(": could not load track\n");
 	  return hr;
 	}
-
 	IStream_Release (pClonedStream);
 	
-	hr = IDirectMusicSegment8Impl_IDirectMusicSegment8_InsertTrack ((LPDIRECTMUSICSEGMENT8)This->SegmentVtbl, pTrack, track_hdr.dwGroup); /* at dsPosition */
-	if (FAILED(hr)) {
-	  ERR(": could not insert track\n");
-	  return hr;
-	}
 	IDirectMusicTrack_Release(pTrack); pTrack = NULL; /* now we can release at as it inserted */
 
 	liMove.QuadPart = Chunk.dwSize;
@@ -886,7 +853,7 @@ static HRESULT IDirectMusicSegment8Impl_IPersistStream_ParseTrackList (LPPERSIST
       switch (Chunk.fccID) {
       case  DMUS_FOURCC_TRACK_FORM: {
 	TRACE_(dmfile)(": TRACK form\n");
-	hr = IDirectMusicSegment8Impl_IPersistStream_ParseTrackForm (iface, &Chunk, pStm, This);
+	hr = IDirectMusicSegment8Impl_IPersistStream_ParseTrackForm (iface, &Chunk, pStm);
 	if (FAILED(hr)) return hr;	
 	break;
       }
@@ -939,7 +906,7 @@ static HRESULT IDirectMusicSegment8Impl_IPersistStream_ParseSegmentForm (LPPERSI
       switch (Chunk.fccID) {
       case DMUS_FOURCC_SEGMENT_CHUNK: {
 	DWORD checkSz = sizeof(FOURCC);
-	FIXME_(dmfile)(": segment chunk\n");
+	TRACE_(dmfile)(": segment chunk\n");
 #if 1
 	/** DX 7 */
 	IStream_Read (pStm, &This->header.dwRepeats,    sizeof(This->header.dwRepeats), NULL);

dlls/dmime/segtriggertrack.c

@@ -237,8 +237,8 @@ HRESULT WINAPI IDirectMusicSegTriggerTrack_IPersistStream_IsDirty (LPPERSISTSTRE
   return S_FALSE;
 }
 
-static HRESULT IDirectMusicSegTriggerTrack_IPersistStream_ParseSegment (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm, IDirectMusicSegTriggerTrack* This) {
-
+static HRESULT IDirectMusicSegTriggerTrack_IPersistStream_ParseSegment (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm) {
+  ICOM_THIS_MULTI(IDirectMusicSegTriggerTrack, PersistStreamVtbl, iface);
   DMUS_PRIVATE_CHUNK Chunk;
   DWORD ListSize[3], ListCount[3];
   LARGE_INTEGER liMove; /* used when skipping chunks */
@@ -308,8 +308,8 @@ static HRESULT IDirectMusicSegTriggerTrack_IPersistStream_ParseSegment (LPPERSIS
   return S_OK;
 }
 
-static HRESULT IDirectMusicSegTriggerTrack_IPersistStream_ParseSegmentsList (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm, IDirectMusicSegTriggerTrack* This) {
-
+static HRESULT IDirectMusicSegTriggerTrack_IPersistStream_ParseSegmentsList (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm) {
+  /*ICOM_THIS_MULTI(IDirectMusicSegTriggerTrack, PersistStreamVtbl, iface);*/
   HRESULT hr = E_FAIL;
   DMUS_PRIVATE_CHUNK Chunk;
   DWORD ListSize[3], ListCount[3];
@@ -336,7 +336,7 @@ static HRESULT IDirectMusicSegTriggerTrack_IPersistStream_ParseSegmentsList (LPP
       switch (Chunk.fccID) { 
       case DMUS_FOURCC_SEGMENT_LIST: {
 	TRACE_(dmfile)(": SEGMENT list\n"); 
-	hr = IDirectMusicSegTriggerTrack_IPersistStream_ParseSegment (iface, &Chunk, pStm, This);
+	hr = IDirectMusicSegTriggerTrack_IPersistStream_ParseSegment (iface, &Chunk, pStm);
 	if (FAILED(hr)) return hr;	
 	break;
       }
@@ -362,8 +362,8 @@ static HRESULT IDirectMusicSegTriggerTrack_IPersistStream_ParseSegmentsList (LPP
   return S_OK;
 }
 
-static HRESULT IDirectMusicSegTriggerTrack_IPersistStream_ParseSegTrackList (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm, IDirectMusicSegTriggerTrack* This) {
-
+static HRESULT IDirectMusicSegTriggerTrack_IPersistStream_ParseSegTrackList (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm) {
+  /*ICOM_THIS_MULTI(IDirectMusicSegTriggerTrack, PersistStreamVtbl, iface);*/
   HRESULT hr = E_FAIL;
   DMUS_PRIVATE_CHUNK Chunk;
   DWORD ListSize[3], ListCount[3];
@@ -396,7 +396,7 @@ static HRESULT IDirectMusicSegTriggerTrack_IPersistStream_ParseSegTrackList (LPP
       switch (Chunk.fccID) { 
       case DMUS_FOURCC_SEGMENTS_LIST: {
 	TRACE_(dmfile)(": SEGMENTS list\n"); 
-	hr = IDirectMusicSegTriggerTrack_IPersistStream_ParseSegmentsList (iface, &Chunk, pStm, This);
+	hr = IDirectMusicSegTriggerTrack_IPersistStream_ParseSegmentsList (iface, &Chunk, pStm);
 	if (FAILED(hr)) return hr;
 	break;
       }
@@ -441,7 +441,7 @@ HRESULT WINAPI IDirectMusicSegTriggerTrack_IPersistStream_Load (LPPERSISTSTREAM
     switch (Chunk.fccID) {
     case DMUS_FOURCC_SEGTRACK_LIST: {
       TRACE_(dmfile)(": segment trigger track list\n");
-      hr = IDirectMusicSegTriggerTrack_IPersistStream_ParseSegTrackList (iface, &Chunk, pStm, This);
+      hr = IDirectMusicSegTriggerTrack_IPersistStream_ParseSegTrackList (iface, &Chunk, pStm);
       if (FAILED(hr)) return hr;
       break;    
     }

dlls/dmime/tempotrack.c

@@ -254,16 +254,16 @@ HRESULT WINAPI IDirectMusicTempoTrack_IPersistStream_Load (LPPERSISTSTREAM iface
   TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
   switch (Chunk.fccID) {	
   case DMUS_FOURCC_TEMPO_TRACK: {
-    TRACE_(dmfile)(": tempo track\n");
+    TRACE_(dmfile)(": Tempo track\n");
 #if 1
     IStream_Read (pStm, &StreamSize, sizeof(DWORD), NULL);
     StreamSize -= sizeof(DWORD);
     StreamCount = 0;
-    TRACE_(dmfile)(": items (size = %lu, chunkSize = %lu)\n", StreamSize, Chunk.dwSize - sizeof(DWORD));
+    TRACE_(dmfile)(" - sizeof(DMUS_IO_TEMPO_ITEM): %lu (chunkSize = %lu)\n", StreamSize, Chunk.dwSize - sizeof(DWORD));
     do {
       IStream_Read (pStm, &item, sizeof(item), NULL);
       ++nItem;
-      TRACE_(dmfile)("DMUS_IO_TEMPO_ITEM: item %ld\n", nItem);
+      TRACE_(dmfile)("DMUS_IO_TEMPO_ITEM #%ld\n", nItem);
       TRACE_(dmfile)(" - lTime = %lu\n", item.lTime);
       TRACE_(dmfile)(" - dblTempo = %g\n", item.dblTempo);
       StreamCount += sizeof(item);

dlls/dmstyle/chordtrack.c

@@ -241,8 +241,9 @@ HRESULT WINAPI IDirectMusicChordTrack_IPersistStream_IsDirty (LPPERSISTSTREAM if
   return S_FALSE;
 }
 
-static HRESULT IDirectMusicChordTrack_IPersistStream_ParseChordTrackList (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm, IDirectMusicChordTrack* This) {
+static HRESULT IDirectMusicChordTrack_IPersistStream_ParseChordTrackList (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm) {
 
+  ICOM_THIS_MULTI(IDirectMusicChordTrack, PersistStreamVtbl, iface);
   DMUS_PRIVATE_CHUNK Chunk;
   DWORD ListSize[3], ListCount[3];
   LARGE_INTEGER liMove; /* used when skipping chunks */
@@ -293,7 +294,7 @@ static HRESULT IDirectMusicChordTrack_IPersistStream_ParseChordTrackList (LPPERS
 
       for (it = 0; it < num; ++it) {
 	IStream_Read (pStm, &subchords, sizeof(DMUS_IO_SUBCHORD), NULL);
-	TRACE_(dmfile)("DMUS_IO_SUBCHORD #%ld\n", it);
+	TRACE_(dmfile)("DMUS_IO_SUBCHORD #%ld\n", it+1);
 	TRACE_(dmfile)(" - dwChordPattern: %lu\n", subchords.dwChordPattern);
 	TRACE_(dmfile)(" - dwScalePattern: %lu\n", subchords.dwScalePattern);
 	TRACE_(dmfile)(" - dwInversionPoints: %lu\n", subchords.dwInversionPoints);
@@ -323,7 +324,7 @@ HRESULT WINAPI IDirectMusicChordTrack_IPersistStream_Load (LPPERSISTSTREAM iface
   LARGE_INTEGER liMove;
   HRESULT hr;
  
-  FIXME(": Loading not fully implemented yet\n");
+  FIXME("(%p, %p): Loading not fully implemented yet\n", This, pStm);
 
   IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
   TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
@@ -334,7 +335,7 @@ HRESULT WINAPI IDirectMusicChordTrack_IPersistStream_Load (LPPERSISTSTREAM iface
     switch (Chunk.fccID) { 
     case DMUS_FOURCC_CHORDTRACK_LIST: {
       TRACE_(dmfile)(": Chord track list\n");
-      hr = IDirectMusicChordTrack_IPersistStream_ParseChordTrackList (iface, &Chunk, pStm, This);
+      hr = IDirectMusicChordTrack_IPersistStream_ParseChordTrackList (iface, &Chunk, pStm);
       if (FAILED(hr)) return hr;
       break;    
     }
@@ -356,7 +357,6 @@ HRESULT WINAPI IDirectMusicChordTrack_IPersistStream_Load (LPPERSISTSTREAM iface
   }
   }
 
-
   return S_OK;
 }
 

dlls/dmstyle/styletrack.c

@@ -231,23 +231,189 @@ ULONG WINAPI IDirectMusicStyleTrack_IPersistStream_Release (LPPERSISTSTREAM ifac
 }
 
 HRESULT WINAPI IDirectMusicStyleTrack_IPersistStream_GetClassID (LPPERSISTSTREAM iface, CLSID* pClassID) {
-	return E_NOTIMPL;
+  ICOM_THIS_MULTI(IDirectMusicStyleTrack, PersistStreamVtbl, iface);
+  TRACE("(%p, %p)\n", This, pClassID);
+  memcpy(pClassID, &CLSID_DirectMusicStyleTrack, sizeof(CLSID));
+  return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicStyleTrack_IPersistStream_IsDirty (LPPERSISTSTREAM iface) {
-	return E_NOTIMPL;
+  ICOM_THIS_MULTI(IDirectMusicStyleTrack, PersistStreamVtbl, iface);
+  FIXME("(%p): stub, always S_FALSE\n", This);
+  return S_FALSE;
+}
+
+static HRESULT IDirectMusicStyleTrack_IPersistStream_ParseStyleRef (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm) {
+  /*ICOM_THIS_MULTI(IDirectMusicStyleTrack, PersistStreamVtbl, iface);*/
+  DMUS_PRIVATE_CHUNK Chunk;
+  DWORD ListSize[3], ListCount[3];
+  LARGE_INTEGER liMove; /* used when skipping chunks */
+
+  DWORD dwTimeStamp;
+
+  if (pChunk->fccID != DMUS_FOURCC_STYLE_REF_LIST) {
+    ERR_(dmfile)(": %s chunk should be a SEGMENT list\n", debugstr_fourcc (pChunk->fccID));
+    return E_FAIL;
+  }
+
+  ListSize[0] = pChunk->dwSize - sizeof(FOURCC);
+  ListCount[0] = 0;
+
+  do {
+    IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
+    ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
+    TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
+    switch (Chunk.fccID) { 
+    case DMUS_FOURCC_TIME_STAMP_CHUNK: {
+      TRACE_(dmfile)(": Time Stamp chunck \n");
+      IStream_Read (pStm, &dwTimeStamp, sizeof(DWORD), NULL);
+      TRACE_(dmfile)(" - dwTimeStamp: %lu\n", dwTimeStamp);
+      break;
+    }
+    case FOURCC_LIST: {
+      IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL);
+      TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(Chunk.fccID));
+      ListSize[1] = Chunk.dwSize - sizeof(FOURCC);
+      ListCount[1] = 0;
+      switch (Chunk.fccID) { 
+	/**
+	 * should be a DMRF (DirectMusic Reference) list @TODO
+	 */
+      case DMUS_FOURCC_REF_LIST: {
+	FIXME_(dmfile)(": DMRF (DM References) list, not yet handled\n");
+	liMove.QuadPart = Chunk.dwSize - sizeof(FOURCC);
+	IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
+	break;						
+      }
+      default: {
+	TRACE_(dmfile)(": unknown (skipping)\n");
+	liMove.QuadPart = Chunk.dwSize - sizeof(FOURCC);
+	IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
+	break;						
+      }
+      }	
+      break;
+    }
+    default: {
+      TRACE_(dmfile)(": unknown chunk (irrevelant & skipping)\n");
+      liMove.QuadPart = Chunk.dwSize;
+      IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
+      break;						
+    }
+    }
+    TRACE_(dmfile)(": ListCount[0] = %ld < ListSize[0] = %ld\n", ListCount[0], ListSize[0]);
+  } while (ListCount[0] < ListSize[0]);
+
+  return S_OK;
+}
+
+static HRESULT IDirectMusicStyleTrack_IPersistStream_ParseStyleTrackList (LPPERSISTSTREAM iface, DMUS_PRIVATE_CHUNK* pChunk, IStream* pStm) {
+
+  /*ICOM_THIS_MULTI(IDirectMusicStyleTrack, PersistStreamVtbl, iface);*/
+  DMUS_PRIVATE_CHUNK Chunk;
+  DWORD ListSize[3], ListCount[3];
+  LARGE_INTEGER liMove; /* used when skipping chunks */
+  HRESULT hr;
+
+  if (pChunk->fccID != DMUS_FOURCC_STYLE_TRACK_LIST) {
+    ERR_(dmfile)(": %s chunk should be a STYLETRACK list\n", debugstr_fourcc (pChunk->fccID));
+    return E_FAIL;
+  }  
+
+  ListSize[0] = pChunk->dwSize - sizeof(FOURCC);
+  ListCount[0] = 0;
+
+  do {
+    IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
+    ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
+    TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
+    switch (Chunk.fccID) { 
+    case FOURCC_LIST: { 
+      IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL);
+      TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(Chunk.fccID));
+      ListSize[1] = Chunk.dwSize - sizeof(FOURCC);
+      ListCount[1] = 0;
+      switch (Chunk.fccID) { 
+      case DMUS_FOURCC_STYLE_REF_LIST: {
+	TRACE_(dmfile)(": STYLE_REF list\n"); 
+	hr = IDirectMusicStyleTrack_IPersistStream_ParseStyleRef (iface, &Chunk, pStm);
+	if (FAILED(hr)) return hr;	
+	break;
+      }
+      default: {
+	TRACE_(dmfile)(": unknown (skipping)\n");
+	liMove.QuadPart = Chunk.dwSize - sizeof(FOURCC);
+	IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
+	break;						
+      }
+      }
+      break;
+    }
+    default: {
+      TRACE_(dmfile)(": unknown chunk (irrevelant & skipping)\n");
+      liMove.QuadPart = Chunk.dwSize;
+      IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
+      break;		
+    }
+    }
+    TRACE_(dmfile)(": ListCount[0] = %ld < ListSize[0] = %ld\n", ListCount[0], ListSize[0]);
+  } while (ListCount[0] < ListSize[0]);
+
+  return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicStyleTrack_IPersistStream_Load (LPPERSISTSTREAM iface, IStream* pStm) {
-	FIXME(": Loading not implemented yet\n");
+  ICOM_THIS_MULTI(IDirectMusicStyleTrack, PersistStreamVtbl, iface);
+
+  DMUS_PRIVATE_CHUNK Chunk;
+  LARGE_INTEGER liMove;
+  HRESULT hr;
+ 
+  FIXME("(%p, %p): Loading not fully implemented yet\n", This, pStm);
+
+  IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
+  TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
+  switch (Chunk.fccID) {	
+  case FOURCC_LIST: {
+    IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL);
+    TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
+    switch (Chunk.fccID) { 
+    case DMUS_FOURCC_STYLE_TRACK_LIST: {
+      TRACE_(dmfile)(": Chord track list\n");
+      hr = IDirectMusicStyleTrack_IPersistStream_ParseStyleTrackList (iface, &Chunk, pStm);
+      if (FAILED(hr)) return hr;
+      break;    
+    }
+    default: {
+      TRACE_(dmfile)(": unexpected chunk; loading failed)\n");
+      liMove.QuadPart = Chunk.dwSize;
+      IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
+      return E_FAIL;
+    }
+    }
+    TRACE_(dmfile)(": reading finished\n");
+    break;
+  }
+  default: {
+    TRACE_(dmfile)(": unexpected chunk; loading failed)\n");
+    liMove.QuadPart = Chunk.dwSize;
+    IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); /* skip the rest of the chunk */
+    return E_FAIL;
+  }
+  }
+
   return S_OK;
 }
 
 HRESULT WINAPI IDirectMusicStyleTrack_IPersistStream_Save (LPPERSISTSTREAM iface, IStream* pStm, BOOL fClearDirty) {
+  ICOM_THIS_MULTI(IDirectMusicStyleTrack, PersistStreamVtbl, iface);
+  FIXME("(%p): Saving not implemented yet\n", This);
   return E_NOTIMPL;
 }
 
 HRESULT WINAPI IDirectMusicStyleTrack_IPersistStream_GetSizeMax (LPPERSISTSTREAM iface, ULARGE_INTEGER* pcbSize) {
+  ICOM_THIS_MULTI(IDirectMusicStyleTrack, PersistStreamVtbl, iface);
+  FIXME("(%p, %p): stub\n", This, pcbSize);
   return E_NOTIMPL;
 }