x64dbg
/
btparser
mirror of https://github.com/x64dbg/btparser
1
0
Fork 0
Code Releases Activity
btparser/cparser/tests/exp_lex/SF2Template.bt

823 lines
20 KiB
Plaintext
Raw Blame History

1:
2:
3:
4:
5:
6:
7:
8:
9:
10:
11:
12: typedef CHAR ID [ 4 ] ;
13:
14: local int cGrayZone = 0xD9DADC ;
15: local int cOrange = 0xAAE3F9 ;
16: local int cSytrus = 0xAAF7FF ;
17: local int cGreenGreens = 0xAAECDF ;
18: local int cCureMarine = 0xFFE1CE ;
19: local int cCureMarine_Alt = 0xFDF1DD ;
20: local int cPurpleMadness = 0xEEC3DD ;
21: local int cPurpleMadness_Alt = 0xFFE1FA ;
22:
23:
24:
25:
26:
27: typedef enum < WORD > {
28: monoSample = 1 ,
29: rightSample = 2 ,
30: leftSample = 4 ,
31: linkedSample = 8 ,
32: RomMonoSample = 0x8001 ,
33: RomRightSample = 0x8002 ,
34: RomLeftSample = 0x8004 ,
35: RomLinkedSample = 0x8008 ,
36: } SFSampleLink ;
37:
38: typedef enum < WORD > {
39: startAddrsOffset = 0 ,
40: endAddrsOffset = 1 ,
41: startloopAddrsOffset = 2 ,
42: endloopAddrsOffset = 3 ,
43: startAddrsCoarseOffset = 4 ,
44: modLfoToPitch = 5 ,
45: vibLfoToPitch = 6 ,
46: modEnvToPitch = 7 ,
47: initialFilterFc = 8 ,
48: initialFilterQ = 9 ,
49: modLfoToFilterFc = 10 ,
50: modEnvToFilterFc = 11 ,
51: endAddrsCoarseOffset = 12 ,
52: modLfoToVolume = 13 ,
53: chorusEffectsSend = 15 ,
54: reverbEffectsSend = 16 ,
55: pan = 17 ,
56: delayModLFO = 21 ,
57: freqModLFO = 22 ,
58: delayVibLFO = 23 ,
59: freqVibLFO = 24 ,
60: delayModEnv = 25 ,
61: attackModEnv = 26 ,
62: holdModEnv = 27 ,
63: decayModEnv = 28 ,
64: sustainModEnv = 29 ,
65: releaseModEnv = 30 ,
66: keynumToModEnvHold = 31 ,
67: keynumToModEnvDecay = 32 ,
68: delayVolEnv = 33 ,
69: attackVolEnv = 34 ,
70: holdVolEnv = 35 ,
71: decayVolEnv = 36 ,
72: sustainVolEnv = 37 ,
73: releaseVolEnv = 38 ,
74: keynumToVolEnvHold = 39 ,
75: keynumToVolEnvDecay = 40 ,
76: instrument = 41 ,
77: keyRange = 43 ,
78: velRange = 44 ,
79: startloopAddrsCoarseOffset = 45 ,
80: keynum = 46 ,
81: velocity = 47 ,
82: initialAttenuation = 48 ,
83: endloopAddrsCoarseOffset = 50 ,
84: coarseTune = 51 ,
85: fineTune = 52 ,
86: sampleID = 53 ,
87: sampleModes = 54 ,
88: scaleTuning = 56 ,
89: exclusiveClass = 57 ,
90: overridingRootKey = 58 ,
91: endOper = 60 ,
92: } SFGenerator ;
93:
94: typedef enum < BYTE > {
95: noController = 0 ,
96: noteOnVelocity = 2 ,
97: noteOnKeyNumber = 3 ,
98: polyPressure = 10 ,
99: channelPressure = 13 ,
100: pitchWheel = 14 ,
101: pitchWheelSensitivity = 16 ,
102: link = 127 ,
103: } SFGeneralController ;
104:
105: typedef enum < BYTE > {
106: generalController = 0 ,
107: midiController = 1 ,
108: } SFControllerPalette ;
109:
110: typedef enum < BYTE > {
111: increase = 0 ,
112: decrease = 1 ,
113: } SFControllerDirection ;
114:
115: typedef enum < BYTE > {
116: unipolar = 0 ,
117: bipolar = 1 ,
118: } SFControllerPolarity ;
119:
120: typedef enum < BYTE > {
121: linearType = 0 ,
122: concaveType = 1 ,
123: convexType = 2 ,
124: switchType = 3 ,
125: } SFControllerType ;
126:
127: typedef struct {
128: union {
129: SFGeneralController general : 7 ;
130: BYTE midi : 7 ;
131: } index ;
132: SFControllerPalette palette : 1 ;
133: SFControllerDirection direction : 1 ;
134: SFControllerPolarity polarity : 1 ;
135: SFControllerType type : 6 ;
136: } SFModulator ;
137:
138: typedef enum < WORD > {
139: linear = 0 ,
140: absoluteValue = 2 ,
141: } SFTransform ;
142:
143: typedef struct
144: {
145: BYTE byLo ;
146: BYTE byHi ;
147: } rangesType ;
148:
149: typedef union
150: {
151: rangesType ranges ;
152: SHORT shAmount ;
153: WORD wAmount ;
154: } genAmountType ;
155:
156:
157: typedef struct {
158: WORD wMajor ;
159: WORD wMinor ;
160: } sfVersionTag ;
161:
162: typedef struct {
163: CHAR achPresetName [ 20 ] ;
164: WORD wPreset ;
165: WORD wBank ;
166: WORD wPresetBagNdx ;
167: DWORD dwLibrary ;
168: DWORD dwGenre ;
169: DWORD dwMorphology ;
170: } sfPresetHeader ;
171:
172: typedef struct
173: {
174: WORD wGenNdx ;
175: WORD wModNdx ;
176: } sfPresetBag ;
177:
178: typedef struct
179: {
180: SFModulator sfModSrcOper ;
181: SFGenerator sfModDestOper ;
182: SHORT modAmount ;
183: SFModulator sfModAmtSrcOper ;
184: SFTransform sfModTransOper ;
185: } sfModList ;
186:
187: typedef struct
188: {
189: SFGenerator sfGenOper ;
190: genAmountType genAmount ;
191: } sfGenList ;
192:
193: typedef struct
194: {
195: CHAR achInstName [ 20 ] ;
196: WORD wInstBagNdx ;
197: } sfInst ;
198:
199: typedef struct
200: {
201: WORD wInstGenNdx ;
202: WORD wInstModNdx ;
203: } sfInstBag ;
204:
205: typedef struct
206: {
207: SFModulator sfModSrcOper ;
208: SFGenerator sfModDestOper ;
209: SHORT modAmount ;
210: SFModulator sfModAmtSrcOper ;
211: SFTransform sfModTransOper ;
212: } sfInstModList ;
213:
214: typedef struct
215: {
216: SFGenerator sfGenOper ;
217: genAmountType genAmount ;
218: } sfInstGenList ;
219:
220: typedef struct
221: {
222: CHAR achSampleName [ 20 ] ;
223: DWORD dwStart ;
224: DWORD dwEnd ;
225: DWORD dwStartloop ;
226: DWORD dwEndloop ;
227: DWORD dwSampleRate ;
228: BYTE byOriginalKey ;
229: CHAR chCorrection ;
230: WORD wSampleLink ;
231: SFSampleLink sfSampleType ;
232: } sfSample ;
233:
234:
235: typedef struct {
236: ID chunkID ;
237: DWORD chunkSize ;
238: CHAR text [ chunkSize ] ;
239:
240:
241: if ( ( chunkSize & 1 ) && ( FTell ( ) < FileSize ( ) ) )
242: UCHAR padding ;
243: } ZSTRCk ;
244:
245: typedef struct {
246: ID chunkID ;
247: DWORD chunkSize ;
248: local quad pos = FTell ( ) ;
249:
250: if ( FileSize ( ) - pos >= sizeof ( sfVersionTag ) ) {
251: sfVersionTag version ;
252: }
253:
254: local int unknownDataSize = chunkSize - ( FTell ( ) - pos ) ;
255: if ( unknownDataSize > 0 ) {
256: Printf ( "Encountered unknown data in chunk '%s' of size %d at position 0x%LX.\n" ,
257: chunkID , unknownDataSize , FTell ( ) ) ;
258: UCHAR unknownData [ unknownDataSize ] ;
259: }
260:
261:
262: if ( ( chunkSize & 1 ) && ( FTell ( ) < FileSize ( ) ) )
263: UCHAR padding ;
264: } sfVersionTagCk ;
265:
266: typedef struct {
267: ID chunkID ;
268: DWORD chunkSize ;
269:
270: SHORT samples [ chunkSize / 2 ] ;
271:
272: local int unknownDataSize = chunkSize - ( FTell ( ) - pos ) ;
273: if ( unknownDataSize > 0 ) {
274: Printf ( "Encountered unknown data in chunk '%s' of size %d at position 0x%LX.\n" ,
275: chunkID , unknownDataSize , FTell ( ) ) ;
276: UCHAR unknownData [ unknownDataSize ] ;
277: }
278:
279:
280: if ( ( chunkSize & 1 ) && ( FTell ( ) < FileSize ( ) ) )
281: UCHAR padding ;
282: } smplCk ;
283:
284: typedef struct {
285: ID chunkID ;
286: DWORD chunkSize ;
287:
288: BYTE samples [ chunkSize ] ;
289:
290:
291: if ( ( chunkSize & 1 ) && ( FTell ( ) < FileSize ( ) ) )
292: UCHAR padding ;
293: } sm24Ck ;
294:
295: typedef struct {
296: ID chunkID ;
297: DWORD chunkSize ;
298: local quad pos = FTell ( ) ;
299:
300: while ( chunkSize - ( FTell ( ) - pos ) >= sizeof ( sfPresetHeader ) ) {
301: sfPresetHeader header ;
302: }
303:
304: local int unknownDataSize = chunkSize - ( FTell ( ) - pos ) ;
305: if ( unknownDataSize > 0 ) {
306: Printf ( "Encountered unknown data in chunk '%s' of size %d at position 0x%LX.\n" ,
307: chunkID , unknownDataSize , FTell ( ) ) ;
308: UCHAR unknownData [ unknownDataSize ] ;
309: }
310:
311:
312: if ( ( chunkSize & 1 ) && ( FTell ( ) < FileSize ( ) ) )
313: UCHAR padding ;
314: } phdrCk ;
315:
316: typedef struct {
317: ID chunkID ;
318: DWORD chunkSize ;
319: local quad pos = FTell ( ) ;
320:
321: while ( chunkSize - ( FTell ( ) - pos ) >= sizeof ( sfPresetBag ) ) {
322: sfPresetBag bag ;
323: }
324:
325: local int unknownDataSize = chunkSize - ( FTell ( ) - pos ) ;
326: if ( unknownDataSize > 0 ) {
327: Printf ( "Encountered unknown data in chunk '%s' of size %d at position 0x%LX.\n" ,
328: chunkID , unknownDataSize , FTell ( ) ) ;
329: UCHAR unknownData [ unknownDataSize ] ;
330: }
331:
332:
333: if ( ( chunkSize & 1 ) && ( FTell ( ) < FileSize ( ) ) )
334: UCHAR padding ;
335: } pbagCk ;
336:
337: typedef struct {
338: ID chunkID ;
339: DWORD chunkSize ;
340: local quad pos = FTell ( ) ;
341:
342: while ( chunkSize - ( FTell ( ) - pos ) >= sizeof ( sfModList ) ) {
343: sfModList mod ;
344: }
345:
346: local int unknownDataSize = chunkSize - ( FTell ( ) - pos ) ;
347: if ( unknownDataSize > 0 ) {
348: Printf ( "Encountered unknown data in chunk '%s' of size %d at position 0x%LX.\n" ,
349: chunkID , unknownDataSize , FTell ( ) ) ;
350: UCHAR unknownData [ unknownDataSize ] ;
351: }
352:
353:
354: if ( ( chunkSize & 1 ) && ( FTell ( ) < FileSize ( ) ) )
355: UCHAR padding ;
356: } pmodCk ;
357:
358: typedef struct {
359: ID chunkID ;
360: DWORD chunkSize ;
361: local quad pos = FTell ( ) ;
362:
363: while ( chunkSize - ( FTell ( ) - pos ) >= sizeof ( sfGenList ) ) {
364: sfGenList gen ;
365: }
366:
367: local int unknownDataSize = chunkSize - ( FTell ( ) - pos ) ;
368: if ( unknownDataSize > 0 ) {
369: Printf ( "Encountered unknown data in chunk '%s' of size %d at position 0x%LX.\n" ,
370: chunkID , unknownDataSize , FTell ( ) ) ;
371: UCHAR unknownData [ unknownDataSize ] ;
372: }
373:
374:
375: if ( ( chunkSize & 1 ) && ( FTell ( ) < FileSize ( ) ) )
376: UCHAR padding ;
377: } pgenCk ;
378:
379: typedef struct {
380: ID chunkID ;
381: DWORD chunkSize ;
382: local quad pos = FTell ( ) ;
383:
384: while ( chunkSize - ( FTell ( ) - pos ) >= sizeof ( sfInst ) ) {
385: sfInst inst ;
386: }
387:
388: local int unknownDataSize = chunkSize - ( FTell ( ) - pos ) ;
389: if ( unknownDataSize > 0 ) {
390: Printf ( "Encountered unknown data in chunk '%s' of size %d at position 0x%LX.\n" ,
391: chunkID , unknownDataSize , FTell ( ) ) ;
392: UCHAR unknownData [ unknownDataSize ] ;
393: }
394:
395:
396: if ( ( chunkSize & 1 ) && ( FTell ( ) < FileSize ( ) ) )
397: UCHAR padding ;
398: } instCk ;
399:
400: typedef struct {
401: ID chunkID ;
402: DWORD chunkSize ;
403: local quad pos = FTell ( ) ;
404:
405: while ( chunkSize - ( FTell ( ) - pos ) >= sizeof ( sfInstBag ) ) {
406: sfInstBag bag ;
407: }
408:
409: local int unknownDataSize = chunkSize - ( FTell ( ) - pos ) ;
410: if ( unknownDataSize > 0 ) {
411: Printf ( "Encountered unknown data in chunk '%s' of size %d at position 0x%LX.\n" ,
412: chunkID , unknownDataSize , FTell ( ) ) ;
413: UCHAR unknownData [ unknownDataSize ] ;
414: }
415:
416:
417: if ( ( chunkSize & 1 ) && ( FTell ( ) < FileSize ( ) ) )
418: UCHAR padding ;
419: } ibagCk ;
420:
421: typedef struct {
422: ID chunkID ;
423: DWORD chunkSize ;
424: local quad pos = FTell ( ) ;
425:
426: while ( chunkSize - ( FTell ( ) - pos ) >= sizeof ( sfInstModList ) ) {
427: sfInstModList mod ;
428: }
429:
430: local int unknownDataSize = chunkSize - ( FTell ( ) - pos ) ;
431: if ( unknownDataSize > 0 ) {
432: Printf ( "Encountered unknown data in chunk '%s' of size %d at position 0x%LX.\n" ,
433: chunkID , unknownDataSize , FTell ( ) ) ;
434: UCHAR unknownData [ unknownDataSize ] ;
435: }
436:
437:
438: if ( ( chunkSize & 1 ) && ( FTell ( ) < FileSize ( ) ) )
439: UCHAR padding ;
440: } imodCk ;
441:
442: typedef struct {
443: ID chunkID ;
444: DWORD chunkSize ;
445: local quad pos = FTell ( ) ;
446:
447: while ( chunkSize - ( FTell ( ) - pos ) >= sizeof ( sfInstGenList ) ) {
448: sfInstGenList gen ;
449: }
450:
451: local int unknownDataSize = chunkSize - ( FTell ( ) - pos ) ;
452: if ( unknownDataSize > 0 ) {
453: Printf ( "Encountered unknown data in chunk '%s' of size %d at position 0x%LX.\n" ,
454: chunkID , unknownDataSize , FTell ( ) ) ;
455: UCHAR unknownData [ unknownDataSize ] ;
456: }
457:
458:
459: if ( ( chunkSize & 1 ) && ( FTell ( ) < FileSize ( ) ) )
460: UCHAR padding ;
461: } igenCk ;
462:
463: typedef struct {
464: ID chunkID ;
465: DWORD chunkSize ;
466: local quad pos = FTell ( ) ;
467:
468: while ( chunkSize - ( FTell ( ) - pos ) >= sizeof ( sfSample ) ) {
469: sfSample sample ;
470: }
471:
472: local int unknownDataSize = chunkSize - ( FTell ( ) - pos ) ;
473: if ( unknownDataSize > 0 ) {
474: Printf ( "Encountered unknown data in chunk '%s' of size %d at position 0x%LX.\n" ,
475: chunkID , unknownDataSize , FTell ( ) ) ;
476: UCHAR unknownData [ unknownDataSize ] ;
477: }
478:
479:
480: if ( ( chunkSize & 1 ) && ( FTell ( ) < FileSize ( ) ) )
481: UCHAR padding ;
482: } shdrCk ;
483:
484:
485: typedef struct {
486: ID chunkID ;
487: DWORD chunkSize ;
488: CHAR data [ chunkSize ] ;
489:
490:
491: if ( ( chunkSize & 1 ) && ( FTell ( ) < FileSize ( ) ) )
492: UCHAR padding ;
493: } UNKNOWNLISTSUBCHUNK ;
494:
495: typedef struct {
496: ID chunkID ;
497: DWORD chunkSize ;
498: local quad pos = FTell ( ) ;
499: ID chunkType ;
500:
501:
502: local char tag [ 5 ] ;
503: local DWORD size ;
504: while ( FTell ( ) - pos < chunkSize )
505: {
506:
507: ReadBytes ( tag , FTell ( ) , 4 ) ;
508: tag [ 4 ] = 0 ;
509:
510:
511: size = ReadUInt ( FTell ( ) + 4 ) ;
512: if ( FTell ( ) - pos + size > chunkSize ) {
513: Printf ( "Chunk '%s' of size %d at position 0x%LX exceeds the parent chunk size boundary.\n" , tag , size , FTell ( ) ) ;
514: return - 1 ;
515: }
516:
517:
518: switch ( tag )
519: {
520: case "ifil" :
521: SetBackColor ( cOrange ) ;
522: sfVersionTagCk ifil ;
523: break ;
524: case "isng" :
525: SetBackColor ( cOrange ) ;
526: ZSTRCk isng ;
527: break ;
528: case "INAM" :
529: SetBackColor ( cOrange ) ;
530: ZSTRCk INAM ;
531: break ;
532: case "iver" :
533: SetBackColor ( cSytrus ) ;
534: sfVersionTagCk iver ;
535: break ;
536: case "ICRD" :
537: SetBackColor ( cSytrus ) ;
538: ZSTRCk ICRD ;
539: break ;
540: case "IENG" :
541: SetBackColor ( cSytrus ) ;
542: ZSTRCk IENG ;
543: break ;
544: case "IPRD" :
545: SetBackColor ( cSytrus ) ;
546: ZSTRCk IPRD ;
547: break ;
548: case "ICOP" :
549: SetBackColor ( cSytrus ) ;
550: ZSTRCk ICOP ;
551: break ;
552: case "ICMT" :
553: SetBackColor ( cSytrus ) ;
554: ZSTRCk ICMT ;
555: break ;
556: case "ISFT" :
557: SetBackColor ( cSytrus ) ;
558: ZSTRCk ISFT ;
559: break ;
560: default :
561:
562: Printf ( "Encountered unknown chunk '%s' of size %d at position 0x%LX.\n" ,
563: tag , size , FTell ( ) ) ;
564: SetBackColor ( cNone ) ;
565: UNKNOWNLISTSUBCHUNK chunk ;
566: break ;
567: }
568: }
569:
570:
571: if ( ( chunkSize & 1 ) && ( FTell ( ) < FileSize ( ) ) )
572: UCHAR padding ;
573: } INFOCk ;
574:
575: typedef struct {
576: ID chunkID ;
577: DWORD chunkSize ;
578: local quad pos = FTell ( ) ;
579: ID chunkType ;
580:
581:
582: local char tag [ 5 ] ;
583: local DWORD size ;
584: while ( FTell ( ) - pos < chunkSize )
585: {
586:
587: ReadBytes ( tag , FTell ( ) , 4 ) ;
588: tag [ 4 ] = 0 ;
589:
590:
591: size = ReadUInt ( FTell ( ) + 4 ) ;
592: if ( FTell ( ) - pos + size > chunkSize ) {
593: Printf ( "Chunk '%s' of size %d at position 0x%LX exceeds the parent chunk size boundary.\n" , tag , size , FTell ( ) ) ;
594: return - 1 ;
595: }
596:
597:
598: switch ( tag )
599: {
600: case "smpl" :
601: SetBackColor ( cGreenGreens ) ;
602: smplCk smpl ;
603: break ;
604: case "sm24" :
605: SetBackColor ( cGreenGreens ) ;
606: sm24Ck sm24 ;
607: break ;
608: default :
609:
610: Printf ( "Encountered unknown chunk '%s' of size %d at position 0x%LX.\n" ,
611: tag , size , FTell ( ) ) ;
612: SetBackColor ( cNone ) ;
613: UNKNOWNLISTSUBCHUNK chunk ;
614: break ;
615: }
616: }
617:
618:
619: if ( ( chunkSize & 1 ) && ( FTell ( ) < FileSize ( ) ) )
620: UCHAR padding ;
621: } sdtaCk ;
622:
623: typedef struct {
624: ID chunkID ;
625: DWORD chunkSize ;
626: local quad pos = FTell ( ) ;
627: ID chunkType ;
628:
629:
630: local char tag [ 5 ] ;
631: local DWORD size ;
632: while ( FTell ( ) - pos < chunkSize )
633: {
634:
635: ReadBytes ( tag , FTell ( ) , 4 ) ;
636: tag [ 4 ] = 0 ;
637:
638:
639: size = ReadUInt ( FTell ( ) + 4 ) ;
640: if ( FTell ( ) - pos + size > chunkSize ) {
641: Printf ( "Chunk '%s' of size %d at position 0x%LX exceeds the parent chunk size boundary.\n" , tag , size , FTell ( ) ) ;
642: return - 1 ;
643: }
644:
645:
646: switch ( tag )
647: {
648: case "phdr" :
649: SetBackColor ( cCureMarine ) ;
650: phdrCk phdr ;
651: break ;
652: case "pbag" :
653: SetBackColor ( cCureMarine_Alt ) ;
654: pbagCk pbag ;
655: break ;
656: case "pmod" :
657: SetBackColor ( cCureMarine ) ;
658: pmodCk pmod ;
659: break ;
660: case "pgen" :
661: SetBackColor ( cCureMarine_Alt ) ;
662: pgenCk pgen ;
663: break ;
664: case "inst" :
665: SetBackColor ( cPurpleMadness ) ;
666: instCk inst ;
667: break ;
668: case "ibag" :
669: SetBackColor ( cPurpleMadness_Alt ) ;
670: ibagCk ibag ;
671: break ;
672: case "imod" :
673: SetBackColor ( cPurpleMadness ) ;
674: imodCk imod ;
675: break ;
676: case "igen" :
677: SetBackColor ( cPurpleMadness_Alt ) ;
678: igenCk igen ;
679: break ;
680: case "shdr" :
681: SetBackColor ( cSytrus ) ;
682: shdrCk shdr ;
683: break ;
684: default :
685:
686: Printf ( "Encountered unknown chunk '%s' of size %d at position 0x%LX.\n" ,
687: tag , size , FTell ( ) ) ;
688: SetBackColor ( cNone ) ;
689: UNKNOWNLISTSUBCHUNK subchunk ;
690: break ;
691: }
692: }
693:
694:
695: if ( ( chunkSize & 1 ) && ( FTell ( ) < FileSize ( ) ) )
696: UCHAR padding ;
697: } pdtaCk ;
698:
699:
700: typedef struct {
701: ID chunkID ;
702: DWORD chunkSize ;
703: local quad pos = FTell ( ) ;
704: ID chunkType ;
705:
706:
707: local char tag [ 5 ] ;
708: local DWORD size ;
709: while ( FTell ( ) - pos < chunkSize )
710: {
711:
712: ReadBytes ( tag , FTell ( ) , 4 ) ;
713: tag [ 4 ] = 0 ;
714:
715:
716: size = ReadUInt ( FTell ( ) + 4 ) ;
717: if ( FTell ( ) - pos + size > chunkSize ) {
718: Printf ( "Chunk '%s' of size %d at position 0x%LX exceeds the parent chunk size boundary.\n" , tag , size , FTell ( ) ) ;
719: return - 1 ;
720: }
721:
722: UNKNOWNLISTSUBCHUNK subchunk ;
723: }
724:
725:
726: if ( ( chunkSize & 1 ) && ( FTell ( ) < FileSize ( ) ) )
727: UCHAR padding ;
728: } UNKNOWNLISTCHUNK ;
729:
730: typedef struct {
731: ID chunkID ;
732: DWORD chunkSize ;
733: UCHAR unknownData [ chunkSize ] ;
734:
735:
736: if ( ( chunkSize & 1 ) && ( FTell ( ) < FileSize ( ) ) )
737: UCHAR padding ;
738: } UNKNOWNCHUNK ;
739:
740:
741: typedef struct
742: {
743: ID groupID ;
744: DWORD size ;
745: ID riffType ;
746: } RIFFHEADER ;
747:
748:
749:
750:
751:
752:
753: local quad riff_pos = FTell ( ) ;
754: LittleEndian ( ) ;
755: SetBackColor ( cGrayZone ) ;
756: RIFFHEADER header ;
757:
758:
759: if ( header . groupID != "RIFF" || header . riffType != "sfbk" )
760: {
761: Warning ( "File is not a valid SF2 file. Template stopped." ) ;
762: return - 1 ;
763: }
764:
765:
766: local char tag [ 5 ] ;
767: local DWORD size ;
768: local char list_tag [ 5 ] ;
769: while ( FTell ( ) + 8 <= FileSize ( ) && FTell ( ) - riff_pos != header . size + 8 )
770: {
771:
772: ReadBytes ( tag , FTell ( ) , 4 ) ;
773: tag [ 4 ] = 0 ;
774:
775:
776: size = ReadUInt ( FTell ( ) + 4 ) ;
777:
778:
779: switch ( tag )
780: {
781: case "LIST" :
782:
783: ReadBytes ( list_tag , FTell ( ) + 8 , 4 ) ;
784: list_tag [ 4 ] = 0 ;
785:
786: switch ( list_tag )
787: {
788: case "INFO" :
789: SetBackColor ( cGrayZone ) ;
790: INFOCk INFO ;
791: break ;
792: case "sdta" :
793: SetBackColor ( cGrayZone ) ;
794: sdtaCk sdta ;
795: break ;
796: case "pdta" :
797: SetBackColor ( cGrayZone ) ;
798: pdtaCk pdta ;
799: break ;
800: default :
801: SetBackColor ( cNone ) ;
802: UNKNOWNLISTCHUNK list ;
803: break ;
804: }
805: break ;
806: default :
807:
808: Printf ( "Encountered unknown chunk '%s' of size %d at position 0x%LX.\n" ,
809: tag , size , FTell ( ) ) ;
810: SetBackColor ( cNone ) ;
811: UNKNOWNCHUNK unknown ;
812: break ;
813: }
814: }
815:
816:
817: local quad actual_size = FTell ( ) - riff_pos ;
818: if ( actual_size != 8 + header . size )
819: {
820: Printf ( "RIFF file size mismatch (header value %Ld, actual size %Ld).\n" , header . size , actual_size - 8 ) ;
821: return - 1 ;
822: }
823: tok_eof
View Git Blame Copy Permalink