dlls/dmime/segment.c

   1 /* IDirectMusicSegment8 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 "dmime_private.h"
  22 #include "dmobject.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(dmime);
  25 WINE_DECLARE_DEBUG_CHANNEL(dmfile);
  26
  27 /*****************************************************************************
  28  * IDirectMusicSegmentImpl implementation
  29  */
  30 typedef struct IDirectMusicSegment8Impl {
  31     IDirectMusicSegment8 IDirectMusicSegment8_iface;
  32     struct dmobject dmobj;
  33     LONG ref;
  34     DMUS_IO_SEGMENT_HEADER header;
  35     IDirectMusicGraph *pGraph;
  36     struct list Tracks;
  37 } IDirectMusicSegment8Impl;
  38
  39 static inline IDirectMusicSegment8Impl *impl_from_IDirectMusicSegment8(IDirectMusicSegment8 *iface)
  40 {
  41   return CONTAINING_RECORD(iface, IDirectMusicSegment8Impl, IDirectMusicSegment8_iface);
  42 }
  43
  44 static HRESULT WINAPI IDirectMusicSegment8Impl_QueryInterface(IDirectMusicSegment8 *iface,
  45         REFIID riid, void **ret_iface)
  46 {
  47     IDirectMusicSegment8Impl *This = impl_from_IDirectMusicSegment8(iface);
  48
  49     TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ret_iface);
  50
  51     *ret_iface = NULL;
  52
  53     if (IsEqualIID (riid, &IID_IUnknown) || IsEqualIID (riid, &IID_IDirectMusicSegment) ||
  54             IsEqualIID(riid, &IID_IDirectMusicSegment2) ||
  55             IsEqualIID (riid, &IID_IDirectMusicSegment8))
  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 IDirectMusicSegment8Impl_AddRef(IDirectMusicSegment8 *iface)
  71 {
  72     IDirectMusicSegment8Impl *This = impl_from_IDirectMusicSegment8(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 IDirectMusicSegment8Impl_Release(IDirectMusicSegment8 *iface)
  81 {
  82     IDirectMusicSegment8Impl *This = impl_from_IDirectMusicSegment8(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         DMIME_UnlockModule();
  90     }
  91
  92     return ref;
  93 }
  94
  95 static HRESULT WINAPI IDirectMusicSegment8Impl_GetLength(IDirectMusicSegment8 *iface,
  96         MUSIC_TIME *pmtLength)
  97 {
  98   IDirectMusicSegment8Impl *This = impl_from_IDirectMusicSegment8(iface);
  99
 100   TRACE("(%p, %p)\n", This, pmtLength);
 101   if (NULL == pmtLength) {
 102     return E_POINTER;
 103   }
 104   *pmtLength = This->header.mtLength;
 105   return S_OK;
 106 }
 107
 108 static HRESULT WINAPI IDirectMusicSegment8Impl_SetLength(IDirectMusicSegment8 *iface,
 109         MUSIC_TIME mtLength)
 110 {
 111   IDirectMusicSegment8Impl *This = impl_from_IDirectMusicSegment8(iface);
 112
 113   TRACE("(%p, %d)\n", This, mtLength);
 114   This->header.mtLength = mtLength;
 115   return S_OK;
 116 }
 117
 118 static HRESULT WINAPI IDirectMusicSegment8Impl_GetRepeats(IDirectMusicSegment8 *iface,
 119         DWORD *pdwRepeats)
 120 {
 121   IDirectMusicSegment8Impl *This = impl_from_IDirectMusicSegment8(iface);
 122
 123   TRACE("(%p, %p)\n", This, pdwRepeats);
 124   if (NULL == pdwRepeats) {
 125     return E_POINTER;
 126   }
 127   *pdwRepeats = This->header.dwRepeats;
 128   return S_OK;
 129 }
 130
 131 static HRESULT WINAPI IDirectMusicSegment8Impl_SetRepeats(IDirectMusicSegment8 *iface,
 132         DWORD dwRepeats)
 133 {
 134   IDirectMusicSegment8Impl *This = impl_from_IDirectMusicSegment8(iface);
 135
 136   TRACE("(%p, %d)\n", This, dwRepeats);
 137   This->header.dwRepeats = dwRepeats;
 138   return S_OK;
 139 }
 140
 141 static HRESULT WINAPI IDirectMusicSegment8Impl_GetDefaultResolution(IDirectMusicSegment8 *iface,
 142         DWORD *pdwResolution)
 143 {
 144   IDirectMusicSegment8Impl *This = impl_from_IDirectMusicSegment8(iface);
 145
 146   TRACE("(%p, %p)\n", This, pdwResolution);
 147   if (NULL == pdwResolution) {
 148     return E_POINTER;
 149   }
 150   *pdwResolution = This->header.dwResolution;
 151   return S_OK;
 152 }
 153
 154 static HRESULT WINAPI IDirectMusicSegment8Impl_SetDefaultResolution(IDirectMusicSegment8 *iface,
 155         DWORD dwResolution)
 156 {
 157   IDirectMusicSegment8Impl *This = impl_from_IDirectMusicSegment8(iface);
 158
 159   TRACE("(%p, %d)\n", This, dwResolution);
 160   This->header.dwResolution = dwResolution;
 161   return S_OK;
 162 }
 163
 164 static HRESULT WINAPI IDirectMusicSegment8Impl_GetTrack(IDirectMusicSegment8 *iface,
 165         REFGUID rguidType, DWORD dwGroupBits, DWORD dwIndex, IDirectMusicTrack **ppTrack)
 166 {
 167   IDirectMusicSegment8Impl *This = impl_from_IDirectMusicSegment8(iface);
 168   CLSID pIt_clsid;
 169   struct list* pEntry = NULL;
 170   LPDMUS_PRIVATE_SEGMENT_TRACK pIt = NULL;
 171   IPersistStream* pCLSIDStream = NULL;
 172   HRESULT hr = S_OK;
 173
 174   TRACE("(%p, %s, %d, 0x%x, %p)\n", This, debugstr_dmguid(rguidType), dwGroupBits, dwIndex, ppTrack);
 175
 176   if (NULL == ppTrack) {
 177     return E_POINTER;
 178   }
 179
 180   LIST_FOR_EACH (pEntry, &This->Tracks) {
 181     pIt = LIST_ENTRY(pEntry, DMUS_PRIVATE_SEGMENT_TRACK, entry);
 182     TRACE(" - %p -> 0x%x,%p\n", pIt, pIt->dwGroupBits, pIt->pTrack);
 183     if (0xFFFFFFFF != dwGroupBits && 0 == (pIt->dwGroupBits & dwGroupBits)) continue ;
 184     if (FALSE == IsEqualGUID(&GUID_NULL, rguidType)) {
 185       /**
 186        * it rguidType is not null we must check if CLSIDs are equal
 187        * and the unique way to get it is using IPersistStream Interface
 188        */
 189       hr = IDirectMusicTrack_QueryInterface(pIt->pTrack, &IID_IPersistStream, (void**) &pCLSIDStream);
 190       if (FAILED(hr)) {
 191         ERR("(%p): object %p don't implement IPersistStream Interface. Expect a crash (critical problem)\n", This, pIt->pTrack);
 192         continue ;
 193       }
 194       hr = IPersistStream_GetClassID(pCLSIDStream, &pIt_clsid);
 195       IPersistStream_Release(pCLSIDStream); pCLSIDStream = NULL;
 196       if (FAILED(hr)) {
 197         ERR("(%p): non-implemented GetClassID for object %p\n", This, pIt->pTrack);
 198         continue ;
 199       }
 200       TRACE(" - %p -> %s\n", pIt, debugstr_dmguid(&pIt_clsid));
 201       if (FALSE == IsEqualGUID(&pIt_clsid, rguidType)) continue ;
 202     }
 203     if (0 == dwIndex) {
 204       *ppTrack = pIt->pTrack;
 205       IDirectMusicTrack_AddRef(*ppTrack);
 206       return S_OK;
 207     }
 208     --dwIndex;
 209   }
 210   return DMUS_E_NOT_FOUND;
 211 }
 212
 213 static HRESULT WINAPI IDirectMusicSegment8Impl_GetTrackGroup(IDirectMusicSegment8 *iface,
 214         IDirectMusicTrack *pTrack, DWORD *pdwGroupBits)
 215 {
 216   IDirectMusicSegment8Impl *This = impl_from_IDirectMusicSegment8(iface);
 217   struct list* pEntry = NULL;
 218   LPDMUS_PRIVATE_SEGMENT_TRACK pIt = NULL;
 219
 220   TRACE("(%p, %p, %p)\n", This, pTrack, pdwGroupBits);
 221
 222   if (NULL == pdwGroupBits) {
 223     return E_POINTER;
 224   }
 225
 226   LIST_FOR_EACH (pEntry, &This->Tracks) {
 227     pIt = LIST_ENTRY(pEntry, DMUS_PRIVATE_SEGMENT_TRACK, entry);
 228     TRACE(" - %p -> %d,%p\n", pIt, pIt->dwGroupBits, pIt->pTrack);
 229     if (NULL != pIt && pIt->pTrack == pTrack) {
 230       *pdwGroupBits = pIt->dwGroupBits;
 231       return S_OK;
 232     }
 233   }
 234
 235   return DMUS_E_NOT_FOUND;
 236 }
 237
 238 static HRESULT WINAPI IDirectMusicSegment8Impl_InsertTrack(IDirectMusicSegment8 *iface,
 239         IDirectMusicTrack *pTrack, DWORD dwGroupBits)
 240 {
 241   IDirectMusicSegment8Impl *This = impl_from_IDirectMusicSegment8(iface);
 242   DWORD i = 0;
 243   struct list* pEntry = NULL;
 244   LPDMUS_PRIVATE_SEGMENT_TRACK pIt = NULL;
 245   LPDMUS_PRIVATE_SEGMENT_TRACK pNewSegTrack = NULL;
 246
 247   TRACE("(%p, %p, %d)\n", This, pTrack, dwGroupBits);
 248
 249   LIST_FOR_EACH (pEntry, &This->Tracks) {
 250     i++;
 251     pIt = LIST_ENTRY(pEntry, DMUS_PRIVATE_SEGMENT_TRACK, entry);
 252     TRACE(" - #%u: %p -> %d,%p\n", i, pIt, pIt->dwGroupBits, pIt->pTrack);
 253     if (NULL != pIt && pIt->pTrack == pTrack) {
 254       ERR("(%p, %p): track is already in list\n", This, pTrack);
 255       return E_FAIL;
 256     }
 257   }
 258
 259   pNewSegTrack = HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, sizeof(DMUS_PRIVATE_SEGMENT_TRACK));
 260   if (NULL == pNewSegTrack)
 261     return  E_OUTOFMEMORY;
 262
 263   pNewSegTrack->dwGroupBits = dwGroupBits;
 264   pNewSegTrack->pTrack = pTrack;
 265   IDirectMusicTrack_Init(pTrack, (IDirectMusicSegment *)iface);
 266   IDirectMusicTrack_AddRef(pTrack);
 267   list_add_tail (&This->Tracks, &pNewSegTrack->entry);
 268
 269   return S_OK;
 270 }
 271
 272 static HRESULT WINAPI IDirectMusicSegment8Impl_RemoveTrack(IDirectMusicSegment8 *iface,
 273         IDirectMusicTrack *pTrack)
 274 {
 275   IDirectMusicSegment8Impl *This = impl_from_IDirectMusicSegment8(iface);
 276   struct list* pEntry = NULL;
 277   LPDMUS_PRIVATE_SEGMENT_TRACK pIt = NULL;
 278
 279   TRACE("(%p, %p)\n", This, pTrack);
 280
 281   LIST_FOR_EACH (pEntry, &This->Tracks) {
 282     pIt = LIST_ENTRY(pEntry, DMUS_PRIVATE_SEGMENT_TRACK, entry);
 283     if (pIt->pTrack == pTrack) {
 284       TRACE("(%p, %p): track in list\n", This, pTrack);
 285
 286       list_remove(&pIt->entry);
 287       IDirectMusicTrack_Init(pIt->pTrack, NULL);
 288       IDirectMusicTrack_Release(pIt->pTrack);
 289       HeapFree(GetProcessHeap(), 0, pIt);
 290
 291       return S_OK;
 292     }
 293   }
 294
 295   return S_FALSE;
 296 }
 297
 298 static HRESULT WINAPI IDirectMusicSegment8Impl_InitPlay(IDirectMusicSegment8 *iface,
 299         IDirectMusicSegmentState **ppSegState, IDirectMusicPerformance *pPerformance, DWORD dwFlags)
 300 {
 301   IDirectMusicSegment8Impl *This = impl_from_IDirectMusicSegment8(iface);
 302   HRESULT hr;
 303
 304   FIXME("(%p, %p, %p, %d): semi-stub\n", This, ppSegState, pPerformance, dwFlags);
 305   if (NULL == ppSegState) {
 306     return E_POINTER;
 307   }
 308   hr = create_dmsegmentstate(&IID_IDirectMusicSegmentState,(void**) ppSegState);
 309   if (FAILED(hr)) {
 310     return hr;
 311   }
 312   /* TODO: DMUS_SEGF_FLAGS */
 313   return S_OK;
 314 }
 315
 316 static HRESULT WINAPI IDirectMusicSegment8Impl_GetGraph(IDirectMusicSegment8 *iface,
 317         IDirectMusicGraph **ppGraph)
 318 {
 319   IDirectMusicSegment8Impl *This = impl_from_IDirectMusicSegment8(iface);
 320
 321   FIXME("(%p, %p): semi-stub\n", This, ppGraph);
 322   if (NULL == ppGraph) {
 323     return E_POINTER;
 324   }
 325   if (NULL == This->pGraph) {
 326     return DMUS_E_NOT_FOUND;
 327   }
 328   /**
 329    * should return This, as seen in msdn
 330    * "...The segment object implements IDirectMusicGraph directly..."
 331    */
 332   *ppGraph = This->pGraph;
 333   IDirectMusicGraph_AddRef(This->pGraph);
 334   return S_OK;
 335 }
 336
 337 static HRESULT WINAPI IDirectMusicSegment8Impl_SetGraph(IDirectMusicSegment8 *iface,
 338         IDirectMusicGraph *pGraph)
 339 {
 340   IDirectMusicSegment8Impl *This = impl_from_IDirectMusicSegment8(iface);
 341
 342   FIXME("(%p, %p): to complete\n", This, pGraph);
 343   if (NULL != This->pGraph) {
 344     IDirectMusicGraph_Release(This->pGraph);
 345   }
 346   This->pGraph = pGraph;
 347   if (NULL != This->pGraph) {
 348     IDirectMusicGraph_AddRef(This->pGraph);
 349   }
 350   return S_OK;
 351 }
 352
 353 static HRESULT WINAPI IDirectMusicSegment8Impl_AddNotificationType(IDirectMusicSegment8 *iface,
 354         REFGUID rguidNotificationType)
 355 {
 356   IDirectMusicSegment8Impl *This = impl_from_IDirectMusicSegment8(iface);
 357   FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 358   return S_OK;
 359 }
 360
 361 static HRESULT WINAPI IDirectMusicSegment8Impl_RemoveNotificationType(IDirectMusicSegment8 *iface,
 362         REFGUID rguidNotificationType)
 363 {
 364   IDirectMusicSegment8Impl *This = impl_from_IDirectMusicSegment8(iface);
 365   FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 366   return S_OK;
 367 }
 368
 369 static HRESULT WINAPI IDirectMusicSegment8Impl_GetParam(IDirectMusicSegment8 *iface,
 370         REFGUID rguidType, DWORD dwGroupBits, DWORD dwIndex, MUSIC_TIME mtTime, MUSIC_TIME *pmtNext,
 371         void *pParam)
 372 {
 373   IDirectMusicSegment8Impl *This = impl_from_IDirectMusicSegment8(iface);
 374   CLSID pIt_clsid;
 375   struct list* pEntry = NULL;
 376   IDirectMusicTrack* pTrack = NULL;
 377   IPersistStream* pCLSIDStream = NULL;
 378   LPDMUS_PRIVATE_SEGMENT_TRACK pIt = NULL;
 379   HRESULT hr = S_OK;
 380
 381   FIXME("(%p, %s, 0x%x, %d, %d, %p, %p)\n", This, debugstr_dmguid(rguidType), dwGroupBits, dwIndex, mtTime, pmtNext, pParam);
 382
 383   if (DMUS_SEG_ANYTRACK == dwIndex) {
 384
 385     LIST_FOR_EACH (pEntry, &This->Tracks) {
 386       pIt = LIST_ENTRY(pEntry, DMUS_PRIVATE_SEGMENT_TRACK, entry);
 387
 388       hr = IDirectMusicTrack_QueryInterface(pIt->pTrack, &IID_IPersistStream, (void**) &pCLSIDStream);
 389       if (FAILED(hr)) {
 390         ERR("(%p): object %p don't implement IPersistStream Interface. Expect a crash (critical problem)\n", This, pIt->pTrack);
 391         continue ;
 392       }
 393
 394       TRACE(" - %p -> 0x%x,%p\n", pIt, pIt->dwGroupBits, pIt->pTrack);
 395
 396       if (0xFFFFFFFF != dwGroupBits && 0 == (pIt->dwGroupBits & dwGroupBits)) continue ;
 397       hr = IPersistStream_GetClassID(pCLSIDStream, &pIt_clsid);
 398       IPersistStream_Release(pCLSIDStream); pCLSIDStream = NULL;
 399       if (FAILED(hr)) {
 400         ERR("(%p): non-implemented GetClassID for object %p\n", This, pIt->pTrack);
 401         continue ;
 402       }
 403       if (FALSE == IsEqualGUID(&pIt_clsid, rguidType)) continue ;
 404       if (FAILED(IDirectMusicTrack_IsParamSupported(pIt->pTrack, rguidType))) continue ;
 405       hr = IDirectMusicTrack_GetParam(pIt->pTrack, rguidType, mtTime, pmtNext, pParam);
 406       if (SUCCEEDED(hr)) return hr;
 407     }
 408     ERR("(%p): not found\n", This);
 409     return DMUS_E_TRACK_NOT_FOUND;
 410   }
 411
 412   hr = IDirectMusicSegment8Impl_GetTrack(iface, &GUID_NULL, dwGroupBits, dwIndex, &pTrack);
 413   if (FAILED(hr)) {
 414     ERR("(%p): not found\n", This);
 415     return DMUS_E_TRACK_NOT_FOUND;
 416   }
 417
 418   hr = IDirectMusicTrack_GetParam(pTrack, rguidType, mtTime, pmtNext, pParam);
 419   IDirectMusicTrack_Release(pTrack); pTrack = NULL;
 420
 421   return hr;
 422 }
 423
 424 static HRESULT WINAPI IDirectMusicSegment8Impl_SetParam(IDirectMusicSegment8 *iface,
 425         REFGUID rguidType, DWORD dwGroupBits, DWORD dwIndex, MUSIC_TIME mtTime, void *pParam)
 426 {
 427   IDirectMusicSegment8Impl *This = impl_from_IDirectMusicSegment8(iface);
 428   FIXME("(%p, %s, %d, %d, %d, %p): stub\n", This, debugstr_dmguid(rguidType), dwGroupBits, dwIndex, mtTime, pParam);
 429   return S_OK;
 430 }
 431
 432 static HRESULT WINAPI IDirectMusicSegment8Impl_Clone(IDirectMusicSegment8 *iface,
 433         MUSIC_TIME mtStart, MUSIC_TIME mtEnd, IDirectMusicSegment **ppSegment)
 434 {
 435   IDirectMusicSegment8Impl *This = impl_from_IDirectMusicSegment8(iface);
 436   FIXME("(%p, %d, %d, %p): stub\n", This, mtStart, mtEnd, ppSegment);
 437   return S_OK;
 438 }
 439
 440 static HRESULT WINAPI IDirectMusicSegment8Impl_SetStartPoint(IDirectMusicSegment8 *iface,
 441         MUSIC_TIME mtStart)
 442 {
 443   IDirectMusicSegment8Impl *This = impl_from_IDirectMusicSegment8(iface);
 444
 445   TRACE("(%p, %d)\n", This, mtStart);
 446   if (mtStart >= This->header.mtLength) {
 447     return DMUS_E_OUT_OF_RANGE;
 448   }
 449   This->header.mtPlayStart = mtStart;
 450   return S_OK;
 451 }
 452
 453 static HRESULT WINAPI IDirectMusicSegment8Impl_GetStartPoint(IDirectMusicSegment8 *iface,
 454         MUSIC_TIME *pmtStart)
 455 {
 456   IDirectMusicSegment8Impl *This = impl_from_IDirectMusicSegment8(iface);
 457
 458   TRACE("(%p, %p)\n", This, pmtStart);
 459   if (NULL == pmtStart) {
 460     return E_POINTER;
 461   }
 462   *pmtStart = This->header.mtPlayStart;
 463   return S_OK;
 464 }
 465
 466 static HRESULT WINAPI IDirectMusicSegment8Impl_SetLoopPoints(IDirectMusicSegment8 *iface,
 467         MUSIC_TIME mtStart, MUSIC_TIME mtEnd)
 468 {
 469   IDirectMusicSegment8Impl *This = impl_from_IDirectMusicSegment8(iface);
 470
 471   TRACE("(%p, %d, %d)\n", This, mtStart, mtEnd);
 472   if (mtStart >= This->header.mtLength || mtEnd > This->header.mtLength || mtStart > mtEnd) {
 473     return DMUS_E_OUT_OF_RANGE;
 474   }
 475   This->header.mtLoopStart = mtStart;
 476   This->header.mtLoopEnd   = mtEnd;
 477   return S_OK;
 478 }
 479
 480 static HRESULT WINAPI IDirectMusicSegment8Impl_GetLoopPoints(IDirectMusicSegment8 *iface,
 481         MUSIC_TIME *pmtStart, MUSIC_TIME *pmtEnd)
 482 {
 483   IDirectMusicSegment8Impl *This = impl_from_IDirectMusicSegment8(iface);
 484
 485   TRACE("(%p, %p, %p)\n", This, pmtStart, pmtEnd);
 486   if (NULL == pmtStart || NULL == pmtEnd) {
 487     return E_POINTER;
 488   }
 489   *pmtStart = This->header.mtLoopStart;
 490   *pmtEnd   = This->header.mtLoopEnd;
 491   return S_OK;
 492 }
 493
 494 static HRESULT WINAPI IDirectMusicSegment8Impl_SetPChannelsUsed(IDirectMusicSegment8 *iface,
 495         DWORD dwNumPChannels, DWORD *paPChannels)
 496 {
 497         IDirectMusicSegment8Impl *This = impl_from_IDirectMusicSegment8(iface);
 498         FIXME("(%p, %d, %p): stub\n", This, dwNumPChannels, paPChannels);
 499         return S_OK;
 500 }
 501
 502 static HRESULT WINAPI IDirectMusicSegment8Impl_SetTrackConfig(IDirectMusicSegment8 *iface,
 503         REFGUID rguidTrackClassID, DWORD dwGroupBits, DWORD dwIndex, DWORD dwFlagsOn,
 504         DWORD dwFlagsOff)
 505 {
 506         IDirectMusicSegment8Impl *This = impl_from_IDirectMusicSegment8(iface);
 507         FIXME("(%p, %s, %d, %d, %d, %d): stub\n", This, debugstr_dmguid(rguidTrackClassID), dwGroupBits, dwIndex, dwFlagsOn, dwFlagsOff);
 508         return S_OK;
 509 }
 510
 511 static HRESULT WINAPI IDirectMusicSegment8Impl_GetAudioPathConfig(IDirectMusicSegment8 *iface,
 512         IUnknown **ppAudioPathConfig)
 513 {
 514         IDirectMusicSegment8Impl *This = impl_from_IDirectMusicSegment8(iface);
 515         FIXME("(%p, %p): stub\n", This, ppAudioPathConfig);
 516         return S_OK;
 517 }
 518
 519 static HRESULT WINAPI IDirectMusicSegment8Impl_Compose(IDirectMusicSegment8 *iface,
 520         MUSIC_TIME mtTime, IDirectMusicSegment *pFromSegment, IDirectMusicSegment *pToSegment,
 521         IDirectMusicSegment **ppComposedSegment)
 522 {
 523         IDirectMusicSegment8Impl *This = impl_from_IDirectMusicSegment8(iface);
 524         FIXME("(%p, %d, %p, %p, %p): stub\n", This, mtTime, pFromSegment, pToSegment, ppComposedSegment);
 525         return S_OK;
 526 }
 527
 528 static HRESULT WINAPI IDirectMusicSegment8Impl_Download(IDirectMusicSegment8 *iface,
 529         IUnknown *pAudioPath)
 530 {
 531         IDirectMusicSegment8Impl *This = impl_from_IDirectMusicSegment8(iface);
 532         FIXME("(%p, %p): stub\n", This, pAudioPath);
 533         return S_OK;
 534 }
 535
 536 static HRESULT WINAPI IDirectMusicSegment8Impl_Unload(IDirectMusicSegment8 *iface,
 537         IUnknown *pAudioPath)
 538 {
 539         IDirectMusicSegment8Impl *This = impl_from_IDirectMusicSegment8(iface);
 540         FIXME("(%p, %p): stub\n", This, pAudioPath);
 541         return S_OK;
 542 }
 543
 544 static const IDirectMusicSegment8Vtbl dmsegment8_vtbl = {
 545     IDirectMusicSegment8Impl_QueryInterface,
 546     IDirectMusicSegment8Impl_AddRef,
 547     IDirectMusicSegment8Impl_Release,
 548     IDirectMusicSegment8Impl_GetLength,
 549     IDirectMusicSegment8Impl_SetLength,
 550     IDirectMusicSegment8Impl_GetRepeats,
 551     IDirectMusicSegment8Impl_SetRepeats,
 552     IDirectMusicSegment8Impl_GetDefaultResolution,
 553     IDirectMusicSegment8Impl_SetDefaultResolution,
 554     IDirectMusicSegment8Impl_GetTrack,
 555     IDirectMusicSegment8Impl_GetTrackGroup,
 556     IDirectMusicSegment8Impl_InsertTrack,
 557     IDirectMusicSegment8Impl_RemoveTrack,
 558     IDirectMusicSegment8Impl_InitPlay,
 559     IDirectMusicSegment8Impl_GetGraph,
 560     IDirectMusicSegment8Impl_SetGraph,
 561     IDirectMusicSegment8Impl_AddNotificationType,
 562     IDirectMusicSegment8Impl_RemoveNotificationType,
 563     IDirectMusicSegment8Impl_GetParam,
 564     IDirectMusicSegment8Impl_SetParam,
 565     IDirectMusicSegment8Impl_Clone,
 566     IDirectMusicSegment8Impl_SetStartPoint,
 567     IDirectMusicSegment8Impl_GetStartPoint,
 568     IDirectMusicSegment8Impl_SetLoopPoints,
 569     IDirectMusicSegment8Impl_GetLoopPoints,
 570     IDirectMusicSegment8Impl_SetPChannelsUsed,
 571     IDirectMusicSegment8Impl_SetTrackConfig,
 572     IDirectMusicSegment8Impl_GetAudioPathConfig,
 573     IDirectMusicSegment8Impl_Compose,
 574     IDirectMusicSegment8Impl_Download,
 575     IDirectMusicSegment8Impl_Unload
 576 };
 577
 578 /* IDirectMusicSegment8Impl IDirectMusicObject part: */
 579 static HRESULT WINAPI seg_IDirectMusicObject_ParseDescriptor(IDirectMusicObject *iface,
 580         IStream *stream, DMUS_OBJECTDESC *desc)
 581 {
 582     struct chunk_entry riff = {0};
 583     DWORD supported = DMUS_OBJ_OBJECT | DMUS_OBJ_VERSION;
 584     HRESULT hr;
 585
 586     TRACE("(%p, %p, %p)\n", iface, stream, desc);
 587
 588     if (!stream || !desc)
 589         return E_POINTER;
 590
 591     if ((hr = stream_get_chunk(stream, &riff)) != S_OK)
 592         return hr;
 593     if (riff.id != FOURCC_RIFF || !(riff.type == DMUS_FOURCC_SEGMENT_FORM ||
 594                 riff.type == mmioFOURCC('W','A','V','E'))) {
 595         TRACE("loading failed: unexpected %s\n", debugstr_chunk(&riff));
 596         stream_skip_chunk(stream, &riff);
 597         return E_FAIL;
 598     }
 599
 600     if (riff.type == DMUS_FOURCC_SEGMENT_FORM)
 601         supported |= DMUS_OBJ_NAME | DMUS_OBJ_CATEGORY;
 602     else
 603         supported |= DMUS_OBJ_NAME_INFO;
 604     hr = dmobj_parsedescriptor(stream, &riff, desc, supported);
 605     if (FAILED(hr))
 606         return hr;
 607
 608     desc->guidClass = CLSID_DirectMusicSegment;
 609     desc->dwValidData |= DMUS_OBJ_CLASS;
 610
 611     TRACE("returning descriptor:\n%s\n", debugstr_DMUS_OBJECTDESC (desc));
 612     return S_OK;
 613 }
 614
 615 static const IDirectMusicObjectVtbl dmobject_vtbl = {
 616     dmobj_IDirectMusicObject_QueryInterface,
 617     dmobj_IDirectMusicObject_AddRef,
 618     dmobj_IDirectMusicObject_Release,
 619     dmobj_IDirectMusicObject_GetDescriptor,
 620     dmobj_IDirectMusicObject_SetDescriptor,
 621     seg_IDirectMusicObject_ParseDescriptor
 622 };
 623
 624 /* IDirectMusicSegment8Impl IPersistStream part: */
 625 static HRESULT load_track(IDirectMusicSegment8Impl *This, IStream *pClonedStream,
 626         IDirectMusicTrack **ppTrack, DMUS_IO_TRACK_HEADER *pTrack_hdr)
 627 {
 628   HRESULT hr = E_FAIL;
 629   IPersistStream* pPersistStream = NULL;
 630
 631   hr = CoCreateInstance (&pTrack_hdr->guidClassID, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectMusicTrack, (LPVOID*) ppTrack);
 632   if (FAILED(hr)) {
 633     ERR(": could not create object\n");
 634     return hr;
 635   }
 636   /* acquire PersistStream interface */
 637   hr = IDirectMusicTrack_QueryInterface (*ppTrack, &IID_IPersistStream, (LPVOID*) &pPersistStream);
 638   if (FAILED(hr)) {
 639     ERR(": could not acquire IPersistStream\n");
 640     return hr;
 641   }
 642   /* load */
 643   hr = IPersistStream_Load (pPersistStream, pClonedStream);
 644   if (FAILED(hr)) {
 645     ERR(": failed to load object\n");
 646     return hr;
 647   }
 648
 649   /* release all loading-related stuff */
 650   IPersistStream_Release (pPersistStream);
 651
 652   hr = IDirectMusicSegment8_InsertTrack(&This->IDirectMusicSegment8_iface, *ppTrack,
 653                                         pTrack_hdr->dwGroup); /* at dsPosition */
 654   if (FAILED(hr)) {
 655     ERR(": could not insert track\n");
 656     return hr;
 657   }
 658
 659   return S_OK;
 660 }
 661
 662 static HRESULT parse_track_form(IDirectMusicSegment8Impl *This, DMUS_PRIVATE_CHUNK *pChunk,
 663         IStream *pStm)
 664 {
 665   HRESULT hr = E_FAIL;
 666   DMUS_PRIVATE_CHUNK Chunk;
 667   DWORD StreamSize, StreamCount, ListSize[3];
 668   LARGE_INTEGER liMove; /* used when skipping chunks */
 669
 670   DMUS_IO_TRACK_HEADER        track_hdr;
 671   DMUS_IO_TRACK_EXTRAS_HEADER track_xhdr;
 672   IDirectMusicTrack*          pTrack = NULL;
 673
 674   if (pChunk->fccID != DMUS_FOURCC_TRACK_FORM) {
 675     ERR_(dmfile)(": %s chunk should be a TRACK form\n", debugstr_fourcc (pChunk->fccID));
 676     return E_FAIL;
 677   }
 678
 679   StreamSize = pChunk->dwSize - sizeof(FOURCC);
 680   StreamCount = 0;
 681
 682   do {
 683     IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
 684     StreamCount += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
 685     TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
 686
 687     switch (Chunk.fccID) {
 688     case DMUS_FOURCC_TRACK_CHUNK: {
 689       TRACE_(dmfile)(": track chunk\n");
 690       IStream_Read (pStm, &track_hdr, sizeof(DMUS_IO_TRACK_HEADER), NULL);
 691       TRACE_(dmfile)(" - class: %s\n", debugstr_guid (&track_hdr.guidClassID));
 692       TRACE_(dmfile)(" - dwGroup: %d\n", track_hdr.dwGroup);
 693       TRACE_(dmfile)(" - ckid: %s\n", debugstr_fourcc (track_hdr.ckid));
 694       TRACE_(dmfile)(" - fccType: %s\n", debugstr_fourcc (track_hdr.fccType));
 695       break;
 696     }
 697     case DMUS_FOURCC_TRACK_EXTRAS_CHUNK: {
 698       TRACE_(dmfile)(": track extras chunk\n");
 699       IStream_Read (pStm, &track_xhdr, sizeof(DMUS_IO_TRACK_EXTRAS_HEADER), NULL);
 700       break;
 701     }
 702
 703     case DMUS_FOURCC_COMMANDTRACK_CHUNK: {
 704       TRACE_(dmfile)(": COMMANDTRACK track\n");
 705       liMove.QuadPart = Chunk.dwSize;
 706       IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 707       break;
 708     }
 709
 710     case FOURCC_LIST: {
 711       IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL);
 712       TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(Chunk.fccID));
 713       ListSize[0] = Chunk.dwSize - sizeof(FOURCC);
 714       if (Chunk.fccID == track_hdr.fccType && 0 == track_hdr.ckid) {
 715         LPSTREAM pClonedStream = NULL;
 716
 717         TRACE_(dmfile)(": TRACK list\n");
 718
 719         IStream_Clone (pStm, &pClonedStream);
 720
 721         liMove.QuadPart = 0;
 722         liMove.QuadPart -= sizeof(FOURCC) + (sizeof(FOURCC)+sizeof(DWORD));
 723         IStream_Seek (pClonedStream, liMove, STREAM_SEEK_CUR, NULL);
 724
 725         hr = load_track(This, pClonedStream, &pTrack, &track_hdr);
 726         if (FAILED(hr)) {
 727           ERR(": could not load track\n");
 728           return hr;
 729         }
 730         IStream_Release (pClonedStream);
 731
 732         IDirectMusicTrack_Release(pTrack); pTrack = NULL; /* now we can release at as it inserted */
 733
 734         liMove.QuadPart = ListSize[0];
 735         IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 736
 737       } else {
 738         TRACE_(dmfile)(": unknown (skipping)\n");
 739         liMove.QuadPart = Chunk.dwSize;
 740         IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 741       }
 742       break;
 743     }
 744
 745     case FOURCC_RIFF: {
 746       IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL);
 747       TRACE_(dmfile)(": RIFF chunk of type %s\n", debugstr_fourcc(Chunk.fccID));
 748
 749       ListSize[0] = Chunk.dwSize - sizeof(FOURCC);
 750
 751       if (Chunk.fccID == track_hdr.fccType && 0 == track_hdr.ckid) {
 752         LPSTREAM pClonedStream = NULL;
 753
 754         TRACE_(dmfile)(": TRACK RIFF\n");
 755
 756         IStream_Clone (pStm, &pClonedStream);
 757
 758         liMove.QuadPart = 0;
 759         liMove.QuadPart -= sizeof(FOURCC) + (sizeof(FOURCC)+sizeof(DWORD));
 760         IStream_Seek (pClonedStream, liMove, STREAM_SEEK_CUR, NULL);
 761
 762         hr = load_track(This, pClonedStream, &pTrack, &track_hdr);
 763         if (FAILED(hr)) {
 764           ERR(": could not load track\n");
 765           return hr;
 766         }
 767         IStream_Release (pClonedStream);
 768
 769         IDirectMusicTrack_Release(pTrack); pTrack = NULL; /* now we can release at as it inserted */
 770
 771         /** now safe move the cursor */
 772         liMove.QuadPart = ListSize[0];
 773         IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 774
 775       } else {
 776         TRACE_(dmfile)(": unknown RIFF fmt (skipping)\n");
 777         liMove.QuadPart = ListSize[0];
 778         IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 779       }
 780       break;
 781     }
 782
 783     default: {
 784       if (0 == track_hdr.fccType && Chunk.fccID == track_hdr.ckid) {
 785         LPSTREAM pClonedStream = NULL;
 786
 787         TRACE_(dmfile)(": TRACK solo\n");
 788
 789         IStream_Clone (pStm, &pClonedStream);
 790
 791         liMove.QuadPart = 0;
 792         liMove.QuadPart -= (sizeof(FOURCC) + sizeof(DWORD));
 793         IStream_Seek (pClonedStream, liMove, STREAM_SEEK_CUR, NULL);
 794
 795         hr = load_track(This, pClonedStream, &pTrack, &track_hdr);
 796         if (FAILED(hr)) {
 797           ERR(": could not load track\n");
 798           return hr;
 799         }
 800         IStream_Release (pClonedStream);
 801
 802         IDirectMusicTrack_Release(pTrack); pTrack = NULL; /* now we can release at as it inserted */
 803
 804         liMove.QuadPart = Chunk.dwSize;
 805         IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 806
 807         break;
 808       }
 809
 810       TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
 811       liMove.QuadPart = Chunk.dwSize;
 812       IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 813       break;
 814     }
 815     }
 816     TRACE_(dmfile)(": StreamCount[0] = %d < StreamSize[0] = %d\n", StreamCount, StreamSize);
 817   } while (StreamCount < StreamSize);
 818
 819   return S_OK;
 820 }
 821
 822 static HRESULT parse_track_list(IDirectMusicSegment8Impl *This, DMUS_PRIVATE_CHUNK *pChunk,
 823         IStream *pStm)
 824 {
 825   HRESULT hr = E_FAIL;
 826   DMUS_PRIVATE_CHUNK Chunk;
 827   DWORD StreamSize, ListSize[3], ListCount[3];
 828   LARGE_INTEGER liMove; /* used when skipping chunks */
 829
 830   if (pChunk->fccID != DMUS_FOURCC_TRACK_LIST) {
 831     ERR_(dmfile)(": %s chunk should be a TRACK list\n", debugstr_fourcc (pChunk->fccID));
 832     return E_FAIL;
 833   }
 834
 835   ListSize[0] = pChunk->dwSize - sizeof(FOURCC);
 836   ListCount[0] = 0;
 837
 838   do {
 839     IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
 840     ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
 841     TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
 842     switch (Chunk.fccID) {
 843     case FOURCC_RIFF: {
 844       IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL);
 845       TRACE_(dmfile)(": RIFF chunk of type %s", debugstr_fourcc(Chunk.fccID));
 846       StreamSize = Chunk.dwSize - sizeof(FOURCC);
 847       switch (Chunk.fccID) {
 848       case  DMUS_FOURCC_TRACK_FORM: {
 849         TRACE_(dmfile)(": TRACK form\n");
 850         hr = parse_track_form(This, &Chunk, pStm);
 851         if (FAILED(hr)) return hr;
 852         break;
 853       }
 854       default: {
 855         TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
 856         liMove.QuadPart = StreamSize;
 857         IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 858         break;
 859       }
 860       }
 861       break;
 862     }
 863     default: {
 864       TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
 865       liMove.QuadPart = Chunk.dwSize;
 866       IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 867       break;
 868     }
 869     }
 870     TRACE_(dmfile)(": ListCount[0] = %d < ListSize[0] = %d\n", ListCount[0], ListSize[0]);
 871   } while (ListCount[0] < ListSize[0]);
 872
 873   return S_OK;
 874 }
 875
 876 static HRESULT parse_segment_form(IDirectMusicSegment8Impl *This, DWORD StreamSize, IStream *pStm)
 877 {
 878   HRESULT hr = E_FAIL;
 879   DMUS_PRIVATE_CHUNK Chunk;
 880   DWORD StreamCount, ListSize[3], ListCount[3];
 881   LARGE_INTEGER liMove; /* used when skipping chunks */
 882
 883   StreamSize -= sizeof(FOURCC);
 884   StreamCount = 0;
 885
 886   do {
 887     IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
 888     StreamCount += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
 889     TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
 890
 891     hr = IDirectMusicUtils_IPersistStream_ParseDescGeneric(&Chunk, pStm, &This->dmobj.desc);
 892     if (FAILED(hr)) return hr;
 893
 894     if (hr == S_FALSE) {
 895       switch (Chunk.fccID) {
 896       case DMUS_FOURCC_SEGMENT_CHUNK: {
 897         DWORD checkSz = sizeof(FOURCC);
 898         TRACE_(dmfile)(": segment chunk\n");
 899         /** DX 7 */
 900         IStream_Read (pStm, &This->header.dwRepeats,    sizeof(This->header.dwRepeats), NULL);
 901         checkSz += sizeof(This->header.dwRepeats);
 902         IStream_Read (pStm, &This->header.mtLength,     sizeof(This->header.mtLength), NULL);
 903         checkSz += sizeof(This->header.mtLength);
 904         IStream_Read (pStm, &This->header.mtPlayStart,  sizeof(This->header.mtPlayStart), NULL);
 905         checkSz += sizeof(This->header.mtPlayStart);
 906         IStream_Read (pStm, &This->header.mtLoopStart,  sizeof(This->header.mtLoopStart), NULL);
 907         checkSz += sizeof(This->header.mtLoopStart);
 908         IStream_Read (pStm, &This->header.mtLoopEnd,    sizeof(This->header.mtLoopEnd), NULL);
 909         checkSz += sizeof(This->header.mtLoopEnd);
 910         IStream_Read (pStm, &This->header.dwResolution, sizeof(This->header.dwResolution), NULL);
 911         checkSz += sizeof(This->header.dwResolution);
 912         TRACE_(dmfile)("dwRepeats: %u\n", This->header.dwRepeats);
 913         TRACE_(dmfile)("mtLength: %u\n",  This->header.mtLength);
 914         TRACE_(dmfile)("mtPlayStart: %u\n",  This->header.mtPlayStart);
 915         TRACE_(dmfile)("mtLoopStart: %u\n",  This->header.mtLoopStart);
 916         TRACE_(dmfile)("mtLoopEnd: %u\n",  This->header.mtLoopEnd);
 917         TRACE_(dmfile)("dwResolution: %u\n", This->header.dwResolution);
 918         /** DX 8 */
 919         if (Chunk.dwSize > checkSz) {
 920           IStream_Read (pStm, &This->header.rtLength,    sizeof(This->header.rtLength), NULL);
 921           checkSz += sizeof(This->header.rtLength);
 922           IStream_Read (pStm, &This->header.dwFlags,     sizeof(This->header.dwFlags), NULL);
 923           checkSz += sizeof(This->header.dwFlags);
 924         }
 925         /** DX 9 */
 926         if (Chunk.dwSize > checkSz) {
 927           IStream_Read (pStm, &This->header.rtLoopStart,  sizeof(This->header.rtLoopStart), NULL);
 928           checkSz += sizeof(This->header.rtLoopStart);
 929           IStream_Read (pStm, &This->header.rtLoopEnd,    sizeof(This->header.rtLoopEnd), NULL);
 930           checkSz += sizeof(This->header.rtLoopEnd);
 931           IStream_Read (pStm, &This->header.rtPlayStart,  sizeof(This->header.rtPlayStart), NULL);
 932           checkSz += sizeof(This->header.rtPlayStart);
 933         }
 934         liMove.QuadPart = Chunk.dwSize - checkSz + sizeof(FOURCC);
 935         IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 936         break;
 937       }
 938       case FOURCC_LIST: {
 939         IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL);
 940         TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(Chunk.fccID));
 941         ListSize[0] = Chunk.dwSize - sizeof(FOURCC);
 942         ListCount[0] = 0;
 943         switch (Chunk.fccID) {
 944         case DMUS_FOURCC_UNFO_LIST: {
 945           TRACE_(dmfile)(": UNFO list\n");
 946           do {
 947             IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
 948             ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
 949             TRACE_(dmfile)(": %s chunk (size = %d)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
 950
 951             hr = IDirectMusicUtils_IPersistStream_ParseUNFOGeneric(&Chunk, pStm, &This->dmobj.desc);
 952             if (FAILED(hr)) return hr;
 953
 954             if (hr == S_FALSE) {
 955               switch (Chunk.fccID) {
 956               default: {
 957                 TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
 958                 liMove.QuadPart = Chunk.dwSize;
 959                 IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 960                 break;
 961               }
 962               }
 963             }
 964
 965             TRACE_(dmfile)(": ListCount[0] = %d < ListSize[0] = %d\n", ListCount[0], ListSize[0]);
 966           } while (ListCount[0] < ListSize[0]);
 967           break;
 968         }
 969         case DMUS_FOURCC_TRACK_LIST: {
 970           TRACE_(dmfile)(": TRACK list\n");
 971           hr = parse_track_list(This, &Chunk, pStm);
 972           if (FAILED(hr)) return hr;
 973           break;
 974         }
 975         default: {
 976           TRACE_(dmfile)(": unknown (skipping)\n");
 977           liMove.QuadPart = Chunk.dwSize - sizeof(FOURCC);
 978           IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 979           break;
 980         }
 981         }
 982         break;
 983       }
 984       default: {
 985         TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
 986         liMove.QuadPart = Chunk.dwSize;
 987         IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 988         break;
 989       }
 990       }
 991     }
 992     TRACE_(dmfile)(": StreamCount[0] = %d < StreamSize[0] = %d\n", StreamCount, StreamSize);
 993   } while (StreamCount < StreamSize);
 994
 995   return S_OK;
 996 }
 997
 998 static inline IDirectMusicSegment8Impl *impl_from_IPersistStream(IPersistStream *iface)
 999 {
1000     return CONTAINING_RECORD(iface, IDirectMusicSegment8Impl, dmobj.IPersistStream_iface);
1001 }
1002
1003 static HRESULT WINAPI seg_IPersistStream_Load(IPersistStream *iface, IStream *stream)
1004 {
1005     IDirectMusicSegment8Impl *This = impl_from_IPersistStream(iface);
1006     struct chunk_entry riff = {0};
1007     HRESULT hr;
1008
1009     TRACE("(%p, %p): Loading\n", This, stream);
1010
1011     if (!stream)
1012         return E_POINTER;
1013
1014     if (stream_get_chunk(stream, &riff) != S_OK || riff.id != FOURCC_RIFF)
1015         return DMUS_E_UNSUPPORTED_STREAM;
1016
1017     stream_reset_chunk_start(stream, &riff);
1018     hr = IDirectMusicObject_ParseDescriptor(&This->dmobj.IDirectMusicObject_iface, stream,
1019             &This->dmobj.desc);
1020     if (FAILED(hr))
1021         return hr;
1022     stream_reset_chunk_data(stream, &riff);
1023
1024     if (riff.type == DMUS_FOURCC_SEGMENT_FORM)
1025         hr = parse_segment_form(This, riff.size, stream);
1026     else {
1027         FIXME("WAVE form loading not implemented\n");
1028         hr = S_OK;
1029     }
1030
1031     return hr;
1032 }
1033
1034 static const IPersistStreamVtbl persiststream_vtbl = {
1035     dmobj_IPersistStream_QueryInterface,
1036     dmobj_IPersistStream_AddRef,
1037     dmobj_IPersistStream_Release,
1038     dmobj_IPersistStream_GetClassID,
1039     unimpl_IPersistStream_IsDirty,
1040     seg_IPersistStream_Load,
1041     unimpl_IPersistStream_Save,
1042     unimpl_IPersistStream_GetSizeMax
1043 };
1044
1045 /* for ClassFactory */
1046 HRESULT WINAPI create_dmsegment(REFIID lpcGUID, void **ppobj)
1047 {
1048   IDirectMusicSegment8Impl* obj;
1049   HRESULT hr;
1050
1051   obj = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectMusicSegment8Impl));
1052   if (NULL == obj) {
1053     *ppobj = NULL;
1054     return E_OUTOFMEMORY;
1055   }
1056   obj->IDirectMusicSegment8_iface.lpVtbl = &dmsegment8_vtbl;
1057   obj->ref = 1;
1058   dmobject_init(&obj->dmobj, &CLSID_DirectMusicSegment,
1059           (IUnknown *)&obj->IDirectMusicSegment8_iface);
1060   obj->dmobj.IDirectMusicObject_iface.lpVtbl = &dmobject_vtbl;
1061   obj->dmobj.IPersistStream_iface.lpVtbl = &persiststream_vtbl;
1062   list_init (&obj->Tracks);
1063
1064   DMIME_LockModule();
1065   hr = IDirectMusicSegment8_QueryInterface(&obj->IDirectMusicSegment8_iface, lpcGUID, ppobj);
1066   IDirectMusicSegment8_Release(&obj->IDirectMusicSegment8_iface);
1067
1068   return hr;
1069 }