?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
gphoto2.ds: Set supported groups.
[wine.git] / dlls / dmloader / container.c
blobc14a5bd61106260c5fe730cf3aa3f02b9288022a
1 /* IDirectMusicContainerImpl
2 *
3 * Copyright (C) 2003-2004 Rok Mandeljc
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU Lesser General Public
7 * License as published by the Free Software Foundation; either
8 * version 2.1 of the License, or (at your option) any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 * Lesser General Public License for more details.
14 *
15 * You should have received a copy of the GNU Lesser General Public
16 * License along with this program; if not, write to the Free Software
17 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
18 */
19
20 #include "dmloader_private.h"
21 #include "dmobject.h"
22
23 WINE_DEFAULT_DEBUG_CHANNEL(dmloader);
24 WINE_DECLARE_DEBUG_CHANNEL(dmfile);
25 WINE_DECLARE_DEBUG_CHANNEL(dmdump);
26
27 #define DMUS_MAX_CATEGORY_SIZE DMUS_MAX_CATEGORY*sizeof(WCHAR)
28 #define DMUS_MAX_NAME_SIZE DMUS_MAX_NAME*sizeof(WCHAR)
29 #define DMUS_MAX_FILENAME_SIZE DMUS_MAX_FILENAME*sizeof(WCHAR)
30
31 typedef struct riff_chunk {
32 FOURCC fccID;
33 DWORD dwSize;
34 } WINE_CHUNK;
35
36 /* contained object entry */
37 typedef struct container_entry {
38 struct list entry;
39 DMUS_OBJECTDESC Desc;
40 BOOL bIsRIFF;
41 DWORD dwFlags; /* DMUS_CONTAINED_OBJF_KEEP: keep object in loader's cache, even when container is released */
42 WCHAR *wszAlias;
43 IDirectMusicObject *pObject; /* needed when releasing from loader's cache on container release */
44 } WINE_CONTAINER_ENTRY, *LPWINE_CONTAINER_ENTRY;
45
46 /*****************************************************************************
47 * IDirectMusicContainerImpl implementation
48 */
49 typedef struct IDirectMusicContainerImpl {
50 IDirectMusicContainer IDirectMusicContainer_iface;
51 struct dmobject dmobj;
52 LONG ref;
53 IStream *pStream;
54 DMUS_IO_CONTAINER_HEADER Header; /* header */
55 struct list *pContainedObjects; /* data */
56 } IDirectMusicContainerImpl;
57
58 static inline IDirectMusicContainerImpl *impl_from_IDirectMusicContainer(IDirectMusicContainer *iface)
59 {
60 return CONTAINING_RECORD(iface, IDirectMusicContainerImpl, IDirectMusicContainer_iface);
61 }
62
63 static HRESULT destroy_dmcontainer(IDirectMusicContainerImpl *This)
64 {
65 LPDIRECTMUSICLOADER pLoader;
66 LPDIRECTMUSICGETLOADER pGetLoader;
67 struct list *pEntry;
68 LPWINE_CONTAINER_ENTRY pContainedObject;
69
70 /* get loader (from stream we loaded from) */
71 TRACE(": getting loader\n");
72 IStream_QueryInterface (This->pStream, &IID_IDirectMusicGetLoader, (LPVOID*)&pGetLoader);
73 IDirectMusicGetLoader_GetLoader (pGetLoader, &pLoader);
74 IDirectMusicGetLoader_Release (pGetLoader);
75
76 /* release objects from loader's cache (if appropriate) */
77 TRACE(": releasing objects from loader's cache\n");
78 LIST_FOR_EACH (pEntry, This->pContainedObjects) {
79 pContainedObject = LIST_ENTRY (pEntry, WINE_CONTAINER_ENTRY, entry);
80 /* my tests indicate that container releases objects *only*
81 if they were loaded at its load-time (makes sense, it doesn't
82 have pointers to objects otherwise); BTW: native container seems
83 to ignore the flags (I won't) */
84 if (pContainedObject->pObject && !(pContainedObject->dwFlags & DMUS_CONTAINED_OBJF_KEEP)) {
85 /* flags say it shouldn't be kept in loader's cache */
86 IDirectMusicLoader_ReleaseObject (pLoader, pContainedObject->pObject);
87 }
88 }
89 IDirectMusicLoader_Release (pLoader);
90
91 /* release stream we loaded from */
92 IStream_Release (This->pStream);
93
94 /* FIXME: release allocated entries */
95
96 return S_OK;
97 }
98
99 static HRESULT WINAPI IDirectMusicContainerImpl_QueryInterface(IDirectMusicContainer *iface, REFIID riid, void **ret_iface)
100 {
101 IDirectMusicContainerImpl *This = impl_from_IDirectMusicContainer(iface);
102
103 TRACE("(%p, %s, %p)\n", This, debugstr_dmguid(riid), ret_iface);
104
105 if (IsEqualIID (riid, &IID_IUnknown) || IsEqualIID (riid, &IID_IDirectMusicContainer))
106 *ret_iface = &This->IDirectMusicContainer_iface;
107 else if (IsEqualIID (riid, &IID_IDirectMusicObject))
108 *ret_iface = &This->dmobj.IDirectMusicObject_iface;
109 else if (IsEqualIID (riid, &IID_IPersistStream))
110 *ret_iface = &This->dmobj.IPersistStream_iface;
111 else {
112 WARN("Unknown interface %s\n", debugstr_dmguid(riid));
113 *ret_iface = NULL;
114 return E_NOINTERFACE;
115 }
116
117 IUnknown_AddRef((IUnknown*)*ret_iface);
118 return S_OK;
119 }
120
121 static ULONG WINAPI IDirectMusicContainerImpl_AddRef(IDirectMusicContainer *iface)
122 {
123 IDirectMusicContainerImpl *This = impl_from_IDirectMusicContainer(iface);
124 LONG ref = InterlockedIncrement(&This->ref);
125
126 TRACE("(%p) ref=%d\n", This, ref);
127
128 return ref;
129 }
130
131 static ULONG WINAPI IDirectMusicContainerImpl_Release(IDirectMusicContainer *iface)
132 {
133 IDirectMusicContainerImpl *This = impl_from_IDirectMusicContainer(iface);
134 LONG ref = InterlockedDecrement(&This->ref);
135
136 TRACE("(%p) ref=%d\n", This, ref);
137
138 if (!ref) {
139 if (This->pStream)
140 destroy_dmcontainer(This);
141 HeapFree(GetProcessHeap(), 0, This);
142 unlock_module();
143 }
144
145 return ref;
146 }
147
148 static HRESULT WINAPI IDirectMusicContainerImpl_EnumObject(IDirectMusicContainer *iface,
149 REFGUID rguidClass, DWORD dwIndex, DMUS_OBJECTDESC *pDesc, WCHAR *pwszAlias)
150 {
151 IDirectMusicContainerImpl *This = impl_from_IDirectMusicContainer(iface);
152 struct list *pEntry;
153 LPWINE_CONTAINER_ENTRY pContainedObject;
154 DWORD dwCount = 0;
155
156 TRACE("(%p, %s, %d, %p, %p)\n", This, debugstr_dmguid(rguidClass), dwIndex, pDesc, pwszAlias);
157
158 if (!pDesc)
159 return E_POINTER;
160 if (pDesc->dwSize != sizeof(DMUS_OBJECTDESC)) {
161 ERR(": invalid pDesc->dwSize %d\n", pDesc->dwSize);
162 return E_INVALIDARG;
163 }
164
165 DM_STRUCT_INIT(pDesc);
166
167 LIST_FOR_EACH (pEntry, This->pContainedObjects) {
168 pContainedObject = LIST_ENTRY (pEntry, WINE_CONTAINER_ENTRY, entry);
169
170 if (IsEqualGUID (rguidClass, &GUID_DirectMusicAllTypes) || IsEqualGUID (rguidClass, &pContainedObject->Desc.guidClass)) {
171 if (dwCount == dwIndex) {
172 HRESULT result = S_OK;
173 if (pwszAlias) {
174 lstrcpynW (pwszAlias, pContainedObject->wszAlias, DMUS_MAX_FILENAME);
175 if (strlenW (pContainedObject->wszAlias) > DMUS_MAX_FILENAME)
176 result = DMUS_S_STRING_TRUNCATED;
177 }
178 *pDesc = pContainedObject->Desc;
179 return result;
180 }
181 dwCount++;
182 }
183 }
184
185 TRACE(": not found\n");
186 return S_FALSE;
187 }
188
189 static const IDirectMusicContainerVtbl dmcontainer_vtbl = {
190 IDirectMusicContainerImpl_QueryInterface,
191 IDirectMusicContainerImpl_AddRef,
192 IDirectMusicContainerImpl_Release,
193 IDirectMusicContainerImpl_EnumObject
194 };
195
196 /* IDirectMusicObject part: */
197 static inline IDirectMusicContainerImpl *impl_from_IDirectMusicObject(IDirectMusicObject *iface)
198 {
199 return CONTAINING_RECORD(iface, IDirectMusicContainerImpl, dmobj.IDirectMusicObject_iface);
200 }
201
202 static HRESULT WINAPI IDirectMusicObjectImpl_ParseDescriptor(IDirectMusicObject *iface,
203 IStream *pStream, DMUS_OBJECTDESC *pDesc)
204 {
205 IDirectMusicContainerImpl *This = impl_from_IDirectMusicObject(iface);
206 WINE_CHUNK Chunk;
207 DWORD StreamSize, StreamCount, ListSize[1], ListCount[1];
208 LARGE_INTEGER liMove; /* used when skipping chunks */
209
210 TRACE("(%p, %p, %p)\n", This, pStream, pDesc);
211
212 /* check whether arguments are OK */
213 if (IsBadReadPtr (pStream, sizeof(LPVOID))) {
214 ERR(": pStream bad read pointer\n");
215 return E_POINTER;
216 }
217 /* check whether pDesc is OK */
218 if (IsBadReadPtr (pDesc, sizeof(DWORD))) {
219 ERR(": pDesc->dwSize bad read pointer\n");
220 return E_POINTER;
221 }
222 if (pDesc->dwSize != sizeof(DMUS_OBJECTDESC)) {
223 ERR(": invalid pDesc->dwSize\n");
224 return E_INVALIDARG;
225 }
226 if (IsBadWritePtr (pDesc, sizeof(DMUS_OBJECTDESC))) {
227 ERR(": pDesc bad write pointer\n");
228 return E_POINTER;
229 }
230
231 DM_STRUCT_INIT(pDesc);
232
233 /* here we go... */
234 IStream_Read (pStream, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
235 TRACE_(dmfile)(": %s chunk (size = 0x%08X)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
236 switch (Chunk.fccID) {
237 case FOURCC_RIFF: {
238 IStream_Read (pStream, &Chunk.fccID, sizeof(FOURCC), NULL);
239 TRACE_(dmfile)(": RIFF chunk of type %s", debugstr_fourcc(Chunk.fccID));
240 StreamSize = Chunk.dwSize - sizeof(FOURCC);
241 StreamCount = 0;
242 if (Chunk.fccID == DMUS_FOURCC_CONTAINER_FORM) {
243 TRACE_(dmfile)(": container form\n");
244 /* set guidClass */
245 pDesc->dwValidData |= DMUS_OBJ_CLASS;
246 pDesc->guidClass = CLSID_DirectMusicContainer;
247 do {
248 IStream_Read (pStream, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
249 StreamCount += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
250 TRACE_(dmfile)(": %s chunk (size = 0x%08X)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
251 switch (Chunk.fccID) {
252 case DMUS_FOURCC_GUID_CHUNK: {
253 TRACE_(dmfile)(": GUID chunk\n");
254 pDesc->dwValidData |= DMUS_OBJ_OBJECT;
255 IStream_Read (pStream, &pDesc->guidObject, Chunk.dwSize, NULL);
256 TRACE_(dmdump)(": GUID: %s\n", debugstr_guid(&pDesc->guidObject));
257 break;
258 }
259 case DMUS_FOURCC_VERSION_CHUNK: {
260 TRACE_(dmfile)(": version chunk\n");
261 pDesc->dwValidData |= DMUS_OBJ_VERSION;
262 IStream_Read (pStream, &pDesc->vVersion, Chunk.dwSize, NULL);
263 TRACE_(dmdump)(": version: %s\n", debugstr_dmversion(&pDesc->vVersion));
264 break;
265 }
266 case DMUS_FOURCC_DATE_CHUNK: {
267 TRACE_(dmfile)(": date chunk\n");
268 IStream_Read (pStream, &pDesc->ftDate, Chunk.dwSize, NULL);
269 pDesc->dwValidData |= DMUS_OBJ_DATE;
270 TRACE_(dmdump)(": date: %s\n", debugstr_filetime(&pDesc->ftDate));
271 break;
272 }
273 case DMUS_FOURCC_CATEGORY_CHUNK: {
274 TRACE_(dmfile)(": category chunk\n");
275 /* if it happens that string is too long,
276 read what we can and skip the rest*/
277 if (Chunk.dwSize > DMUS_MAX_CATEGORY_SIZE) {
278 IStream_Read (pStream, pDesc->wszCategory, DMUS_MAX_CATEGORY_SIZE, NULL);
279 liMove.QuadPart = Chunk.dwSize - DMUS_MAX_CATEGORY_SIZE;
280 IStream_Seek (pStream, liMove, STREAM_SEEK_CUR, NULL);
281 } else {
282 IStream_Read (pStream, pDesc->wszCategory, Chunk.dwSize, NULL);
283 }
284 pDesc->dwValidData |= DMUS_OBJ_CATEGORY;
285 TRACE_(dmdump)(": category: %s\n", debugstr_w(pDesc->wszCategory));
286 break;
287 }
288 case FOURCC_LIST: {
289 IStream_Read (pStream, &Chunk.fccID, sizeof(FOURCC), NULL);
290 TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(Chunk.fccID));
291 ListSize[0] = Chunk.dwSize - sizeof(FOURCC);
292 ListCount[0] = 0;
293 switch (Chunk.fccID) {
294 /* evil M$ UNFO list, which can (!?) contain INFO elements */
295 case DMUS_FOURCC_UNFO_LIST: {
296 TRACE_(dmfile)(": UNFO list\n");
297 do {
298 IStream_Read (pStream, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
299 ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
300 TRACE_(dmfile)(": %s chunk (size = 0x%08X)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
301 switch (Chunk.fccID) {
302 /* don't ask me why, but M$ puts INFO elements in UNFO list sometimes
303 (though strings seem to be valid unicode) */
304 case mmioFOURCC('I','N','A','M'):
305 case DMUS_FOURCC_UNAM_CHUNK: {
306 TRACE_(dmfile)(": name chunk\n");
307 /* if it happens that string is too long,
308 read what we can and skip the rest*/
309 if (Chunk.dwSize > DMUS_MAX_NAME_SIZE) {
310 IStream_Read (pStream, pDesc->wszName, DMUS_MAX_NAME_SIZE, NULL);
311 liMove.QuadPart = Chunk.dwSize - DMUS_MAX_NAME_SIZE;
312 IStream_Seek (pStream, liMove, STREAM_SEEK_CUR, NULL);
313 } else {
314 IStream_Read (pStream, pDesc->wszName, Chunk.dwSize, NULL);
315 }
316 pDesc->dwValidData |= DMUS_OBJ_NAME;
317 TRACE_(dmdump)(": name: %s\n", debugstr_w(pDesc->wszName));
318 break;
319 }
320 default: {
321 TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
322 liMove.QuadPart = Chunk.dwSize;
323 IStream_Seek (pStream, liMove, STREAM_SEEK_CUR, NULL);
324 break;
325 }
326 }
327 TRACE_(dmfile)(": ListCount[0] = 0x%08X < ListSize[0] = 0x%08X\n", ListCount[0], ListSize[0]);
328 } while (ListCount[0] < ListSize[0]);
329 break;
330 }
331 default: {
332 TRACE_(dmfile)(": unknown (skipping)\n");
333 liMove.QuadPart = Chunk.dwSize - sizeof(FOURCC);
334 IStream_Seek (pStream, liMove, STREAM_SEEK_CUR, NULL);
335 break;
336 }
337 }
338 break;
339 }
340 default: {
341 TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
342 liMove.QuadPart = Chunk.dwSize;
343 IStream_Seek (pStream, liMove, STREAM_SEEK_CUR, NULL);
344 break;
345 }
346 }
347 TRACE_(dmfile)(": StreamCount[0] = 0x%08X < StreamSize[0] = 0x%08X\n", StreamCount, StreamSize);
348 } while (StreamCount < StreamSize);
349 } else {
350 TRACE_(dmfile)(": unexpected chunk; loading failed)\n");
351 liMove.QuadPart = StreamSize;
352 IStream_Seek (pStream, liMove, STREAM_SEEK_CUR, NULL); /* skip the rest of the chunk */
353 return E_FAIL;
354 }
355
356 TRACE_(dmfile)(": reading finished\n");
357 break;
358 }
359 default: {
360 TRACE_(dmfile)(": unexpected chunk; loading failed)\n");
361 liMove.QuadPart = Chunk.dwSize;
362 IStream_Seek (pStream, liMove, STREAM_SEEK_CUR, NULL); /* skip the rest of the chunk */
363 return DMUS_E_INVALIDFILE;
364 }
365 }
366
367 TRACE(": returning descriptor:\n");
368 if (TRACE_ON(dmloader))
369 dump_DMUS_OBJECTDESC(pDesc);
370 return S_OK;
371 }
372
373 static const IDirectMusicObjectVtbl dmobject_vtbl = {
374 dmobj_IDirectMusicObject_QueryInterface,
375 dmobj_IDirectMusicObject_AddRef,
376 dmobj_IDirectMusicObject_Release,
377 dmobj_IDirectMusicObject_GetDescriptor,
378 dmobj_IDirectMusicObject_SetDescriptor,
379 IDirectMusicObjectImpl_ParseDescriptor
380 };
381
382 /* IPersistStream part: */
383 static inline IDirectMusicContainerImpl *impl_from_IPersistStream(IPersistStream *iface)
384 {
385 return CONTAINING_RECORD(iface, IDirectMusicContainerImpl, dmobj.IPersistStream_iface);
386 }
387
388 static HRESULT WINAPI IPersistStreamImpl_Load(IPersistStream *iface, IStream *pStm)
389 {
390 IDirectMusicContainerImpl *This = impl_from_IPersistStream(iface);
391 WINE_CHUNK Chunk;
392 DWORD StreamSize, StreamCount, ListSize[3], ListCount[3];
393 LARGE_INTEGER liMove; /* used when skipping chunks */
394 ULARGE_INTEGER uliPos; /* needed when dealing with RIFF chunks */
395 LPDIRECTMUSICGETLOADER pGetLoader;
396 LPDIRECTMUSICLOADER pLoader;
397 HRESULT result = S_OK;
398
399 TRACE("(%p, %p):\n", This, pStm);
400
401 /* check whether pStm is valid read pointer */
402 if (IsBadReadPtr (pStm, sizeof(LPVOID))) {
403 ERR(": pStm bad read pointer\n");
404 return E_POINTER;
405 }
406 /* if stream is already set, this means the container is already loaded */
407 if (This->pStream) {
408 TRACE(": stream is already set, which means container is already loaded\n");
409 return DMUS_E_ALREADY_LOADED;
410 }
411
412 /* get loader since it will be needed later */
413 if (FAILED(IStream_QueryInterface (pStm, &IID_IDirectMusicGetLoader, (LPVOID*)&pGetLoader))) {
414 ERR(": stream not supported\n");
415 return DMUS_E_UNSUPPORTED_STREAM;
416 }
417 IDirectMusicGetLoader_GetLoader (pGetLoader, &pLoader);
418 IDirectMusicGetLoader_Release (pGetLoader);
419
420 This->pStream = pStm;
421 IStream_AddRef (pStm); /* add count for later references */
422
423 /* start with load */
424 IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
425 TRACE_(dmfile)(": %s chunk (size = 0x%08X)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
426 switch (Chunk.fccID) {
427 case FOURCC_RIFF: {
428 IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL);
429 TRACE_(dmfile)(": RIFF chunk of type %s", debugstr_fourcc(Chunk.fccID));
430 StreamSize = Chunk.dwSize - sizeof(FOURCC);
431 StreamCount = 0;
432 switch (Chunk.fccID) {
433 case DMUS_FOURCC_CONTAINER_FORM: {
434 TRACE_(dmfile)(": container form\n");
435 This->dmobj.desc.guidClass = CLSID_DirectMusicContainer;
436 This->dmobj.desc.dwValidData |= DMUS_OBJ_CLASS;
437 do {
438 IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
439 StreamCount += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
440 TRACE_(dmfile)(": %s chunk (size = 0x%08X)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
441 switch (Chunk.fccID) {
442 case DMUS_FOURCC_CONTAINER_CHUNK: {
443 TRACE_(dmfile)(": container header chunk\n");
444 IStream_Read (pStm, &This->Header, Chunk.dwSize, NULL);
445 TRACE_(dmdump)(": container header chunk:\n%s\n", debugstr_DMUS_IO_CONTAINER_HEADER(&This->Header));
446 break;
447 }
448 case DMUS_FOURCC_GUID_CHUNK: {
449 TRACE_(dmfile)(": GUID chunk\n");
450 IStream_Read (pStm, &This->dmobj.desc.guidObject, Chunk.dwSize, NULL);
451 This->dmobj.desc.dwValidData |= DMUS_OBJ_OBJECT;
452 TRACE_(dmdump)(": GUID: %s\n", debugstr_guid(&This->dmobj.desc.guidObject));
453 break;
454 }
455 case DMUS_FOURCC_VERSION_CHUNK: {
456 TRACE_(dmfile)(": version chunk\n");
457 IStream_Read (pStm, &This->dmobj.desc.vVersion, Chunk.dwSize, NULL);
458 This->dmobj.desc.dwValidData |= DMUS_OBJ_VERSION;
459 TRACE_(dmdump)(": version: %s\n", debugstr_dmversion(&This->dmobj.desc.vVersion));
460 break;
461 }
462 case DMUS_FOURCC_DATE_CHUNK: {
463 TRACE_(dmfile)(": date chunk\n");
464 IStream_Read (pStm, &This->dmobj.desc.ftDate, Chunk.dwSize, NULL);
465 This->dmobj.desc.dwValidData |= DMUS_OBJ_DATE;
466 TRACE_(dmdump)(": date: %s\n", debugstr_filetime(&This->dmobj.desc.ftDate));
467 break;
468 }
469 case DMUS_FOURCC_CATEGORY_CHUNK: {
470 TRACE_(dmfile)(": category chunk\n");
471 /* if it happens that string is too long,
472 read what we can and skip the rest*/
473 if (Chunk.dwSize > DMUS_MAX_CATEGORY_SIZE) {
474 IStream_Read (pStm, This->dmobj.desc.wszCategory, DMUS_MAX_CATEGORY_SIZE, NULL);
475 liMove.QuadPart = Chunk.dwSize - DMUS_MAX_CATEGORY_SIZE;
476 IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
477 } else {
478 IStream_Read (pStm, This->dmobj.desc.wszCategory, Chunk.dwSize, NULL);
479 }
480 This->dmobj.desc.dwValidData |= DMUS_OBJ_CATEGORY;
481 TRACE_(dmdump)(": category: %s\n", debugstr_w(This->dmobj.desc.wszCategory));
482 break;
483 }
484 case FOURCC_LIST: {
485 IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL);
486 TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(Chunk.fccID));
487 ListSize[0] = Chunk.dwSize - sizeof(FOURCC);
488 ListCount[0] = 0;
489 switch (Chunk.fccID) {
490 case DMUS_FOURCC_UNFO_LIST: {
491 TRACE_(dmfile)(": UNFO list\n");
492 do {
493 IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
494 ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
495 TRACE_(dmfile)(": %s chunk (size = 0x%08X)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
496 switch (Chunk.fccID) {
497 /* don't ask me why, but M$ puts INFO elements in UNFO list sometimes
498 (though strings seem to be valid unicode) */
499 case mmioFOURCC('I','N','A','M'):
500 case DMUS_FOURCC_UNAM_CHUNK: {
501 TRACE_(dmfile)(": name chunk\n");
502 /* if it happens that string is too long,
503 read what we can and skip the rest*/
504 if (Chunk.dwSize > DMUS_MAX_NAME_SIZE) {
505 IStream_Read (pStm, This->dmobj.desc.wszName, DMUS_MAX_NAME_SIZE, NULL);
506 liMove.QuadPart = Chunk.dwSize - DMUS_MAX_NAME_SIZE;
507 IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
508 } else {
509 IStream_Read (pStm, This->dmobj.desc.wszName, Chunk.dwSize, NULL);
510 }
511 This->dmobj.desc.dwValidData |= DMUS_OBJ_NAME;
512 TRACE_(dmdump)(": name: %s\n", debugstr_w(This->dmobj.desc.wszName));
513 break;
514 }
515 default: {
516 TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
517 liMove.QuadPart = Chunk.dwSize;
518 IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
519 break;
520 }
521 }
522 TRACE_(dmfile)(": ListCount[0] = 0x%08X < ListSize[0] = 0x%08X\n", ListCount[0], ListSize[0]);
523 } while (ListCount[0] < ListSize[0]);
524 break;
525 }
526 case DMUS_FOURCC_CONTAINED_OBJECTS_LIST: {
527 TRACE_(dmfile)(": contained objects list\n");
528 do {
529 IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
530 ListCount[0] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
531 TRACE_(dmfile)(": %s chunk (size = 0x%08X)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
532 switch (Chunk.fccID) {
533 case FOURCC_LIST: {
534 IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL);
535 TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(Chunk.fccID));
536 ListSize[1] = Chunk.dwSize - sizeof(FOURCC);
537 ListCount[1] = 0;
538 switch (Chunk.fccID) {
539 case DMUS_FOURCC_CONTAINED_OBJECT_LIST: {
540 LPWINE_CONTAINER_ENTRY pNewEntry;
541 TRACE_(dmfile)(": contained object list\n");
542 pNewEntry = HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, sizeof(WINE_CONTAINER_ENTRY));
543 DM_STRUCT_INIT(&pNewEntry->Desc);
544 do {
545 IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
546 ListCount[1] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
547 TRACE_(dmfile)(": %s chunk (size = 0x%08X)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
548 switch (Chunk.fccID) {
549 case DMUS_FOURCC_CONTAINED_ALIAS_CHUNK: {
550 TRACE_(dmfile)(": alias chunk\n");
551 pNewEntry->wszAlias = HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, Chunk.dwSize);
552 IStream_Read (pStm, pNewEntry->wszAlias, Chunk.dwSize, NULL);
553 TRACE_(dmdump)(": alias: %s\n", debugstr_w(pNewEntry->wszAlias));
554 break;
555 }
556 case DMUS_FOURCC_CONTAINED_OBJECT_CHUNK: {
557 DMUS_IO_CONTAINED_OBJECT_HEADER tmpObjectHeader;
558 TRACE_(dmfile)(": contained object header chunk\n");
559 IStream_Read (pStm, &tmpObjectHeader, Chunk.dwSize, NULL);
560 TRACE_(dmdump)(": contained object header:\n%s\n", debugstr_DMUS_IO_CONTAINED_OBJECT_HEADER(&tmpObjectHeader));
561 /* copy guidClass */
562 pNewEntry->Desc.dwValidData |= DMUS_OBJ_CLASS;
563 pNewEntry->Desc.guidClass = tmpObjectHeader.guidClassID;
564 /* store flags */
565 pNewEntry->dwFlags = tmpObjectHeader.dwFlags;
566 break;
567 }
568 /* now read data... it may be safe to read everything after object header chunk,
569 but I'm not comfortable with MSDN's "the header is *normally* followed by ..." */
570 case FOURCC_LIST: {
571 IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL);
572 TRACE_(dmfile)(": LIST chunk of type %s", debugstr_fourcc(Chunk.fccID));
573 ListSize[2] = Chunk.dwSize - sizeof(FOURCC);
574 ListCount[2] = 0;
575 switch (Chunk.fccID) {
576 case DMUS_FOURCC_REF_LIST: {
577 TRACE_(dmfile)(": reference list\n");
578 pNewEntry->bIsRIFF = 0;
579 do {
580 IStream_Read (pStm, &Chunk, sizeof(FOURCC)+sizeof(DWORD), NULL);
581 ListCount[2] += sizeof(FOURCC) + sizeof(DWORD) + Chunk.dwSize;
582 TRACE_(dmfile)(": %s chunk (size = 0x%08X)", debugstr_fourcc (Chunk.fccID), Chunk.dwSize);
583 switch (Chunk.fccID) {
584 case DMUS_FOURCC_REF_CHUNK: {
585 DMUS_IO_REFERENCE tmpReferenceHeader; /* temporary structure */
586 TRACE_(dmfile)(": reference header chunk\n");
587 memset (&tmpReferenceHeader, 0, sizeof(DMUS_IO_REFERENCE));
588 IStream_Read (pStm, &tmpReferenceHeader, Chunk.dwSize, NULL);
589 /* copy retrieved data to DMUS_OBJECTDESC */
590 if (!IsEqualCLSID (&pNewEntry->Desc.guidClass, &tmpReferenceHeader.guidClassID)) ERR(": object header declares different CLSID than reference header?\n");
591 /* it shouldn't be necessary to copy guidClass, since it was set in contained object header already...
592 yet if they happen to be different, I'd rather stick to this one */
593 pNewEntry->Desc.guidClass = tmpReferenceHeader.guidClassID;
594 pNewEntry->Desc.dwValidData |= tmpReferenceHeader.dwValidData;
595 break;
596 }
597 case DMUS_FOURCC_GUID_CHUNK: {
598 TRACE_(dmfile)(": guid chunk\n");
599 /* no need to set flags since they were copied from reference header */
600 IStream_Read (pStm, &pNewEntry->Desc.guidObject, Chunk.dwSize, NULL);
601 break;
602 }
603 case DMUS_FOURCC_DATE_CHUNK: {
604 TRACE_(dmfile)(": file date chunk\n");
605 /* no need to set flags since they were copied from reference header */
606 IStream_Read (pStm, &pNewEntry->Desc.ftDate, Chunk.dwSize, NULL);
607 break;
608 }
609 case DMUS_FOURCC_NAME_CHUNK: {
610 TRACE_(dmfile)(": name chunk\n");
611 /* no need to set flags since they were copied from reference header */
612 IStream_Read (pStm, pNewEntry->Desc.wszName, Chunk.dwSize, NULL);
613 break;
614 }
615 case DMUS_FOURCC_FILE_CHUNK: {
616 TRACE_(dmfile)(": file name chunk\n");
617 /* no need to set flags since they were copied from reference header */
618 IStream_Read (pStm, pNewEntry->Desc.wszFileName, Chunk.dwSize, NULL);
619 break;
620 }
621 case DMUS_FOURCC_CATEGORY_CHUNK: {
622 TRACE_(dmfile)(": category chunk\n");
623 /* no need to set flags since they were copied from reference header */
624 IStream_Read (pStm, pNewEntry->Desc.wszCategory, Chunk.dwSize, NULL);
625 break;
626 }
627 case DMUS_FOURCC_VERSION_CHUNK: {
628 TRACE_(dmfile)(": version chunk\n");
629 /* no need to set flags since they were copied from reference header */
630 IStream_Read (pStm, &pNewEntry->Desc.vVersion, Chunk.dwSize, NULL);
631 break;
632 }
633 default: {
634 TRACE_(dmfile)(": unknown chunk (skipping)\n");
635 liMove.QuadPart = Chunk.dwSize;
636 IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); /* skip this chunk */
637 break;
638 }
639 }
640 TRACE_(dmfile)(": ListCount[2] = 0x%08X < ListSize[2] = 0x%08X\n", ListCount[2], ListSize[2]);
641 } while (ListCount[2] < ListSize[2]);
642 break;
643 }
644 default: {
645 TRACE_(dmfile)(": unexpected chunk; loading failed)\n");
646 return E_FAIL;
647 }
648 }
649 break;
650 }
651
652 case FOURCC_RIFF: {
653 IStream_Read (pStm, &Chunk.fccID, sizeof(FOURCC), NULL);
654 TRACE_(dmfile)(": RIFF chunk of type %s", debugstr_fourcc(Chunk.fccID));
655 if (IS_VALID_DMFORM (Chunk.fccID)) {
656 TRACE_(dmfile)(": valid DMUSIC form\n");
657 pNewEntry->bIsRIFF = 1;
658 /* we'll have to skip whole RIFF chunk after SetObject is called */
659 liMove.QuadPart = 0;
660 IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, &uliPos);
661 uliPos.QuadPart += (Chunk.dwSize - sizeof(FOURCC)); /* set uliPos at the end of RIFF chunk */
662 /* move at the beginning of RIFF chunk */
663 liMove.QuadPart = 0;
664 liMove.QuadPart -= (sizeof(FOURCC)+sizeof(DWORD)+sizeof(FOURCC));
665 IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
666 /* put pointer to stream in descriptor */
667 pNewEntry->Desc.dwValidData |= DMUS_OBJ_STREAM;
668 pNewEntry->Desc.pStream = pStm; /* we don't have to worry about cloning, since SetObject will perform it */
669 /* wait till we get on the end of object list */
670 } else {
671 TRACE_(dmfile)(": invalid DMUSIC form (skipping)\n");
672 liMove.QuadPart = Chunk.dwSize - sizeof(FOURCC);
673 IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
674 /* FIXME: should we return E_FAIL? */
675 }
676 break;
677 }
678 default: {
679 TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
680 liMove.QuadPart = Chunk.dwSize;
681 IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
682 break;
683 }
684 }
685 TRACE_(dmfile)(": ListCount[1] = 0x%08X < ListSize[1] = 0x%08X\n", ListCount[1], ListSize[1]);
686 } while (ListCount[1] < ListSize[1]);
687 /* SetObject: this will fill descriptor with additional info and add alias in loader's cache */
688 IDirectMusicLoader_SetObject (pLoader, &pNewEntry->Desc);
689 /* now that SetObject collected appropriate info into descriptor we can live happily ever after;
690 or not, since we have to clean evidence of loading through stream... *sigh*
691 and we have to skip rest of the chunk, if we loaded through RIFF */
692 if (pNewEntry->bIsRIFF) {
693 liMove.QuadPart = uliPos.QuadPart;
694 IStream_Seek (pStm, liMove, STREAM_SEEK_SET, NULL);
695 pNewEntry->Desc.dwValidData &= ~DMUS_OBJ_STREAM; /* clear flag (and with bitwise complement) */
696 pNewEntry->Desc.pStream = NULL;
697 }
698 /* add entry to list of objects */
699 list_add_tail (This->pContainedObjects, &pNewEntry->entry);
700 break;
701 }
702 default: {
703 TRACE_(dmfile)(": unknown (skipping)\n");
704 liMove.QuadPart = Chunk.dwSize - sizeof(FOURCC);
705 IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
706 break;
707 }
708 }
709 break;
710 }
711 default: {
712 TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
713 liMove.QuadPart = Chunk.dwSize;
714 IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
715 break;
716 }
717 }
718 TRACE_(dmfile)(": ListCount[0] = 0x%08X < ListSize[0] = 0x%08X\n", ListCount[0], ListSize[0]);
719 } while (ListCount[0] < ListSize[0]);
720 break;
721 }
722 default: {
723 TRACE_(dmfile)(": unknown (skipping)\n");
724 liMove.QuadPart = Chunk.dwSize - sizeof(FOURCC);
725 IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
726 break;
727 }
728 }
729 break;
730 }
731 default: {
732 TRACE_(dmfile)(": unknown chunk (irrelevant & skipping)\n");
733 liMove.QuadPart = Chunk.dwSize;
734 IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL);
735 break;
736 }
737 }
738 TRACE_(dmfile)(": StreamCount[0] = 0x%08X < StreamSize[0] = 0x%08X\n", StreamCount, StreamSize);
739 } while (StreamCount < StreamSize);
740 break;
741 }
742 default: {
743 TRACE_(dmfile)(": unexpected chunk; loading failed)\n");
744 liMove.QuadPart = StreamSize;
745 IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); /* skip the rest of the chunk */
746 return E_FAIL;
747 }
748 }
749 TRACE_(dmfile)(": reading finished\n");
750 This->dmobj.desc.dwValidData |= DMUS_OBJ_LOADED;
751 break;
752 }
753 default: {
754 TRACE_(dmfile)(": unexpected chunk; loading failed)\n");
755 liMove.QuadPart = Chunk.dwSize;
756 IStream_Seek (pStm, liMove, STREAM_SEEK_CUR, NULL); /* skip the rest of the chunk */
757 return E_FAIL;
758 }
759 }
760
761 /* now, if DMUS_CONTAINER_NOLOADS is not set, we are supposed to load contained objects;
762 so when we call GetObject later, they'll already be in cache */
763 if (!(This->Header.dwFlags & DMUS_CONTAINER_NOLOADS)) {
764 struct list *pEntry;
765 LPWINE_CONTAINER_ENTRY pContainedObject;
766
767 TRACE(": DMUS_CONTAINER_NOLOADS not set... load all objects\n");
768
769 LIST_FOR_EACH (pEntry, This->pContainedObjects) {
770 IDirectMusicObject* pObject;
771 pContainedObject = LIST_ENTRY (pEntry, WINE_CONTAINER_ENTRY, entry);
772 /* get object from loader and then release it */
773 if (SUCCEEDED(IDirectMusicLoader_GetObject (pLoader, &pContainedObject->Desc, &IID_IDirectMusicObject, (LPVOID*)&pObject))) {
774 pContainedObject->pObject = pObject; /* for final release */
775 IDirectMusicObject_Release (pObject); /* we don't really need this one */
776 } else {
777 WARN(": failed to load contained object\n");
778 result = DMUS_S_PARTIALLOAD;
779 }
780 }
781 }
782
783 IDirectMusicLoader_Release (pLoader); /* release loader */
784
785 #if 0
786 /* DEBUG: dumps whole container object tree: */
787 if (TRACE_ON(dmloader)) {
788 int r = 0;
789 LPWINE_CONTAINER_ENTRY tmpEntry;
790 struct list *listEntry;
791
792 TRACE("*** IDirectMusicContainer (%p) ***\n", This->ContainerVtbl);
793 TRACE(" - Objects:\n");
794 LIST_FOR_EACH (listEntry, This->pContainedObjects) {
795 tmpEntry = LIST_ENTRY( listEntry, WINE_CONTAINER_ENTRY, entry );
796 TRACE(" - Object[%i]:\n", r);
797 TRACE(" - wszAlias: %s\n", debugstr_w(tmpEntry->wszAlias));
798 TRACE(" - Object descriptor:\n%s\n", debugstr_DMUS_OBJECTDESC(&tmpEntry->Desc));
799 r++;
800 }
801 }
802 #endif
803
804 return result;
805 }
806
807 static const IPersistStreamVtbl persiststream_vtbl = {
808 dmobj_IPersistStream_QueryInterface,
809 dmobj_IPersistStream_AddRef,
810 dmobj_IPersistStream_Release,
811 dmobj_IPersistStream_GetClassID,
812 unimpl_IPersistStream_IsDirty,
813 IPersistStreamImpl_Load,
814 unimpl_IPersistStream_Save,
815 unimpl_IPersistStream_GetSizeMax
816 };
817
818 /* for ClassFactory */
819 HRESULT WINAPI create_dmcontainer(REFIID lpcGUID, void **ppobj)
820 {
821 IDirectMusicContainerImpl* obj;
822 HRESULT hr;
823
824 obj = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(IDirectMusicContainerImpl));
825 if (NULL == obj) {
826 *ppobj = NULL;
827 return E_OUTOFMEMORY;
828 }
829 obj->IDirectMusicContainer_iface.lpVtbl = &dmcontainer_vtbl;
830 obj->ref = 1;
831 dmobject_init(&obj->dmobj, &CLSID_DirectMusicContainer,
832 (IUnknown*)&obj->IDirectMusicContainer_iface);
833 obj->dmobj.IDirectMusicObject_iface.lpVtbl = &dmobject_vtbl;
834 obj->dmobj.IPersistStream_iface.lpVtbl = &persiststream_vtbl;
835 obj->pContainedObjects = HeapAlloc (GetProcessHeap (), HEAP_ZERO_MEMORY, sizeof(struct list));
836 list_init (obj->pContainedObjects);
837
838 lock_module();
839
840 hr = IDirectMusicContainer_QueryInterface(&obj->IDirectMusicContainer_iface, lpcGUID, ppobj);
841 IDirectMusicContainer_Release(&obj->IDirectMusicContainer_iface);
842
843 return hr;
844 }
Windows API implementation