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