dlls/dmusic/instrument.c

   1 /*
   2  * IDirectMusicInstrument Implementation
   3  *
   4  * Copyright (C) 2003-2004 Rok Mandeljc
   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 "dmusic_private.h"
  22
  23 WINE_DEFAULT_DEBUG_CHANNEL(dmusic);
  24
  25 static const GUID IID_IDirectMusicInstrumentPRIVATE = { 0xbcb20080, 0xa40c, 0x11d1, { 0x86, 0xbc, 0x00, 0xc0, 0x4f, 0xbf, 0x8f, 0xef } };
  26
  27 /* IDirectMusicInstrument IUnknown part: */
  28 static HRESULT WINAPI IDirectMusicInstrumentImpl_QueryInterface(LPDIRECTMUSICINSTRUMENT iface, REFIID riid, LPVOID *ret_iface)
  29 {
  30     TRACE("(%p)->(%s, %p)\n", iface, debugstr_dmguid(riid), ret_iface);
  31
  32     if (IsEqualIID(riid, &IID_IUnknown) ||
  33         IsEqualIID(riid, &IID_IDirectMusicInstrument))
  34     {
  35         *ret_iface = iface;
  36         IDirectMusicInstrument_AddRef(iface);
  37         return S_OK;
  38     }
  39     else if (IsEqualIID(riid, &IID_IDirectMusicInstrumentPRIVATE))
  40     {
  41         /* it seems to me that this interface is only basic IUnknown, without any
  42          * other inherited functions... *sigh* this is the worst scenario, since it means
  43          * that whoever calls it knows the layout of original implementation table and therefore
  44          * tries to get data by direct access... expect crashes
  45          */
  46         FIXME("*sigh*... requested private/unspecified interface\n");
  47
  48         *ret_iface = iface;
  49         IDirectMusicInstrument_AddRef(iface);
  50         return S_OK;
  51     }
  52
  53     WARN("(%p)->(%s, %p): not found\n", iface, debugstr_dmguid(riid), ret_iface);
  54
  55     return E_NOINTERFACE;
  56 }
  57
  58 static ULONG WINAPI IDirectMusicInstrumentImpl_AddRef(LPDIRECTMUSICINSTRUMENT iface)
  59 {
  60     IDirectMusicInstrumentImpl *This = impl_from_IDirectMusicInstrument(iface);
  61     ULONG ref = InterlockedIncrement(&This->ref);
  62
  63     TRACE("(%p)->(): new ref = %u\n", iface, ref);
  64
  65     return ref;
  66 }
  67
  68 static ULONG WINAPI IDirectMusicInstrumentImpl_Release(LPDIRECTMUSICINSTRUMENT iface)
  69 {
  70     IDirectMusicInstrumentImpl *This = impl_from_IDirectMusicInstrument(iface);
  71     ULONG ref = InterlockedDecrement(&This->ref);
  72
  73     TRACE("(%p)->(): new ref = %u\n", iface, ref);
  74
  75     if (!ref)
  76     {
  77         ULONG i;
  78
  79         HeapFree(GetProcessHeap(), 0, This->regions);
  80         for (i = 0; i < This->nb_articulations; i++)
  81             HeapFree(GetProcessHeap(), 0, This->articulations->connections);
  82         HeapFree(GetProcessHeap(), 0, This->articulations);
  83         HeapFree(GetProcessHeap(), 0, This);
  84         DMUSIC_UnlockModule();
  85     }
  86
  87     return ref;
  88 }
  89
  90 /* IDirectMusicInstrumentImpl IDirectMusicInstrument part: */
  91 static HRESULT WINAPI IDirectMusicInstrumentImpl_GetPatch(LPDIRECTMUSICINSTRUMENT iface, DWORD* pdwPatch)
  92 {
  93     IDirectMusicInstrumentImpl *This = impl_from_IDirectMusicInstrument(iface);
  94
  95     TRACE("(%p)->(%p)\n", This, pdwPatch);
  96
  97     *pdwPatch = MIDILOCALE2Patch(&This->header.Locale);
  98
  99     return S_OK;
 100 }
 101
 102 static HRESULT WINAPI IDirectMusicInstrumentImpl_SetPatch(LPDIRECTMUSICINSTRUMENT iface, DWORD dwPatch)
 103 {
 104     IDirectMusicInstrumentImpl *This = impl_from_IDirectMusicInstrument(iface);
 105
 106     TRACE("(%p)->(%d): stub\n", This, dwPatch);
 107
 108     Patch2MIDILOCALE(dwPatch, &This->header.Locale);
 109
 110     return S_OK;
 111 }
 112
 113 static const IDirectMusicInstrumentVtbl DirectMusicInstrument_Vtbl =
 114 {
 115     IDirectMusicInstrumentImpl_QueryInterface,
 116     IDirectMusicInstrumentImpl_AddRef,
 117     IDirectMusicInstrumentImpl_Release,
 118     IDirectMusicInstrumentImpl_GetPatch,
 119     IDirectMusicInstrumentImpl_SetPatch
 120 };
 121
 122 /* for ClassFactory */
 123 HRESULT DMUSIC_CreateDirectMusicInstrumentImpl (LPCGUID lpcGUID, LPVOID* ppobj, LPUNKNOWN pUnkOuter) {
 124         IDirectMusicInstrumentImpl* dminst;
 125         HRESULT hr;
 126
 127         dminst = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectMusicInstrumentImpl));
 128         if (NULL == dminst) {
 129                 *ppobj = NULL;
 130                 return E_OUTOFMEMORY;
 131         }
 132         dminst->IDirectMusicInstrument_iface.lpVtbl = &DirectMusicInstrument_Vtbl;
 133         dminst->ref = 1;
 134
 135         DMUSIC_LockModule();
 136         hr = IDirectMusicInstrument_QueryInterface(&dminst->IDirectMusicInstrument_iface, lpcGUID,
 137                 ppobj);
 138         IDirectMusicInstrument_Release(&dminst->IDirectMusicInstrument_iface);
 139
 140         return hr;
 141 }
 142
 143 static HRESULT read_from_stream(IStream *stream, void *data, ULONG size)
 144 {
 145     ULONG bytes_read;
 146     HRESULT hr;
 147
 148     hr = IStream_Read(stream, data, size, &bytes_read);
 149     if(FAILED(hr)){
 150         TRACE("IStream_Read failed: %08x\n", hr);
 151         return hr;
 152     }
 153     if (bytes_read < size) {
 154         TRACE("Didn't read full chunk: %u < %u\n", bytes_read, size);
 155         return E_FAIL;
 156     }
 157
 158     return S_OK;
 159 }
 160
 161 static inline DWORD subtract_bytes(DWORD len, DWORD bytes)
 162 {
 163     if(bytes > len){
 164         TRACE("Apparent mismatch in chunk lengths? %u bytes remaining, %u bytes read\n", len, bytes);
 165         return 0;
 166     }
 167     return len - bytes;
 168 }
 169
 170 static inline HRESULT advance_stream(IStream *stream, ULONG bytes)
 171 {
 172     LARGE_INTEGER move;
 173     HRESULT ret;
 174
 175     move.QuadPart = bytes;
 176
 177     ret = IStream_Seek(stream, move, STREAM_SEEK_CUR, NULL);
 178     if (FAILED(ret))
 179         WARN("IStream_Seek failed: %08x\n", ret);
 180
 181     return ret;
 182 }
 183
 184 static HRESULT load_region(IDirectMusicInstrumentImpl *This, IStream *stream, instrument_region *region, ULONG length)
 185 {
 186     HRESULT ret;
 187     DMUS_PRIVATE_CHUNK chunk;
 188
 189     TRACE("(%p, %p, %p, %u)\n", This, stream, region, length);
 190
 191     while (length)
 192     {
 193         ret = read_from_stream(stream, &chunk, sizeof(chunk));
 194         if (FAILED(ret))
 195             return ret;
 196
 197         length = subtract_bytes(length, sizeof(chunk));
 198
 199         switch (chunk.fccID)
 200         {
 201             case FOURCC_RGNH:
 202                 TRACE("RGNH chunk (region header): %u bytes\n", chunk.dwSize);
 203
 204                 ret = read_from_stream(stream, &region->header, sizeof(region->header));
 205                 if (FAILED(ret))
 206                     return ret;
 207
 208                 length = subtract_bytes(length, sizeof(region->header));
 209                 break;
 210
 211             case FOURCC_WSMP:
 212                 TRACE("WSMP chunk (wave sample): %u bytes\n", chunk.dwSize);
 213
 214                 ret = read_from_stream(stream, &region->wave_sample, sizeof(region->wave_sample));
 215                 if (FAILED(ret))
 216                     return ret;
 217                 length = subtract_bytes(length, sizeof(region->wave_sample));
 218
 219                 if (!(region->loop_present = (chunk.dwSize != sizeof(region->wave_sample))))
 220                     break;
 221
 222                 ret = read_from_stream(stream, &region->wave_loop, sizeof(region->wave_loop));
 223                 if (FAILED(ret))
 224                     return ret;
 225
 226                 length = subtract_bytes(length, sizeof(region->wave_loop));
 227                 break;
 228
 229             case FOURCC_WLNK:
 230                 TRACE("WLNK chunk (wave link): %u bytes\n", chunk.dwSize);
 231
 232                 ret = read_from_stream(stream, &region->wave_link, sizeof(region->wave_link));
 233                 if (FAILED(ret))
 234                     return ret;
 235
 236                 length = subtract_bytes(length, sizeof(region->wave_link));
 237                 break;
 238
 239             default:
 240                 TRACE("Unknown chunk %s (skipping): %u bytes\n", debugstr_fourcc(chunk.fccID), chunk.dwSize);
 241
 242                 ret = advance_stream(stream, chunk.dwSize);
 243                 if (FAILED(ret))
 244                     return ret;
 245
 246                 length = subtract_bytes(length, chunk.dwSize);
 247                 break;
 248         }
 249     }
 250
 251     return S_OK;
 252 }
 253
 254 static HRESULT load_articulation(IDirectMusicInstrumentImpl *This, IStream *stream, ULONG length)
 255 {
 256     HRESULT ret;
 257     instrument_articulation *articulation;
 258
 259     if (!This->articulations)
 260         This->articulations = HeapAlloc(GetProcessHeap(), 0, sizeof(*This->articulations));
 261     else
 262         This->articulations = HeapReAlloc(GetProcessHeap(), 0, This->articulations, sizeof(*This->articulations) * (This->nb_articulations + 1));
 263     if (!This->articulations)
 264         return E_OUTOFMEMORY;
 265
 266     articulation = &This->articulations[This->nb_articulations];
 267
 268     ret = read_from_stream(stream, &articulation->connections_list, sizeof(CONNECTIONLIST));
 269     if (FAILED(ret))
 270         return ret;
 271
 272     articulation->connections = HeapAlloc(GetProcessHeap(), 0, sizeof(CONNECTION) * articulation->connections_list.cConnections);
 273     if (!articulation->connections)
 274         return E_OUTOFMEMORY;
 275
 276     ret = read_from_stream(stream, articulation->connections, sizeof(CONNECTION) * articulation->connections_list.cConnections);
 277     if (FAILED(ret))
 278     {
 279         HeapFree(GetProcessHeap(), 0, articulation->connections);
 280         return ret;
 281     }
 282
 283     subtract_bytes(length, sizeof(CONNECTIONLIST) + sizeof(CONNECTION) * articulation->connections_list.cConnections);
 284
 285     This->nb_articulations++;
 286
 287     return S_OK;
 288 }
 289
 290 /* Function that loads all instrument data and which is called from IDirectMusicCollection_GetInstrument as in native */
 291 HRESULT IDirectMusicInstrumentImpl_CustomLoad(IDirectMusicInstrument *iface, IStream *stream)
 292 {
 293     IDirectMusicInstrumentImpl *This = impl_from_IDirectMusicInstrument(iface);
 294     HRESULT hr;
 295     DMUS_PRIVATE_CHUNK chunk;
 296     ULONG i = 0;
 297     ULONG length = This->length;
 298
 299     TRACE("(%p, %p): offset = 0x%s, length = %u)\n", This, stream, wine_dbgstr_longlong(This->liInstrumentPosition.QuadPart), This->length);
 300
 301     if (This->loaded)
 302         return S_OK;
 303
 304     hr = IStream_Seek(stream, This->liInstrumentPosition, STREAM_SEEK_SET, NULL);
 305     if (FAILED(hr))
 306     {
 307         WARN("IStream_Seek failed: %08x\n", hr);
 308         return DMUS_E_UNSUPPORTED_STREAM;
 309     }
 310
 311     This->regions = HeapAlloc(GetProcessHeap(), 0, sizeof(*This->regions) * This->header.cRegions);
 312     if (!This->regions)
 313         return E_OUTOFMEMORY;
 314
 315     while (length)
 316     {
 317         hr = read_from_stream(stream, &chunk, sizeof(chunk));
 318         if (FAILED(hr))
 319             goto error;
 320
 321         length = subtract_bytes(length, sizeof(chunk) + chunk.dwSize);
 322
 323         switch (chunk.fccID)
 324         {
 325             case FOURCC_INSH:
 326             case FOURCC_DLID:
 327                 TRACE("Chunk %s: %u bytes\n", debugstr_fourcc(chunk.fccID), chunk.dwSize);
 328
 329                 /* Instrument header and id are already set so just skip */
 330                 hr = advance_stream(stream, chunk.dwSize);
 331                 if (FAILED(hr))
 332                     goto error;
 333
 334                 break;
 335
 336             case FOURCC_LIST: {
 337                 DWORD size = chunk.dwSize;
 338
 339                 TRACE("LIST chunk: %u bytes\n", chunk.dwSize);
 340
 341                 hr = read_from_stream(stream, &chunk.fccID, sizeof(chunk.fccID));
 342                 if (FAILED(hr))
 343                     goto error;
 344
 345                 size = subtract_bytes(size, sizeof(chunk.fccID));
 346
 347                 switch (chunk.fccID)
 348                 {
 349                     case FOURCC_LRGN:
 350                         TRACE("LRGN chunk (regions list): %u bytes\n", size);
 351
 352                         while (size)
 353                         {
 354                             hr = read_from_stream(stream, &chunk, sizeof(chunk));
 355                             if (FAILED(hr))
 356                                 goto error;
 357
 358                             if (chunk.fccID != FOURCC_LIST)
 359                             {
 360                                 TRACE("Unknown chunk %s: %u bytes\n", debugstr_fourcc(chunk.fccID), chunk.dwSize);
 361                                 goto error;
 362                             }
 363
 364                             hr = read_from_stream(stream, &chunk.fccID, sizeof(chunk.fccID));
 365                             if (FAILED(hr))
 366                                 goto error;
 367
 368                             if (chunk.fccID == FOURCC_RGN)
 369                             {
 370                                 TRACE("RGN chunk (region): %u bytes\n", chunk.dwSize);
 371                                 hr = load_region(This, stream, &This->regions[i++], chunk.dwSize - sizeof(chunk.fccID));
 372                             }
 373                             else
 374                             {
 375                                 TRACE("Unknown chunk %s: %u bytes\n", debugstr_fourcc(chunk.fccID), chunk.dwSize);
 376                                 hr = advance_stream(stream, chunk.dwSize - sizeof(chunk.fccID));
 377                             }
 378                             if (FAILED(hr))
 379                                 goto error;
 380
 381                             size = subtract_bytes(size, chunk.dwSize + sizeof(chunk));
 382                         }
 383                         break;
 384
 385                     case FOURCC_LART:
 386                         TRACE("LART chunk (articulations list): %u bytes\n", size);
 387
 388                         while (size)
 389                         {
 390                             hr = read_from_stream(stream, &chunk, sizeof(chunk));
 391                             if (FAILED(hr))
 392                                 goto error;
 393
 394                             if (chunk.fccID == FOURCC_ART1)
 395                             {
 396                                 TRACE("ART1 chunk (level 1 articulation): %u bytes\n", chunk.dwSize);
 397                                 hr = load_articulation(This, stream, chunk.dwSize);
 398                             }
 399                             else
 400                             {
 401                                 TRACE("Unknown chunk %s: %u bytes\n", debugstr_fourcc(chunk.fccID), chunk.dwSize);
 402                                 hr = advance_stream(stream, chunk.dwSize);
 403                             }
 404                             if (FAILED(hr))
 405                                 goto error;
 406
 407                             size = subtract_bytes(size, chunk.dwSize + sizeof(chunk));
 408                         }
 409                         break;
 410
 411                     default:
 412                         TRACE("Unknown chunk %s: %u bytes\n", debugstr_fourcc(chunk.fccID), chunk.dwSize);
 413
 414                         hr = advance_stream(stream, chunk.dwSize - sizeof(chunk.fccID));
 415                         if (FAILED(hr))
 416                             goto error;
 417
 418                         size = subtract_bytes(size, chunk.dwSize - sizeof(chunk.fccID));
 419                         break;
 420                 }
 421                 break;
 422             }
 423
 424             default:
 425                 TRACE("Unknown chunk %s: %u bytes\n", debugstr_fourcc(chunk.fccID), chunk.dwSize);
 426
 427                 hr = advance_stream(stream, chunk.dwSize);
 428                 if (FAILED(hr))
 429                     goto error;
 430
 431                 break;
 432         }
 433     }
 434
 435     This->loaded = TRUE;
 436
 437     return S_OK;
 438
 439 error:
 440     HeapFree(GetProcessHeap(), 0, This->regions);
 441     This->regions = NULL;
 442
 443     return DMUS_E_UNSUPPORTED_STREAM;
 444 }