?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Ownerdraw buttons should erase themselves in WM_ERASEBKGND.
[wine.git] / dlls / dmusic / helper.c
blobef2f90fcb8b9e69562ed4d279d43317f95bf06d6
1 /* Helper functions for dmusic file handling
2 *
3 * Copyright (C) 2003 Rok Mandeljc
4 *
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License as published by
7 * the Free Software Foundation; either version 2 of the License, or
8 * (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
13 * GNU Library General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18 */
19 #if 0
20 #include <stdarg.h>
21
22 #include "windef.h"
23 #include "winbase.h"
24 #include "winuser.h"
25 #include "wingdi.h"
26 #include "wine/debug.h"
27 #include "wine/unicode.h"
28
29 #include "dmusic_private.h"
30
31 /* used while still in testing */
32 WINE_DEFAULT_DEBUG_CHANNEL(dmfile);
33 WINE_DECLARE_DEBUG_CHANNEL(dmfiledat);
34
35 /******************************************************************************
36 * DMUSIC_FillUNFOFromFileHandle:
37 * - fills a UNFO_List struct (dmusic_private.h) with data from file handle.
38 * - IMPORTANT: it expects a LIST chunk at beginning, so if you are calling it
39 * from another DMUSIC_Fill* function, make sure pointer is at
40 * correct place!
41 */
42 HRESULT WINAPI DMUSIC_FillUNFOFromFileHandle (UNFO_List UNFO, HANDLE fd)
43 {
44 rawChunk chunk;
45 DWORD BytesRead, ListCount = 0, ListSize;
46
47 TRACE("reading 'LIST' chunk...\n");
48 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL); /* read 'LIST' */
49 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL); /* read size of 'LIST' chunk */
50 if (chunk.id == FOURCC_LIST && ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL) && chunk.id == DMUS_FOURCC_UNFO_LIST) {
51 TRACE("'UNFO': UNFO list\n");
52 ListSize = chunk.size - sizeof(FOURCC); /* list contents size is same as size of LIST chunk - size of following field ID*/
53 do {
54 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL); /* read ID of following field */
55 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL); /* read size of following field */
56 ListCount += chunk.size + sizeof(DWORD) + sizeof(FOURCC);
57 switch (chunk.id)
58 {
59 case DMUS_FOURCC_UNAM_CHUNK: {
60 TRACE("'UNAM': name\n");
61 UNFO.name = (WCHAR*) HeapAlloc (GetProcessHeap (), 0, chunk.size); /* allocate space */
62 ReadFile (fd, UNFO.name, chunk.size, &BytesRead, NULL);
63 TRACE_(dmfiledat)("=> name = %s\n", debugstr_w(UNFO.name));
64 break;
65 } case DMUS_FOURCC_UART_CHUNK: {
66 TRACE("'UART': artist\n");
67 UNFO.artist = (WCHAR*) HeapAlloc (GetProcessHeap (), 0, chunk.size); /* allocate space */
68 ReadFile (fd, UNFO.artist, chunk.size, &BytesRead, NULL);
69 TRACE_(dmfiledat)("artist = %s\n", debugstr_w(UNFO.artist));
70 break;
71 } case DMUS_FOURCC_UCOP_CHUNK: {
72 TRACE("'UCOP': copyright\n");
73 UNFO.copyright = (WCHAR*) HeapAlloc (GetProcessHeap (), 0, chunk.size); /* allocate space */
74 ReadFile (fd, UNFO.copyright, chunk.size, &BytesRead, NULL);
75 TRACE_(dmfiledat)("=> copyright = %s\n", debugstr_w(UNFO.copyright));
76 break;
77 } case DMUS_FOURCC_USBJ_CHUNK:{
78 TRACE("'USBJ': subject\n");
79 UNFO.subject = (WCHAR*) HeapAlloc (GetProcessHeap (), 0, chunk.size); /* allocate space */
80 ReadFile (fd, UNFO.subject, chunk.size, &BytesRead, NULL);
81 TRACE_(dmfiledat)("=> subject = %s\n", debugstr_w(UNFO.subject));
82 break;
83 } case DMUS_FOURCC_UCMT_CHUNK: {
84 TRACE("'UCMT': comment\n");
85 UNFO.comment = (WCHAR*) HeapAlloc (GetProcessHeap (), 0, chunk.size); /* allocate space */
86 ReadFile (fd, UNFO.comment, chunk.size, &BytesRead, NULL);
87 TRACE_(dmfiledat)("=> comment = %s\n", debugstr_w(UNFO.comment));
88 break;
89 } default: {
90 WARN("invalid chunk (only 'UNAM', 'UART', 'UCOP', 'USBJ', 'UCMT' allowed)\n");
91 break;
92 }
93 }
94 TRACE("ListCount (%ld) < ListSize(%ld)\n", ListCount, ListSize);
95 } while (ListCount < ListSize);
96 } else {
97 WARN("'UNFO' not found: not an UNFO list\n");
98 }
99 return S_OK;
100 }
101
102 /******************************************************************************
103 * DMUSIC_FillReferenceFromFileHandle:
104 * - fills a Reference struct (dmusic_private.h) with data from file handle.
105 * - IMPORTANT: it expects a LIST chunk at beginning, so if you are calling it
106 * from another DMUSIC_Fill* function, make sure pointer is at
107 * correct place!
108 */
109 HRESULT WINAPI DMUSIC_FillReferenceFromFileHandle (Reference reference, HANDLE fd)
110 {
111 rawChunk chunk;
112 DWORD BytesRead, ListCount = 0, ListSize;
113
114 TRACE("reading 'LIST' chunk...\n");
115 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL); /* read 'LIST' */
116 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL); /* read size of 'LIST' chunk */
117 if (chunk.id == FOURCC_LIST && ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL) && chunk.id == DMUS_FOURCC_REF_LIST) {
118 TRACE("'DMRF': reference list\n");
119 ListSize = chunk.size - sizeof(FOURCC); /* list contents size is same as size of LIST chunk - size of following field ID*/
120 do {
121 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL); /* read ID of following field */
122 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL); /* read size of following field */
123 ListCount += chunk.size + sizeof(DWORD) + sizeof(FOURCC);
124 switch (chunk.id)
125 {
126 case DMUS_FOURCC_REF_CHUNK: {
127 TRACE("'refh': reference header\n");
128 ReadFile (fd, &reference.header, chunk.size, &BytesRead, NULL);
129 TRACE_(dmfiledat)("=> guidClassID = %s; dwValidData = %ld\n", debugstr_guid (&reference.header.guidClassID), reference.header.dwValidData);
130 break;
131 } case DMUS_FOURCC_GUID_CHUNK: {
132 TRACE("'guid': GUID\n");
133 ReadFile (fd, &reference.guid, chunk.size, &BytesRead, NULL);
134 TRACE_(dmfiledat)("=> GUID = %s\n", debugstr_guid (&reference.guid));
135 break;
136 } case DMUS_FOURCC_DATE_CHUNK: {
137 TRACE("'date': file date\n");
138 ReadFile (fd, &reference.date, chunk.size, &BytesRead, NULL);
139 TRACE_(dmfiledat)("=> file date = %ld%ld\n", reference.date.dwHighDateTime, reference.date.dwLowDateTime);
140 break;
141 } case DMUS_FOURCC_NAME_CHUNK: {
142 TRACE("'name': name\n");
143 reference.name = (WCHAR*) HeapAlloc (GetProcessHeap (), 0, chunk.size);
144 ReadFile (fd, reference.name, chunk.size, &BytesRead, NULL);
145 TRACE_(dmfiledat)("=> name = %s\n", debugstr_w (reference.name));
146 break;
147 } case DMUS_FOURCC_FILE_CHUNK: {
148 TRACE("'file': file name\n");
149 reference.file = (WCHAR*) HeapAlloc (GetProcessHeap (), 0, chunk.size);
150 ReadFile (fd, reference.file, chunk.size, &BytesRead, NULL);
151 TRACE_(dmfiledat)("=> file name = %s\n", debugstr_w (reference.file));
152 break;
153 } case DMUS_FOURCC_CATEGORY_CHUNK: {
154 TRACE("'catg': category\n");
155 reference.category = (WCHAR*) HeapAlloc (GetProcessHeap (), 0, chunk.size);
156 ReadFile (fd, reference.category, chunk.size, &BytesRead, NULL);
157 TRACE_(dmfiledat)("=> category = %s\n", debugstr_w (reference.category));
158 break;
159 } case DMUS_FOURCC_VERSION_CHUNK: {
160 TRACE("'vers': version\n");
161 ReadFile (fd, &reference.version, sizeof(DMUS_IO_VERSION), &BytesRead, NULL);
162 TRACE_(dmfiledat)("=> version = %ld%ld\n", reference.version.dwVersionMS, reference.version.dwVersionLS);
163 break;
164 } default: {
165 WARN("invalid chunk (only 'refh, 'guid', 'date', 'name', 'file', 'catg', 'vers' allowed\n");
166 break;
167 }
168 }
169 TRACE("ListCount (%ld) < ListSize (%ld)\n", ListCount, ListSize);
170 } while (ListCount < ListSize);
171 }
172
173 return S_OK;
174 }
175
176 /******************************************************************************
177 * DMUSIC_FillBandFromFileHandle:
178 * - fills a IDirectMusicBandImpl struct with data from file handle.
179 * - IMPORTANT: it expects a RIFF chunk at beginning, so if you are calling it
180 * from another DMUSIC_Fill* function, make sure pointer is at
181 * correct place!
182 * - TODO: replace data in function with data in IDirectMusicBandImpl
183 */
184 HRESULT WINAPI DMUSIC_FillBandFromFileHandle (IDirectMusicBandImpl *band, HANDLE fd)
185 {
186 rawChunk chunk;
187 DWORD BytesRead, ListCount = 0, ListSize, ListCount2 = 0, ListSize2, FileCount = 0, FileSize;
188 /* FIXME: Replace stuff located below with the stuff in band */
189 UNFO_List UNFO;
190 DMUS_IO_VERSION version;
191 GUID guid;
192 /* only in singular form for time being */
193 DMUS_IO_INSTRUMENT header;
194 Reference reference;
195
196 TRACE("reading 'RIFF' chunk...\n");
197 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL); /* read 'RIFF' */
198 if (chunk.id == FOURCC_RIFF) {
199 TRACE("'RIFF': RIFF file\n");
200 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL); /* read size of 'RIFF' chunk */
201 FileSize = chunk.size - sizeof(FOURCC); /* file content size = size of 'RIFF' chunk - FOURCC ID of following form */
202 TRACE("reading chunks ...\n");
203 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL); /* read ID of following form */
204 if (chunk.id == DMUS_FOURCC_BAND_FORM) {
205 TRACE("'DMBD': band form\n");
206 do {
207 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
208 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL);
209 FileCount += chunk.size + sizeof(DWORD) + sizeof(FOURCC);
210 switch (chunk.id)
211 {
212 case DMUS_FOURCC_GUID_CHUNK: {
213 TRACE("'guid': GUID\n");
214 ReadFile (fd, &guid, chunk.size, &BytesRead, NULL);
215 TRACE_(dmfiledat)("=> GUID = %s\n", debugstr_guid(&guid));
216 break;
217 } case DMUS_FOURCC_VERSION_CHUNK: {
218 TRACE("'vers': version\n");
219 ReadFile (fd, &version, chunk.size, &BytesRead, NULL);
220 TRACE_(dmfiledat)("=> version = %ld%ld\n", version.dwVersionMS, version.dwVersionLS);
221 break;
222 } case FOURCC_LIST:{
223 TRACE("'LIST': list chunk (size = %ld)\n", chunk.size);
224 ListSize = chunk.size - sizeof(FOURCC); /* list content size = size of 'LIST' chunk - FOURCC ID of the list */
225 ListCount = 0; /* reset */
226 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL); /* read list ID */
227 switch (chunk.id)
228 {
229 case DMUS_FOURCC_UNFO_LIST: {
230 TRACE("'UNFO': UNFO list (content size = %ld)\n", ListSize);
231 SetFilePointer (fd, -(sizeof(DWORD) + 2*sizeof(FOURCC)), NULL, FILE_CURRENT); /* set pointer at beginning of list */
232 DMUSIC_FillUNFOFromFileHandle (UNFO, fd); /* forward to DMUSIC_FillUNFOFromFileHandle */
233 break;
234 } case DMUS_FOURCC_INSTRUMENTS_LIST: {
235 TRACE("'lbil': instrumets list (content size = %ld)\n", ListSize);
236 do {
237 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
238 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL);
239 ListCount += sizeof(FOURCC) + sizeof(DWORD) + chunk.size;
240 if (chunk.id == FOURCC_LIST && ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL) && chunk.id == DMUS_FOURCC_INSTRUMENT_LIST) {
241 ListSize2 = chunk.size - sizeof(FOURCC); /* list content size = size of 'LIST' chunk - FOURCC ID of the list */
242 ListCount2 = 0; /* reset */
243 TRACE("'lbin': instrument (size = %ld)\n", ListSize2);
244 do {
245 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
246 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL);
247 ListCount2 += sizeof(FOURCC) + sizeof(DWORD) + chunk.size;
248 switch (chunk.id)
249 {
250 case DMUS_FOURCC_INSTRUMENT_CHUNK: {
251 TRACE("'bins': instrument header\n");
252 ReadFile (fd, &header, chunk.size, &BytesRead, NULL);
253 TRACE_(dmfiledat)("=> dwPatch = %ld; dwAssignPatch = %ld; dwPChannel = %ld; dwFlags = %ld; bPan = %i; bVolume = %i; nTranspose = %i; dwChannelPriority = %ld; nPitchBendRange = %i", \
254 header.dwPatch, header.dwAssignPatch, header.dwPChannel, header.dwFlags, header.bPan, header.bVolume, header.nTranspose, header.dwChannelPriority, header.nPitchBendRange);
255 break;
256 } case FOURCC_LIST: {
257 TRACE("'LIST': list chunk (size = %ld)\n", chunk.size);
258 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
259 if (chunk.id == DMUS_FOURCC_REF_LIST) {
260 TRACE("'DMRF': reference list (size = %ld)\n", chunk.size - 4); /* set pointer at beginning of list */
261 SetFilePointer (fd, -(sizeof(DWORD) + 2*sizeof(FOURCC)), NULL, FILE_CURRENT);
262 DMUSIC_FillReferenceFromFileHandle (reference, fd); /* forward to DMUSIC_FillReferenceFromFileHandle */
263 } else WARN("invalid chunk (only 'DMRF' chunk allowed\n");
264 break;
265 } default: {
266 WARN("invalid chunk (only 'bins' and 'LIST' chunks allowed\n");
267 break;
268 }
269 }
270 TRACE("ListCount2 (%ld) < ListSize2 (%ld)\n", ListCount2, ListSize2);
271 } while (ListCount2 < ListSize2);
272 } else WARN("invalid chunk (only 'lbin' chunk allowed)\n");
273 TRACE("ListCount (%ld) < ListSize (%ld)\n", ListCount, ListSize);
274 } while (ListCount < ListSize);
275 break;
276 } default: {
277 WARN("invalid chunk (only 'UNFO' and 'lbil' chunks allowed\n");
278 break;
279 }
280 }
281 break;
282 } default: {
283 WARN("invalid chunk (only 'guid', 'vers' and 'LIST' chunks allowed)\n");
284 break;
285 }
286 }
287 TRACE("FileCount (%ld) < FileSize (%ld)\n", FileCount, FileSize);
288 } while (FileCount < FileSize);
289 }
290 } else {
291 WARN("'RIFF' not found: not a RIFF file\n");
292 }
293
294 return S_OK;
295 }
296
297 /******************************************************************************
298 * DMUSIC_FillTrackFromFileHandle:
299 * - fills a IDirectMusicTrack8Impl struct with data from file handle.
300 * - IMPORTANT: it expects a RIFF chunk at beginning, so if you are calling it
301 * from another DMUSIC_Fill* function, make sure pointer is at
302 * correct place!
303 * - TODO: replace data in function with data in IDirectMusicTrackImpl
304 * implement loading for missing (empty) clauses
305 * fix a problem with tempo track loading (look at code)
306 */
307 HRESULT WINAPI DMUSIC_FillTrackFromFileHandle (IDirectMusicTrack8Impl *segment, HANDLE fd)
308 {
309 rawChunk chunk;
310 DWORD BytesRead, ListCount = 0, ListCount2 = 0, ListCount3 = 0, ListCount4 = 0, \
311 ListSize, ListSize2, ListSize3, ListSize4, FileCount = 0, FileSize, FileCount2 = 0, FileSize2 /* *2s, *3s and *4s are for various subchunks */;
312 int i;
313
314 /* general track info */
315 DMUS_IO_TRACK_HEADER header;
316 DMUS_IO_TRACK_EXTRAS_HEADER extheader;
317 GUID guid;
318 DMUS_IO_VERSION version;
319 UNFO_List UNFO;
320 /* tempo track stuff */
321 DMUS_IO_TEMPO_ITEM tempo;
322 /* chord track stuff */
323 DWORD chordHeader;
324 ChordData chordData;
325 /* command track stuff */
326 DMUS_IO_COMMAND command;
327 /* sytle list stuff (support only 1 while still in parse development mode)*/
328 DWORD timestamp;
329 Reference reference;
330 /* band track stuff */
331 BandTrack bandTrack;
332 /* wave track stuff (only singular) */
333 WaveTrack waveTrack;
334 /* segment trigger track stuff */
335 SegTriggerTrack segTriggerTrack;
336 /* time signature track stuff */
337 TimeSigTrack timeSigTrack;
338 /* script track list stuff */
339 ScriptEvent event;
340
341 TRACE("reading 'RIFF' chunk...\n");
342 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
343 if (chunk.id == FOURCC_RIFF) {
344 TRACE ("'RIFF': RIFF file\n");
345 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL); /* read size of 'RIFF' chunk */
346 FileSize = chunk.size - sizeof(FOURCC); /* file content size = size of 'RIFF' chunk - FOURCC ID of following form */
347 TRACE("reading chunks ...\n");
348 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL); /* read ID of following form */
349 if (chunk.id == DMUS_FOURCC_TRACK_FORM) {
350 TRACE("'DMTK': track form\n");
351 do {
352 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
353 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL);
354 FileCount += chunk.size + sizeof(DWORD) + sizeof(FOURCC);
355 switch (chunk.id)
356 {
357 case DMUS_FOURCC_TRACK_CHUNK: {
358 TRACE("'trkh': track header\n");
359 ReadFile (fd, &header, chunk.size, &BytesRead, NULL);
360 TRACE_(dmfiledat)("=> track guidClassID = %s; dwPosition = %ld; dwGroup = %ld; ckid = %ld; fccType = %ld\n", \
361 debugstr_guid (&header.guidClassID), header.dwPosition, header.dwGroup, header.ckid, header.fccType);
362 break;
363 } case DMUS_FOURCC_TRACK_EXTRAS_CHUNK: {
364 TRACE("'trkx': extra track flags\n");
365 ReadFile (fd, &extheader, chunk.size, &BytesRead, NULL);
366 TRACE_(dmfiledat)("=> dwFlags = %ld; dwPriority = %ld\n", extheader.dwFlags,
367 extheader.dwPriority);
368 break;
369 } case DMUS_FOURCC_GUID_CHUNK: {
370 TRACE("'guid': GUID\n");
371 ReadFile (fd, &guid, chunk.size, &BytesRead, NULL);
372 TRACE_(dmfiledat)("=> GUID = %s\n", debugstr_guid(&guid));
373 break;
374 } case DMUS_FOURCC_VERSION_CHUNK: {
375 TRACE("'vers': version\n");
376 ReadFile (fd, &version, chunk.size, &BytesRead, NULL);
377 TRACE_(dmfiledat)("=> version = %ld%ld\n", version.dwVersionMS, version.dwVersionLS);
378 break;
379 } case FOURCC_LIST:{
380 TRACE("'LIST': list (size = %ld)\n", chunk.size);
381 ListSize = chunk.size - sizeof(FOURCC); /* list content size = size of 'LIST' chunk - FOURCC ID of the list */
382 ListCount = 0; /* reset */
383 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
384 switch (chunk.id)
385 {
386 case DMUS_FOURCC_UNFO_LIST: {
387 TRACE("'UNFO': UNFO list (forward to DMUSIC_FillUNFOFromFileHandle(...))\n");
388 SetFilePointer (fd, -(sizeof(DWORD) + 2*sizeof(FOURCC)), NULL, FILE_CURRENT); /* place pointer before the 'LIST' chunk */
389 DMUSIC_FillUNFOFromFileHandle (UNFO, fd); /* forward to DMUSIC_FillUNFOFromFileHandle */
390 break;
391 } case DMUS_FOURCC_CHORDTRACK_LIST: {
392 TRACE("'cord': chord track list\n");
393 do {
394 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
395 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL);
396 ListCount += sizeof(FOURCC) + sizeof(DWORD) + chunk.size;
397 switch (chunk.id)
398 {
399 case DMUS_FOURCC_CHORDTRACKHEADER_CHUNK: {
400 TRACE("'crdh': chord header\n");
401 ReadFile (fd, &chordHeader, chunk.size, &BytesRead, NULL);
402 TRACE_(dmfiledat)("=> chord root = %i; scale = %i\n", (chordHeader && 0xFF000000) >> 24, chordHeader && 0x00FFFFFF);
403 break;
404 } case DMUS_FOURCC_CHORDTRACKBODY_CHUNK: {
405 TRACE("'crdb': chord body\n");
406 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL); /* read sizeof (DMUS_IO_CHORD) */
407 ReadFile (fd, &chordData.chord, chunk.size, &BytesRead, NULL); /* read DMUS_IO_CHORD */
408 TRACE_(dmfiledat)("=> wszName[16] = %s; mtTime = %li; chord.wMeasure = %d; chord.bBeat = %i; bFlags = %i\n", \
409 debugstr_w (chordData.chord.wszName), chordData.chord.mtTime, chordData.chord.wMeasure, chordData.chord.bBeat, chordData.chord.bFlags);
410 ReadFile (fd, &chordData.nrofsubchords, sizeof(DWORD), &BytesRead, NULL); /* read number of subchords */
411 TRACE_(dmfiledat)("=> number of subchords = %ld\n", chordData.nrofsubchords);
412 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL); /* read sizeof (DMUS_IO_SUBCHORD) */
413 chordData.subchord = (DMUS_IO_SUBCHORD*) HeapAlloc (GetProcessHeap (), 0, sizeof(DMUS_IO_SUBCHORD) * chordData.nrofsubchords); /* allocate space */
414 for (i = 0; i < chordData.nrofsubchords; i++)
415 {
416 TRACE_(dmfiledat)("=> subchord[%i]: dwChordPattern = %ld; dwScalePattern = %ld; dwInversionPoints = %ld; dwLevels = %ld; bChordRoot = %i; bScaleRoot = %i\n", \
417 i, chordData.subchord[i].dwChordPattern, chordData.subchord[i].dwScalePattern, chordData.subchord[i].dwInversionPoints, chordData.subchord[i].dwLevels, \
418 chordData.subchord[i].bChordRoot, chordData.subchord[i].bScaleRoot);
419 }
420 ReadFile (fd, chordData.subchord, chunk.size*chordData.nrofsubchords, &BytesRead, NULL);
421 break;
422 } default: {
423 WARN("Invalid chunk (only 'crdh' and 'crdb' chunks allowed)\n");
424 break;
425 }
426 }
427 TRACE("ListCount (%ld) < ListSize (%ld)\n", ListCount, ListSize);
428 } while (ListCount < ListSize);
429 break;
430 } case DMUS_FOURCC_STYLE_TRACK_LIST: {
431 TRACE("'sttr': style track list\n");
432 do {
433 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
434 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL);
435 ListCount += sizeof(FOURCC) + sizeof(DWORD) + chunk.size;
436 if (chunk.id == FOURCC_LIST && ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL) && chunk.id == DMUS_FOURCC_STYLE_REF_LIST) {
437 ListSize2 = chunk.size - sizeof(FOURCC);
438 ListCount2 = 0;
439 TRACE("'strf': style reference list (size = %ld)\n", ListSize2);
440 do {
441
442 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
443 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL);
444 ListCount2 += sizeof(FOURCC) + sizeof(DWORD) + chunk.size;
445 switch (chunk.id)
446 {
447 case DMUS_FOURCC_TIME_STAMP_CHUNK: {
448 TRACE("'stmp': time stamp\n");
449 ReadFile (fd, &timestamp, chunk.size, &BytesRead, NULL);
450 TRACE_(dmfiledat)("=> time stamp = %ld\n", timestamp);
451 break;
452 } case FOURCC_LIST: {
453 TRACE("'LIST': list\n");
454 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
455 if (chunk.id == DMUS_FOURCC_REF_LIST){
456 TRACE("'DMRF': reference list (forward to DMUSIC_FillReferenceFromFileHandle(...)\n");
457 SetFilePointer (fd, -(sizeof(DWORD) + 2*sizeof(FOURCC)), NULL, FILE_CURRENT); /* place pointer before 'LIST' chunk */
458 DMUSIC_FillReferenceFromFileHandle (reference, fd);
459 } else {
460 WARN("invalid chunk (only 'DMRF' chunk allwed)\n");
461 }
462 break;
463 } default: {
464 WARN("invalid chunk (only 'stmp' and 'LIST' chunk allowed)\n");
465 break;
466 }
467 }
468 TRACE("ListCount2 (%ld) < ListSize2 (%ld)\n", ListCount2, ListSize2);
469 } while (ListCount2 < ListSize2);
470 } else {
471 WARN("invalid chunk (only 'strf' allowed)\n");
472 }
473 TRACE("ListCount (%ld) < ListSize (%ld)\n", ListCount, ListSize);
474 } while (ListCount < ListSize);
475 break;
476 } case DMUS_FOURCC_PERS_TRACK_LIST: {
477 FIXME("'pftr': chordmap track list: not supported yet\n");
478 break;
479 } case DMUS_FOURCC_LYRICSTRACK_LIST: {
480 FIXME("'lyrt': lyrics track list: not supported yet\n");
481 break;
482 } case DMUS_FOURCC_MARKERTRACK_LIST: {
483 FIXME("'MARK': marker track list: not supported yet\n");
484 break;
485 } case DMUS_FOURCC_MELODYFORM_TRACK_LIST: {
486 FIXME("'mfrm': melody formulation track list: not supported yet\n");
487 break;
488 } case DMUS_FOURCC_PARAMCONTROLTRACK_TRACK_LIST: {
489 FIXME("'prmt': parameter control track list: not supported yet\n");
490 break;
491 } case DMUS_FOURCC_SCRIPTTRACK_LIST: {
492 TRACE("'scrt': script track list\n");
493 do {
494 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
495 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL);
496 ListCount += sizeof(FOURCC) + sizeof(DWORD) + chunk.size;
497 if (chunk.id == FOURCC_LIST && ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL) && chunk.id == DMUS_FOURCC_SCRIPTTRACKEVENTS_LIST) {
498 TRACE("'scrl': script events list\n");
499 ListSize2 = chunk.size - sizeof(FOURCC); /* list content size = size of 'LIST' chunk - FOURCC ID of the list */
500 ListCount2 = 0;
501 do {
502 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
503 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL);
504 ListCount2 += sizeof(FOURCC) + sizeof(DWORD) + chunk.size;
505 if (chunk.id == FOURCC_LIST && ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL) && chunk.id == DMUS_FOURCC_SCRIPTTRACKEVENT_LIST) {
506 TRACE("'scre': script event list\n");
507 ListSize3 = chunk.size - sizeof(FOURCC); /* list content size = size of 'LIST' chunk - FOURCC ID of the list */
508 ListCount3 = 0;
509 do {
510 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
511 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL);
512 ListCount3 += sizeof(FOURCC) + sizeof(DWORD) + chunk.size;
513 switch (chunk.id)
514 {
515 case DMUS_FOURCC_SCRIPTTRACKEVENTHEADER_CHUNK: {
516 TRACE("'scrh': event header\n");
517 ReadFile (fd, &event.header, chunk.size, &BytesRead, NULL);
518 TRACE_(dmfiledat)("=> dwFlags = %ld; lTimeLogical = %li; lTimePhysical = %li\n", \
519 event.header.dwFlags, event.header.lTimeLogical, event.header.lTimePhysical);
520 break;
521 } case FOURCC_LIST: {
522 TRACE("'LIST': list\n");
523 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
524 if (chunk.id == DMUS_FOURCC_REF_LIST){
525 TRACE("'DMRF': reference list (forward to DMUSIC_FillReferenceFromFileHandle(...)\n");
526 SetFilePointer (fd, -(sizeof(DWORD) + 2*sizeof(FOURCC)), NULL, FILE_CURRENT); /* place pointer before 'LIST' chunk */
527 DMUSIC_FillReferenceFromFileHandle (event.reference, fd);
528 } else {
529 WARN("invalid chunk (only 'DMRF' chunk allwed)\n");
530 }
531 break;
532 } case DMUS_FOURCC_SCRIPTTRACKEVENTNAME_CHUNK: {
533 TRACE("'scrn': routine name\n");
534 event.name = (WCHAR*) HeapAlloc (GetProcessHeap (), 0, chunk.size);
535 ReadFile (fd, event.name, chunk.size, &BytesRead, NULL);
536 TRACE_(dmfiledat)("=> routine name = %s\n", debugstr_w (event.name));
537 break;
538 } default: {
539 WARN("invalid chunk (only 'scrh', 'scrn' and 'LIST' chunk allowed)\n");
540 break;
541 }
542 }
543 TRACE("ListCount3 (%ld) < ListSize3 (%ld)\n", ListCount3, ListSize3);
544 } while (ListCount3 < ListSize3);
545 } else {
546 WARN("invalid chunk (only 'scre' chunk allowed)\n");
547 }
548 TRACE("ListCount2 (%ld) < ListSize2 (%ld)\n", ListCount2, ListSize2);
549 } while (ListCount2 < ListSize2);
550 } else {
551 WARN("invalid chunk (only 'scrl' chunk allowed)\n");
552 }
553 TRACE("ListCount (%ld) < ListSize (%ld)\n", ListCount, ListSize);
554 } while (ListCount < ListSize);
555 break;
556 } case DMUS_FOURCC_SEGTRACK_LIST: {
557 TRACE("'segt': segment trigger track list\n");
558 do {
559 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
560 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL);
561 ListCount += sizeof(FOURCC) + sizeof(DWORD) + chunk.size;
562 switch (chunk.id)
563 {
564 case DMUS_FOURCC_SEGTRACK_CHUNK: {
565 TRACE("'sgth': segment track header\n");
566 ReadFile (fd, &segTriggerTrack.header, chunk.size, &BytesRead, NULL);
567 TRACE_(dmfiledat)("=> dwFlags = %ld\n", segTriggerTrack.header.dwFlags);
568 break;
569 } case FOURCC_LIST: {
570 TRACE("'LIST': list\n");
571 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
572 if (chunk.id == DMUS_FOURCC_SEGMENTS_LIST) {
573 TRACE("'lsgl': segment lists list\n");
574 ListSize2 = chunk.size - sizeof(FOURCC); /* list content size = size of 'LIST' chunk - FOURCC ID of the list */
575 ListCount2 = 0;
576 do {
577 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
578 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL);
579 ListCount2 += sizeof(FOURCC) + sizeof(DWORD) + chunk.size;
580 if (chunk.id == FOURCC_LIST && ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL) && chunk.id == DMUS_FOURCC_SEGMENT_LIST) {
581 ListSize3 = chunk.size - sizeof(FOURCC);
582 ListCount3 = 0;
583 do {
584 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
585 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL);
586 ListCount3 += sizeof(FOURCC) + sizeof(DWORD) + chunk.size;
587 switch (chunk.id)
588 {
589 case DMUS_FOURCC_SEGMENTITEM_CHUNK: {
590 TRACE("'sgih': segment item header\n");
591 ReadFile (fd, &segTriggerTrack.itemHeader, chunk.size, &BytesRead, NULL);
592 TRACE_(dmfiledat)("=> lTimeLogical = %li; lTimePhysical = %li; dwPlayFlags = %ld; dwFlags = %ld\n", \
593 segTriggerTrack.itemHeader.lTimeLogical, segTriggerTrack.itemHeader.lTimePhysical, \
594 segTriggerTrack.itemHeader.dwPlayFlags, segTriggerTrack.itemHeader.dwFlags);
595 break;
596 } case DMUS_FOURCC_SEGMENTITEMNAME_CHUNK: {
597 TRACE("'snam': motif name\n");
598 segTriggerTrack.motifName = (WCHAR*) HeapAlloc (GetProcessHeap (), 0, chunk.size);
599 ReadFile (fd, segTriggerTrack.motifName, chunk.size, &BytesRead, NULL);
600 TRACE_(dmfiledat)("=> motif name = %s\n", debugstr_w (segTriggerTrack.motifName));
601 break;
602 } case FOURCC_LIST: {
603 TRACE("'LIST': list\n");
604 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
605 if (chunk.id == DMUS_FOURCC_REF_LIST) {
606 TRACE("'DMRF': reference list (forward to DMUSIC_FillReferenceFromFileHandle(...)\n");
607 SetFilePointer (fd, -(sizeof(DWORD) + 2*sizeof(FOURCC)), NULL, FILE_CURRENT); /* place pointer before 'LIST' chunk */
608 DMUSIC_FillReferenceFromFileHandle (segTriggerTrack.reference, fd);
609 } else {
610 WARN("invalid chunk (only 'DMRF' chunk allowed)\n");
611 }
612 break;
613 } default: {
614 WARN("invalid chunk (only 'sgih', 'snam' and 'LIST' chunks allowed)\n");
615 break;
616 }
617 }
618 TRACE("ListCount3 (%ld) < ListSize3 (%ld)\n", ListCount3, ListSize3);
619 } while (ListCount3 < ListSize3);
620 } else {
621 WARN("invalid chunk (only 'lseg' chunk allowed)\n");
622 }
623 TRACE("ListCount2 (%ld) < ListSize2 (%ld)\n", ListCount2, ListSize2);
624 } while (ListCount2 < ListSize2);
625 } else {
626 WARN("invalid chunk (only 'lsgl' chunk allowed\n");
627 }
628 break;
629 } default: {
630 WARN("invalid chunk (only 'sgth' and 'LIST' chunks allowed)\n");
631 break;
632 }
633 }
634 TRACE("ListCount (%ld) < ListSize (%ld)\n", ListCount, ListSize);
635 } while (ListCount < ListSize);
636 break;
637 } case DMUS_FOURCC_TIMESIGTRACK_LIST: {
638 TRACE("'TIMS': time signature track list\n");
639 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
640 if (chunk.id == DMUS_FOURCC_TIMESIGNATURE_TRACK) {
641 TRACE("'tims': time signatures\n");
642 timeSigTrack.nrofitems = chunk.size - sizeof(DWORD);
643 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL);
644 if (chunk.size != sizeof(DMUS_IO_TIMESIGNATURE_ITEM))
645 WARN("there seem to be a problem: file claims that size of DMUSIC_IO_TEMPO_ITEM is %ld, while real sizeof returns %i\n", chunk.size, sizeof(DMUS_IO_TIMESIGNATURE_ITEM));
646 timeSigTrack.nrofitems /= chunk.size;
647 TRACE_(dmfiledat)("=> number of items = %ld\n", timeSigTrack.nrofitems);
648 timeSigTrack.items = (DMUS_IO_TIMESIGNATURE_ITEM*) HeapAlloc (GetProcessHeap (), 0, chunk.size * timeSigTrack.nrofitems);
649 ReadFile(fd, timeSigTrack.items, chunk.size * timeSigTrack.nrofitems, &BytesRead, NULL);
650 for (i = 0; i < timeSigTrack.nrofitems; i++)
651 {
652 TRACE_(dmfiledat)("=> time signature[%i]: lTime = %li; bBeatsPerMeasure = %i; bBeat = %i; wGridsPerBeat = %d\n", \
653 i, timeSigTrack.items[i].lTime, timeSigTrack.items[i].bBeatsPerMeasure, timeSigTrack.items[i].bBeat, timeSigTrack.items[i].wGridsPerBeat);
654 }
655 } else {
656 WARN("invalid chunk (only 'tims' chunk allowed)\n");
657 }
658 break;
659 } case DMUS_FOURCC_WAVETRACK_LIST: {
660 TRACE("'wavt': wave track list\n");
661 do {
662 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
663 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL);
664 ListCount += sizeof(FOURCC) + sizeof(DWORD) + chunk.size;
665 switch (chunk.id)
666 {
667 case DMUS_FOURCC_WAVETRACK_CHUNK: {
668 TRACE("'wath': wave track header\n");
669 ReadFile (fd, &waveTrack.header, chunk.size, &BytesRead, NULL);
670 TRACE_(dmfiledat)("=> lVolume = %li; dwFlags = %ld\n", waveTrack.header.lVolume, waveTrack.header.dwFlags);
671 break;
672 } case FOURCC_LIST: {
673 TRACE("'LIST': list\n");
674 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
675 if (chunk.id == DMUS_FOURCC_WAVEPART_LIST) {
676 TRACE("'wavp': wave parts list\n");
677 ListSize2 = chunk.size - sizeof(FOURCC);
678 ListCount2 = 0;
679 do {
680 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
681 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL);
682 ListCount2 += sizeof(FOURCC) + sizeof(DWORD) + chunk.size;
683 switch (chunk.id)
684 {
685 case DMUS_FOURCC_WAVEPART_CHUNK: {
686 TRACE("'waph': wave part header\n");
687 ReadFile (fd, &waveTrack.partHeader, chunk.size, &BytesRead, NULL);
688 TRACE_(dmfiledat)("=> lVolume = %li; dwVariations = %ld; dwPChannel = %ld; dwLockToPart = %ld; dwFlags = %ld; dwIndex = %ld\n", \
689 waveTrack.partHeader.lVolume, waveTrack.partHeader.dwVariations, waveTrack.partHeader.dwPChannel, \
690 waveTrack.partHeader.dwLockToPart, waveTrack.partHeader.dwFlags, waveTrack.partHeader.dwIndex);
691 break;
692 } case FOURCC_LIST: {
693 TRACE("'LIST': list\n");
694 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
695 if (chunk.id == DMUS_FOURCC_WAVEITEM_LIST) {
696 TRACE("'wavi': wave items list\n");
697 ListSize3 = chunk.size - sizeof(FOURCC);
698 ListCount3 = 0;
699 do {
700 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
701 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL);
702 ListCount3 += sizeof(FOURCC) + sizeof(DWORD) + chunk.size;
703 if (chunk.id == FOURCC_LIST && ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL) && chunk.id == DMUS_FOURCC_WAVE_LIST) {
704 TRACE("'wave': wave item list\n");
705 ListSize4 = chunk.size - sizeof(FOURCC); /* list content size = size of 'LIST' chunk - FOURCC ID of the list */
706 ListCount4 = 0; /* reset */
707 do {
708 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
709 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL);
710 ListCount4 += sizeof(FOURCC) + sizeof(DWORD) + chunk.size;
711 switch (chunk.id)
712 {
713 case DMUS_FOURCC_WAVEITEM_CHUNK: {
714 TRACE("'waih': wave item header\n");
715 ReadFile (fd, &waveTrack.itemHeader, chunk.size, &BytesRead, NULL);
716 TRACE_(dmfiledat)("=> lVolume = %li; lPitch = %li; dwVariations = %ld; rtTime = FIXME; rtStartOffset = FIXME; rtReserved = FIXME; rtDuration = FIXME; mtLogicalTime = %li; dwLoopStart = %ld; dwLoopEnd = %ld; dwFlags = %ld\n", \
717 waveTrack.itemHeader.lVolume, waveTrack.itemHeader.lPitch, waveTrack.itemHeader.dwVariations, /*waveTrack.itemHeader.rtTime, \
718 waveTrack.itemHeader.rtStartOffset, waveTrack.itemHeader.rtReserved, waveTrack.itemHeader.rtDuration, */waveTrack.itemHeader.mtLogicalTime, \
719 waveTrack.itemHeader.dwLoopStart, waveTrack.itemHeader.dwLoopEnd, waveTrack.itemHeader.dwFlags);
720 break;
721 } case mmioFOURCC('w','v','c','u'): {
722 FIXME("'wvcu': undocumented and unknown chunk type (skipping)\n");
723 SetFilePointer (fd, chunk.size, NULL, FILE_CURRENT); /* skip */
724 break;
725 } case FOURCC_LIST: {
726 TRACE("'LIST': list\n");
727 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
728 if (chunk.id == DMUS_FOURCC_REF_LIST) {
729 TRACE("'DMRF': reference list (forward to DMUSIC_FillReferenceFromFileHandle(...)\n");
730 SetFilePointer (fd, -(sizeof(DWORD) + 2*sizeof(FOURCC)), NULL, FILE_CURRENT); /* place pointer before 'LIST' chunk */
731 DMUSIC_FillReferenceFromFileHandle (waveTrack.reference, fd);
732 } else {
733 WARN ("invalid chunk (only 'DMRF' chunk allowed\n");
734 }
735 break;
736 } default: {
737 WARN("invalid chunk (only 'waih' and 'LIST' (and undocumented 'wvcu') chunks allowed)\n");
738 }
739 }
740 TRACE("ListCount4 (%ld) < ListSize4 (%ld)\n", ListCount4, ListSize4);
741 } while (ListCount4 < ListSize4);
742 } else {
743 WARN("invalid chunk (only 'wave' chunk allowed)\n");
744 }
745 TRACE("ListCount3 (%ld) < ListSize3 (%ld)\n", ListCount3, ListSize3);
746 } while (ListCount3 < ListSize3);
747 } else {
748 WARN("invalid chunk (only 'wavi' chunk allowed)\n");
749 }
750 break;
751 } default: {
752 WARN("invalid chunk (only 'waph' and 'LIST' chunks allowed)\n");
753 break;
754 }
755 }
756 TRACE("ListCount2 (%ld) < ListSize2 (%ld)\n", ListCount2, ListSize2);
757 } while (ListCount2 < ListSize2);
758 } else {
759 WARN("invalid chunk (only 'wavp' chunk allwed)\n");
760 }
761 break;
762 } default: {
763 WARN("invalid chunk (only 'wath' and 'LIST' chunks allowed)\n");
764 break;
765 }
766 }
767 TRACE("ListCount (%ld) < ListSize (%ld)\n", ListCount, ListSize);
768 } while (ListCount < ListSize);
769 break;
770 } default: {
771 WARN ("invalid chunk (only 'UNFO', 'cord', 'sttr', 'pftr', 'lyrt', 'MARK' and 'mfrm' chunks allowed)\n");
772 break;
773 }
774 }
775 break;
776 } case FOURCC_RIFF: {
777 TRACE("'RIFF': embedded RIFF chunk (probably band track form)\n");
778 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
779 if (chunk.id == DMUS_FOURCC_BANDTRACK_FORM) {
780 TRACE("'DMBT': band track form\n");
781 FileSize2 = chunk.size - sizeof(FOURCC);
782 do {
783 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
784 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL);
785 FileCount2 += sizeof(FOURCC) + sizeof(DWORD) + chunk.size;
786 switch (chunk.id)
787 {
788 case DMUS_FOURCC_BANDTRACK_CHUNK: {
789 TRACE("'dbth': band track header\n");
790 ReadFile (fd, &bandTrack.header, chunk.size, &BytesRead, NULL);
791 TRACE_(dmfiledat)("=> bAutoDownload = %d\n", bandTrack.header.bAutoDownload);
792 break;
793 } case DMUS_FOURCC_GUID_CHUNK: {
794 TRACE("'guid': GUID\n");
795 ReadFile (fd, &bandTrack.guid, chunk.size, &BytesRead, NULL);
796 TRACE_(dmfiledat)("=> GUID = %s\n", debugstr_guid (&bandTrack.guid));
797 break;
798 } case DMUS_FOURCC_VERSION_CHUNK: {
799 TRACE("'vers': version\n");
800 ReadFile (fd, &bandTrack.version, chunk.size, &BytesRead, NULL);
801 TRACE_(dmfiledat)("=> version = %ld%ld\n", bandTrack.version.dwVersionMS, bandTrack.version.dwVersionLS);
802 break;
803 } case FOURCC_LIST: {
804 TRACE("'LIST': list (content size = %ld)\n", chunk.size);
805 ListSize = chunk.size - sizeof(FOURCC);
806 ListCount = 0;
807 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
808 switch (chunk.id)
809 {
810 case DMUS_FOURCC_UNFO_LIST:{
811 TRACE("'UNFO': UNFO list (forward to DMUSIC_FillUNFOFromFileHandle)\n");
812 SetFilePointer (fd, -(sizeof(DWORD) + 2*sizeof(FOURCC)), NULL, FILE_CURRENT); /* place pointer before 'LIST' chunk */
813 DMUSIC_FillUNFOFromFileHandle (UNFO, fd);
814 break;
815 } case DMUS_FOURCC_BANDS_LIST: {
816 TRACE("'lbdl': bands list (content size = %ld)\n", ListSize);
817 do {
818 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
819 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL);
820 ListCount += sizeof(FOURCC) + sizeof(DWORD) + chunk.size;
821 if (chunk.id == FOURCC_LIST && ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL) && chunk.id == DMUS_FOURCC_BAND_LIST) {
822 ListSize2 = chunk.size - sizeof(FOURCC);
823 ListCount2 = 0;
824 TRACE("'lbnd': band list (content size = %ld)\n", ListSize2);
825 do {
826 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
827 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL);
828 ListCount2 += sizeof(FOURCC) + sizeof(DWORD) + chunk.size;
829 switch (chunk.id)
830 {
831 case DMUS_FOURCC_BANDITEM_CHUNK: {
832 TRACE("'bdih': old band header\n");
833 ReadFile (fd, &bandTrack.header1, chunk.size, &BytesRead, NULL);
834 TRACE_(dmfiledat)("=> lBandTime = %li\n", bandTrack.header1.lBandTime);
835 break;
836 } case DMUS_FOURCC_BANDITEM_CHUNK2: {
837 TRACE("'bd2h': new band header\n");
838 ReadFile (fd, &bandTrack.header2, chunk.size, &BytesRead, NULL);
839 TRACE_(dmfiledat)("=> lBandTimeLogical = %li; lBandTimePhysical = %li\n", \
840 bandTrack.header2.lBandTimeLogical, bandTrack.header2.lBandTimePhysical);
841 break;
842 } case FOURCC_RIFF: {
843 TRACE("'RIFF': embedded RIFF (size = %ld; could be embedded band form)\n", chunk.size);
844 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
845 if (chunk.id == DMUS_FOURCC_BAND_FORM) {
846 TRACE("'DMBD': embedded band form (forward to DMUSIC_FillBandFromFileHandle)\n");
847 SetFilePointer (fd, -(sizeof(DWORD) + 2*sizeof(FOURCC)), NULL, FILE_CURRENT); /* place pointer before 'RIFF' chunk */
848 DMUSIC_FillBandFromFileHandle (NULL, fd);
849 } else WARN("invalid chunk (only 'DMBD' chunk allowed)\n");
850 break;
851 } default: {
852 WARN("invalid chunk (only 'bdih', 'bd2h' and 'RIFF' chunks allowed)\n");
853 break;
854 }
855 }
856 TRACE("ListCount2 (%ld) < ListSize2 (%ld)\n", ListCount2, ListSize2);
857 } while (ListCount2 < ListSize2);
858 } else WARN("unknown chunk - expect error\n");
859
860 } while (ListCount < ListSize);
861 break;
862 } default: {
863 WARN("invalid chunk (only 'UNFO' and 'lbdl' chunks allowed)\n");
864 }
865 }
866 break;
867 } default: {
868 WARN("invalid chunk (only 'dbth', 'guid', 'vers' and 'LIST' chunks allowed)\n");
869 break;
870 }
871 }
872 TRACE("FileCount2 (%ld) < FileSize2 (%ld)\n", FileCount2, FileSize2);
873 } while (FileCount2 < FileSize2);
874 } else {
875 WARN("invalid chunk (only 'DMBT' chunk allowed\n");
876 }
877 break;
878 } case DMUS_FOURCC_COMMANDTRACK_CHUNK: {
879 TRACE("'cmnd': command track\n");
880 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL); /* read sizeof(DMUS_IO_COMMAND) */
881 ReadFile (fd, &command, chunk.size, &BytesRead, NULL); /* read DMUS_IO_COMMAND */
882 TRACE_(dmfiledat)("wMeasure = %d; bBeat = %i; bCommand = %i; bGrooveLevel = %i; bGrooveRange = %i; bRepeatMode = %i\n", \
883 command.wMeasure, command.bBeat, command.bCommand, command.bGrooveLevel, command.bGrooveRange, command.bRepeatMode);
884 break;
885 } case DMUS_FOURCC_MUTE_CHUNK: {
886 FIXME("'mute': mute track chunk: not supported yet\n");
887 break;
888 } case DMUS_FOURCC_PATTERN_FORM: {
889 FIXME("'DMPT': pattern track form: not supported yet\n");
890 break;
891 } case DMUS_FOURCC_SEQ_TRACK: {
892 FIXME("'seqt': sequence track chunk: not supported yet\n");
893 break;
894 } case DMUS_FOURCC_SIGNPOST_TRACK_CHUNK: {
895 FIXME("'sgnp': signpost track chunk: not supported yet\n");
896 break;
897 } case DMUS_FOURCC_SYSEX_TRACK: {
898 FIXME("'syex': sysex track chunk: not supported yet\n");
899 break;
900 } case DMUS_FOURCC_TEMPO_TRACK: {
901 TRACE("'tetr': tempo track chunk\n");
902 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL);
903 if (chunk.size != sizeof(DMUS_IO_TEMPO_ITEM))
904 WARN("there seem to be a problem: file claims that size of DMUSIC_IO_TEMPO_ITEM is %ld, while real sizeof returns %i\n", \
905 chunk.size, sizeof(DMUS_IO_TEMPO_ITEM));
906 ReadFile (fd, &tempo, chunk.size, &BytesRead, NULL);
907 TRACE_(dmfiledat)("=> lTime = %ld; dblTempo = %f\n", tempo.lTime, tempo.dblTempo);
908 break;
909 } default: {
910 WARN("invalid chunk (too many too list)\n");
911 break;
912 }
913 }
914 TRACE("FileCount (%ld) < FileSize (%ld)\n", FileCount, FileSize);
915 } while (FileCount < FileSize);
916 } else {
917 WARN("invalid chunk (only 'DMTK' chunk allowed)\n");
918 }
919 } else {
920 WARN("'RIFF' not found: not a RIFF file\n");
921 }
922
923 return S_OK;
924 }
925
926 /******************************************************************************
927 * DMUSIC_FillSegmentFromFileHandle:
928 * - fills a IDirectMusicSegment8Impl struct with data from file handle.
929 * - IMPORTANT: it expects a RIFF chunk at beginning, so if you are calling it
930 * from another DMUSIC_Fill* function, make sure pointer is at
931 * correct place!
932 * - TODO: replace data in function with data in IDirectMusicSegmentImpl
933 * implement loading for missing (empty) clauses
934 */
935 HRESULT WINAPI DMUSIC_FillSegmentFromFileHandle (IDirectMusicSegment8Impl *segment, HANDLE fd)
936 {
937 rawChunk chunk;
938 DWORD BytesRead, ListCount = 0, ListSize, FileCount = 0, FileSize;
939 /* FIXME: Replace stuff located below with the stuff in segment */
940 UNFO_List UNFO;
941 DMUS_IO_SEGMENT_HEADER header;
942 DMUS_IO_VERSION version;
943 GUID guid;
944
945 TRACE("reading 'RIFF' chunk...\n");
946 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
947 if (chunk.id == FOURCC_RIFF) {
948 TRACE("'RIFF': RIFF file\n");
949 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL); /* read size of 'RIFF' chunk */
950 FileSize = chunk.size - sizeof(FOURCC); /* file content size = size of 'RIFF' chunk - FOURCC ID of following form */
951 TRACE("reading chunks ...\n");
952 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL); /* read ID of following form */
953 if (chunk.id == DMUS_FOURCC_SEGMENT_FORM) {
954 TRACE("DMSG: segment form\n");
955 do {
956 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
957 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL);
958 FileCount += chunk.size + sizeof(DWORD) + sizeof(FOURCC);
959 switch (chunk.id)
960 {
961 case DMUS_FOURCC_SEGMENT_CHUNK: {
962 TRACE("segh: segment header\n");
963 ReadFile (fd, &header, chunk.size, &BytesRead, NULL);
964 TRACE_(dmfiledat)("=> dwRepeats = %ld; mtLength = %li; mtPlayStart = %li; mtLoopStart = %li; mtLoopEnd = %li; dwResolution = %ld; rtLength = FIXME; dwFlags = %ld; dwReserved = %ld\n", \
965 header.dwRepeats, header.mtLength, header.mtPlayStart, header.mtLoopStart, header.mtLoopEnd, header.dwResolution/*, header.rtLength*/, header.dwFlags, header.dwReserved);
966 break;
967 } case DMUS_FOURCC_GUID_CHUNK: {
968 TRACE("'guid': GUID\n");
969 ReadFile (fd, &guid, chunk.size, &BytesRead, NULL);
970 TRACE_(dmfiledat)("=> GUID = %s\n", debugstr_guid(&guid));
971 break;
972 } case DMUS_FOURCC_VERSION_CHUNK: {
973 TRACE("'vers': version\n");
974 ReadFile (fd, &version, chunk.size, &BytesRead, NULL);
975 TRACE_(dmfiledat)("=> version = %ld%ld\n", version.dwVersionMS, version.dwVersionLS);
976 break;
977 } case FOURCC_LIST:{
978 TRACE("'LIST': list (size) = %ld\n", chunk.size);
979 ListSize = chunk.size - sizeof(FOURCC); /* list content size = size of 'LIST' chunk - FOURCC ID of the list */
980 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
981 switch (chunk.id)
982 {
983 case DMUS_FOURCC_UNFO_LIST: {
984 TRACE("'UNFO': UNFO list (forward to DMUSIC_FillUNFOFromFileHandle(...))\n");
985 SetFilePointer (fd, -(sizeof(DWORD) + 2*sizeof(FOURCC)), NULL, FILE_CURRENT); /* place pointer before the 'LIST' chunk */
986 DMUSIC_FillUNFOFromFileHandle (UNFO, fd);
987 break;
988 } case DMUS_FOURCC_TRACK_LIST: {
989 TRACE("'trkl': track list chunk (forward)\n");
990 do {
991 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL); /* read RIFF */
992 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL); /* read track size */
993 TRACE("track size = %ld\n", chunk.size);
994 ListCount += chunk.size + sizeof(DWORD) + sizeof(FOURCC);
995 SetFilePointer (fd, -(sizeof(DWORD) + sizeof(FOURCC)), NULL, FILE_CURRENT); /* place pointer before the 'RIFF' chunk */
996 DMUSIC_FillTrackFromFileHandle (NULL, fd); /* read encapsulated track as if it was in a track file */
997 TRACE("(Track) List Count = %ld < (Track) List Size = %ld\n", ListCount, ListSize);
998 } while (ListCount < ListSize);
999 break;
1000 }
1001 }
1002 break;
1003 } case FOURCC_RIFF: {
1004 TRACE("'RIFF': embedded RIFF (size = %ld; could be embedded container form)\n", chunk.size);
1005 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
1006 if (chunk.id == DMUS_FOURCC_CONTAINER_FORM) {
1007 TRACE("'DMCN': embedded container form (forward to DMUSIC_FillContainerFromFileHandle(...))\n");
1008 SetFilePointer (fd, -(sizeof(DWORD) + 2*sizeof(FOURCC)), NULL, FILE_CURRENT); /* place pointer before 'RIFF' chunk */
1009 DMUSIC_FillContainerFromFileHandle (NULL, fd);
1010 } else WARN("invalid chunk (only 'DMCN' chunk allowed)\n");
1011 break;
1012 } case DMUS_FOURCC_TOOLGRAPH_FORM: {
1013 FIXME("'DMTG': toolgraph chunk: not supported yet\n");
1014 break;
1015 } case DMUS_FOURCC_AUDIOPATH_FORM: {
1016 FIXME("'DMAP': audiopath chunk: not supported yet\n");
1017 break;
1018 } default: {
1019 WARN("invalid chunk (only 'segh', 'guid', 'vers', 'LIST', 'RIFF', 'DMTG' and 'DMAP' chunks allowed)\n");
1020 break;
1021 }
1022 }
1023 TRACE("FileCount (%ld) < FileSize (%ld)\n", FileCount, FileSize);
1024 } while (FileCount < FileSize);
1025 } else {
1026 WARN("invalid chunk (only 'DMSG' chunk allowed)\n");
1027 }
1028 } else {
1029 WARN("'RIFF' not found: not a RIFF file\n");
1030 }
1031
1032 return S_OK;
1033 }
1034
1035 /******************************************************************************
1036 * DMUSIC_FillScriptFromFileHandle:
1037 * - fills a IDirectMusicScriptImpl struct with data from file handle.
1038 * - IMPORTANT: it expects a RIFF chunk at beginning, so if you are calling it
1039 * from another DMUSIC_Fill* function, make sure pointer is at
1040 * correct place!
1041 * - TODO: replace data in function with data in IDirectMusicScriptImpl
1042 */
1043
1044 HRESULT WINAPI DMUSIC_FillScriptFromFileHandle (IDirectMusicScriptImpl *script, HANDLE fd)
1045 {
1046 rawChunk chunk;
1047 DWORD BytesRead/*, ListCount = 0*/, ListSize, FileCount = 0, FileSize;
1048 /* FIXME: Replace stuff located below with the stuff in script */
1049 UNFO_List UNFO;
1050 DMUS_IO_SCRIPT_HEADER header;
1051 DMUS_IO_VERSION version, scriptversion;
1052 GUID guid;
1053 WCHAR* scriptlang;
1054 WCHAR* scriptsrc;
1055 Reference scriptsrcref;
1056
1057 TRACE("reading 'RIFF' chunk...\n");
1058 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
1059 if (chunk.id == FOURCC_RIFF) {
1060 TRACE("'RIFF': RIFF file\n");
1061 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL); /* read size of 'RIFF' chunk */
1062 FileSize = chunk.size - sizeof(FOURCC); /* file content size = size of 'RIFF' chunk - FOURCC ID of following form */
1063 TRACE("reading chunks ...\n");
1064 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL); /* read ID of following form */
1065 if (chunk.id == DMUS_FOURCC_SCRIPT_FORM) {
1066 TRACE("'DMSC': script form\n");
1067 do {
1068 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
1069 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL);
1070 FileCount += chunk.size + sizeof(DWORD) + sizeof(FOURCC);
1071 switch (chunk.id)
1072 {
1073 case DMUS_FOURCC_SCRIPT_CHUNK: {
1074 TRACE("'schd': script header\n");
1075 ReadFile (fd, &header, chunk.size, &BytesRead, NULL);
1076 TRACE_(dmfiledat)("=> dwFlags = %ld\n", header.dwFlags);
1077 break;
1078 } case DMUS_FOURCC_GUID_CHUNK: {
1079 TRACE("'guid': GUID\n");
1080 ReadFile (fd, &guid, chunk.size, &BytesRead, NULL);
1081 TRACE_(dmfiledat)("=> GUID = %s\n", debugstr_guid(&guid));
1082 break;
1083 } case DMUS_FOURCC_VERSION_CHUNK: {
1084 TRACE("'vers': version\n");
1085 ReadFile (fd, &version, chunk.size, &BytesRead, NULL);
1086 TRACE_(dmfiledat)("=> version = %ld%ld\n", version.dwVersionMS, version.dwVersionLS);
1087 break;
1088 } case FOURCC_LIST:{
1089 TRACE("'LIST': list (size) = %ld\n", chunk.size);
1090 ListSize = chunk.size - sizeof(FOURCC); /* list content size = size of 'LIST' chunk - FOURCC ID of the list */
1091 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
1092 switch (chunk.id)
1093 {
1094 case DMUS_FOURCC_UNFO_LIST: {
1095 TRACE("'UNFO': UNFO list (forward to DMUSIC_FillUNFOFromFileHandle(...))\n");
1096 SetFilePointer (fd, -(sizeof(DWORD) + 2*sizeof(FOURCC)), NULL, FILE_CURRENT); /* place pointer before the 'LIST' chunk */
1097 DMUSIC_FillUNFOFromFileHandle (UNFO, fd);
1098 break;
1099 } case DMUS_FOURCC_REF_LIST: {
1100 TRACE("'DMRF': reference list (forward to DMUSIC_FillReferenceFromFileHandle(...)\n");
1101 SetFilePointer (fd, -(sizeof(DWORD) + 2*sizeof(FOURCC)), NULL, FILE_CURRENT); /* place pointer before 'LIST' chunk */
1102 DMUSIC_FillReferenceFromFileHandle (scriptsrcref, fd);
1103 } default: {
1104 WARN("invalid chunk (only 'UNFO' and 'DMRF' chunks allowed)\n");
1105 }
1106 }
1107 break;
1108 } case DMUS_FOURCC_SCRIPTVERSION_CHUNK: {
1109 TRACE("'scve': DirectMusic version\n");
1110 ReadFile (fd, &scriptversion, chunk.size, &BytesRead, NULL);
1111 TRACE_(dmfiledat)("=> script version = %ld%ld\n", scriptversion.dwVersionMS, scriptversion.dwVersionLS);
1112 break;
1113 } case FOURCC_RIFF: {
1114 TRACE("'RIFF': embedded RIFF (size = %ld; could be embedded container form)\n", chunk.size);
1115 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
1116 if (chunk.id == DMUS_FOURCC_CONTAINER_FORM) {
1117 TRACE("'DMCN': embedded container form (forward to DMUSIC_FillContainerFromFileHandle(...))\n");
1118 SetFilePointer (fd, -(sizeof(DWORD) + 2*sizeof(FOURCC)), NULL, FILE_CURRENT); /* place pointer before 'RIFF' chunk */
1119 DMUSIC_FillContainerFromFileHandle (NULL, fd);
1120 } else WARN("invalid chunk (only 'DMCN' chunk allowed)\n");
1121 break;
1122 } case DMUS_FOURCC_SCRIPTLANGUAGE_CHUNK: {
1123 TRACE("'scla': scripting language\n");
1124 scriptlang = (WCHAR*) HeapAlloc (GetProcessHeap (), 0, chunk.size); /* allocate space */
1125 ReadFile (fd, scriptlang, chunk.size, &BytesRead, NULL);
1126 TRACE_(dmfiledat)("script language = %s\n", debugstr_w(scriptlang));
1127 break;
1128 } case DMUS_FOURCC_SCRIPTSOURCE_CHUNK: {
1129 TRACE("'scsr': script source\n");
1130 scriptsrc = (WCHAR*) HeapAlloc (GetProcessHeap (), 0, chunk.size); /* allocate space */
1131 ReadFile (fd, scriptsrc, chunk.size, &BytesRead, NULL);
1132 TRACE_(dmfiledat)("script source = %s\n", debugstr_w(scriptsrc));
1133 break;
1134 } default: {
1135 WARN("invalid chunk (only 'schd', 'guid', 'vers', 'LIST', 'scve', 'RIFF' and 'scla' chunks allowed)\n");
1136 break;
1137 }
1138 }
1139 TRACE("FileCount (%ld) < FileSize (%ld)\n", FileCount, FileSize);
1140 } while (FileCount < FileSize);
1141 } else {
1142 WARN("invalid chunk (only 'DMSC' chunk allowed)\n");
1143 }
1144 } else {
1145 WARN("'RIFF' not found: not a RIFF file\n");
1146 }
1147
1148 return S_OK;
1149 }
1150
1151 /******************************************************************************
1152 * DMUSIC_FillContainerFromFileHandle:
1153 * - fills a IDirectMusicContainerImpl struct with data from file handle.
1154 * - IMPORTANT: it expects a RIFF chunk at beginning, so if you are calling it
1155 * from another DMUSIC_Fill* function, make sure pointer is at
1156 * correct place!
1157 * - TODO: replace data in function with data in IDirectMusicContainerImpl
1158 */
1159 HRESULT WINAPI DMUSIC_FillContainerFromFileHandle (IDirectMusicContainerImpl *container, HANDLE fd)
1160 {
1161 rawChunk chunk;
1162 DWORD BytesRead, ListCount = 0, ListSize, ListCount2 = 0, ListSize2, FileCount = 0, FileSize;
1163 /* FIXME: Replace stuff located below with the stuff in container */
1164 UNFO_List UNFO;
1165 DMUS_IO_CONTAINER_HEADER header;
1166 DMUS_IO_VERSION version;
1167 GUID guid;
1168 WCHAR* alias;
1169 DMUS_IO_CONTAINED_OBJECT_HEADER objheader;
1170 Reference dataref;
1171
1172 TRACE("reading 'RIFF' chunk...\n");
1173 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
1174 if (chunk.id == FOURCC_RIFF) {
1175 TRACE("'RIFF': RIFF file\n");
1176 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL); /* read size of 'RIFF' chunk */
1177 FileSize = chunk.size - sizeof(FOURCC); /* file content size = size of 'RIFF' chunk - FOURCC ID of following form */
1178 TRACE("reading chunks ...\n");
1179 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL); /* read ID of following form */
1180 if (chunk.id == DMUS_FOURCC_CONTAINER_FORM) {
1181 TRACE("'DMCN': container form\n");
1182 do {
1183 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
1184 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL);
1185 FileCount += chunk.size + sizeof(DWORD) + sizeof(FOURCC);
1186 switch (chunk.id)
1187 {
1188 case DMUS_FOURCC_CONTAINER_CHUNK: {
1189 TRACE("'conh': container header\n");
1190 ReadFile (fd, &header, chunk.size, &BytesRead, NULL);
1191 TRACE_(dmfiledat)("=> dwFlags = %ld\n", header.dwFlags);
1192 break;
1193 } case DMUS_FOURCC_GUID_CHUNK: {
1194 TRACE("'guid': GUID\n");
1195 ReadFile (fd, &guid, chunk.size, &BytesRead, NULL);
1196 TRACE_(dmfiledat)("=> GUID = %s\n", debugstr_guid(&guid));
1197 break;
1198 } case DMUS_FOURCC_VERSION_CHUNK: {
1199 TRACE("'vers': version\n");
1200 ReadFile (fd, &version, chunk.size, &BytesRead, NULL);
1201 TRACE_(dmfiledat)("=> version = %ld%ld\n", version.dwVersionMS, version.dwVersionLS);
1202 break;
1203 } case FOURCC_LIST:{
1204 TRACE("'LIST': list (size) = %ld\n", chunk.size);
1205 ListSize = chunk.size - sizeof(FOURCC); /* list content size = size of 'LIST' chunk - FOURCC ID of the list */
1206 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
1207 switch (chunk.id)
1208 {
1209 case DMUS_FOURCC_UNFO_LIST: {
1210 TRACE("'UNFO': UNFO list (forward to DMUSIC_FillUNFOFromFileHandle(...))\n");
1211 SetFilePointer (fd, -(sizeof(DWORD) + 2*sizeof(FOURCC)), NULL, FILE_CURRENT); /* place pointer before the 'LIST' chunk */
1212 DMUSIC_FillUNFOFromFileHandle (UNFO, fd);
1213 break;
1214 } case DMUS_FOURCC_CONTAINED_OBJECTS_LIST: {
1215 TRACE("'cosl': objects list (content size = %ld)\n", ListSize);
1216 do {
1217 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
1218 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL);
1219 ListCount += sizeof(FOURCC) + sizeof(DWORD) + chunk.size;
1220 if (chunk.id == FOURCC_LIST && ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL) && chunk.id == DMUS_FOURCC_CONTAINED_OBJECT_LIST) {
1221 ListSize2 = chunk.size - sizeof(FOURCC); /* list content size = size of 'LIST' chunk - FOURCC ID of the list */
1222 ListCount2 = 0; /* reset */
1223 TRACE("'cobl': object (content size = %ld)\n", ListSize2);
1224 do {
1225 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
1226 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL);
1227 ListCount2 += sizeof(FOURCC) + sizeof(DWORD) + chunk.size;
1228 switch (chunk.id)
1229 {
1230 case DMUS_FOURCC_CONTAINED_ALIAS_CHUNK: {
1231 TRACE("'coba': alias (size = %ld)\n", chunk.size);
1232 alias = (WCHAR*) HeapAlloc (GetProcessHeap (), 0, chunk.size); /* allocate space */
1233 ReadFile (fd, alias, chunk.size, &BytesRead, NULL);
1234 TRACE_(dmfiledat)("=> alias = %s\n", debugstr_w(alias));
1235 break;
1236 } case DMUS_FOURCC_CONTAINED_OBJECT_CHUNK: {
1237 TRACE("'cobh': object header (size = %ld)\n", chunk.size);
1238 ReadFile (fd, &objheader, chunk.size, &BytesRead, NULL);
1239 TRACE_(dmfiledat)("=> guidClassID = %s; dwFlags = %ld; ckid = %ld; fccType = %ld\n", \
1240 debugstr_guid(&objheader.guidClassID), objheader.dwFlags, objheader.ckid, objheader.fccType);
1241 break;
1242 } case FOURCC_LIST: {
1243 TRACE("'LIST': list chunk (size = %ld)\n", chunk.size);
1244 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
1245 if (chunk.id == DMUS_FOURCC_REF_LIST) {
1246 TRACE("'DMRF': reference list (instead of 'data' chunk: size = %ld)\n", chunk.size - 4); /* set pointer at beginning of list */
1247 SetFilePointer (fd, -(sizeof(DWORD) + 2*sizeof(FOURCC)), NULL, FILE_CURRENT);
1248 DMUSIC_FillReferenceFromFileHandle (dataref, fd); /* forward to DMUSIC_FillReferenceFromFileHandle */
1249 } else WARN("invalid chunk (only 'DMRF' chunk allowed\n");
1250 break;
1251 } case FOURCC_RIFF: {
1252 TRACE("'RIFF': encapsulated data (can be 'DMSG' or 'DMSG')\n");
1253 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
1254 SetFilePointer (fd, -(sizeof(DWORD) + 2*sizeof(FOURCC)), NULL, FILE_CURRENT); /* place pointer before 'RIFF' chunk */
1255 switch (chunk.id)
1256 {
1257 case DMUS_FOURCC_SEGMENT_FORM: {
1258 TRACE("'DMSG': embedded segment form (forward to DMUSIC_FillSegmentFromFileHandle(...))\n");
1259 DMUSIC_FillSegmentFromFileHandle (NULL, fd);
1260 break;
1261 } case DMUS_FOURCC_STYLE_FORM: {
1262 TRACE("'DMST': embedded style form (forward to DMUSIC_FillStyleFromFileHandle(...))\n");
1263 DMUSIC_FillStyleFromFileHandle (NULL, fd);
1264 break;
1265 } case mmioFOURCC('W','A','V','E'): {
1266 FIXME("'WAVE': not yet supported (skipping)\n");
1267 SetFilePointer (fd, sizeof(FOURCC) + sizeof(DWORD) + chunk.size, NULL, FILE_CURRENT); /* skip */
1268 break;
1269 } default: {
1270 WARN("invalid chunk (only 'DMSG' and 'DMST' chunks allowed)\n");
1271 break;
1272 }
1273 }
1274 break;
1275 } default: {
1276 WARN("invalid chunk (only 'coba', 'cobh', 'data' and 'LIST' chunks allowed\n");
1277 break;
1278 }
1279 }
1280 TRACE("ListCount2 (%ld) < ListSize2 (%ld)\n", ListCount2, ListSize2);
1281 } while (ListCount2 < ListSize2);
1282 } else WARN("invalid chunk (only 'cobl' chunk allowed)\n");
1283 TRACE("ListCount (%ld) < ListSize (%ld)\n", ListCount, ListSize);
1284 } while (ListCount < ListSize);
1285 break;
1286 } default: {
1287 WARN("invalid chunk (only 'UNFO' and 'cosl' chunks allowed)\n");
1288 }
1289 }
1290 break;
1291 } default: {
1292 WARN("invalid chunk (only 'schd', 'guid', 'vers', 'LIST', 'scve', 'RIFF' and 'scla' chunks allowed)\n");
1293 break;
1294 }
1295 }
1296 TRACE("FileCount (%ld) < FileSize (%ld)\n", FileCount, FileSize);
1297 } while (FileCount < FileSize);
1298 } else {
1299 WARN("invalid chunk (only 'DMSC' chunk allowed)\n");
1300 }
1301 } else {
1302 WARN("'RIFF' not found: not a RIFF file\n");
1303 }
1304
1305 return S_OK;
1306 }
1307
1308 /******************************************************************************
1309 * DMUSIC_FillStyleFromFileHandle:
1310 * - fills a IDirectMusicStyle8Impl struct with data from file handle.
1311 * - IMPORTANT: it expects a RIFF chunk at beginning, so if you are calling it
1312 * from another DMUSIC_Fill* function, make sure pointer is at
1313 * correct place!
1314 * - TODO: replace data in function with data in IDirectMusicStyleImpl
1315 */
1316 HRESULT WINAPI DMUSIC_FillStyleFromFileHandle (IDirectMusicStyle8Impl *style, HANDLE fd)
1317 {
1318 rawChunk chunk;
1319 DWORD BytesRead, ListCount = 0, ListSize, ListCount2 = 0, ListSize2, FileCount = 0, FileSize;
1320 int i;
1321 /* FIXME: Replace stuff located below with the stuff in container */
1322 UNFO_List UNFO;
1323 DMUS_IO_STYLE header;
1324 DMUS_IO_VERSION version;
1325 GUID guid;
1326 Part part;
1327 Pattern pattern;
1328
1329 TRACE("reading 'RIFF' chunk...\n");
1330 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
1331 if (chunk.id == FOURCC_RIFF) {
1332 TRACE("'RIFF': RIFF file\n");
1333 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL); /* read size of 'RIFF' chunk */
1334 FileSize = chunk.size - sizeof(FOURCC); /* file content size = size of 'RIFF' chunk - FOURCC ID of following form */
1335 TRACE("reading chunks ...\n");
1336 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL); /* read ID of following form */
1337 if (chunk.id == DMUS_FOURCC_STYLE_FORM) {
1338 TRACE("'DMST': style form\n");
1339 do {
1340 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
1341 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL);
1342 FileCount += chunk.size + sizeof(DWORD) + sizeof(FOURCC);
1343
1344 switch (chunk.id)
1345 {
1346 case DMUS_FOURCC_STYLE_CHUNK: {
1347 TRACE("'styh': style header\n");
1348 ReadFile (fd, &header, chunk.size, &BytesRead, NULL);
1349 TRACE_(dmfiledat)("=> timeSig.bBeatsPerMeasure = %i; timeSig.bBeat = %i; timeSig.wGridsPerBeat = %d; dblTempo = %f\n", \
1350 header.timeSig.bBeatsPerMeasure, header.timeSig.bBeat, header.timeSig.wGridsPerBeat, header.dblTempo);
1351 break;
1352 } case DMUS_FOURCC_GUID_CHUNK: {
1353 TRACE("'guid': GUID\n");
1354 ReadFile (fd, &guid, chunk.size, &BytesRead, NULL);
1355 TRACE_(dmfiledat)("=> GUID = %s\n", debugstr_guid(&guid));
1356 break;
1357 } case DMUS_FOURCC_VERSION_CHUNK: {
1358 TRACE("'vers': version\n");
1359 ReadFile (fd, &version, chunk.size, &BytesRead, NULL);
1360 TRACE_(dmfiledat)("=> version = %ld%ld\n", version.dwVersionMS, version.dwVersionLS);
1361 break;
1362 } case FOURCC_RIFF: {
1363 TRACE("'RIFF': embedded RIFF (size = %ld; could be embedded band form)\n", chunk.size);
1364 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
1365 if (chunk.id == DMUS_FOURCC_BAND_FORM) {
1366 TRACE("'DMBD': embedded band form (forward to DMUSIC_FillBandFromFileHandle)\n");
1367 SetFilePointer (fd, -(sizeof(DWORD) + 2*sizeof(FOURCC)), NULL, FILE_CURRENT); /* place pointer before 'RIFF' chunk */
1368 DMUSIC_FillBandFromFileHandle (NULL, fd);
1369 } else WARN("invalid chunk (only 'DMBD' chunk allowed)\n");
1370 break;
1371 } case FOURCC_LIST:{
1372 TRACE("'LIST': list (size) = %ld\n", chunk.size);
1373 ListSize = chunk.size - sizeof(FOURCC); /* list content size = size of 'LIST' chunk - FOURCC ID of the list */
1374 ListCount = 0;
1375 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
1376 switch (chunk.id)
1377 {
1378 case DMUS_FOURCC_UNFO_LIST: {
1379 TRACE("'UNFO': UNFO list (forward to DMUSIC_FillUNFOFromFileHandle(...))\n");
1380 SetFilePointer (fd, -(sizeof(DWORD) + 2*sizeof(FOURCC)), NULL, FILE_CURRENT); /* place pointer before the 'LIST' chunk */
1381 DMUSIC_FillUNFOFromFileHandle (UNFO, fd);
1382 break;
1383 } case DMUS_FOURCC_PART_LIST: {
1384 TRACE("'part': parts list (content size = %ld)\n", ListSize);
1385 do {
1386 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
1387 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL);
1388 ListCount += sizeof(FOURCC) + sizeof(DWORD) + chunk.size;
1389 switch (chunk.id)
1390 {
1391 case DMUS_FOURCC_PART_CHUNK: {
1392 TRACE("'prth': part header\n");
1393 ReadFile (fd, &part.header, chunk.size, &BytesRead, NULL);
1394 TRACE_(dmfiledat)("=> timeSig.bBeatsPerMeasure = %i; timeSig.bBeat = %i; timeSig.wGridsPerBeat = %d; dwVariationChoices = %p; guidPartID = %s; wNbrMeasures = %d; bPlayModeFlags = %i; bInvertUpper = %i; bInvertLower = %i; bPad = %p; dwFlags = %ld\n", \
1395 part.header.timeSig.bBeatsPerMeasure, part.header.timeSig.bBeat, part.header.timeSig.wGridsPerBeat, part.header.dwVariationChoices, \
1396 debugstr_guid (&part.header.guidPartID), part.header.wNbrMeasures, part.header.bPlayModeFlags, part.header.bInvertUpper, part.header.bInvertLower, \
1397 part.header.bPad, part.header.dwFlags);
1398 break;
1399 } case DMUS_FOURCC_NOTE_CHUNK: {
1400 TRACE("'note': notes (size = %ld)\n", chunk.size);
1401 part.nrofnotes = chunk.size - sizeof(DWORD); /* pure contents of 'note' (without first DWORD) */
1402 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL); /* read sizeof (DMUS_IO_STYLENOTE) */
1403 part.nrofnotes /= chunk.size; /* nrofnotes = pure contents / sizeof (DMUS_IO_STYLENOTE) */
1404 part.notes = (DMUS_IO_STYLENOTE*) HeapAlloc (GetProcessHeap (), 0, chunk.size * part.nrofnotes);
1405 ReadFile (fd, part.notes, chunk.size * part.nrofnotes, &BytesRead, NULL);
1406 TRACE_(dmfiledat)("=> number of notes = %ld\n", part.nrofnotes);
1407 for (i = 0; i < part.nrofnotes; i++)
1408 {
1409 TRACE_(dmfiledat)("=> note[%i]: mtGridStart = %li; dwVariation = %ld; mtDuration = %li; nTimeOffset = %i; wMusicValue = %d; bVelocity = %i; bTimeRange = %i; bDurRange = %i; bVelRange = %i; bInversionID = %i; bPlayModeFlags = %i; bNoteFlags= %i;\n", \
1410 i, part.notes[i].mtGridStart, part.notes[i].dwVariation, part.notes[i].mtDuration, part.notes[i].nTimeOffset, part.notes[i].wMusicValue, part.notes[i].bVelocity, part.notes[i].bTimeRange, \
1411 part.notes[i].bDurRange, part.notes[i].bVelRange, part.notes[i].bInversionID, part.notes[i].bPlayModeFlags, part.notes[i].bNoteFlags);
1412 }
1413 break;
1414 } case DMUS_FOURCC_CURVE_CHUNK: {
1415 TRACE("'crve': curves (size = %ld)\n", chunk.size);
1416 part.nrofcurves = chunk.size - sizeof(DWORD); /* pure contents of 'crve' (without first DWORD) */
1417 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL); /* read sizeof (DMUS_IO_STYLECURVE) */
1418 part.nrofcurves /= chunk.size; /* nrofnotes = pure contents / sizeof (DMUS_IO_STYLECURVE) */
1419 part.curves = (DMUS_IO_STYLECURVE*) HeapAlloc (GetProcessHeap (), 0, chunk.size * part.nrofcurves);
1420 ReadFile (fd, part.curves, chunk.size * part.nrofcurves, &BytesRead, NULL);
1421 TRACE_(dmfiledat)("=> number of curves = %ld\n", part.nrofcurves);
1422 for (i = 0; i < part.nrofcurves; i++)
1423 {
1424 TRACE_(dmfiledat)("=> curve[%i]: mtGridStart = %li; dwVariation = %ld; mtDuration = %li; mtResetDuration = %li; nTimeOffset = %i; nStartValue = %i; nEndValue = %i; nResetValue = %i; bEventType = %i; bCurveShape = %i; bCCData = %i; bFlags = %i; wParamType = %d;wMergeIndex = %d\n", \
1425 i, part.curves[i].mtGridStart, part.curves[i].dwVariation, part.curves[i].mtDuration, part.curves[i].mtResetDuration, part.curves[i].nTimeOffset, part.curves[i].nStartValue, part.curves[i].nEndValue, \
1426 part.curves[i].nResetValue, part.curves[i].bEventType, part.curves[i].bCurveShape, part.curves[i].bCCData, part.curves[i].bFlags, part.curves[i].wParamType, part.curves[i].wMergeIndex);
1427 }
1428 break;
1429 } case DMUS_FOURCC_MARKER_CHUNK: {
1430 TRACE("'mrkr': markers (size = %ld)\n", chunk.size);
1431 part.nrofmarkers = chunk.size - sizeof(DWORD); /* pure contents of 'mrkr' (without first DWORD) */
1432 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL); /* read sizeof (DMUS_IO_STYLEMARKER) */
1433 part.nrofmarkers /= chunk.size; /* nrofnotes = pure contents / sizeof (DMUS_IO_STYLEMARKER) */
1434 part.markers = (DMUS_IO_STYLEMARKER*) HeapAlloc (GetProcessHeap (), 0, chunk.size * part.nrofmarkers);
1435 ReadFile (fd, part.markers, chunk.size * part.nrofmarkers, &BytesRead, NULL);
1436 TRACE_(dmfiledat)("=> number of markers = %ld\n", part.nrofmarkers);
1437 for (i = 0; i < part.nrofmarkers; i++)
1438 {
1439 TRACE_(dmfiledat)("=> marker[%i]: mtGridStart = %li; dwVariation = %ld; wMarkerFlags = %d\n", \
1440 i, part.markers[i].mtGridStart, part.markers[i].dwVariation, part.markers[i].wMarkerFlags);
1441 }
1442 break;
1443 } case DMUS_FOURCC_RESOLUTION_CHUNK: {
1444 TRACE("'rsln': resolutions (size = %ld)\n", chunk.size);
1445 part.nrofresolutions = chunk.size - sizeof(DWORD); /* pure contents of 'rsln' (without first DWORD) */
1446 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL); /* read sizeof (DMUS_IO_STYLERESOLUTION) */
1447 part.nrofresolutions /= chunk.size; /* nrofnotes = pure contents / sizeof (DMUS_IO_STYLERESOLUTION) */
1448 part.resolutions = (DMUS_IO_STYLERESOLUTION*) HeapAlloc (GetProcessHeap (), 0, chunk.size * part.nrofresolutions);
1449 ReadFile (fd, part.resolutions, chunk.size * part.nrofresolutions, &BytesRead, NULL);
1450 TRACE_(dmfiledat)("=> number of resolutions = %ld\n", part.nrofresolutions);
1451 for (i = 0; i < part.nrofresolutions; i++)
1452 {
1453 TRACE_(dmfiledat)("=> resolution[%i]: dwVariation = %ld; wMusicValue = %d; bInversionID = %i; bPlayModeFlags = %i", \
1454 i, part.resolutions[i].dwVariation, part.resolutions[i].wMusicValue, part.resolutions[i].bInversionID, part.resolutions[i].bPlayModeFlags);
1455 }
1456 break;
1457 } case DMUS_FOURCC_ANTICIPATION_CHUNK: {
1458 TRACE("'anpn': anticipations (size = %ld)\n", chunk.size);
1459 part.nrofanticipations = chunk.size - sizeof(DWORD); /* pure contents of 'anpn' (without first DWORD) */
1460 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL); /* read sizeof (DMUS_IO_STYLE_ANTICIPATION) */
1461 part.nrofanticipations /= chunk.size; /* nrofnotes = pure contents / sizeof (DMUS_IO_STYLE_ANTICIPATION) */
1462 part.anticipations = (DMUS_IO_STYLE_ANTICIPATION*) HeapAlloc (GetProcessHeap (), 0, chunk.size * part.nrofanticipations);
1463 ReadFile (fd, part.anticipations, chunk.size * part.nrofanticipations, &BytesRead, NULL);
1464 TRACE_(dmfiledat)("=> number of anticipations = %ld\n", part.nrofanticipations);
1465 for (i = 0; i < part.nrofanticipations; i++)
1466 {
1467 TRACE_(dmfiledat)("=> anticipation[%i]: mtGridStart = %li; dwVariation = %ld; nTimeOffset = %i; bTimeRange = %i\n", \
1468 i, part.anticipations[i].mtGridStart, part.anticipations[i].dwVariation, part.anticipations[i].nTimeOffset, part.anticipations[i].bTimeRange);
1469 }
1470 break;
1471 } case FOURCC_LIST: {
1472 TRACE("'LIST': list chunk (size = %ld)\n", chunk.size);
1473 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
1474 if (chunk.id == DMUS_FOURCC_UNFO_LIST) {
1475 TRACE("'UNFO': UNFO list (forward to DMUSIC_FillUNFOFromFileHandle(...))\n");
1476 SetFilePointer (fd, -(sizeof(DWORD) + 2*sizeof(FOURCC)), NULL, FILE_CURRENT); /* set pointer at beginning of list */
1477 DMUSIC_FillUNFOFromFileHandle (part.UNFO, fd);
1478 } else WARN("invalid chunk (only 'UNFO' chunk allowed\n");
1479 break;
1480 } default: {
1481 WARN("invalid chunk (only 'prth','note', 'crve', 'mrkr', 'rsln', 'anpn' and 'LIST' chunks allowed\n");
1482 break;
1483 }
1484 }
1485 TRACE("ListCount (%ld) < ListSize (%ld)\n", ListCount, ListSize);
1486 } while (ListCount < ListSize);
1487 break;
1488 } case DMUS_FOURCC_PATTERN_LIST: {
1489 TRACE("'pttn': patterns list (content size = %ld)\n", ListSize);
1490 do {
1491 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
1492 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL);
1493 ListCount += sizeof(FOURCC) + sizeof(DWORD) + chunk.size;
1494 switch (chunk.id)
1495 {
1496 case DMUS_FOURCC_PATTERN_CHUNK: {
1497 TRACE("'ptnh': pattern header\n");
1498 ReadFile (fd, &pattern.header, chunk.size, &BytesRead, NULL);
1499 TRACE_(dmfiledat)("=> timeSig.bBeatsPerMeasure = %i; timeSig.bBeat = %i; timeSig.wGridsPerBeat = %d; bGrooveBottom = %i; bGrooveTop = %i; wEmbellishment = %d; wNbrMeasures = %d; bDestGrooveBottom = %i; bDestGrooveTop = %i; dwFlags = %ld\n", \
1500 pattern.header.timeSig.bBeatsPerMeasure, pattern.header.timeSig.bBeat, pattern.header.timeSig.wGridsPerBeat, pattern.header.bGrooveBottom, pattern.header.bGrooveTop, pattern.header.wEmbellishment, \
1501 pattern.header.wNbrMeasures, pattern.header.bDestGrooveBottom, pattern.header.bDestGrooveTop, pattern.header.dwFlags);
1502 break;
1503 } case DMUS_FOURCC_RHYTHM_CHUNK: {
1504 TRACE("'rhtm': rhytms\n");
1505 pattern.nrofrhytms = chunk.size / sizeof(DWORD);
1506 TRACE_(dmfiledat)("=> number of rhytms = %ld\n", pattern.nrofrhytms);
1507 pattern.rhytms = (DWORD*) HeapAlloc (GetProcessHeap (), 0, sizeof(DWORD) * pattern.nrofrhytms);
1508 ReadFile (fd, pattern.rhytms, sizeof(DWORD) * pattern.nrofrhytms, &BytesRead, NULL);
1509 for (i = 0; i < pattern.nrofrhytms; i++)
1510 {
1511 TRACE_(dmfiledat)("=> rhytm[%i] = %ld\n", i, pattern.rhytms[i]);
1512 }
1513 break;
1514 } case DMUS_FOURCC_MOTIFSETTINGS_CHUNK: {
1515 TRACE("'mtfs': motif settings\n");
1516 ReadFile (fd, &pattern.motsettings, chunk.size, &BytesRead, NULL);
1517 TRACE_(dmfiledat)("=> dwRepeats = %ld; mtPlayStart = %li; mtLoopStart = %li; mtLoopEnd = %li; dwResolution = %ld\n", \
1518 pattern.motsettings.dwRepeats, pattern.motsettings.mtPlayStart, pattern.motsettings.mtLoopStart, pattern.motsettings.mtLoopEnd, pattern.motsettings.dwResolution);
1519 break;
1520 } case FOURCC_LIST: {
1521 TRACE("'LIST': list chunk (size = %ld)\n", chunk.size);
1522 ListSize2 = chunk.size - sizeof(FOURCC); /* list content size = size of 'LIST' chunk - FOURCC ID of the list */
1523 ListCount2 = 0;
1524 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
1525 switch (chunk.id)
1526 {
1527 case DMUS_FOURCC_UNFO_LIST: {
1528 TRACE("'UNFO': UNFO list (forward to DMUSIC_FillUNFOFromFileHandle(...))\n");
1529 SetFilePointer (fd, -(sizeof(DWORD) + 2*sizeof(FOURCC)), NULL, FILE_CURRENT); /* place pointer before the 'LIST' chunk */
1530 DMUSIC_FillUNFOFromFileHandle (UNFO, fd);
1531 break;
1532 } case DMUS_FOURCC_PARTREF_LIST: {
1533 TRACE("'pref': part references list (content size = %ld)\n", ListSize2);
1534 do {
1535 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
1536 ReadFile (fd, &chunk.size, sizeof(DWORD), &BytesRead, NULL);
1537 ListCount2 += sizeof(FOURCC) + sizeof(DWORD) + chunk.size;
1538 switch (chunk.id)
1539 {
1540 case DMUS_FOURCC_PARTREF_CHUNK: {
1541 TRACE("'prfc': part reference\n");
1542 ReadFile (fd, &pattern.partref, chunk.size, &BytesRead, NULL);
1543 TRACE_(dmfiledat)("=> guidPartID = %s; wLogicalPartID = %d; bVariationLockID = %i; bSubChordLevel = %i; bPriority = %i; bRandomVariation = %i; wPad = %d; dwPChannel = %ld\n", \
1544 debugstr_guid (&pattern.partref.guidPartID), pattern.partref.wLogicalPartID, pattern.partref.bVariationLockID, pattern.partref.bSubChordLevel, \
1545 pattern.partref.bPriority, pattern.partref.bRandomVariation, pattern.partref.wPad, pattern.partref.dwPChannel);
1546 break;
1547 } case FOURCC_LIST: {
1548 TRACE("'LIST': list chunk (MSDN doesn't mention it)\n");
1549 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
1550 if (chunk.id == DMUS_FOURCC_UNFO_LIST) {
1551 TRACE("'UNFO': UNFO list (forward to DMUSIC_FillUNFOFromFileHandle(...))\n");
1552 SetFilePointer (fd, -(sizeof(DWORD) + 2*sizeof(FOURCC)), NULL, FILE_CURRENT); /* place pointer before the 'LIST' chunk */
1553 DMUSIC_FillUNFOFromFileHandle (UNFO, fd);
1554 } else {
1555 WARN("invalid chunk (only 'UNFO' chunk allowed)\n");
1556 }
1557 break;
1558 } default: {
1559 WARN("invalid chunk (only 'prfc' and 'UNFO'chunk allowed)\n");
1560 }
1561 }
1562 TRACE("ListCount2 (%ld) < ListSize2 (%ld)\n", ListCount2, ListSize2);
1563 } while (ListCount2 < ListSize2);
1564 break;
1565 } default: {
1566 WARN("invalid chunk (only 'UNFO' and 'pref' chunks allowed\n");
1567 break;
1568 }
1569 }
1570 break;
1571 } case FOURCC_RIFF: {
1572 TRACE("'RIFF': embedded RIFF (size = %ld; could be embedded band form)\n", chunk.size);
1573 ReadFile (fd, &chunk.id, sizeof(FOURCC), &BytesRead, NULL);
1574 if (chunk.id == DMUS_FOURCC_BAND_FORM) {
1575 TRACE("'DMBD': embedded band form (forward to DMUSIC_FillBandFromFileHandle(...))\n");
1576 SetFilePointer (fd, -(sizeof(DWORD) + 2*sizeof(FOURCC)), NULL, FILE_CURRENT); /* place pointer before 'RIFF' chunk */
1577 DMUSIC_FillBandFromFileHandle (NULL, fd);
1578 } else WARN("invalid chunk (only 'DMBD' chunk allowed)\n");
1579 break;
1580 } default: {
1581 WARN("invalid chunk (only 'prnh','rhtm', 'mtfs', 'LIST' and 'RIFF' chunks allowed\n");
1582 break;
1583 }
1584 }
1585 TRACE("ListCount (%ld) < ListSize (%ld)\n", ListCount, ListSize);
1586 } while (ListCount < ListSize);
1587 break;
1588 } default: {
1589 WARN("invalid chunk (only 'UNFO', 'part', 'pttn' and 'RIFF' chunks allowed)\n");
1590 }
1591 }
1592 break;
1593 } default: {
1594 WARN("invalid chunk (only 'styh', 'guid', 'vers', 'LIST', and 'RIFF' chunks allowed)\n");
1595 break;
1596 }
1597 }
1598 TRACE("FileCount (%ld) < FileSize (%ld)\n", FileCount, FileSize);
1599 } while (FileCount < FileSize);
1600 } else {
1601 WARN("invalid chunk (only 'DMST' chunk allowed)\n");
1602 }
1603 } else {
1604 WARN("'RIFF' not found: not a RIFF file\n");
1605 }
1606
1607 return S_OK;
1608 }
1609
1610 #endif
Windows API implementation