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
  23 WINE_DEFAULT_DEBUG_CHANNEL(dmime);
  24
  25 struct track_entry
  26 {
  27     struct list entry;
  28     DWORD dwGroupBits;
  29     DWORD flags;
  30     IDirectMusicTrack *pTrack;
  31 };
  32
  33 static void track_entry_destroy(struct track_entry *entry)
  34 {
  35     HRESULT hr;
  36
  37     if (FAILED(hr = IDirectMusicTrack_Init(entry->pTrack, NULL)))
  38         WARN("Failed to de-init track %p, hr %#lx\n", entry->pTrack, hr);
  39     IDirectMusicTrack_Release(entry->pTrack);
  40
  41     free(entry);
  42 }
  43
  44 struct segment
  45 {
  46     IDirectMusicSegment8 IDirectMusicSegment8_iface;
  47     struct dmobject dmobj;
  48     LONG ref;
  49     DMUS_IO_SEGMENT_HEADER header;
  50     IDirectMusicGraph *pGraph;
  51     struct list tracks;
  52
  53     PCMWAVEFORMAT wave_format;
  54     void *wave_data;
  55     int data_size;
  56 };
  57
  58 static struct segment *segment_create(void);
  59
  60 static inline struct segment *impl_from_IDirectMusicSegment8(IDirectMusicSegment8 *iface)
  61 {
  62     return CONTAINING_RECORD(iface, struct segment, IDirectMusicSegment8_iface);
  63 }
  64
  65 static HRESULT WINAPI segment_QueryInterface(IDirectMusicSegment8 *iface, REFIID riid, void **ret_iface)
  66 {
  67     struct segment *This = impl_from_IDirectMusicSegment8(iface);
  68
  69     TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ret_iface);
  70
  71     *ret_iface = NULL;
  72
  73     if (IsEqualIID (riid, &IID_IUnknown) || IsEqualIID (riid, &IID_IDirectMusicSegment) ||
  74             IsEqualIID(riid, &IID_IDirectMusicSegment2) ||
  75             IsEqualIID (riid, &IID_IDirectMusicSegment8))
  76         *ret_iface = iface;
  77     else if (IsEqualIID (riid, &IID_IDirectMusicObject))
  78         *ret_iface = &This->dmobj.IDirectMusicObject_iface;
  79     else if (IsEqualIID (riid, &IID_IPersistStream))
  80         *ret_iface = &This->dmobj.IPersistStream_iface;
  81     else {
  82         WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ret_iface);
  83         return E_NOINTERFACE;
  84     }
  85
  86     IUnknown_AddRef((IUnknown*)*ret_iface);
  87     return S_OK;
  88 }
  89
  90 static ULONG WINAPI segment_AddRef(IDirectMusicSegment8 *iface)
  91 {
  92     struct segment *This = impl_from_IDirectMusicSegment8(iface);
  93     LONG ref = InterlockedIncrement(&This->ref);
  94
  95     TRACE("(%p) ref=%ld\n", This, ref);
  96
  97     return ref;
  98 }
  99
 100 static ULONG WINAPI segment_Release(IDirectMusicSegment8 *iface)
 101 {
 102     struct segment *This = impl_from_IDirectMusicSegment8(iface);
 103     LONG ref = InterlockedDecrement(&This->ref);
 104
 105     TRACE("(%p) ref=%ld\n", This, ref);
 106
 107     if (!ref) {
 108         struct track_entry *entry, *next;
 109
 110         LIST_FOR_EACH_ENTRY_SAFE(entry, next, &This->tracks, struct track_entry, entry)
 111         {
 112             list_remove(&entry->entry);
 113             track_entry_destroy(entry);
 114         }
 115         free(This->wave_data);
 116         free(This);
 117     }
 118
 119     return ref;
 120 }
 121
 122 static HRESULT WINAPI segment_GetLength(IDirectMusicSegment8 *iface, MUSIC_TIME *length)
 123 {
 124     struct segment *This = impl_from_IDirectMusicSegment8(iface);
 125
 126     TRACE("(%p, %p)\n", This, length);
 127
 128     if (!length) return E_POINTER;
 129     *length = This->header.mtLength;
 130
 131     return S_OK;
 132 }
 133
 134 static HRESULT WINAPI segment_SetLength(IDirectMusicSegment8 *iface, MUSIC_TIME length)
 135 {
 136     struct segment *This = impl_from_IDirectMusicSegment8(iface);
 137
 138     TRACE("(%p, %ld)\n", This, length);
 139
 140     This->header.mtLength = length;
 141
 142     return S_OK;
 143 }
 144
 145 static HRESULT WINAPI segment_GetRepeats(IDirectMusicSegment8 *iface, DWORD *repeats)
 146 {
 147     struct segment *This = impl_from_IDirectMusicSegment8(iface);
 148
 149     TRACE("(%p, %p)\n", This, repeats);
 150
 151     if (!repeats) return E_POINTER;
 152     *repeats = This->header.dwRepeats;
 153
 154     return S_OK;
 155 }
 156
 157 static HRESULT WINAPI segment_SetRepeats(IDirectMusicSegment8 *iface, DWORD repeats)
 158 {
 159     struct segment *This = impl_from_IDirectMusicSegment8(iface);
 160
 161     TRACE("(%p, %ld)\n", This, repeats);
 162     This->header.dwRepeats = repeats;
 163
 164     return S_OK;
 165 }
 166
 167 static HRESULT WINAPI segment_GetDefaultResolution(IDirectMusicSegment8 *iface, DWORD *resolution)
 168 {
 169     struct segment *This = impl_from_IDirectMusicSegment8(iface);
 170
 171     TRACE("(%p, %p)\n", This, resolution);
 172
 173     if (!resolution) return E_POINTER;
 174     *resolution = This->header.dwResolution;
 175
 176     return S_OK;
 177 }
 178
 179 static HRESULT WINAPI segment_SetDefaultResolution(IDirectMusicSegment8 *iface, DWORD resolution)
 180 {
 181     struct segment *This = impl_from_IDirectMusicSegment8(iface);
 182
 183     TRACE("(%p, %ld)\n", This, resolution);
 184     This->header.dwResolution = resolution;
 185
 186     return S_OK;
 187 }
 188
 189 static HRESULT WINAPI segment_GetTrack(IDirectMusicSegment8 *iface, REFGUID type, DWORD group,
 190         DWORD index, IDirectMusicTrack **ret_track)
 191 {
 192   struct segment *This = impl_from_IDirectMusicSegment8(iface);
 193   struct track_entry *entry;
 194   HRESULT hr = S_OK;
 195
 196   TRACE("(%p, %s, %#lx, %#lx, %p)\n", This, debugstr_dmguid(type), group, index, ret_track);
 197
 198   if (!ret_track) return E_POINTER;
 199
 200   LIST_FOR_EACH_ENTRY(entry, &This->tracks, struct track_entry, entry)
 201   {
 202       if (group != -1 && !(entry->dwGroupBits & group)) continue;
 203
 204       if (!IsEqualGUID(&GUID_NULL, type))
 205       {
 206           CLSID entry_type = GUID_NULL;
 207           IPersistStream *persist;
 208
 209           if (SUCCEEDED(hr = IDirectMusicTrack_QueryInterface(entry->pTrack, &IID_IPersistStream, (void **)&persist)))
 210           {
 211               hr = IPersistStream_GetClassID(persist, &entry_type);
 212               if (SUCCEEDED(hr)) TRACE(" - %p -> %s\n", entry, debugstr_dmguid(&entry_type));
 213               IPersistStream_Release(persist);
 214           }
 215
 216           if (!IsEqualGUID(&entry_type, type)) continue;
 217       }
 218
 219       if (!index--)
 220       {
 221           *ret_track = entry->pTrack;
 222           IDirectMusicTrack_AddRef(entry->pTrack);
 223           return S_OK;
 224       }
 225   }
 226
 227   return DMUS_E_NOT_FOUND;
 228 }
 229
 230 static HRESULT WINAPI segment_GetTrackGroup(IDirectMusicSegment8 *iface, IDirectMusicTrack *track, DWORD *ret_group)
 231 {
 232   struct segment *This = impl_from_IDirectMusicSegment8(iface);
 233   struct track_entry *entry;
 234
 235   TRACE("(%p, %p, %p)\n", This, track, ret_group);
 236
 237   if (!ret_group) return E_POINTER;
 238
 239   LIST_FOR_EACH_ENTRY(entry, &This->tracks, struct track_entry, entry)
 240   {
 241       if (entry->pTrack == track)
 242       {
 243           *ret_group = entry->dwGroupBits;
 244           return S_OK;
 245       }
 246   }
 247
 248   return DMUS_E_NOT_FOUND;
 249 }
 250
 251 static HRESULT segment_append_track(struct segment *This, IDirectMusicTrack *track, DWORD group, DWORD flags)
 252 {
 253     struct track_entry *entry;
 254     HRESULT hr;
 255
 256     if (!(entry = calloc(1, sizeof(*entry)))) return E_OUTOFMEMORY;
 257     entry->dwGroupBits = group;
 258     entry->flags = flags;
 259     entry->pTrack = track;
 260     IDirectMusicTrack_AddRef(track);
 261
 262     hr = IDirectMusicTrack_Init(track, (IDirectMusicSegment *)&This->IDirectMusicSegment8_iface);
 263     if (FAILED(hr)) track_entry_destroy(entry);
 264     else list_add_tail(&This->tracks, &entry->entry);
 265
 266     return hr;
 267 }
 268
 269 static HRESULT WINAPI segment_InsertTrack(IDirectMusicSegment8 *iface, IDirectMusicTrack *track, DWORD group)
 270 {
 271     struct segment *This = impl_from_IDirectMusicSegment8(iface);
 272     struct track_entry *entry;
 273
 274     TRACE("(%p, %p, %#lx)\n", This, track, group);
 275
 276     if (!group) return E_INVALIDARG;
 277
 278     LIST_FOR_EACH_ENTRY(entry, &This->tracks, struct track_entry, entry)
 279         if (entry->pTrack == track) return E_FAIL;
 280
 281     return segment_append_track(This, track, group, 0);
 282 }
 283
 284 static HRESULT WINAPI segment_RemoveTrack(IDirectMusicSegment8 *iface, IDirectMusicTrack *track)
 285 {
 286     struct segment *This = impl_from_IDirectMusicSegment8(iface);
 287     struct track_entry *entry;
 288
 289     TRACE("(%p, %p)\n", This, track);
 290
 291     LIST_FOR_EACH_ENTRY(entry, &This->tracks, struct track_entry, entry)
 292     {
 293         if (entry->pTrack == track)
 294         {
 295             list_remove(&entry->entry);
 296             track_entry_destroy(entry);
 297             return S_OK;
 298         }
 299     }
 300
 301     return S_FALSE;
 302 }
 303
 304 static HRESULT WINAPI segment_InitPlay(IDirectMusicSegment8 *iface,
 305         IDirectMusicSegmentState **state, IDirectMusicPerformance *performance, DWORD flags)
 306 {
 307     struct segment *This = impl_from_IDirectMusicSegment8(iface);
 308     HRESULT hr;
 309
 310     FIXME("(%p, %p, %p, %ld): semi-stub\n", This, state, performance, flags);
 311
 312     if (!state) return E_POINTER;
 313     if (FAILED(hr = create_dmsegmentstate(&IID_IDirectMusicSegmentState, (void **)state))) return hr;
 314
 315     /* TODO: DMUS_SEGF_FLAGS */
 316     return S_OK;
 317 }
 318
 319 static HRESULT WINAPI segment_GetGraph(IDirectMusicSegment8 *iface, IDirectMusicGraph **graph)
 320 {
 321     struct segment *This = impl_from_IDirectMusicSegment8(iface);
 322
 323     FIXME("(%p, %p): semi-stub\n", This, graph);
 324
 325     if (!graph) return E_POINTER;
 326     if (!(*graph = This->pGraph)) return DMUS_E_NOT_FOUND;
 327     IDirectMusicGraph_AddRef(This->pGraph);
 328
 329     return S_OK;
 330 }
 331
 332 static HRESULT WINAPI segment_SetGraph(IDirectMusicSegment8 *iface, IDirectMusicGraph *graph)
 333 {
 334     struct segment *This = impl_from_IDirectMusicSegment8(iface);
 335
 336     FIXME("(%p, %p): to complete\n", This, graph);
 337
 338     if (This->pGraph) IDirectMusicGraph_Release(This->pGraph);
 339     if ((This->pGraph = graph)) IDirectMusicGraph_AddRef(This->pGraph);
 340
 341     return S_OK;
 342 }
 343
 344 static HRESULT WINAPI segment_AddNotificationType(IDirectMusicSegment8 *iface, REFGUID rguidNotificationType)
 345 {
 346     struct segment *This = impl_from_IDirectMusicSegment8(iface);
 347     FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 348     return S_OK;
 349 }
 350
 351 static HRESULT WINAPI segment_RemoveNotificationType(IDirectMusicSegment8 *iface, REFGUID rguidNotificationType)
 352 {
 353     struct segment *This = impl_from_IDirectMusicSegment8(iface);
 354     FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 355     return S_OK;
 356 }
 357
 358 static HRESULT WINAPI segment_GetParam(IDirectMusicSegment8 *iface, REFGUID type, DWORD group,
 359         DWORD index, MUSIC_TIME time, MUSIC_TIME *next, void *param)
 360 {
 361     struct segment *This = impl_from_IDirectMusicSegment8(iface);
 362     IDirectMusicTrack *track;
 363     unsigned int i, count;
 364     HRESULT hr = DMUS_E_TRACK_NOT_FOUND;
 365
 366     TRACE("(%p, %s, %#lx, %lu, %ld, %p, %p)\n", This, debugstr_dmguid(type), group, index, time,
 367             next, param);
 368
 369     if (!type)
 370         return E_POINTER;
 371
 372     /* Index is relative to the search pattern: group bits and supported param type */
 373     for (i = 0, count = 0; i < DMUS_SEG_ANYTRACK && count <= index; i++) {
 374         if (FAILED(segment_GetTrack(iface, &GUID_NULL, group, i, &track))) break;
 375         if (FAILED(IDirectMusicTrack_IsParamSupported(track, type)))
 376             continue;
 377         if (index == count || index == DMUS_SEG_ANYTRACK)
 378             hr = IDirectMusicTrack_GetParam(track, type, time, next, param);
 379         IDirectMusicTrack_Release(track);
 380
 381         if (SUCCEEDED(hr))
 382             return hr;
 383         count++;
 384     }
 385
 386     TRACE("(%p): not found\n", This);
 387
 388     return hr;
 389 }
 390
 391 static HRESULT WINAPI segment_SetParam(IDirectMusicSegment8 *iface, REFGUID type,
 392         DWORD group, DWORD index, MUSIC_TIME music_time, void *param)
 393 {
 394     struct segment *This = impl_from_IDirectMusicSegment8(iface);
 395     struct track_entry *entry;
 396     HRESULT hr;
 397
 398     TRACE("(%p, %s, %#lx, %ld, %ld, %p)\n", This, debugstr_dmguid(type), group,
 399             index, music_time, param);
 400
 401     LIST_FOR_EACH_ENTRY(entry, &This->tracks, struct track_entry, entry)
 402     {
 403         if (group != -1)
 404         {
 405             if (!(group & entry->dwGroupBits)) continue;
 406             if (index != DMUS_SEG_ALLTRACKS && index--) continue;
 407         }
 408
 409         if (SUCCEEDED(hr = IDirectMusicTrack_IsParamSupported(entry->pTrack, type))
 410                 && FAILED(hr = IDirectMusicTrack_SetParam(entry->pTrack, type, music_time, param)))
 411             WARN("SetParam for track %p failed, hr %#lx\n", entry->pTrack, hr);
 412     }
 413
 414     return S_OK;
 415 }
 416
 417 static HRESULT WINAPI segment_Clone(IDirectMusicSegment8 *iface, MUSIC_TIME start, MUSIC_TIME end,
 418         IDirectMusicSegment **segment)
 419 {
 420     struct segment *This = impl_from_IDirectMusicSegment8(iface);
 421     struct segment *clone;
 422     IDirectMusicTrack *track;
 423     struct track_entry *entry;
 424     HRESULT hr = S_OK;
 425
 426     TRACE("(%p, %ld, %ld, %p)\n", This, start, end, segment);
 427
 428     if (!segment) return E_POINTER;
 429
 430     if (!(clone = segment_create()))
 431     {
 432         *segment = NULL;
 433         return E_OUTOFMEMORY;
 434     }
 435
 436     clone->header = This->header;
 437     if ((clone->pGraph = This->pGraph)) IDirectMusicGraph_AddRef(clone->pGraph);
 438
 439     LIST_FOR_EACH_ENTRY(entry, &This->tracks, struct track_entry, entry)
 440     {
 441         if (FAILED(hr = IDirectMusicTrack_Clone(entry->pTrack, start, end, &track))) break;
 442         if (FAILED(hr = segment_append_track(clone, track, entry->dwGroupBits, entry->flags))) break;
 443     }
 444
 445     *segment = (IDirectMusicSegment *)&clone->IDirectMusicSegment8_iface;
 446     return FAILED(hr) ? S_FALSE : S_OK;
 447 }
 448
 449 static HRESULT WINAPI segment_SetStartPoint(IDirectMusicSegment8 *iface, MUSIC_TIME start)
 450 {
 451     struct segment *This = impl_from_IDirectMusicSegment8(iface);
 452
 453     TRACE("(%p, %ld)\n", This, start);
 454
 455     if (start >= This->header.mtLength) return DMUS_E_OUT_OF_RANGE;
 456     This->header.mtPlayStart = start;
 457
 458     return S_OK;
 459 }
 460
 461 static HRESULT WINAPI segment_GetStartPoint(IDirectMusicSegment8 *iface, MUSIC_TIME *start)
 462 {
 463     struct segment *This = impl_from_IDirectMusicSegment8(iface);
 464
 465     TRACE("(%p, %p)\n", This, start);
 466     if (!start) return E_POINTER;
 467     *start = This->header.mtPlayStart;
 468
 469     return S_OK;
 470 }
 471
 472 static HRESULT WINAPI segment_SetLoopPoints(IDirectMusicSegment8 *iface, MUSIC_TIME start, MUSIC_TIME end)
 473 {
 474     struct segment *This = impl_from_IDirectMusicSegment8(iface);
 475
 476     TRACE("(%p, %ld, %ld)\n", This, start, end);
 477
 478     if ((end || start) && (start >= This->header.mtLength || end > This->header.mtLength || start > end))
 479         return DMUS_E_OUT_OF_RANGE;
 480     This->header.mtLoopStart = start;
 481     This->header.mtLoopEnd = end;
 482
 483     return S_OK;
 484 }
 485
 486 static HRESULT WINAPI segment_GetLoopPoints(IDirectMusicSegment8 *iface, MUSIC_TIME *start, MUSIC_TIME *end)
 487 {
 488     struct segment *This = impl_from_IDirectMusicSegment8(iface);
 489
 490     TRACE("(%p, %p, %p)\n", This, start, end);
 491
 492     if (!start || !end) return E_POINTER;
 493     *start = This->header.mtLoopStart;
 494     *end = This->header.mtLoopEnd;
 495
 496     return S_OK;
 497 }
 498
 499 static HRESULT WINAPI segment_SetPChannelsUsed(IDirectMusicSegment8 *iface, DWORD dwNumPChannels, DWORD *paPChannels)
 500 {
 501     struct segment *This = impl_from_IDirectMusicSegment8(iface);
 502     FIXME("(%p, %ld, %p): stub\n", This, dwNumPChannels, paPChannels);
 503     return S_OK;
 504 }
 505
 506 static HRESULT WINAPI segment_SetTrackConfig(IDirectMusicSegment8 *iface, REFGUID rguidTrackClassID,
 507         DWORD dwGroupBits, DWORD dwIndex, DWORD dwFlagsOn, DWORD dwFlagsOff)
 508 {
 509     struct segment *This = impl_from_IDirectMusicSegment8(iface);
 510     FIXME("(%p, %s, %#lx, %ld, %ld, %ld): stub\n", This, debugstr_dmguid(rguidTrackClassID),
 511             dwGroupBits, dwIndex, dwFlagsOn, dwFlagsOff);
 512     return S_OK;
 513 }
 514
 515 static HRESULT WINAPI segment_GetAudioPathConfig(IDirectMusicSegment8 *iface, IUnknown **ppAudioPathConfig)
 516 {
 517     struct segment *This = impl_from_IDirectMusicSegment8(iface);
 518     FIXME("(%p, %p): stub\n", This, ppAudioPathConfig);
 519     return S_OK;
 520 }
 521
 522 static HRESULT WINAPI segment_Compose(IDirectMusicSegment8 *iface, MUSIC_TIME mtTime,
 523         IDirectMusicSegment *pFromSegment, IDirectMusicSegment *pToSegment, IDirectMusicSegment **ppComposedSegment)
 524 {
 525     struct segment *This = impl_from_IDirectMusicSegment8(iface);
 526     FIXME("(%p, %ld, %p, %p, %p): stub\n", This, mtTime, pFromSegment, pToSegment, ppComposedSegment);
 527     return S_OK;
 528 }
 529
 530 static HRESULT WINAPI segment_Download(IDirectMusicSegment8 *iface, IUnknown *audio_path)
 531 {
 532     struct segment *This = impl_from_IDirectMusicSegment8(iface);
 533     TRACE("(%p, %p)\n", This, audio_path);
 534     return IDirectMusicSegment8_SetParam(iface, &GUID_DownloadToAudioPath, -1, DMUS_SEG_ALLTRACKS, 0, audio_path);
 535 }
 536
 537 static HRESULT WINAPI segment_Unload(IDirectMusicSegment8 *iface, IUnknown *audio_path)
 538 {
 539     struct segment *This = impl_from_IDirectMusicSegment8(iface);
 540     TRACE("(%p, %p)\n", This, audio_path);
 541     return IDirectMusicSegment8_SetParam(iface, &GUID_UnloadFromAudioPath, -1, DMUS_SEG_ALLTRACKS, 0, audio_path);
 542 }
 543
 544 static const IDirectMusicSegment8Vtbl segment_vtbl =
 545 {
 546     segment_QueryInterface,
 547     segment_AddRef,
 548     segment_Release,
 549     segment_GetLength,
 550     segment_SetLength,
 551     segment_GetRepeats,
 552     segment_SetRepeats,
 553     segment_GetDefaultResolution,
 554     segment_SetDefaultResolution,
 555     segment_GetTrack,
 556     segment_GetTrackGroup,
 557     segment_InsertTrack,
 558     segment_RemoveTrack,
 559     segment_InitPlay,
 560     segment_GetGraph,
 561     segment_SetGraph,
 562     segment_AddNotificationType,
 563     segment_RemoveNotificationType,
 564     segment_GetParam,
 565     segment_SetParam,
 566     segment_Clone,
 567     segment_SetStartPoint,
 568     segment_GetStartPoint,
 569     segment_SetLoopPoints,
 570     segment_GetLoopPoints,
 571     segment_SetPChannelsUsed,
 572     segment_SetTrackConfig,
 573     segment_GetAudioPathConfig,
 574     segment_Compose,
 575     segment_Download,
 576     segment_Unload,
 577 };
 578
 579 static HRESULT WINAPI segment_object_ParseDescriptor(IDirectMusicObject *iface, IStream *stream, DMUS_OBJECTDESC *desc)
 580 {
 581     struct chunk_entry riff = {0};
 582     DWORD supported = DMUS_OBJ_OBJECT | DMUS_OBJ_VERSION;
 583     HRESULT hr;
 584
 585     TRACE("(%p, %p, %p)\n", iface, stream, desc);
 586
 587     if (!stream || !desc)
 588         return E_POINTER;
 589
 590     if ((hr = stream_get_chunk(stream, &riff)) != S_OK)
 591         return hr;
 592     if (riff.id != FOURCC_RIFF || !(riff.type == DMUS_FOURCC_SEGMENT_FORM ||
 593                 riff.type == mmioFOURCC('W','A','V','E'))) {
 594         TRACE("loading failed: unexpected %s\n", debugstr_chunk(&riff));
 595         stream_skip_chunk(stream, &riff);
 596         return E_FAIL;
 597     }
 598
 599     if (riff.type == DMUS_FOURCC_SEGMENT_FORM)
 600         supported |= DMUS_OBJ_NAME | DMUS_OBJ_CATEGORY;
 601     else
 602         supported |= DMUS_OBJ_NAME_INFO;
 603     hr = dmobj_parsedescriptor(stream, &riff, desc, supported);
 604     if (FAILED(hr))
 605         return hr;
 606
 607     desc->guidClass = CLSID_DirectMusicSegment;
 608     desc->dwValidData |= DMUS_OBJ_CLASS;
 609
 610     dump_DMUS_OBJECTDESC(desc);
 611     return S_OK;
 612 }
 613
 614 static const IDirectMusicObjectVtbl segment_object_vtbl =
 615 {
 616     dmobj_IDirectMusicObject_QueryInterface,
 617     dmobj_IDirectMusicObject_AddRef,
 618     dmobj_IDirectMusicObject_Release,
 619     dmobj_IDirectMusicObject_GetDescriptor,
 620     dmobj_IDirectMusicObject_SetDescriptor,
 621     segment_object_ParseDescriptor,
 622 };
 623
 624 static HRESULT parse_track_form(struct segment *This, IStream *stream, const struct chunk_entry *riff)
 625 {
 626     struct chunk_entry chunk = {.parent = riff};
 627     IDirectMusicTrack *track = NULL;
 628     IPersistStream *ps = NULL;
 629     IStream *clone;
 630     DMUS_IO_TRACK_HEADER thdr;
 631     DMUS_IO_TRACK_EXTRAS_HEADER txhdr = {0};
 632     HRESULT hr;
 633
 634     TRACE("Parsing track form in %p: %s\n", stream, debugstr_chunk(riff));
 635
 636     /* First chunk must be the track header */
 637     if (FAILED(hr = stream_get_chunk(stream, &chunk)))
 638         return hr;
 639     if (chunk.id != DMUS_FOURCC_TRACK_CHUNK)
 640         return DMUS_E_TRACK_HDR_NOT_FIRST_CK;
 641     if (FAILED(hr = stream_chunk_get_data(stream, &chunk, &thdr, sizeof(thdr))))
 642         return hr;
 643     TRACE("Found DMUS_IO_TRACK_HEADER\n");
 644     TRACE("\tclass: %s\n", debugstr_guid (&thdr.guidClassID));
 645     TRACE("\tdwGroup: %#lx\n", thdr.dwGroup);
 646     TRACE("\tckid: %s\n", debugstr_fourcc (thdr.ckid));
 647     TRACE("\tfccType: %s\n", debugstr_fourcc (thdr.fccType));
 648
 649     if (!!thdr.ckid == !!thdr.fccType) {
 650         WARN("One and only one of the ckid (%s) and fccType (%s) need to be set\n",
 651                 debugstr_fourcc(thdr.ckid), debugstr_fourcc(thdr.fccType));
 652         return DMUS_E_INVALID_TRACK_HDR;
 653     }
 654
 655     /* Optional chunks */
 656     while ((hr = stream_next_chunk(stream, &chunk)) == S_OK) {
 657         if ((thdr.ckid && chunk.id == thdr.ckid) ||
 658                 (!thdr.ckid && (chunk.id == FOURCC_LIST || chunk.id == FOURCC_RIFF) &&
 659                  chunk.type == thdr.fccType))
 660             break;
 661
 662         if (chunk.id == DMUS_FOURCC_TRACK_EXTRAS_CHUNK &&
 663                 SUCCEEDED(stream_chunk_get_data(stream, &chunk, &txhdr, sizeof(txhdr)))) {
 664             FIXME("DMUS_IO_TRACK_EXTRAS_HEADER chunk not fully handled\n");
 665             TRACE("dwFlags: %#lx, dwPriority: %lu\n", txhdr.dwFlags, txhdr.dwPriority);
 666         }
 667     }
 668     if (hr != S_OK)
 669         return hr == S_FALSE ? DMUS_E_TRACK_NOT_FOUND : hr;
 670
 671     /* Some DirectMusicTrack implementation expect the stream to start with their data chunk */
 672     if (FAILED(hr = IStream_Clone(stream, &clone)))
 673         return hr;
 674     stream_reset_chunk_start(clone, &chunk);
 675
 676     /* Load the track */
 677     hr = CoCreateInstance(&thdr.guidClassID, NULL, CLSCTX_INPROC_SERVER, &IID_IDirectMusicTrack,
 678             (void **)&track);
 679     if (FAILED(hr))
 680         goto done;
 681     hr = IDirectMusicTrack_QueryInterface(track, &IID_IPersistStream, (void **)&ps);
 682     if (FAILED(hr))
 683         goto done;
 684     hr = IPersistStream_Load(ps, clone);
 685     if (FAILED(hr))
 686         goto done;
 687
 688     hr = segment_append_track(This, track, thdr.dwGroup, txhdr.dwFlags);
 689
 690 done:
 691     if (ps)
 692         IPersistStream_Release(ps);
 693     if (track)
 694         IDirectMusicTrack_Release(track);
 695     IStream_Release(clone);
 696
 697     return hr;
 698 }
 699
 700 static HRESULT parse_track_list(struct segment *This, IStream *stream, const struct chunk_entry *trkl)
 701 {
 702     struct chunk_entry chunk = {.parent = trkl};
 703     HRESULT hr;
 704
 705     TRACE("Parsing track list in %p: %s\n", stream, debugstr_chunk(trkl));
 706
 707     while ((hr = stream_next_chunk(stream, &chunk)) == S_OK)
 708         if (chunk.id == FOURCC_RIFF && chunk.type == DMUS_FOURCC_TRACK_FORM)
 709             hr = parse_track_form(This, stream, &chunk);
 710
 711     return SUCCEEDED(hr) ? S_OK : hr;
 712 }
 713
 714 static inline void dump_segment_header(DMUS_IO_SEGMENT_HEADER *h, DWORD size)
 715 {
 716     unsigned int dx = 9;
 717
 718     if (size == offsetof(DMUS_IO_SEGMENT_HEADER, rtLength))
 719         dx = 7;
 720     else if (size == offsetof(DMUS_IO_SEGMENT_HEADER, rtLoopStart))
 721         dx = 8;
 722     TRACE("Found DirectX%d DMUS_IO_SEGMENT_HEADER\n", dx);
 723     TRACE("\tdwRepeats: %lu\n", h->dwRepeats);
 724     TRACE("\tmtLength: %lu\n", h->mtLength);
 725     TRACE("\tmtPlayStart: %lu\n", h->mtPlayStart);
 726     TRACE("\tmtLoopStart: %lu\n", h->mtLoopStart);
 727     TRACE("\tmtLoopEnd: %lu\n", h->mtLoopEnd);
 728     TRACE("\tdwResolution: %lu\n", h->dwResolution);
 729     if (dx >= 8) {
 730         TRACE("\trtLength: %s\n", wine_dbgstr_longlong(h->rtLength));
 731         TRACE("\tdwFlags: %lu\n", h->dwFlags);
 732         TRACE("\tdwReserved: %lu\n", h->dwReserved);
 733     }
 734     if (dx == 9) {
 735         TRACE("\trtLoopStart: %s\n", wine_dbgstr_longlong(h->rtLoopStart));
 736         TRACE("\trtLoopEnd: %s\n", wine_dbgstr_longlong(h->rtLoopEnd));
 737         if (size > offsetof(DMUS_IO_SEGMENT_HEADER, rtPlayStart))
 738             TRACE("\trtPlayStart: %s\n", wine_dbgstr_longlong(h->rtPlayStart));
 739     }
 740 }
 741
 742 static HRESULT parse_dmsg_chunk(struct segment *This, IStream *stream, const struct chunk_entry *riff)
 743 {
 744     struct chunk_entry chunk = {.parent = riff};
 745     HRESULT hr;
 746
 747     TRACE("Parsing segment form in %p: %s\n", stream, debugstr_chunk(riff));
 748
 749     if (FAILED(hr = dmobj_parsedescriptor(stream, riff, &This->dmobj.desc, DMUS_OBJ_NAME | DMUS_OBJ_CATEGORY))
 750                 || FAILED(hr = stream_reset_chunk_data(stream, riff)))
 751         return hr;
 752
 753     while ((hr = stream_next_chunk(stream, &chunk)) == S_OK) {
 754         switch (chunk.id) {
 755             case DMUS_FOURCC_SEGMENT_CHUNK:
 756                 /* DX9 without rtPlayStart field */
 757                 if (chunk.size == offsetof(DMUS_IO_SEGMENT_HEADER, rtPlayStart))
 758                     WARN("Missing rtPlayStart field in %s\n", debugstr_chunk(&chunk));
 759                 /* DX7, DX8 and DX9 structure sizes */
 760                 else if (chunk.size != offsetof(DMUS_IO_SEGMENT_HEADER, rtLength) &&
 761                         chunk.size != offsetof(DMUS_IO_SEGMENT_HEADER, rtLoopStart) &&
 762                         chunk.size != sizeof(DMUS_IO_SEGMENT_HEADER)) {
 763                     WARN("Invalid size of %s\n", debugstr_chunk(&chunk));
 764                     break;
 765                 }
 766                 if (FAILED(hr = stream_chunk_get_data(stream, &chunk, &This->header, chunk.size))) {
 767                     WARN("Failed to read data of %s\n", debugstr_chunk(&chunk));
 768                     return hr;
 769                 }
 770                 dump_segment_header(&This->header, chunk.size);
 771                 break;
 772             case FOURCC_LIST:
 773                 if (chunk.type == DMUS_FOURCC_TRACK_LIST)
 774                     if (FAILED(hr = parse_track_list(This, stream, &chunk)))
 775                         return hr;
 776                 break;
 777             case FOURCC_RIFF:
 778                 FIXME("Loading of embedded RIFF form %s\n", debugstr_fourcc(chunk.type));
 779                 break;
 780         }
 781     }
 782
 783     return SUCCEEDED(hr) ? S_OK : hr;
 784 }
 785
 786 static inline struct segment *impl_from_IPersistStream(IPersistStream *iface)
 787 {
 788     return CONTAINING_RECORD(iface, struct segment, dmobj.IPersistStream_iface);
 789 }
 790
 791 static HRESULT WINAPI segment_persist_stream_Load(IPersistStream *iface, IStream *stream)
 792 {
 793     struct segment *This = impl_from_IPersistStream(iface);
 794     struct chunk_entry chunk = {0};
 795     HRESULT hr;
 796
 797     TRACE("(%p, %p): Loading\n", This, stream);
 798
 799     if (!stream) return E_POINTER;
 800
 801     if ((hr = stream_get_chunk(stream, &chunk)) == S_OK)
 802     {
 803         switch (MAKE_IDTYPE(chunk.id, chunk.type))
 804         {
 805         case MAKE_IDTYPE(FOURCC_RIFF, DMUS_FOURCC_SEGMENT_FORM):
 806             hr = parse_dmsg_chunk(This, stream, &chunk);
 807             break;
 808
 809         case mmioFOURCC('M','T','h','d'):
 810             FIXME("MIDI file loading not supported\n");
 811             break;
 812
 813         case MAKE_IDTYPE(FOURCC_RIFF, mmioFOURCC('W','A','V','E')):
 814         {
 815             IDirectMusicTrack8 *track;
 816
 817             TRACE("Loading segment %p from wave file\n", This);
 818
 819             This->header.mtLength = 1;
 820             if (FAILED(hr = wave_track_create_from_chunk(stream, &chunk, &track))) break;
 821             hr = segment_append_track(This, (IDirectMusicTrack *)track, 1, 0);
 822             break;
 823         }
 824
 825         default:
 826             WARN("Invalid segment chunk %s %s\n", debugstr_fourcc(chunk.id), debugstr_fourcc(chunk.type));
 827             hr = DMUS_E_UNSUPPORTED_STREAM;
 828             break;
 829         }
 830     }
 831
 832     stream_skip_chunk(stream, &chunk);
 833     if (FAILED(hr))
 834     {
 835         WARN("Failed to load segment from stream %p, hr %#lx\n", stream, hr);
 836         return DMUS_E_UNSUPPORTED_STREAM;
 837     }
 838
 839     This->dmobj.desc.guidClass = CLSID_DirectMusicSegment;
 840     This->dmobj.desc.dwValidData |= DMUS_OBJ_CLASS;
 841
 842     return S_OK;
 843 }
 844
 845 static const IPersistStreamVtbl segment_persist_stream_vtbl =
 846 {
 847     dmobj_IPersistStream_QueryInterface,
 848     dmobj_IPersistStream_AddRef,
 849     dmobj_IPersistStream_Release,
 850     dmobj_IPersistStream_GetClassID,
 851     unimpl_IPersistStream_IsDirty,
 852     segment_persist_stream_Load,
 853     unimpl_IPersistStream_Save,
 854     unimpl_IPersistStream_GetSizeMax,
 855 };
 856
 857 static struct segment *segment_create(void)
 858 {
 859     struct segment *obj;
 860
 861     if (!(obj = calloc(1, sizeof(*obj)))) return NULL;
 862     obj->IDirectMusicSegment8_iface.lpVtbl = &segment_vtbl;
 863     obj->ref = 1;
 864     dmobject_init(&obj->dmobj, &CLSID_DirectMusicSegment, (IUnknown *)&obj->IDirectMusicSegment8_iface);
 865     obj->dmobj.IDirectMusicObject_iface.lpVtbl = &segment_object_vtbl;
 866     obj->dmobj.IPersistStream_iface.lpVtbl = &segment_persist_stream_vtbl;
 867     list_init(&obj->tracks);
 868
 869     return obj;
 870 }
 871
 872 /* for ClassFactory */
 873 HRESULT create_dmsegment(REFIID guid, void **ret_iface)
 874 {
 875     struct segment *obj;
 876     HRESULT hr;
 877
 878     if (!(obj = segment_create()))
 879     {
 880         *ret_iface = NULL;
 881         return E_OUTOFMEMORY;
 882     }
 883
 884     hr = IDirectMusicSegment8_QueryInterface(&obj->IDirectMusicSegment8_iface, guid, ret_iface);
 885     IDirectMusicSegment8_Release(&obj->IDirectMusicSegment8_iface);
 886
 887     return hr;
 888 }