dlls/dmstyle/chordtrack.c

   1 /* IDirectMusicChordTrack 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 "dmstyle_private.h"
  22 #include "dmobject.h"
  23
  24 WINE_DEFAULT_DEBUG_CHANNEL(dmstyle);
  25 WINE_DECLARE_DEBUG_CHANNEL(dmfile);
  26
  27 /*****************************************************************************
  28  * IDirectMusicChordTrack implementation
  29  */
  30 typedef struct IDirectMusicChordTrack {
  31     IDirectMusicTrack8 IDirectMusicTrack8_iface;
  32     struct dmobject dmobj;  /* IPersistStream only */
  33     LONG ref;
  34     DWORD dwScale;
  35 }  IDirectMusicChordTrack;
  36
  37 /* IDirectMusicChordTrack IDirectMusicTrack8 part: */
  38 static inline IDirectMusicChordTrack *impl_from_IDirectMusicTrack8(IDirectMusicTrack8 *iface)
  39 {
  40     return CONTAINING_RECORD(iface, IDirectMusicChordTrack, IDirectMusicTrack8_iface);
  41 }
  42
  43 static HRESULT WINAPI chord_track_QueryInterface(IDirectMusicTrack8 *iface, REFIID riid,
  44         void **ret_iface)
  45 {
  46     IDirectMusicChordTrack *This = impl_from_IDirectMusicTrack8(iface);
  47
  48     TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ret_iface);
  49
  50     *ret_iface = NULL;
  51
  52     if (IsEqualIID(riid, &IID_IUnknown) || IsEqualIID(riid, &IID_IDirectMusicTrack) ||
  53             IsEqualIID(riid, &IID_IDirectMusicTrack8))
  54         *ret_iface = iface;
  55     else if (IsEqualIID(riid, &IID_IPersistStream))
  56         *ret_iface = &This->dmobj.IPersistStream_iface;
  57     else {
  58         WARN("(%p, %s, %p): not found\n", This, debugstr_dmguid(riid), ret_iface);
  59         return E_NOINTERFACE;
  60     }
  61
  62     IUnknown_AddRef((IUnknown*)*ret_iface);
  63     return S_OK;
  64 }
  65
  66 static ULONG WINAPI chord_track_AddRef(IDirectMusicTrack8 *iface)
  67 {
  68     IDirectMusicChordTrack *This = impl_from_IDirectMusicTrack8(iface);
  69     LONG ref = InterlockedIncrement(&This->ref);
  70
  71     TRACE("(%p) ref=%ld\n", This, ref);
  72
  73     return ref;
  74 }
  75
  76 static ULONG WINAPI chord_track_Release(IDirectMusicTrack8 *iface)
  77 {
  78     IDirectMusicChordTrack *This = impl_from_IDirectMusicTrack8(iface);
  79     LONG ref = InterlockedDecrement(&This->ref);
  80
  81     TRACE("(%p) ref=%ld\n", This, ref);
  82
  83     if (!ref) free(This);
  84
  85     return ref;
  86 }
  87
  88 static HRESULT WINAPI chord_track_Init(IDirectMusicTrack8 *iface, IDirectMusicSegment *pSegment)
  89 {
  90   IDirectMusicChordTrack *This = impl_from_IDirectMusicTrack8(iface);
  91   FIXME("(%p, %p): stub\n", This, pSegment);
  92   return S_OK;
  93 }
  94
  95 static HRESULT WINAPI chord_track_InitPlay(IDirectMusicTrack8 *iface,
  96         IDirectMusicSegmentState *pSegmentState, IDirectMusicPerformance *pPerformance,
  97         void **ppStateData, DWORD dwVirtualTrack8ID, DWORD dwFlags)
  98 {
  99   IDirectMusicChordTrack *This = impl_from_IDirectMusicTrack8(iface);
 100   FIXME("(%p, %p, %p, %p, %ld, %ld): stub\n", This, pSegmentState, pPerformance, ppStateData, dwVirtualTrack8ID, dwFlags);
 101   return S_OK;
 102 }
 103
 104 static HRESULT WINAPI chord_track_EndPlay(IDirectMusicTrack8 *iface, void *pStateData)
 105 {
 106   IDirectMusicChordTrack *This = impl_from_IDirectMusicTrack8(iface);
 107   FIXME("(%p, %p): stub\n", This, pStateData);
 108   return S_OK;
 109 }
 110
 111 static HRESULT WINAPI chord_track_Play(IDirectMusicTrack8 *iface, void *pStateData,
 112         MUSIC_TIME mtStart, MUSIC_TIME mtEnd, MUSIC_TIME mtOffset, DWORD dwFlags,
 113         IDirectMusicPerformance *pPerf, IDirectMusicSegmentState *pSegSt, DWORD dwVirtualID)
 114 {
 115   IDirectMusicChordTrack *This = impl_from_IDirectMusicTrack8(iface);
 116   FIXME("(%p, %p, %ld, %ld, %ld, %ld, %p, %p, %ld): stub\n", This, pStateData, mtStart, mtEnd, mtOffset, dwFlags, pPerf, pSegSt, dwVirtualID);
 117   return S_OK;
 118 }
 119
 120 static HRESULT WINAPI chord_track_GetParam(IDirectMusicTrack8 *iface, REFGUID type, MUSIC_TIME time,
 121         MUSIC_TIME *next, void *param)
 122 {
 123     IDirectMusicChordTrack *This = impl_from_IDirectMusicTrack8(iface);
 124
 125     TRACE("(%p, %s, %ld, %p, %p):\n", This, debugstr_dmguid(type), time, next, param);
 126
 127     if (!type)
 128         return E_POINTER;
 129
 130     if (IsEqualGUID(type, &GUID_ChordParam)) {
 131         FIXME("GUID_ChordParam not handled yet\n");
 132         return S_OK;
 133     } else if (IsEqualGUID(type, &GUID_RhythmParam)) {
 134         FIXME("GUID_RhythmParam not handled yet\n");
 135         return S_OK;
 136     }
 137
 138     return DMUS_E_GET_UNSUPPORTED;
 139 }
 140
 141 static HRESULT WINAPI chord_track_SetParam(IDirectMusicTrack8 *iface, REFGUID type, MUSIC_TIME time,
 142         void *param)
 143 {
 144     IDirectMusicChordTrack *This = impl_from_IDirectMusicTrack8(iface);
 145
 146     TRACE("(%p, %s, %ld, %p)\n", This, debugstr_dmguid(type), time, param);
 147
 148     if (!type)
 149         return E_POINTER;
 150     if (!IsEqualGUID(type, &GUID_ChordParam))
 151         return DMUS_E_SET_UNSUPPORTED;
 152
 153     FIXME("GUID_ChordParam not handled yet\n");
 154
 155     return S_OK;
 156 }
 157
 158 static HRESULT WINAPI chord_track_IsParamSupported(IDirectMusicTrack8 *iface, REFGUID type)
 159 {
 160     IDirectMusicChordTrack *This = impl_from_IDirectMusicTrack8(iface);
 161
 162     TRACE("(%p, %s)\n", This, debugstr_dmguid(type));
 163
 164     if (!type)
 165         return E_POINTER;
 166
 167     if (IsEqualGUID(type, &GUID_ChordParam) || IsEqualGUID(type, &GUID_RhythmParam))
 168         return S_OK;
 169
 170     TRACE("param unsupported\n");
 171     return DMUS_E_TYPE_UNSUPPORTED;
 172 }
 173
 174 static HRESULT WINAPI chord_track_AddNotificationType(IDirectMusicTrack8 *iface,
 175         REFGUID rguidNotificationType)
 176 {
 177   IDirectMusicChordTrack *This = impl_from_IDirectMusicTrack8(iface);
 178   FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 179   return S_OK;
 180 }
 181
 182 static HRESULT WINAPI chord_track_RemoveNotificationType(IDirectMusicTrack8 *iface,
 183         REFGUID rguidNotificationType)
 184 {
 185   IDirectMusicChordTrack *This = impl_from_IDirectMusicTrack8(iface);
 186   FIXME("(%p, %s): stub\n", This, debugstr_dmguid(rguidNotificationType));
 187   return S_OK;
 188 }
 189
 190 static HRESULT WINAPI chord_track_Clone(IDirectMusicTrack8 *iface, MUSIC_TIME mtStart,
 191         MUSIC_TIME mtEnd, IDirectMusicTrack **ppTrack)
 192 {
 193   IDirectMusicChordTrack *This = impl_from_IDirectMusicTrack8(iface);
 194   FIXME("(%p, %ld, %ld, %p): stub\n", This, mtStart, mtEnd, ppTrack);
 195   return S_OK;
 196 }
 197
 198 static HRESULT WINAPI chord_track_PlayEx(IDirectMusicTrack8 *iface, void *pStateData,
 199         REFERENCE_TIME rtStart, REFERENCE_TIME rtEnd, REFERENCE_TIME rtOffset, DWORD dwFlags,
 200         IDirectMusicPerformance *pPerf, IDirectMusicSegmentState *pSegSt, DWORD dwVirtualID)
 201 {
 202   IDirectMusicChordTrack *This = impl_from_IDirectMusicTrack8(iface);
 203   FIXME("(%p, %p, 0x%s, 0x%s, 0x%s, %ld, %p, %p, %ld): stub\n", This, pStateData, wine_dbgstr_longlong(rtStart),
 204       wine_dbgstr_longlong(rtEnd), wine_dbgstr_longlong(rtOffset), dwFlags, pPerf, pSegSt, dwVirtualID);
 205   return S_OK;
 206 }
 207
 208 static HRESULT WINAPI chord_track_GetParamEx(IDirectMusicTrack8 *iface, REFGUID rguidType,
 209         REFERENCE_TIME rtTime, REFERENCE_TIME *prtNext, void *pParam, void *pStateData,
 210         DWORD dwFlags)
 211 {
 212   IDirectMusicChordTrack *This = impl_from_IDirectMusicTrack8(iface);
 213   FIXME("(%p, %s, 0x%s, %p, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType),
 214       wine_dbgstr_longlong(rtTime), prtNext, pParam, pStateData, dwFlags);
 215   return S_OK;
 216 }
 217
 218 static HRESULT WINAPI chord_track_SetParamEx(IDirectMusicTrack8 *iface, REFGUID rguidType,
 219         REFERENCE_TIME rtTime, void *pParam, void *pStateData, DWORD dwFlags)
 220 {
 221   IDirectMusicChordTrack *This = impl_from_IDirectMusicTrack8(iface);
 222   FIXME("(%p, %s, 0x%s, %p, %p, %ld): stub\n", This, debugstr_dmguid(rguidType),
 223       wine_dbgstr_longlong(rtTime), pParam, pStateData, dwFlags);
 224   return S_OK;
 225 }
 226
 227 static HRESULT WINAPI chord_track_Compose(IDirectMusicTrack8 *iface, IUnknown *context,
 228         DWORD trackgroup, IDirectMusicTrack **track)
 229 {
 230     IDirectMusicChordTrack *This = impl_from_IDirectMusicTrack8(iface);
 231
 232     TRACE("(%p, %p, %ld, %p): method not implemented\n", This, context, trackgroup, track);
 233     return E_NOTIMPL;
 234 }
 235
 236 static HRESULT WINAPI chord_track_Join(IDirectMusicTrack8 *iface, IDirectMusicTrack *pNewTrack,
 237         MUSIC_TIME mtJoin, IUnknown *pContext, DWORD dwTrackGroup,
 238         IDirectMusicTrack **ppResultTrack)
 239 {
 240   IDirectMusicChordTrack *This = impl_from_IDirectMusicTrack8(iface);
 241   FIXME("(%p, %p, %ld, %p, %ld, %p): stub\n", This, pNewTrack, mtJoin, pContext, dwTrackGroup, ppResultTrack);
 242   return S_OK;
 243 }
 244
 245 static const IDirectMusicTrack8Vtbl dmtrack8_vtbl = {
 246     chord_track_QueryInterface,
 247     chord_track_AddRef,
 248     chord_track_Release,
 249     chord_track_Init,
 250     chord_track_InitPlay,
 251     chord_track_EndPlay,
 252     chord_track_Play,
 253     chord_track_GetParam,
 254     chord_track_SetParam,
 255     chord_track_IsParamSupported,
 256     chord_track_AddNotificationType,
 257     chord_track_RemoveNotificationType,
 258     chord_track_Clone,
 259     chord_track_PlayEx,
 260     chord_track_GetParamEx,
 261     chord_track_SetParamEx,
 262     chord_track_Compose,
 263     chord_track_Join
 264 };
 265
 266 static HRESULT parse_chordtrack_list(IDirectMusicChordTrack *This, DMUS_PRIVATE_CHUNK *pChunk,
 267         IStream *pStm)
 268 {
 269   DMUS_PRIVATE_CHUNK Chunk;
 270   DWORD ListSize[3], ListCount[3];
 271   LARGE_INTEGER liMove; /* used when skipping chunks */
 272
 273   if (pChunk->fccID != DMUS_FOURCC_CHORDTRACK_LIST) {
 274     ERR_(dmfile)(": %s chunk should be a CHORDTRACK list\n", debugstr_fourcc (pChunk->fccID));
 275     return E_FAIL;
 276   }
 277
 278   ListSize[0] = pChunk->dwSize - sizeof(FOURCC);
 279   ListCount[0] = 0;
 280
 281   do {
 282     IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
 283     ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
 284     TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
 285     switch (Chunk.fccID) {
 286     case DMUS_FOURCC_CHORDTRACKHEADER_CHUNK: {
 287       TRACE_(dmfile)(": Chord track header chunk\n");
 288       IStream_Read (pStm, &This->dwScale, sizeof(DWORD), NULL);
 289       TRACE_(dmfile)(" - dwScale: %ld\n", This->dwScale);
 290       break;
 291     }
 292     case DMUS_FOURCC_CHORDTRACKBODY_CHUNK: {
 293       DWORD sz;
 294       DWORD it;
 295       DWORD num;
 296       DMUS_IO_CHORD body;
 297       DMUS_IO_SUBCHORD subchords;
 298
 299       TRACE_(dmfile)(": Chord track body chunk\n");
 300
 301       IStream_Read (pStm, &sz, sizeof(DWORD), NULL);
 302       TRACE_(dmfile)(" - sizeof(DMUS_IO_CHORD): %ld\n", sz);
 303       if (sz != sizeof(DMUS_IO_CHORD)) return E_FAIL;
 304       IStream_Read (pStm, &body, sizeof(DMUS_IO_CHORD), NULL);
 305       TRACE_(dmfile)(" - wszName: %s\n", debugstr_w(body.wszName));
 306       TRACE_(dmfile)(" - mtTime: %lu\n", body.mtTime);
 307       TRACE_(dmfile)(" - wMeasure: %u\n", body.wMeasure);
 308       TRACE_(dmfile)(" - bBeat:  %u\n", body.bBeat);
 309       TRACE_(dmfile)(" - bFlags: 0x%02x\n", body.bFlags);
 310
 311       IStream_Read (pStm, &num, sizeof(DWORD), NULL);
 312       TRACE_(dmfile)(" - # DMUS_IO_SUBCHORDS: %ld\n", num);
 313       IStream_Read (pStm, &sz, sizeof(DWORD), NULL);
 314       TRACE_(dmfile)(" - sizeof(DMUS_IO_SUBCHORDS): %ld\n", sz);
 315       if (sz != sizeof(DMUS_IO_SUBCHORD)) return E_FAIL;
 316
 317       for (it = 0; it < num; ++it) {
 318         IStream_Read (pStm, &subchords, sizeof(DMUS_IO_SUBCHORD), NULL);
 319         TRACE_(dmfile)("DMUS_IO_SUBCHORD #%ld\n", it+1);
 320         TRACE_(dmfile)(" - dwChordPattern: %lu\n", subchords.dwChordPattern);
 321         TRACE_(dmfile)(" - dwScalePattern: %lu\n", subchords.dwScalePattern);
 322         TRACE_(dmfile)(" - dwInversionPoints: %lu\n", subchords.dwInversionPoints);
 323         TRACE_(dmfile)(" - dwLevels: %lu\n", subchords.dwLevels);
 324         TRACE_(dmfile)(" - bChordRoot:  %u\n", subchords.bChordRoot);
 325         TRACE_(dmfile)(" - bScaleRoot: %u\n", subchords.bScaleRoot);
 326       }
 327       break;
 328     }
 329     default: {
 330       TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
 331       liMove.QuadPart = Chunk.dwSize;
 332       IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 333       break;
 334     }
 335     }
 336     TRACE_(dmfile)(": ListCount[0] = %ld < ListSize[0] = %ld\n", ListCount[0], ListSize[0]);
 337   } while (ListCount[0] < ListSize[0]);
 338
 339   return S_OK;
 340 }
 341
 342 static inline IDirectMusicChordTrack *impl_from_IPersistStream(IPersistStream *iface)
 343 {
 344     return CONTAINING_RECORD(iface, IDirectMusicChordTrack, dmobj.IPersistStream_iface);
 345 }
 346
 347 static HRESULT WINAPI IPersistStreamImpl_Load(IPersistStream *iface, IStream *pStm)
 348 {
 349   IDirectMusicChordTrack *This = impl_from_IPersistStream(iface);
 350   DMUS_PRIVATE_CHUNK Chunk;
 351   LARGE_INTEGER liMove;
 352   HRESULT hr;
 353
 354   TRACE("(%p, %p): Loading\n", This, pStm);
 355
 356   IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
 357   TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
 358   switch (Chunk.fccID) {
 359   case FOURCC_LIST: {
 360     IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL);
 361     TRACE_(dmfile)(": %s chunk (size = %ld)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
 362     switch (Chunk.fccID) {
 363     case DMUS_FOURCC_CHORDTRACK_LIST: {
 364       TRACE_(dmfile)(": Chord track list\n");
 365       hr = parse_chordtrack_list(This, &Chunk, pStm);
 366       if (FAILED(hr)) return hr;
 367       break;
 368     }
 369     default: {
 370       TRACE_(dmfile)(": unexpected chunk; loading failed)\n");
 371       liMove.QuadPart = Chunk.dwSize;
 372       IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
 373       return E_FAIL;
 374     }
 375     }
 376     TRACE_(dmfile)(": reading finished\n");
 377     break;
 378   }
 379   default: {
 380     TRACE_(dmfile)(": unexpected chunk; loading failed)\n");
 381     liMove.QuadPart = Chunk.dwSize;
 382     IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); /* skip the rest of the chunk */
 383     return E_FAIL;
 384   }
 385   }
 386
 387   return S_OK;
 388 }
 389
 390 static HRESULT WINAPI IPersistStreamImpl_Save(IPersistStream *iface, IStream *stream,
 391         BOOL cleardirty)
 392 {
 393     IDirectMusicChordTrack *This = impl_from_IPersistStream(iface);
 394
 395     FIXME("(%p, %p, %d): stub\n", This, stream, cleardirty);
 396
 397     if (!stream)
 398         return E_POINTER;
 399
 400     return E_NOTIMPL;
 401 }
 402
 403 static const IPersistStreamVtbl persiststream_vtbl = {
 404     dmobj_IPersistStream_QueryInterface,
 405     dmobj_IPersistStream_AddRef,
 406     dmobj_IPersistStream_Release,
 407     dmobj_IPersistStream_GetClassID,
 408     unimpl_IPersistStream_IsDirty,
 409     IPersistStreamImpl_Load,
 410     IPersistStreamImpl_Save,
 411     unimpl_IPersistStream_GetSizeMax
 412 };
 413
 414 /* for ClassFactory */
 415 HRESULT create_dmchordtrack(REFIID lpcGUID, void **ppobj)
 416 {
 417     IDirectMusicChordTrack *track;
 418     HRESULT hr;
 419
 420     *ppobj = NULL;
 421     if (!(track = calloc(1, sizeof(*track)))) return E_OUTOFMEMORY;
 422     track->IDirectMusicTrack8_iface.lpVtbl = &dmtrack8_vtbl;
 423     track->ref = 1;
 424     dmobject_init(&track->dmobj, &CLSID_DirectMusicChordTrack,
 425                   (IUnknown *)&track->IDirectMusicTrack8_iface);
 426     track->dmobj.IPersistStream_iface.lpVtbl = &persiststream_vtbl;
 427
 428     hr = IDirectMusicTrack8_QueryInterface(&track->IDirectMusicTrack8_iface, lpcGUID, ppobj);
 429     IDirectMusicTrack8_Release(&track->IDirectMusicTrack8_iface);
 430
 431     return hr;
 432 }