dlls/dmime/dmobject.c

   1 /*
   2  * Base IDirectMusicObject Implementation
   3  * Keep in sync with the master in dlls/dmusic/dmobject.c
   4  *
   5  * Copyright (C) 2003-2004 Rok Mandeljc
   6  * Copyright (C) 2014 Michael Stefaniuc
   7  *
   8  * This program is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  */
  22
  23 #define COBJMACROS
  24 #include <assert.h>
  25 #include "objbase.h"
  26 #include "dmusici.h"
  27 #include "dmusicf.h"
  28 #include "dmobject.h"
  29 #include "wine/debug.h"
  30
  31 WINE_DEFAULT_DEBUG_CHANNEL(dmobj);
  32 WINE_DECLARE_DEBUG_CHANNEL(dmfile);
  33
  34 /* RIFF format parsing */
  35 #define CHUNK_HDR_SIZE (sizeof(FOURCC) + sizeof(DWORD))
  36
  37 static inline const char *debugstr_fourcc(DWORD fourcc)
  38 {
  39     if (!fourcc) return "''";
  40     return wine_dbg_sprintf("'%c%c%c%c'", (char)(fourcc), (char)(fourcc >> 8),
  41             (char)(fourcc >> 16), (char)(fourcc >> 24));
  42 }
  43
  44 const char *debugstr_chunk(const struct chunk_entry *chunk)
  45 {
  46     const char *type = "";
  47
  48     if (!chunk)
  49         return "(null)";
  50     if (chunk->id == FOURCC_RIFF || chunk->id == FOURCC_LIST)
  51         type = wine_dbg_sprintf("type %s, ", debugstr_fourcc(chunk->type));
  52     return wine_dbg_sprintf("%s chunk, %ssize %u", debugstr_fourcc(chunk->id), type, chunk->size);
  53 }
  54
  55 static HRESULT stream_read(IStream *stream, void *data, ULONG size)
  56 {
  57     ULONG read;
  58     HRESULT hr;
  59
  60     hr = IStream_Read(stream, data, size, &read);
  61     if (FAILED(hr))
  62         TRACE_(dmfile)("IStream_Read failed: %08x\n", hr);
  63     else if (!read && read < size) {
  64         /* All or nothing: Handle a partial read due to end of stream as an error */
  65         TRACE_(dmfile)("Short read: %u < %u\n", read, size);
  66         return E_FAIL;
  67     }
  68
  69     return hr;
  70 }
  71
  72 HRESULT stream_get_chunk(IStream *stream, struct chunk_entry *chunk)
  73 {
  74     static const LARGE_INTEGER zero;
  75     ULONGLONG ck_end = 0, p_end = 0;
  76     HRESULT hr;
  77
  78     hr = IStream_Seek(stream, zero, STREAM_SEEK_CUR, &chunk->offset);
  79     if (FAILED(hr))
  80         return hr;
  81     assert(!(chunk->offset.QuadPart & 1));
  82     if (chunk->parent) {
  83         p_end = chunk->parent->offset.QuadPart + CHUNK_HDR_SIZE + ((chunk->parent->size + 1) & ~1);
  84         if (chunk->offset.QuadPart == p_end)
  85             return S_FALSE;
  86         ck_end = chunk->offset.QuadPart + CHUNK_HDR_SIZE;
  87         if (ck_end > p_end) {
  88             WARN_(dmfile)("No space for sub-chunk header in parent chunk: ends at offset %s > %s\n",
  89                     wine_dbgstr_longlong(ck_end), wine_dbgstr_longlong(p_end));
  90             return E_FAIL;
  91         }
  92     }
  93
  94     hr = stream_read(stream, chunk, CHUNK_HDR_SIZE);
  95     if (hr != S_OK)
  96         return hr;
  97     if (chunk->parent) {
  98         ck_end += (chunk->size + 1) & ~1;
  99         if (ck_end > p_end) {
 100             WARN_(dmfile)("No space for sub-chunk data in parent chunk: ends at offset %s > %s\n",
 101                     wine_dbgstr_longlong(ck_end), wine_dbgstr_longlong(p_end));
 102             return E_FAIL;
 103         }
 104     }
 105
 106     if (chunk->id == FOURCC_LIST || chunk->id == FOURCC_RIFF) {
 107         hr = stream_read(stream, &chunk->type, sizeof(FOURCC));
 108         if (hr != S_OK)
 109             return hr != S_FALSE ? hr : E_FAIL;
 110     }
 111
 112     TRACE_(dmfile)("Returning %s\n", debugstr_chunk(chunk));
 113
 114     return S_OK;
 115 }
 116
 117 HRESULT stream_skip_chunk(IStream *stream, struct chunk_entry *chunk)
 118 {
 119     LARGE_INTEGER end;
 120
 121     end.QuadPart = (chunk->offset.QuadPart + CHUNK_HDR_SIZE + chunk->size + 1) & ~(ULONGLONG)1;
 122
 123     return IStream_Seek(stream, end, STREAM_SEEK_SET, NULL);
 124 }
 125
 126 HRESULT stream_next_chunk(IStream *stream, struct chunk_entry *chunk)
 127 {
 128     HRESULT hr;
 129
 130     if (chunk->id) {
 131         hr = stream_skip_chunk(stream, chunk);
 132         if (FAILED(hr))
 133             return hr;
 134     }
 135
 136     return stream_get_chunk(stream, chunk);
 137 }
 138
 139 HRESULT stream_chunk_get_data(IStream *stream, const struct chunk_entry *chunk, void *data,
 140         ULONG size)
 141 {
 142     if (chunk->size != size) {
 143         WARN_(dmfile)("Chunk %s (size %u, offset %s) doesn't contains the expected data size %u\n",
 144                 debugstr_fourcc(chunk->id), chunk->size,
 145                 wine_dbgstr_longlong(chunk->offset.QuadPart), size);
 146         return E_FAIL;
 147     }
 148     return stream_read(stream, data, size);
 149 }
 150
 151 HRESULT stream_chunk_get_wstr(IStream *stream, const struct chunk_entry *chunk, WCHAR *str,
 152         ULONG size)
 153 {
 154     ULONG len;
 155     HRESULT hr;
 156
 157     hr = IStream_Read(stream, str, min(chunk->size, size), &len);
 158     if (FAILED(hr))
 159         return hr;
 160
 161     /* Don't assume the string is properly zero terminated */
 162     str[min(len, size - 1)] = 0;
 163
 164     if (len < chunk->size)
 165         return S_FALSE;
 166     return S_OK;
 167 }
 168
 169
 170
 171 /* Generic IDirectMusicObject methods */
 172 static inline struct dmobject *impl_from_IDirectMusicObject(IDirectMusicObject *iface)
 173 {
 174     return CONTAINING_RECORD(iface, struct dmobject, IDirectMusicObject_iface);
 175 }
 176
 177 HRESULT WINAPI dmobj_IDirectMusicObject_QueryInterface(IDirectMusicObject *iface, REFIID riid,
 178         void **ret_iface)
 179 {
 180     struct dmobject *This = impl_from_IDirectMusicObject(iface);
 181     return IUnknown_QueryInterface(This->outer_unk, riid, ret_iface);
 182 }
 183
 184 ULONG WINAPI dmobj_IDirectMusicObject_AddRef(IDirectMusicObject *iface)
 185 {
 186     struct dmobject *This = impl_from_IDirectMusicObject(iface);
 187     return IUnknown_AddRef(This->outer_unk);
 188 }
 189
 190 ULONG WINAPI dmobj_IDirectMusicObject_Release(IDirectMusicObject *iface)
 191 {
 192     struct dmobject *This = impl_from_IDirectMusicObject(iface);
 193     return IUnknown_Release(This->outer_unk);
 194 }
 195
 196 HRESULT WINAPI dmobj_IDirectMusicObject_GetDescriptor(IDirectMusicObject *iface,
 197         DMUS_OBJECTDESC *desc)
 198 {
 199     struct dmobject *This = impl_from_IDirectMusicObject(iface);
 200
 201     TRACE("(%p/%p)->(%p)\n", iface, This, desc);
 202
 203     if (!desc)
 204         return E_POINTER;
 205
 206     memcpy(desc, &This->desc, This->desc.dwSize);
 207
 208     return S_OK;
 209 }
 210
 211 HRESULT WINAPI dmobj_IDirectMusicObject_SetDescriptor(IDirectMusicObject *iface,
 212         DMUS_OBJECTDESC *desc)
 213 {
 214     struct dmobject *This = impl_from_IDirectMusicObject(iface);
 215     HRESULT ret = S_OK;
 216
 217     TRACE("(%p, %p)\n", iface, desc);
 218
 219     if (!desc)
 220         return E_POINTER;
 221
 222     /* Immutable property */
 223     if (desc->dwValidData & DMUS_OBJ_CLASS)
 224     {
 225         desc->dwValidData &= ~DMUS_OBJ_CLASS;
 226         ret = S_FALSE;
 227     }
 228     /* Set only valid fields */
 229     if (desc->dwValidData & DMUS_OBJ_OBJECT)
 230         This->desc.guidObject = desc->guidObject;
 231     if (desc->dwValidData & DMUS_OBJ_NAME)
 232         lstrcpynW(This->desc.wszName, desc->wszName, DMUS_MAX_NAME);
 233     if (desc->dwValidData & DMUS_OBJ_CATEGORY)
 234         lstrcpynW(This->desc.wszCategory, desc->wszCategory, DMUS_MAX_CATEGORY);
 235     if (desc->dwValidData & DMUS_OBJ_FILENAME)
 236         lstrcpynW(This->desc.wszFileName, desc->wszFileName, DMUS_MAX_FILENAME);
 237     if (desc->dwValidData & DMUS_OBJ_VERSION)
 238         This->desc.vVersion = desc->vVersion;
 239     if (desc->dwValidData & DMUS_OBJ_DATE)
 240         This->desc.ftDate = desc->ftDate;
 241     if (desc->dwValidData & DMUS_OBJ_MEMORY) {
 242         This->desc.llMemLength = desc->llMemLength;
 243         memcpy(This->desc.pbMemData, desc->pbMemData, desc->llMemLength);
 244     }
 245     if (desc->dwValidData & DMUS_OBJ_STREAM)
 246         IStream_Clone(desc->pStream, &This->desc.pStream);
 247
 248     This->desc.dwValidData |= desc->dwValidData;
 249
 250     return ret;
 251 }
 252
 253 /* Helper for IDirectMusicObject::ParseDescriptor */
 254 static inline void info_get_name(IStream *stream, const struct chunk_entry *info,
 255         DMUS_OBJECTDESC *desc)
 256 {
 257     struct chunk_entry chunk = {.parent = info};
 258     char name[DMUS_MAX_NAME];
 259     ULONG len;
 260     HRESULT hr = E_FAIL;
 261
 262     while (stream_next_chunk(stream, &chunk) == S_OK)
 263         if (chunk.id == mmioFOURCC('I','N','A','M'))
 264             hr = IStream_Read(stream, name, min(chunk.size, sizeof(name)), &len);
 265
 266     if (SUCCEEDED(hr)) {
 267         len = MultiByteToWideChar(CP_ACP, 0, name, len, desc->wszName, sizeof(desc->wszName));
 268         desc->wszName[min(len, sizeof(desc->wszName) - 1)] = 0;
 269         desc->dwValidData |= DMUS_OBJ_NAME;
 270     }
 271 }
 272
 273 static inline void unfo_get_name(IStream *stream, const struct chunk_entry *unfo,
 274         DMUS_OBJECTDESC *desc, BOOL inam)
 275 {
 276     struct chunk_entry chunk = {.parent = unfo};
 277
 278     while (stream_next_chunk(stream, &chunk) == S_OK)
 279         if (chunk.id == DMUS_FOURCC_UNAM_CHUNK || (inam && chunk.id == mmioFOURCC('I','N','A','M')))
 280             if (stream_chunk_get_wstr(stream, &chunk, desc->wszName, sizeof(desc->wszName)) == S_OK)
 281                 desc->dwValidData |= DMUS_OBJ_NAME;
 282 }
 283
 284 HRESULT dmobj_parsedescriptor(IStream *stream, const struct chunk_entry *riff,
 285         DMUS_OBJECTDESC *desc, DWORD supported)
 286 {
 287     struct chunk_entry chunk = {.parent = riff};
 288     HRESULT hr;
 289
 290     TRACE("Looking for %#x in %p: %s\n", supported, stream, debugstr_chunk(riff));
 291
 292     desc->dwValidData = 0;
 293     desc->dwSize = sizeof(*desc);
 294
 295     while ((hr = stream_next_chunk(stream, &chunk)) == S_OK) {
 296         switch (chunk.id) {
 297             case DMUS_FOURCC_GUID_CHUNK:
 298                 if ((supported & DMUS_OBJ_OBJECT) && stream_chunk_get_data(stream, &chunk,
 299                             &desc->guidObject, sizeof(desc->guidObject)) == S_OK)
 300                     desc->dwValidData |= DMUS_OBJ_OBJECT;
 301                 break;
 302             case DMUS_FOURCC_CATEGORY_CHUNK:
 303                 if ((supported & DMUS_OBJ_CATEGORY) && stream_chunk_get_wstr(stream, &chunk,
 304                             desc->wszCategory, sizeof(desc->wszCategory)) == S_OK)
 305                     desc->dwValidData |= DMUS_OBJ_CATEGORY;
 306                 break;
 307             case DMUS_FOURCC_VERSION_CHUNK:
 308                 if ((supported & DMUS_OBJ_VERSION) && stream_chunk_get_data(stream, &chunk,
 309                             &desc->vVersion, sizeof(desc->vVersion)) == S_OK)
 310                     desc->dwValidData |= DMUS_OBJ_VERSION;
 311                 break;
 312             case FOURCC_LIST:
 313                 if (chunk.type == DMUS_FOURCC_UNFO_LIST && (supported & DMUS_OBJ_NAME))
 314                     unfo_get_name(stream, &chunk, desc, supported & DMUS_OBJ_NAME_INAM);
 315                 else if (chunk.type == DMUS_FOURCC_INFO_LIST && (supported & DMUS_OBJ_NAME_INFO))
 316                     info_get_name(stream, &chunk, desc);
 317                 break;
 318         }
 319     }
 320     TRACE("Found %#x\n", desc->dwValidData);
 321
 322     return hr;
 323 }
 324
 325 /* Generic IPersistStream methods */
 326 static inline struct dmobject *impl_from_IPersistStream(IPersistStream *iface)
 327 {
 328     return CONTAINING_RECORD(iface, struct dmobject, IPersistStream_iface);
 329 }
 330
 331 HRESULT WINAPI dmobj_IPersistStream_QueryInterface(IPersistStream *iface, REFIID riid,
 332         void **ret_iface)
 333 {
 334     struct dmobject *This = impl_from_IPersistStream(iface);
 335     return IUnknown_QueryInterface(This->outer_unk, riid, ret_iface);
 336 }
 337
 338 ULONG WINAPI dmobj_IPersistStream_AddRef(IPersistStream *iface)
 339 {
 340     struct dmobject *This = impl_from_IPersistStream(iface);
 341     return IUnknown_AddRef(This->outer_unk);
 342 }
 343
 344 ULONG WINAPI dmobj_IPersistStream_Release(IPersistStream *iface)
 345 {
 346     struct dmobject *This = impl_from_IPersistStream(iface);
 347     return IUnknown_Release(This->outer_unk);
 348 }
 349
 350 HRESULT WINAPI dmobj_IPersistStream_GetClassID(IPersistStream *iface, CLSID *class)
 351 {
 352     struct dmobject *This = impl_from_IPersistStream(iface);
 353
 354     TRACE("(%p, %p)\n", This, class);
 355
 356     if (!class)
 357         return E_POINTER;
 358
 359     *class = This->desc.guidClass;
 360
 361     return S_OK;
 362 }
 363
 364 /* IPersistStream methods not implemented in native */
 365 HRESULT WINAPI unimpl_IPersistStream_GetClassID(IPersistStream *iface, CLSID *class)
 366 {
 367     TRACE("(%p, %p): method not implemented\n", iface, class);
 368     return E_NOTIMPL;
 369 }
 370
 371 HRESULT WINAPI unimpl_IPersistStream_IsDirty(IPersistStream *iface)
 372 {
 373     TRACE("(%p): method not implemented, always returning S_FALSE\n", iface);
 374     return S_FALSE;
 375 }
 376
 377 HRESULT WINAPI unimpl_IPersistStream_Save(IPersistStream *iface, IStream *stream,
 378         BOOL clear_dirty)
 379 {
 380     TRACE("(%p, %p, %d): method not implemented\n", iface, stream, clear_dirty);
 381     return E_NOTIMPL;
 382 }
 383
 384 HRESULT WINAPI unimpl_IPersistStream_GetSizeMax(IPersistStream *iface, ULARGE_INTEGER *size)
 385 {
 386     TRACE("(%p, %p): method not implemented\n", iface, size);
 387     return E_NOTIMPL;
 388 }
 389
 390
 391 void dmobject_init(struct dmobject *dmobj, const GUID *class, IUnknown *outer_unk)
 392 {
 393     dmobj->outer_unk = outer_unk;
 394     dmobj->desc.dwSize = sizeof(dmobj->desc);
 395     dmobj->desc.dwValidData = DMUS_OBJ_CLASS;
 396     dmobj->desc.guidClass = *class;
 397 }