dlls/dmband/bandtrack.c

   1 /*
   2  * Copyright (C) 2003-2004 Rok Mandeljc
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  17  */
  18
  19 #include "dmband_private.h"
  20 #include "dmobject.h"
  21
  22 WINE_DEFAULT_DEBUG_CHANNEL(dmband);
  23
  24 struct band_entry
  25 {
  26     struct list entry;
  27     DMUS_IO_BAND_ITEM_HEADER2 head;
  28     IDirectMusicBand *band;
  29 };
  30
  31 static void band_entry_destroy(struct band_entry *entry)
  32 {
  33     IDirectMusicTrack_Release(entry->band);
  34     free(entry);
  35 }
  36
  37 struct band_track
  38 {
  39     IDirectMusicTrack8 IDirectMusicTrack8_iface;
  40     struct dmobject dmobj; /* IPersistStream only */
  41     LONG ref;
  42     DMUS_IO_BAND_TRACK_HEADER header;
  43     struct list bands;
  44 };
  45
  46 static inline struct band_track *impl_from_IDirectMusicTrack8(IDirectMusicTrack8 *iface)
  47 {
  48     return CONTAINING_RECORD(iface, struct band_track, IDirectMusicTrack8_iface);
  49 }
  50
  51 static HRESULT WINAPI band_track_QueryInterface(IDirectMusicTrack8 *iface, REFIID riid,
  52         void **ret_iface)
  53 {
  54     struct band_track *This = impl_from_IDirectMusicTrack8(iface);
  55
  56     TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ret_iface);
  57
  58     *ret_iface = NULL;
  59
  60     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDirectMusicTrack) ||
  61             IsEqualIID(riid, &IID_IDirectMusicTrack8))
  62         *ret_iface = iface;
  63     else if (IsEqualIID(riid, &IID_IPersistStream))
  64         *ret_iface = &This->dmobj.IPersistStream_iface;
  65     else {
  66         WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ret_iface);
  67         return E_NOINTERFACE;
  68     }
  69
  70     IUnknown_AddRef((IUnknown*)*ret_iface);
  71     return S_OK;
  72 }
  73
  74 static ULONG WINAPI band_track_AddRef(IDirectMusicTrack8 *iface)
  75 {
  76     struct band_track *This = impl_from_IDirectMusicTrack8(iface);
  77     LONG ref = InterlockedIncrement(&This->ref);
  78
  79     TRACE("(%p) ref=%ld\n", This, ref);
  80
  81     return ref;
  82 }
  83
  84 static ULONG WINAPI band_track_Release(IDirectMusicTrack8 *iface)
  85 {
  86     struct band_track *This = impl_from_IDirectMusicTrack8(iface);
  87     LONG ref = InterlockedDecrement(&This->ref);
  88
  89     TRACE("(%p) ref=%ld\n", This, ref);
  90
  91     if (!ref)
  92     {
  93         struct band_entry *entry, *next;
  94
  95         LIST_FOR_EACH_ENTRY_SAFE(entry, next, &This->bands, struct band_entry, entry)
  96         {
  97             list_remove(&entry->entry);
  98             band_entry_destroy(entry);
  99         }
 100
 101         free(This);
 102     }
 103
 104     return ref;
 105 }
 106
 107 static HRESULT WINAPI band_track_Init(IDirectMusicTrack8 *iface, IDirectMusicSegment *pSegment)
 108 {
 109     struct band_track *This = impl_from_IDirectMusicTrack8(iface);
 110     FIXME("(%p, %p): stub\n", This, pSegment);
 111     return S_OK;
 112 }
 113
 114 static HRESULT WINAPI band_track_InitPlay(IDirectMusicTrack8 *iface,
 115         IDirectMusicSegmentState *segment_state, IDirectMusicPerformance *performance,
 116         void **state_data, DWORD virtual_track8id, DWORD flags)
 117 {
 118     struct band_track *This = impl_from_IDirectMusicTrack8(iface);
 119
 120     FIXME("(%p, %p, %p, %p, %ld, %lx): stub\n", This, segment_state, performance, state_data, virtual_track8id, flags);
 121
 122     return S_OK;
 123 }
 124
 125 static HRESULT WINAPI band_track_EndPlay(IDirectMusicTrack8 *iface, void *pStateData)
 126 {
 127     struct band_track *This = impl_from_IDirectMusicTrack8(iface);
 128     FIXME("(%p, %p): stub\n", This, pStateData);
 129     return S_OK;
 130 }
 131
 132 static HRESULT WINAPI band_track_Play(IDirectMusicTrack8 *iface, void *state_data,
 133         MUSIC_TIME mtStart, MUSIC_TIME mtEnd, MUSIC_TIME mtOffset, DWORD flags,
 134         IDirectMusicPerformance *performance, IDirectMusicSegmentState *segment_state,
 135         DWORD virtual_id)
 136 {
 137     struct band_track *This = impl_from_IDirectMusicTrack8(iface);
 138
 139     FIXME("(%p, %p, %ld, %ld, %ld, %lx, %p, %p, %ld): semi-stub\n", This, state_data, mtStart, mtEnd, mtOffset, flags, performance, segment_state, virtual_id);
 140
 141     /* Sends following pMSG:
 142        - DMUS_PATCH_PMSG
 143        - DMUS_TRANSPOSE_PMSG
 144        - DMUS_CHANNEL_PRIORITY_PMSG
 145        - DMUS_MIDI_PMSG
 146     */
 147
 148     return S_OK;
 149 }
 150
 151 static HRESULT WINAPI band_track_GetParam(IDirectMusicTrack8 *iface, REFGUID type, MUSIC_TIME time,
 152         MUSIC_TIME *next, void *param)
 153 {
 154     struct band_track *This = impl_from_IDirectMusicTrack8(iface);
 155
 156     TRACE("(%p, %s, %ld, %p, %p)\n", This, debugstr_dmguid(type), time, next, param);
 157
 158     if (!type)
 159         return E_POINTER;
 160     if (!IsEqualGUID(type, &GUID_BandParam))
 161         return DMUS_E_GET_UNSUPPORTED;
 162
 163     FIXME("GUID_BandParam not handled yet\n");
 164
 165     return S_OK;
 166 }
 167
 168 static HRESULT WINAPI band_track_SetParam(IDirectMusicTrack8 *iface, REFGUID type, MUSIC_TIME time,
 169         void *param)
 170 {
 171     struct band_track *This = impl_from_IDirectMusicTrack8(iface);
 172
 173     TRACE("(%p, %s, %ld, %p)\n", This, debugstr_dmguid(type), time, param);
 174
 175     if (!type)
 176         return E_POINTER;
 177     if (FAILED(IDirectMusicTrack8_IsParamSupported(iface, type)))
 178         return DMUS_E_TYPE_UNSUPPORTED;
 179
 180     if (IsEqualGUID(type, &GUID_BandParam))
 181         FIXME("GUID_BandParam not handled yet\n");
 182     else if (IsEqualGUID(type, &GUID_Clear_All_Bands))
 183         FIXME("GUID_Clear_All_Bands not handled yet\n");
 184     else if (IsEqualGUID(type, &GUID_ConnectToDLSCollection))
 185     {
 186         struct band_entry *entry;
 187
 188         LIST_FOR_EACH_ENTRY(entry, &This->bands, struct band_entry, entry)
 189             band_connect_to_collection(entry->band, param);
 190     }
 191     else if (IsEqualGUID(type, &GUID_Disable_Auto_Download))
 192         FIXME("GUID_Disable_Auto_Download not handled yet\n");
 193     else if (IsEqualGUID(type, &GUID_Download))
 194         FIXME("GUID_Download not handled yet\n");
 195     else if (IsEqualGUID(type, &GUID_DownloadToAudioPath))
 196     {
 197         IDirectMusicPerformance *performance;
 198         IDirectMusicAudioPath *audio_path;
 199         IUnknown *object = param;
 200         struct band_entry *entry;
 201         HRESULT hr;
 202
 203         if (FAILED(hr = IDirectMusicAudioPath_QueryInterface(object, &IID_IDirectMusicPerformance8, (void **)&performance))
 204                 && SUCCEEDED(hr = IDirectMusicAudioPath_QueryInterface(object, &IID_IDirectMusicAudioPath, (void **)&audio_path)))
 205         {
 206             hr = IDirectMusicAudioPath_GetObjectInPath(audio_path, DMUS_PCHANNEL_ALL, DMUS_PATH_PERFORMANCE, 0,
 207                     &GUID_All_Objects, 0, &IID_IDirectMusicPerformance8, (void **)&performance);
 208             IDirectMusicAudioPath_Release(audio_path);
 209         }
 210
 211         if (FAILED(hr))
 212         {
 213             WARN("Failed to get IDirectMusicPerformance from param %p\n", param);
 214             return hr;
 215         }
 216
 217         LIST_FOR_EACH_ENTRY(entry, &This->bands, struct band_entry, entry)
 218             if (FAILED(hr = IDirectMusicBand_Download(entry->band, performance))) break;
 219
 220         IDirectMusicPerformance_Release(performance);
 221     }
 222     else if (IsEqualGUID(type, &GUID_Enable_Auto_Download))
 223         FIXME("GUID_Enable_Auto_Download not handled yet\n");
 224     else if (IsEqualGUID(type, &GUID_IDirectMusicBand))
 225         FIXME("GUID_IDirectMusicBand not handled yet\n");
 226     else if (IsEqualGUID(type, &GUID_StandardMIDIFile))
 227         FIXME("GUID_StandardMIDIFile not handled yet\n");
 228     else if (IsEqualGUID(type, &GUID_UnloadFromAudioPath))
 229     {
 230         struct band_entry *entry;
 231         HRESULT hr;
 232
 233         LIST_FOR_EACH_ENTRY(entry, &This->bands, struct band_entry, entry)
 234             if (FAILED(hr = IDirectMusicBand_Unload(entry->band, NULL))) break;
 235     }
 236
 237     return S_OK;
 238 }
 239
 240 static HRESULT WINAPI band_track_IsParamSupported(IDirectMusicTrack8 *iface, REFGUID rguidType)
 241 {
 242   struct band_track *This = impl_from_IDirectMusicTrack8(iface);
 243
 244   TRACE("(%p, %s)\n", This, debugstr_dmguid(rguidType));
 245
 246   if (!rguidType)
 247     return E_POINTER;
 248
 249   if (IsEqualGUID (rguidType, &GUID_BandParam)
 250       || IsEqualGUID (rguidType, &GUID_Clear_All_Bands)
 251       || IsEqualGUID (rguidType, &GUID_ConnectToDLSCollection)
 252       || IsEqualGUID (rguidType, &GUID_Disable_Auto_Download)
 253       || IsEqualGUID (rguidType, &GUID_Download)
 254       || IsEqualGUID (rguidType, &GUID_DownloadToAudioPath)
 255       || IsEqualGUID (rguidType, &GUID_Enable_Auto_Download)
 256       || IsEqualGUID (rguidType, &GUID_IDirectMusicBand)
 257       || IsEqualGUID (rguidType, &GUID_StandardMIDIFile)
 258       || IsEqualGUID (rguidType, &GUID_Unload)
 259       || IsEqualGUID (rguidType, &GUID_UnloadFromAudioPath)) {
 260     TRACE("param supported\n");
 261     return S_OK;
 262   }
 263
 264   TRACE("param unsupported\n");
 265   return DMUS_E_TYPE_UNSUPPORTED;
 266 }
 267
 268 static HRESULT WINAPI band_track_AddNotificationType(IDirectMusicTrack8 *iface, REFGUID notiftype)
 269 {
 270     struct band_track *This = impl_from_IDirectMusicTrack8(iface);
 271
 272     TRACE("(%p, %s): method not implemented\n", This, debugstr_dmguid(notiftype));
 273     return E_NOTIMPL;
 274 }
 275
 276 static HRESULT WINAPI band_track_RemoveNotificationType(IDirectMusicTrack8 *iface,
 277         REFGUID notiftype)
 278 {
 279     struct band_track *This = impl_from_IDirectMusicTrack8(iface);
 280
 281     TRACE("(%p, %s): method not implemented\n", This, debugstr_dmguid(notiftype));
 282     return E_NOTIMPL;
 283 }
 284
 285 static HRESULT WINAPI band_track_Clone(IDirectMusicTrack8 *iface, MUSIC_TIME mtStart,
 286         MUSIC_TIME mtEnd, IDirectMusicTrack **ppTrack)
 287 {
 288     struct band_track *This = impl_from_IDirectMusicTrack8(iface);
 289     FIXME("(%p, %ld, %ld, %p): stub\n", This, mtStart, mtEnd, ppTrack);
 290     return S_OK;
 291 }
 292
 293 static HRESULT WINAPI band_track_PlayEx(IDirectMusicTrack8 *iface, void *state_data,
 294         REFERENCE_TIME rtStart, REFERENCE_TIME rtEnd, REFERENCE_TIME rtOffset, DWORD flags,
 295         IDirectMusicPerformance *performance, IDirectMusicSegmentState *segment_state,
 296         DWORD virtual_id)
 297 {
 298     struct band_track *This = impl_from_IDirectMusicTrack8(iface);
 299
 300     FIXME("(%p, %p, 0x%s, 0x%s, 0x%s, %lx, %p, %p, %ld): stub\n", This, state_data, wine_dbgstr_longlong(rtStart),
 301         wine_dbgstr_longlong(rtEnd), wine_dbgstr_longlong(rtOffset), flags, performance, segment_state, virtual_id);
 302
 303     return S_OK;
 304 }
 305
 306 static HRESULT WINAPI band_track_GetParamEx(IDirectMusicTrack8 *iface,
 307         REFGUID rguidType, REFERENCE_TIME rtTime, REFERENCE_TIME *rtNext, void *param,
 308         void *state_data, DWORD flags)
 309 {
 310     struct band_track *This = impl_from_IDirectMusicTrack8(iface);
 311
 312     FIXME("(%p, %s, 0x%s, %p, %p, %p, %lx): stub\n", This, debugstr_dmguid(rguidType),
 313         wine_dbgstr_longlong(rtTime), rtNext, param, state_data, flags);
 314
 315     return S_OK;
 316 }
 317
 318 static HRESULT WINAPI band_track_SetParamEx(IDirectMusicTrack8 *iface, REFGUID rguidType,
 319         REFERENCE_TIME rtTime, void *param, void *state_data, DWORD flags)
 320 {
 321     struct band_track *This = impl_from_IDirectMusicTrack8(iface);
 322
 323     FIXME("(%p, %s, 0x%s, %p, %p, %lx): stub\n", This, debugstr_dmguid(rguidType),
 324         wine_dbgstr_longlong(rtTime), param, state_data, flags);
 325
 326     return S_OK;
 327 }
 328
 329 static HRESULT WINAPI band_track_Compose(IDirectMusicTrack8 *iface, IUnknown *context,
 330         DWORD trackgroup, IDirectMusicTrack **track)
 331 {
 332     struct band_track *This = impl_from_IDirectMusicTrack8(iface);
 333
 334     TRACE("(%p, %p, %ld, %p): method not implemented\n", This, context, trackgroup, track);
 335     return E_NOTIMPL;
 336 }
 337
 338 static HRESULT WINAPI band_track_Join(IDirectMusicTrack8 *iface, IDirectMusicTrack *pNewTrack,
 339         MUSIC_TIME mtJoin, IUnknown *pContext, DWORD dwTrackGroup,
 340         IDirectMusicTrack **ppResultTrack)
 341 {
 342     struct band_track *This = impl_from_IDirectMusicTrack8(iface);
 343     FIXME("(%p, %p, %ld, %p, %ld, %p): stub\n", This, pNewTrack, mtJoin, pContext, dwTrackGroup, ppResultTrack);
 344     return S_OK;
 345 }
 346
 347 static const IDirectMusicTrack8Vtbl band_track_vtbl =
 348 {
 349     band_track_QueryInterface,
 350     band_track_AddRef,
 351     band_track_Release,
 352     band_track_Init,
 353     band_track_InitPlay,
 354     band_track_EndPlay,
 355     band_track_Play,
 356     band_track_GetParam,
 357     band_track_SetParam,
 358     band_track_IsParamSupported,
 359     band_track_AddNotificationType,
 360     band_track_RemoveNotificationType,
 361     band_track_Clone,
 362     band_track_PlayEx,
 363     band_track_GetParamEx,
 364     band_track_SetParamEx,
 365     band_track_Compose,
 366     band_track_Join,
 367 };
 368
 369 static HRESULT parse_lbnd_list(struct band_track *This, IStream *stream, struct chunk_entry *parent)
 370 {
 371     struct chunk_entry chunk = {.parent = parent};
 372     DMUS_IO_BAND_ITEM_HEADER2 header2;
 373     struct band_entry *entry;
 374     IDirectMusicBand *band;
 375     HRESULT hr;
 376
 377     while ((hr = stream_next_chunk(stream, &chunk)) == S_OK)
 378     {
 379         switch (MAKE_IDTYPE(chunk.id, chunk.type))
 380         {
 381         case DMUS_FOURCC_BANDITEM_CHUNK:
 382         {
 383             DMUS_IO_BAND_ITEM_HEADER header;
 384
 385             if (SUCCEEDED(hr = stream_chunk_get_data(stream, &chunk, &header, sizeof(header))))
 386             {
 387                 header2.lBandTimeLogical = header.lBandTime;
 388                 header2.lBandTimePhysical = header.lBandTime;
 389             }
 390
 391             break;
 392         }
 393
 394         case DMUS_FOURCC_BANDITEM_CHUNK2:
 395             hr = stream_chunk_get_data(stream, &chunk, &header2, sizeof(header2));
 396             break;
 397
 398         case MAKE_IDTYPE(FOURCC_RIFF, DMUS_FOURCC_BAND_FORM):
 399         {
 400             IPersistStream *persist;
 401
 402             if (FAILED(hr = CoCreateInstance(&CLSID_DirectMusicBand, NULL, CLSCTX_INPROC_SERVER,
 403                     &IID_IDirectMusicBand, (void **)&band)))
 404                 break;
 405
 406             if (SUCCEEDED(hr = IDirectMusicBand_QueryInterface(band, &IID_IPersistStream, (void **)&persist)))
 407             {
 408                 if (SUCCEEDED(hr = stream_reset_chunk_start(stream, &chunk)))
 409                     hr = IPersistStream_Load(persist, stream);
 410                 IPersistStream_Release(persist);
 411             }
 412
 413             break;
 414         }
 415
 416         default:
 417             FIXME("Ignoring chunk %s %s\n", debugstr_fourcc(chunk.id), debugstr_fourcc(chunk.type));
 418             break;
 419         }
 420
 421         if (FAILED(hr)) break;
 422     }
 423
 424     if (FAILED(hr)) return hr;
 425
 426     if (!(entry = calloc(1, sizeof(*entry)))) return E_OUTOFMEMORY;
 427     entry->head = header2;
 428     entry->band = band;
 429     IDirectMusicBand_AddRef(band);
 430     list_add_tail(&This->bands, &entry->entry);
 431
 432     return S_OK;
 433 }
 434
 435 static HRESULT parse_lbdl_list(struct band_track *This, IStream *stream, struct chunk_entry *parent)
 436 {
 437     struct chunk_entry chunk = {.parent = parent};
 438     HRESULT hr;
 439
 440     while ((hr = stream_next_chunk(stream, &chunk)) == S_OK)
 441     {
 442         switch (MAKE_IDTYPE(chunk.id, chunk.type))
 443         {
 444         case MAKE_IDTYPE(FOURCC_LIST, DMUS_FOURCC_BAND_LIST):
 445             hr = parse_lbnd_list(This, stream, &chunk);
 446             break;
 447
 448         default:
 449             FIXME("Ignoring chunk %s %s\n", debugstr_fourcc(chunk.id), debugstr_fourcc(chunk.type));
 450             break;
 451         }
 452
 453         if (FAILED(hr)) break;
 454     }
 455
 456     return S_OK;
 457 }
 458
 459 static HRESULT parse_dmbt_chunk(struct band_track *This, IStream *stream, struct chunk_entry *parent)
 460 {
 461     struct chunk_entry chunk = {.parent = parent};
 462     HRESULT hr;
 463
 464     if (FAILED(hr = dmobj_parsedescriptor(stream, parent, &This->dmobj.desc,
 465                 DMUS_OBJ_OBJECT|DMUS_OBJ_NAME|DMUS_OBJ_NAME_INAM|DMUS_OBJ_VERSION))
 466                 || FAILED(hr = stream_reset_chunk_data(stream, parent)))
 467         return hr;
 468
 469     while ((hr = stream_next_chunk(stream, &chunk)) == S_OK)
 470     {
 471         switch (MAKE_IDTYPE(chunk.id, chunk.type))
 472         {
 473         case DMUS_FOURCC_GUID_CHUNK:
 474         case DMUS_FOURCC_VERSION_CHUNK:
 475         case MAKE_IDTYPE(FOURCC_LIST, DMUS_FOURCC_UNFO_LIST):
 476             /* already parsed by dmobj_parsedescriptor */
 477             break;
 478
 479         case DMUS_FOURCC_BANDTRACK_CHUNK:
 480             hr = stream_chunk_get_data(stream, &chunk, &This->header, sizeof(This->header));
 481             break;
 482
 483         case MAKE_IDTYPE(FOURCC_LIST, DMUS_FOURCC_BANDS_LIST):
 484             hr = parse_lbdl_list(This, stream, &chunk);
 485             break;
 486
 487         default:
 488             FIXME("Ignoring chunk %s %s\n", debugstr_fourcc(chunk.id), debugstr_fourcc(chunk.type));
 489             break;
 490         }
 491
 492         if (FAILED(hr)) break;
 493     }
 494
 495     return hr;
 496 }
 497
 498 static inline struct band_track *impl_from_IPersistStream(IPersistStream *iface)
 499 {
 500     return CONTAINING_RECORD(iface, struct band_track, dmobj.IPersistStream_iface);
 501 }
 502
 503 static HRESULT WINAPI band_track_persist_stream_Load(IPersistStream *iface, IStream *stream)
 504 {
 505     struct band_track *This = impl_from_IPersistStream(iface);
 506     struct chunk_entry chunk = {0};
 507     HRESULT hr;
 508
 509     TRACE("(%p, %p)\n", This, stream);
 510
 511     if ((hr = stream_get_chunk(stream, &chunk)) == S_OK)
 512     {
 513         switch (MAKE_IDTYPE(chunk.id, chunk.type))
 514         {
 515         case MAKE_IDTYPE(FOURCC_RIFF, DMUS_FOURCC_BANDTRACK_FORM):
 516             hr = parse_dmbt_chunk(This, stream, &chunk);
 517             break;
 518
 519         default:
 520             WARN("Invalid band track chunk %s %s\n", debugstr_fourcc(chunk.id), debugstr_fourcc(chunk.type));
 521             hr = DMUS_E_UNSUPPORTED_STREAM;
 522             break;
 523         }
 524     }
 525
 526     if (FAILED(hr)) return hr;
 527
 528     if (TRACE_ON(dmband))
 529     {
 530         struct band_entry *entry;
 531         int i = 0;
 532
 533         TRACE("Loaded DirectMusicBandTrack %p\n", This);
 534         dump_DMUS_OBJECTDESC(&This->dmobj.desc);
 535
 536         TRACE(" - header:\n");
 537         TRACE("    - bAutoDownload: %u\n", This->header.bAutoDownload);
 538
 539         TRACE(" - bands:\n");
 540         LIST_FOR_EACH_ENTRY(entry, &This->bands, struct band_entry, entry)
 541         {
 542             TRACE("    - band[%u]: %p\n", i++, entry->band);
 543             TRACE("        - lBandTimeLogical: %ld\n", entry->head.lBandTimeLogical);
 544             TRACE("        - lBandTimePhysical: %ld\n", entry->head.lBandTimePhysical);
 545         }
 546     }
 547
 548     stream_skip_chunk(stream, &chunk);
 549     return S_OK;
 550 }
 551
 552 static const IPersistStreamVtbl band_track_persist_stream_vtbl =
 553 {
 554     dmobj_IPersistStream_QueryInterface,
 555     dmobj_IPersistStream_AddRef,
 556     dmobj_IPersistStream_Release,
 557     dmobj_IPersistStream_GetClassID,
 558     unimpl_IPersistStream_IsDirty,
 559     band_track_persist_stream_Load,
 560     unimpl_IPersistStream_Save,
 561     unimpl_IPersistStream_GetSizeMax,
 562 };
 563
 564 /* for ClassFactory */
 565 HRESULT create_dmbandtrack(REFIID lpcGUID, void **ppobj)
 566 {
 567     struct band_track *track;
 568     HRESULT hr;
 569
 570     *ppobj = NULL;
 571     if (!(track = calloc(1, sizeof(*track)))) return E_OUTOFMEMORY;
 572     track->IDirectMusicTrack8_iface.lpVtbl = &band_track_vtbl;
 573     track->ref = 1;
 574     dmobject_init(&track->dmobj, &CLSID_DirectMusicBandTrack, (IUnknown *)&track->IDirectMusicTrack8_iface);
 575     track->dmobj.IPersistStream_iface.lpVtbl = &band_track_persist_stream_vtbl;
 576     list_init(&track->bands);
 577
 578     hr = IDirectMusicTrack8_QueryInterface(&track->IDirectMusicTrack8_iface, lpcGUID, ppobj);
 579     IDirectMusicTrack8_Release(&track->IDirectMusicTrack8_iface);
 580
 581     return hr;
 582 }