1 /* MikMod sound library
2 (c) 1998, 1999, 2000, 2001, 2002 Miodrag Vallat and others - see file
3 AUTHORS for complete list.
4
5 This library is free software; you can redistribute it and/or modify
6 it under the terms of the GNU Library General Public License as
7 published by the Free Software Foundation; either version 2 of
8 the License, or (at your option) any later version.
9
10 This program is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 GNU Library General Public License for more details.
14
15 You should have received a copy of the GNU Library General Public
16 License along with this library; if not, write to the Free Software
17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
18 02111-1307, USA.
19 */
20
21 /*==============================================================================
22
23 $Id$
24
25 Impulse tracker (IT) module loader
26
27 ==============================================================================*/
28
29 #ifdef HAVE_CONFIG_H
30 #include "config.h"
31 #endif
32
33 #ifdef HAVE_UNISTD_H
34 #include <unistd.h>
35 #endif
36
37 #include <stdio.h>
38 #ifdef HAVE_MEMORY_H
39 #include <memory.h>
40 #endif
41 #include <string.h>
42
43 #include "mikmod_internals.h"
44 #include "mikmod_ctype.h"
45
46 #ifdef SUNOS
47 extern int fprintf(FILE *, const char *, ...);
48 #endif
49
50 /*========== Module structure */
51
52 /* header */
53 typedef struct ITHEADER {
54 CHAR songname[26];
55 UBYTE blank01[2];
56 UWORD ordnum;
57 UWORD insnum;
58 UWORD smpnum;
59 UWORD patnum;
60 UWORD cwt; /* Created with tracker (y.xx = 0x0yxx) */
61 UWORD cmwt; /* Compatible with tracker ver > than val. */
62 UWORD flags;
63 UWORD special; /* bit 0 set = song message attached */
64 UBYTE globvol;
65 UBYTE mixvol; /* mixing volume [ignored] */
66 UBYTE initspeed;
67 UBYTE inittempo;
68 UBYTE pansep; /* panning separation between channels */
69 UBYTE zerobyte;
70 UWORD msglength;
71 ULONG msgoffset;
72 UBYTE blank02[4];
73 UBYTE pantable[64];
74 UBYTE voltable[64];
75 } ITHEADER;
76
77 /* sample information */
78 typedef struct ITSAMPLE {
79 CHAR filename[12];
80 UBYTE zerobyte;
81 UBYTE globvol;
82 UBYTE flag;
83 UBYTE volume;
84 UBYTE panning;
85 CHAR sampname[28];
86 UWORD convert; /* sample conversion flag */
87 ULONG length;
88 ULONG loopbeg;
89 ULONG loopend;
90 ULONG c5spd;
91 ULONG susbegin;
92 ULONG susend;
93 ULONG sampoffset;
94 UBYTE vibspeed;
95 UBYTE vibdepth;
96 UBYTE vibrate;
97 UBYTE vibwave; /* 0=sine, 1=rampdown, 2=square, 3=random (speed ignored) */
98 } ITSAMPLE;
99
100 /* instrument information */
101
102 #define ITENVCNT 25
103 #define ITNOTECNT 120
104 typedef struct ITINSTHEADER {
105 ULONG size; /* (dword) Instrument size */
106 CHAR filename[12]; /* (char) Instrument filename */
107 UBYTE zerobyte; /* (byte) Instrument type (always 0) */
108 UBYTE volflg;
109 UBYTE volpts;
110 UBYTE volbeg; /* (byte) Volume loop start (node) */
111 UBYTE volend; /* (byte) Volume loop end (node) */
112 UBYTE volsusbeg; /* (byte) Volume sustain begin (node) */
113 UBYTE volsusend; /* (byte) Volume Sustain end (node) */
114 UBYTE panflg;
115 UBYTE panpts;
116 UBYTE panbeg; /* (byte) channel loop start (node) */
117 UBYTE panend; /* (byte) channel loop end (node) */
118 UBYTE pansusbeg; /* (byte) channel sustain begin (node) */
119 UBYTE pansusend; /* (byte) channel Sustain end (node) */
120 UBYTE pitflg;
121 UBYTE pitpts;
122 UBYTE pitbeg; /* (byte) pitch loop start (node) */
123 UBYTE pitend; /* (byte) pitch loop end (node) */
124 UBYTE pitsusbeg; /* (byte) pitch sustain begin (node) */
125 UBYTE pitsusend; /* (byte) pitch Sustain end (node) */
126 UWORD blank;
127 UBYTE globvol;
128 UBYTE chanpan;
129 UWORD fadeout; /* Envelope end / NNA volume fadeout */
130 UBYTE dnc; /* Duplicate note check */
131 UBYTE dca; /* Duplicate check action */
132 UBYTE dct; /* Duplicate check type */
133 UBYTE nna; /* New Note Action [0,1,2,3] */
134 UWORD trkvers; /* tracker version used to save [files only] */
135 UBYTE ppsep; /* Pitch-pan Separation */
136 UBYTE ppcenter; /* Pitch-pan Center */
137 UBYTE rvolvar; /* random volume varations */
138 UBYTE rpanvar; /* random panning varations */
139 UWORD numsmp; /* Number of samples in instrument [files only] */
140 CHAR name[26]; /* Instrument name */
141 UBYTE blank01[6];
142 UWORD samptable[ITNOTECNT];/* sample for each note [note / samp pairs] */
143 UBYTE volenv[200]; /* volume envelope (IT 1.x stuff) */
144 UBYTE oldvoltick[ITENVCNT];/* volume tick position (IT 1.x stuff) */
145 UBYTE volnode[ITENVCNT]; /* amplitude of volume nodes */
146 UWORD voltick[ITENVCNT]; /* tick value of volume nodes */
147 SBYTE pannode[ITENVCNT]; /* panenv - node points */
148 UWORD pantick[ITENVCNT]; /* tick value of panning nodes */
149 SBYTE pitnode[ITENVCNT]; /* pitchenv - node points */
150 UWORD pittick[ITENVCNT]; /* tick value of pitch nodes */
151 } ITINSTHEADER;
152
153 /* unpacked note */
154
155 typedef struct ITNOTE {
156 UBYTE note,ins,volpan,cmd,inf;
157 } ITNOTE;
158
159 /*========== Loader data */
160
161 static ULONG *paraptr=NULL; /* parapointer array (see IT docs) */
162 static ITHEADER *mh=NULL;
163 static ITNOTE *itpat=NULL; /* allocate to space for one full pattern */
164 static UBYTE *mask=NULL; /* arrays allocated to 64 elements and used for */
165 static ITNOTE *last=NULL; /* uncompressing IT's pattern information */
166 static int numtrk=0;
167 static unsigned int old_effect; /* if set, use S3M old-effects stuffs */
168
169 static const CHAR* IT_Version[]={
170 "ImpulseTracker . ",
171 "Compressed ImpulseTracker . ",
172 "ImpulseTracker 2.14p3",
173 "Compressed ImpulseTracker 2.14p3",
174 "ImpulseTracker 2.14p4",
175 "Compressed ImpulseTracker 2.14p4",
176 };
177
178 /* table for porta-to-note command within volume/panning column */
179 static const UBYTE portatable[10]= {0,1,4,8,16,32,64,96,128,255};
180
181 /*========== Loader code */
182
IT_Test(void)183 static BOOL IT_Test(void)
184 {
185 UBYTE id[4];
186
187 if(!_mm_read_UBYTES(id,4,modreader)) return 0;
188 if(!memcmp(id,"IMPM",4)) return 1;
189 return 0;
190 }
191
IT_Init(void)192 static BOOL IT_Init(void)
193 {
194 if(!(mh=(ITHEADER*)MikMod_malloc(sizeof(ITHEADER)))) return 0;
195 if(!(poslookup=(UBYTE*)MikMod_malloc(256*sizeof(UBYTE)))) return 0;
196 if(!(itpat=(ITNOTE*)MikMod_malloc(200*64*sizeof(ITNOTE)))) return 0;
197 if(!(mask=(UBYTE*)MikMod_malloc(64*sizeof(UBYTE)))) return 0;
198 if(!(last=(ITNOTE*)MikMod_malloc(64*sizeof(ITNOTE)))) return 0;
199
200 return 1;
201 }
202
IT_Cleanup(void)203 static void IT_Cleanup(void)
204 {
205 FreeLinear();
206
207 MikMod_free(mh);
208 MikMod_free(poslookup);
209 MikMod_free(itpat);
210 MikMod_free(mask);
211 MikMod_free(last);
212 MikMod_free(paraptr);
213 MikMod_free(origpositions);
214 mh=NULL;
215 poslookup=NULL;
216 itpat=NULL;
217 mask=NULL;
218 last=NULL;
219 paraptr=NULL;
220 origpositions=NULL;
221 }
222
223 /* Because so many IT files have 64 channels as the set number used, but really
224 only use far less (usually from 8 to 24 still), I had to make this function,
225 which determines the number of channels that are actually USED by a pattern.
226
227 NOTE: You must first seek to the file location of the pattern before calling
228 this procedure.
229
230 Returns 0 on error
231 */
IT_GetNumChannels(UWORD patrows)232 static BOOL IT_GetNumChannels(UWORD patrows)
233 {
234 int row=0,flag,ch;
235
236 do {
237 if(_mm_eof(modreader)) {
238 _mm_errno=MMERR_LOADING_PATTERN;
239 return 0;
240 }
241 flag=_mm_read_UBYTE(modreader);
242 if(!flag)
243 row++;
244 else {
245 ch=(flag-1)&63;
246 remap[ch]=0;
247 if(flag & 128) mask[ch]=_mm_read_UBYTE(modreader);
248 if(mask[ch]&1) _mm_skip_BYTE(modreader);
249 if(mask[ch]&2) _mm_skip_BYTE(modreader);
250 if(mask[ch]&4) _mm_skip_BYTE(modreader);
251 if(mask[ch]&8) { _mm_skip_BYTE(modreader);_mm_skip_BYTE(modreader); }
252 }
253 } while(row<patrows);
254
255 return 1;
256 }
257
IT_ConvertTrack(ITNOTE * tr,UWORD numrows)258 static UBYTE* IT_ConvertTrack(ITNOTE* tr,UWORD numrows)
259 {
260 int t;
261 UBYTE note,ins,volpan;
262
263 UniReset();
264
265 for(t=0;t<numrows;t++) {
266 note=tr[t*of.numchn].note;
267 ins=tr[t*of.numchn].ins;
268 volpan=tr[t*of.numchn].volpan;
269
270 if(note!=255) {
271 if(note==253)
272 UniWriteByte(UNI_KEYOFF);
273 else if(note==254) {
274 UniPTEffect(0xc,-1); /* note cut command */
275 volpan=255;
276 } else
277 UniNote(note);
278 }
279
280 if((ins)&&(ins<100))
281 UniInstrument(ins-1);
282 else if(ins==253)
283 UniWriteByte(UNI_KEYOFF);
284 else if(ins!=255) { /* crap */
285 _mm_errno=MMERR_LOADING_PATTERN;
286 return NULL;
287 }
288
289 /* process volume / panning column
290 volume / panning effects do NOT all share the same memory address
291 yet. */
292 if(volpan<=64)
293 UniVolEffect(VOL_VOLUME,volpan);
294 else if(volpan==65) /* fine volume slide up (65-74) - A0 case */
295 UniVolEffect(VOL_VOLSLIDE,0);
296 else if(volpan<=74) { /* fine volume slide up (65-74) - general case */
297 UniVolEffect(VOL_VOLSLIDE,0x0f+((volpan-65)<<4));
298 } else if(volpan==75) /* fine volume slide down (75-84) - B0 case */
299 UniVolEffect(VOL_VOLSLIDE,0);
300 else if(volpan<=84) { /* fine volume slide down (75-84) - general case*/
301 UniVolEffect(VOL_VOLSLIDE,0xf0+(volpan-75));
302 } else if(volpan<=94) /* volume slide up (85-94) */
303 UniVolEffect(VOL_VOLSLIDE,((volpan-85)<<4));
304 else if(volpan<=104)/* volume slide down (95-104) */
305 UniVolEffect(VOL_VOLSLIDE,(volpan-95));
306 else if(volpan<=114)/* pitch slide down (105-114) */
307 UniVolEffect(VOL_PITCHSLIDEDN,(volpan-105));
308 else if(volpan<=124)/* pitch slide up (115-124) */
309 UniVolEffect(VOL_PITCHSLIDEUP,(volpan-115));
310 else if(volpan<=127) { /* crap */
311 _mm_errno=MMERR_LOADING_PATTERN;
312 return NULL;
313 } else if(volpan<=192)
314 UniVolEffect(VOL_PANNING,((volpan-128)==64)?255:((volpan-128)<<2));
315 else if(volpan<=202)/* portamento to note */
316 UniVolEffect(VOL_PORTAMENTO,portatable[volpan-193]);
317 else if(volpan<=212)/* vibrato */
318 UniVolEffect(VOL_VIBRATO,(volpan-203));
319 else if((volpan!=239)&&(volpan!=255)) { /* crap */
320 _mm_errno=MMERR_LOADING_PATTERN;
321 return NULL;
322 }
323
324 S3MIT_ProcessCmd(tr[t*of.numchn].cmd,tr[t*of.numchn].inf,
325 old_effect|S3MIT_IT);
326
327 UniNewline();
328 }
329 return UniDup();
330 }
331
IT_ReadPattern(UWORD patrows)332 static BOOL IT_ReadPattern(UWORD patrows)
333 {
334 int row=0,flag,ch;
335 unsigned int blah;
336 ITNOTE *itt=itpat,dummy,*n,*l;
337 ITNOTE *ite=&itpat[200*64 -1];
338 UBYTE *m;
339
340 memset(itt,255,200*64*sizeof(ITNOTE));
341
342 do {
343 if(_mm_eof(modreader)) {
344 _mm_errno = MMERR_LOADING_PATTERN;
345 return 0;
346 }
347 flag=_mm_read_UBYTE(modreader);
348 if(!flag) {
349 itt=&itt[of.numchn];
350 row++;
351 } else {
352 ch=remap[(flag-1)&63];
353 if(ch!=-1) {
354 n=&itt[ch];
355 l=&last[ch];
356 m=&mask[ch];
357 if(n > ite) { /* malformed file */
358 _mm_errno = MMERR_NOT_A_MODULE;
359 return 0;
360 }
361 } else
362 {
363 n=l=&dummy;
364 blah = 0;
365 m=(UBYTE*)&blah;
366 }
367
368 if(flag&128) *m=_mm_read_UBYTE(modreader);
369 if(*m&1)
370 /* convert IT note off to internal note off */
371 if((l->note=n->note=_mm_read_UBYTE(modreader))==255)
372 l->note=n->note=253;
373 if(*m&2)
374 l->ins=n->ins=_mm_read_UBYTE(modreader);
375 if(*m&4)
376 l->volpan=n->volpan=_mm_read_UBYTE(modreader);
377 if(*m&8) {
378 l->cmd=n->cmd=_mm_read_UBYTE(modreader);
379 l->inf=n->inf=_mm_read_UBYTE(modreader);
380 }
381 if(*m&16)
382 n->note=l->note;
383 if(*m&32)
384 n->ins=l->ins;
385 if(*m&64)
386 n->volpan=l->volpan;
387 if(*m&128) {
388 n->cmd=l->cmd;
389 n->inf=l->inf;
390 }
391 }
392 } while(row<patrows);
393
394 for(blah=0;blah<of.numchn;blah++) {
395 if(!(of.tracks[numtrk++]=IT_ConvertTrack(&itpat[blah],patrows)))
396 return 0;
397 }
398
399 return 1;
400 }
401
LoadMidiString(MREADER * r,CHAR * dest)402 static void LoadMidiString(MREADER* r,CHAR* dest)
403 {
404 CHAR *curp,*lastp;
405
406 _mm_read_UBYTES(dest,32,r);
407 curp=lastp=dest;
408 /* remove blanks and uppercase all */
409 while(*lastp) {
410 if(mik_isalnum((int)*lastp)) *(curp++)=mik_toupper((int)*lastp);
411 lastp++;
412 }
413 *curp=0;
414 }
415
416 /* Load embedded midi information for resonant filters */
IT_LoadMidiConfiguration(MREADER * r)417 static void IT_LoadMidiConfiguration(MREADER* r)
418 {
419 int i;
420
421 memset(filtermacros,0,sizeof(filtermacros));
422 memset(filtersettings,0,sizeof(filtersettings));
423
424 if (r) { /* information is embedded in file */
425 UWORD dat;
426 CHAR midiline[33];
427
428 dat=_mm_read_I_UWORD(r);
429 _mm_fseek(r,8*dat+0x120,SEEK_CUR);
430
431 /* read midi macros */
432 for(i=0;i<UF_MAXMACRO;i++) {
433 LoadMidiString(r,midiline);
434 if((!strncmp(midiline,"F0F00",5))&&
435 ((midiline[5]=='0')||(midiline[5]=='1')))
436 filtermacros[i]=(midiline[5]-'0')|0x80;
437 }
438
439 /* read standalone filters */
440 for(i=0x80;i<0x100;i++) {
441 LoadMidiString(r,midiline);
442 if((!strncmp(midiline,"F0F00",5))&&
443 ((midiline[5]=='0')||(midiline[5]=='1'))) {
444 filtersettings[i].filter=(midiline[5]-'0')|0x80;
445 dat=(midiline[6])?(midiline[6]-'0'):0;
446 if(midiline[7])dat=(dat<<4)|(midiline[7]-'0');
447 filtersettings[i].inf=dat;
448 }
449 }
450 } else { /* use default information */
451 filtermacros[0]=FILT_CUT;
452 for(i=0x80;i<0x90;i++) {
453 filtersettings[i].filter=FILT_RESONANT;
454 filtersettings[i].inf=(i&0x7f)<<3;
455 }
456 }
457 activemacro=0;
458 for(i=0;i<0x80;i++) {
459 filtersettings[i].filter=filtermacros[0];
460 filtersettings[i].inf=i;
461 }
462 }
463
IT_Load(BOOL curious)464 static BOOL IT_Load(BOOL curious)
465 {
466 int t,u,lp;
467 INSTRUMENT *d;
468 SAMPLE *q;
469 /*BOOL compressed=0;*/
470
471 numtrk=0;
472 filters=0;
473
474 /* try to read module header */
475 _mm_read_I_ULONG(modreader); /* kill the 4 byte header */
476 _mm_read_string(mh->songname,26,modreader);
477 _mm_read_UBYTES(mh->blank01,2,modreader);
478 mh->ordnum =_mm_read_I_UWORD(modreader);
479 mh->insnum =_mm_read_I_UWORD(modreader);
480 mh->smpnum =_mm_read_I_UWORD(modreader);
481 mh->patnum =_mm_read_I_UWORD(modreader);
482 mh->cwt =_mm_read_I_UWORD(modreader);
483 mh->cmwt =_mm_read_I_UWORD(modreader);
484 mh->flags =_mm_read_I_UWORD(modreader);
485 mh->special =_mm_read_I_UWORD(modreader);
486 mh->globvol =_mm_read_UBYTE(modreader);
487 mh->mixvol =_mm_read_UBYTE(modreader);
488 mh->initspeed =_mm_read_UBYTE(modreader);
489 mh->inittempo =_mm_read_UBYTE(modreader);
490 mh->pansep =_mm_read_UBYTE(modreader);
491 mh->zerobyte =_mm_read_UBYTE(modreader);
492 mh->msglength =_mm_read_I_UWORD(modreader);
493 mh->msgoffset =_mm_read_I_ULONG(modreader);
494 _mm_read_UBYTES(mh->blank02,4,modreader);
495 _mm_read_UBYTES(mh->pantable,64,modreader);
496 _mm_read_UBYTES(mh->voltable,64,modreader);
497
498 if(_mm_eof(modreader)) {
499 _mm_errno=MMERR_LOADING_HEADER;
500 return 0;
501 }
502 if(mh->ordnum > 256 || mh->insnum > 255 || mh->smpnum > 255 || mh->patnum > 255) {
503 _mm_errno=MMERR_NOT_A_MODULE;
504 return 0;
505 }
506
507 /* set module variables */
508 of.songname = DupStr(mh->songname,26,0); /* make a cstr of songname */
509 of.reppos = 0;
510 of.numpat = mh->patnum;
511 of.numins = mh->insnum;
512 of.numsmp = mh->smpnum;
513 of.initspeed = mh->initspeed;
514 of.inittempo = mh->inittempo;
515 of.initvolume = mh->globvol;
516 of.flags |= UF_BGSLIDES | UF_ARPMEM;
517 if (!(mh->flags & 1))
518 of.flags |= UF_PANNING;
519 of.bpmlimit=32;
520
521 if(mh->songname[25]) {
522 of.numvoices=1+mh->songname[25];
523 #ifdef MIKMOD_DEBUG
524 fprintf(stderr,"Embedded IT limitation to %d voices\n",of.numvoices);
525 #endif
526 }
527
528 /* set the module type */
529 /* 2.17 : IT 2.14p4 */
530 /* 2.16 : IT 2.14p3 with resonant filters */
531 /* 2.15 : IT 2.14p3 (improved compression) */
532 if((mh->cwt<=0x219)&&(mh->cwt>=0x217))
533 of.modtype=MikMod_strdup(IT_Version[mh->cmwt<0x214?4:5]);
534 else if (mh->cwt>=0x215)
535 of.modtype=MikMod_strdup(IT_Version[mh->cmwt<0x214?2:3]);
536 else {
537 of.modtype = MikMod_strdup(IT_Version[mh->cmwt<0x214?0:1]);
538 of.modtype[mh->cmwt<0x214?15:26] = (mh->cwt>>8)+'0';
539 of.modtype[mh->cmwt<0x214?17:28] = ((mh->cwt>>4)&0xf)+'0';
540 of.modtype[mh->cmwt<0x214?18:29] = ((mh->cwt)&0xf)+'0';
541 }
542
543 if(mh->flags&8)
544 of.flags |= UF_XMPERIODS | UF_LINEAR;
545
546 if((mh->cwt>=0x106)&&(mh->flags&16))
547 old_effect=S3MIT_OLDSTYLE;
548 else
549 old_effect=0;
550
551 /* set panning positions */
552 if (mh->flags & 1)
553 for(t=0;t<64;t++) {
554 mh->pantable[t]&=0x7f;
555 if(mh->pantable[t]<64)
556 of.panning[t]=mh->pantable[t]<<2;
557 else if(mh->pantable[t]==64)
558 of.panning[t]=255;
559 else if(mh->pantable[t]==100)
560 of.panning[t]=PAN_SURROUND;
561 else if(mh->pantable[t]==127)
562 of.panning[t]=PAN_CENTER;
563 else {
564 _mm_errno=MMERR_LOADING_HEADER;
565 return 0;
566 }
567 }
568 else
569 for(t=0;t<64;t++)
570 of.panning[t]=PAN_CENTER;
571
572 /* set channel volumes */
573 memcpy(of.chanvol,mh->voltable,64);
574
575 /* read the order data */
576 if(!AllocPositions(mh->ordnum)) return 0;
577 if(!(origpositions=(UWORD*)MikMod_calloc(mh->ordnum,sizeof(UWORD)))) return 0;
578
579 for(t=0;t<mh->ordnum;t++) {
580 origpositions[t]=_mm_read_UBYTE(modreader);
581 if((origpositions[t]>mh->patnum)&&(origpositions[t]<254))
582 origpositions[t]=255;
583 }
584
585 if(_mm_eof(modreader)) {
586 _mm_errno = MMERR_LOADING_HEADER;
587 return 0;
588 }
589
590 poslookupcnt=mh->ordnum;
591 S3MIT_CreateOrders(curious);
592
593 if(!(paraptr=(ULONG*)MikMod_malloc((mh->insnum+mh->smpnum+of.numpat)*
594 sizeof(ULONG)))) return 0;
595
596 /* read the instrument, sample, and pattern parapointers */
597 _mm_read_I_ULONGS(paraptr,mh->insnum+mh->smpnum+of.numpat,modreader);
598
599 if(_mm_eof(modreader)) {
600 _mm_errno = MMERR_LOADING_HEADER;
601 return 0;
602 }
603
604 /* Check for and load midi information for resonant filters */
605 if(mh->cmwt>=0x216) {
606 if(mh->special&8) {
607 IT_LoadMidiConfiguration(modreader);
608 if(_mm_eof(modreader)) {
609 _mm_errno = MMERR_LOADING_HEADER;
610 return 0;
611 }
612 } else
613 IT_LoadMidiConfiguration(NULL);
614 filters=1;
615 }
616
617 /* Check for and load song comment */
618 if((mh->special&1)&&(mh->cwt>=0x104)&&(mh->msglength)) {
619 _mm_fseek(modreader,(long)(mh->msgoffset),SEEK_SET);
620 if(!ReadComment(mh->msglength)) return 0;
621 }
622
623 if(!(mh->flags&4)) of.numins=of.numsmp;
624 if(!AllocSamples()) return 0;
625
626 if(!AllocLinear()) return 0;
627
628 /* Load all samples */
629 q = of.samples;
630 for(t=0;t<mh->smpnum;t++) {
631 ITSAMPLE s;
632
633 /* seek to sample position */
634 _mm_fseek(modreader,(long)(paraptr[mh->insnum+t]+4),SEEK_SET);
635
636 /* load sample info */
637 _mm_read_string(s.filename,12,modreader);
638 s.zerobyte = _mm_read_UBYTE(modreader);
639 s.globvol = _mm_read_UBYTE(modreader);
640 s.flag = _mm_read_UBYTE(modreader);
641 s.volume = _mm_read_UBYTE(modreader);
642 _mm_read_string(s.sampname,26,modreader);
643 s.convert = _mm_read_UBYTE(modreader);
644 s.panning = _mm_read_UBYTE(modreader);
645 s.length = _mm_read_I_ULONG(modreader);
646 s.loopbeg = _mm_read_I_ULONG(modreader);
647 s.loopend = _mm_read_I_ULONG(modreader);
648 s.c5spd = _mm_read_I_ULONG(modreader);
649 s.susbegin = _mm_read_I_ULONG(modreader);
650 s.susend = _mm_read_I_ULONG(modreader);
651 s.sampoffset = _mm_read_I_ULONG(modreader);
652 s.vibspeed = _mm_read_UBYTE(modreader);
653 s.vibdepth = _mm_read_UBYTE(modreader);
654 s.vibrate = _mm_read_UBYTE(modreader);
655 s.vibwave = _mm_read_UBYTE(modreader);
656
657 /* Generate an error if c5spd is > 512k, or samplelength > 256 megs
658 (nothing would EVER be that high) */
659
660 if(_mm_eof(modreader)||(s.c5spd>0x7ffffL)||(s.length>0xfffffffUL)) {
661 _mm_errno = MMERR_LOADING_SAMPLEINFO;
662 return 0;
663 }
664
665 /* Reality check for sample loop information */
666 if((s.flag&16)&&
667 ((s.loopbeg>0xfffffffUL)||(s.loopend>0xfffffffUL))) {
668 _mm_errno = MMERR_LOADING_SAMPLEINFO;
669 return 0;
670 }
671
672 q->samplename = DupStr(s.sampname,26,0);
673 q->speed = s.c5spd / 2;
674 q->panning = ((s.panning&127)==64)?255:(s.panning&127)<<2;
675 q->length = s.length;
676 q->loopstart = s.loopbeg;
677 q->loopend = s.loopend;
678 q->volume = s.volume;
679 q->globvol = s.globvol;
680 q->seekpos = s.sampoffset;
681
682 /* Convert speed to XM linear finetune */
683 if(of.flags&UF_LINEAR)
684 q->speed=speed_to_finetune(s.c5spd,t);
685
686 if(s.panning&128) q->flags|=SF_OWNPAN;
687
688 if(s.vibrate) {
689 q->vibflags |= AV_IT;
690 q->vibtype = s.vibwave;
691 q->vibsweep = s.vibrate * 2;
692 q->vibdepth = s.vibdepth;
693 q->vibrate = s.vibspeed;
694 }
695
696 if(s.flag&2) q->flags|=SF_16BITS;
697 if((s.flag&8)&&(mh->cwt>=0x214)) {
698 q->flags|=SF_ITPACKED;
699 /*compressed=1;*/
700 }
701 if(s.flag&16) q->flags|=SF_LOOP;
702 if(s.flag&64) q->flags|=SF_BIDI;
703
704 if(mh->cwt>=0x200) {
705 if(s.convert&1) q->flags|=SF_SIGNED;
706 if(s.convert&4) q->flags|=SF_DELTA;
707 }
708 q++;
709 }
710
711 /* Load instruments if instrument mode flag enabled */
712 if(mh->flags&4) {
713 if(!AllocInstruments()) return 0;
714 d=of.instruments;
715 of.flags|=UF_NNA|UF_INST;
716
717 for(t=0;t<mh->insnum;t++) {
718 ITINSTHEADER ih;
719
720 /* seek to instrument position */
721 _mm_fseek(modreader,paraptr[t]+4,SEEK_SET);
722
723 /* load instrument info */
724 _mm_read_string(ih.filename,12,modreader);
725 ih.zerobyte = _mm_read_UBYTE(modreader);
726 if(mh->cwt<0x200) {
727 /* load IT 1.xx inst header */
728 ih.volflg = _mm_read_UBYTE(modreader);
729 ih.volbeg = _mm_read_UBYTE(modreader);
730 ih.volend = _mm_read_UBYTE(modreader);
731 ih.volsusbeg = _mm_read_UBYTE(modreader);
732 ih.volsusend = _mm_read_UBYTE(modreader);
733 _mm_read_I_UWORD(modreader);
734 ih.fadeout = _mm_read_I_UWORD(modreader);
735 ih.nna = _mm_read_UBYTE(modreader);
736 ih.dnc = _mm_read_UBYTE(modreader);
737 } else {
738 /* Read IT200+ header */
739 ih.nna = _mm_read_UBYTE(modreader);
740 ih.dct = _mm_read_UBYTE(modreader);
741 ih.dca = _mm_read_UBYTE(modreader);
742 ih.fadeout = _mm_read_I_UWORD(modreader);
743 ih.ppsep = _mm_read_UBYTE(modreader);
744 ih.ppcenter = _mm_read_UBYTE(modreader);
745 ih.globvol = _mm_read_UBYTE(modreader);
746 ih.chanpan = _mm_read_UBYTE(modreader);
747 ih.rvolvar = _mm_read_UBYTE(modreader);
748 ih.rpanvar = _mm_read_UBYTE(modreader);
749 }
750
751 ih.trkvers = _mm_read_I_UWORD(modreader);
752 ih.numsmp = _mm_read_UBYTE(modreader);
753 _mm_skip_BYTE(modreader);
754 _mm_read_string(ih.name,26,modreader);
755 _mm_read_UBYTES(ih.blank01,6,modreader);
756 _mm_read_I_UWORDS(ih.samptable,ITNOTECNT,modreader);
757 if(mh->cwt<0x200) {
758 /* load IT 1xx volume envelope */
759 _mm_read_UBYTES(ih.volenv,200,modreader);
760 for(lp=0;lp<ITENVCNT;lp++) {
761 ih.oldvoltick[lp] = _mm_read_UBYTE(modreader);
762 ih.volnode[lp] = _mm_read_UBYTE(modreader);
763 }
764 } else {
765 /* load IT 2xx volume, pan and pitch envelopes */
766 #if defined __STDC__ || defined _MSC_VER || defined MPW_C
767 #define IT_LoadEnvelope(name,type) \
768 ih. name##flg =_mm_read_UBYTE(modreader); \
769 ih. name##pts =_mm_read_UBYTE(modreader); \
770 if (ih. name##pts > ITENVCNT) \
771 ih. name##pts = ITENVCNT; \
772 ih. name##beg =_mm_read_UBYTE(modreader); \
773 ih. name##end =_mm_read_UBYTE(modreader); \
774 ih. name##susbeg=_mm_read_UBYTE(modreader); \
775 ih. name##susend=_mm_read_UBYTE(modreader); \
776 for(lp=0;lp<ITENVCNT;lp++) { \
777 ih. name##node[lp]=_mm_read_##type (modreader); \
778 ih. name##tick[lp]=_mm_read_I_UWORD(modreader); \
779 } \
780 _mm_skip_BYTE(modreader)
781 #else
782 #define IT_LoadEnvelope(name,type) \
783 ih. name/**/flg =_mm_read_UBYTE(modreader); \
784 ih. name/**/pts =_mm_read_UBYTE(modreader); \
785 if (ih. name/**/pts > ITENVCNT) \
786 ih. name/**/pts = ITENVCNT; \
787 ih. name/**/beg =_mm_read_UBYTE(modreader); \
788 ih. name/**/end =_mm_read_UBYTE(modreader); \
789 ih. name/**/susbeg=_mm_read_UBYTE(modreader); \
790 ih. name/**/susend=_mm_read_UBYTE(modreader); \
791 for(lp=0;lp<ITENVCNT;lp++) { \
792 ih. name/**/node[lp]=_mm_read_/**/type (modreader); \
793 ih. name/**/tick[lp]=_mm_read_I_UWORD(modreader); \
794 } \
795 _mm_skip_BYTE(modreader)
796 #endif
797
798 IT_LoadEnvelope(vol,UBYTE);
799 IT_LoadEnvelope(pan,SBYTE);
800 IT_LoadEnvelope(pit,SBYTE);
801 #undef IT_LoadEnvelope
802 }
803
804 if(_mm_eof(modreader)) {
805 _mm_errno = MMERR_LOADING_SAMPLEINFO;
806 return 0;
807 }
808
809 d->volflg|=EF_VOLENV;
810 d->insname = DupStr(ih.name,26,0);
811 d->nnatype = ih.nna & NNA_MASK;
812
813 if(mh->cwt<0x200) {
814 d->volfade=ih.fadeout<< 6;
815 if(ih.dnc) {
816 d->dct=DCT_NOTE;
817 d->dca=DCA_CUT;
818 }
819
820 if(ih.volflg&1) d->volflg|=EF_ON;
821 if(ih.volflg&2) d->volflg|=EF_LOOP;
822 if(ih.volflg&4) d->volflg|=EF_SUSTAIN;
823
824 /* XM conversion of IT envelope Array */
825 d->volbeg = ih.volbeg;
826 d->volend = ih.volend;
827 d->volsusbeg = ih.volsusbeg;
828 d->volsusend = ih.volsusend;
829
830 if(ih.volflg&1) {
831 for(u=0;u<ITENVCNT;u++)
832 if(ih.oldvoltick[d->volpts]!=0xff) {
833 d->volenv[d->volpts].val=(ih.volnode[d->volpts]<<2);
834 d->volenv[d->volpts].pos=ih.oldvoltick[d->volpts];
835 d->volpts++;
836 } else
837 break;
838 }
839 } else {
840 d->panning=((ih.chanpan&127)==64)?255:(ih.chanpan&127)<<2;
841 if(!(ih.chanpan&128)) d->flags|=IF_OWNPAN;
842
843 if(!(ih.ppsep & 128)) {
844 d->pitpansep=ih.ppsep<<2;
845 d->pitpancenter=ih.ppcenter;
846 d->flags|=IF_PITCHPAN;
847 }
848 d->globvol=ih.globvol>>1;
849 d->volfade=ih.fadeout<<5;
850 d->dct =ih.dct;
851 d->dca =ih.dca;
852
853 if(mh->cwt>=0x204) {
854 d->rvolvar = ih.rvolvar;
855 d->rpanvar = ih.rpanvar;
856 }
857
858 #if defined __STDC__ || defined _MSC_VER || defined MPW_C
859 #define IT_ProcessEnvelope(name) \
860 if(ih. name##flg&1) d-> name##flg|=EF_ON; \
861 if(ih. name##flg&2) d-> name##flg|=EF_LOOP; \
862 if(ih. name##flg&4) d-> name##flg|=EF_SUSTAIN; \
863 d-> name##pts=ih. name##pts; \
864 d-> name##beg=ih. name##beg; \
865 d-> name##end=ih. name##end; \
866 d-> name##susbeg=ih. name##susbeg; \
867 d-> name##susend=ih. name##susend; \
868 \
869 for(u=0;u<ih. name##pts;u++) \
870 d-> name##env[u].pos=ih. name##tick[u]; \
871 \
872 if((d-> name##flg&EF_ON)&&(d-> name##pts<2)) \
873 d-> name##flg&=~EF_ON
874 #else
875 #define IT_ProcessEnvelope(name) \
876 if(ih. name/**/flg&1) d-> name/**/flg|=EF_ON; \
877 if(ih. name/**/flg&2) d-> name/**/flg|=EF_LOOP; \
878 if(ih. name/**/flg&4) d-> name/**/flg|=EF_SUSTAIN; \
879 d-> name/**/pts=ih. name/**/pts; \
880 d-> name/**/beg=ih. name/**/beg; \
881 d-> name/**/end=ih. name/**/end; \
882 d-> name/**/susbeg=ih. name/**/susbeg; \
883 d-> name/**/susend=ih. name/**/susend; \
884 \
885 for(u=0;u<ih. name/**/pts;u++) \
886 d-> name/**/env[u].pos=ih. name/**/tick[u]; \
887 \
888 if((d-> name/**/flg&EF_ON)&&(d-> name/**/pts<2)) \
889 d-> name/**/flg&=~EF_ON
890 #endif
891
892 IT_ProcessEnvelope(vol);
893
894 for(u=0;u<ih.volpts;u++)
895 d->volenv[u].val=(ih.volnode[u]<<2);
896
897 IT_ProcessEnvelope(pan);
898 for(u=0;u<ih.panpts;u++)
899 d->panenv[u].val=
900 ih.pannode[u]==32?255:(ih.pannode[u]+32)<<2;
901
902 IT_ProcessEnvelope(pit);
903 for(u=0;u<ih.pitpts;u++)
904 d->pitenv[u].val=ih.pitnode[u]+32;
905 #undef IT_ProcessEnvelope
906
907 if(ih.pitflg&0x80) {
908 /* filter envelopes not supported yet */
909 d->pitflg&=~EF_ON;
910 ih.pitpts=ih.pitbeg=ih.pitend=0;
911 #ifdef MIKMOD_DEBUG
912 {
913 static int warn=0;
914
915 if(!warn)
916 fprintf(stderr, "\rFilter envelopes not supported yet\n");
917 warn=1;
918 }
919 #endif
920 }
921 }
922
923 for(u=0;u<ITNOTECNT;u++) {
924 d->samplenote[u]=(ih.samptable[u]&255);
925 d->samplenumber[u]=
926 (ih.samptable[u]>>8)?((ih.samptable[u]>>8)-1):0xffff;
927 if(d->samplenumber[u]>=of.numsmp)
928 d->samplenote[u]=255;
929 else if (of.flags&UF_LINEAR) {
930 int note=(int)d->samplenote[u]+noteindex[d->samplenumber[u]];
931 d->samplenote[u]=(note<0)?0:(note>255?255:note);
932 }
933 }
934
935 d++;
936 }
937 } else if(of.flags & UF_LINEAR) {
938 if(!AllocInstruments()) return 0;
939 d=of.instruments;
940 of.flags|=UF_INST;
941
942 for(t=0;t<mh->smpnum;t++,d++)
943 for(u=0;u<ITNOTECNT;u++) {
944 if(d->samplenumber[u]>=of.numsmp)
945 d->samplenote[u]=255;
946 else {
947 int note=(int)d->samplenote[u]+noteindex[d->samplenumber[u]];
948 d->samplenote[u]=(note<0)?0:(note>255?255:note);
949 }
950 }
951 }
952
953 /* Figure out how many channels this song actually uses */
954 of.numchn=0;
955 memset(remap,-1,UF_MAXCHAN*sizeof(UBYTE));
956 for(t=0;t<of.numpat;t++) {
957 UWORD packlen;
958
959 /* seek to pattern position */
960 if(paraptr[mh->insnum+mh->smpnum+t]) { /* 0 -> empty 64 row pattern */
961 _mm_fseek(modreader,((long)paraptr[mh->insnum+mh->smpnum+t]),SEEK_SET);
962 _mm_read_I_UWORD(modreader);
963 /* read pattern length (# of rows)
964 Impulse Tracker never creates patterns with less than 32 rows,
965 but some other trackers do, so we only check for more than 256
966 rows */
967 packlen=_mm_read_I_UWORD(modreader);
968 if(packlen>256) {
969 _mm_errno=MMERR_LOADING_PATTERN;
970 return 0;
971 }
972 _mm_read_I_ULONG(modreader);
973 if(!IT_GetNumChannels(packlen)) return 0;
974 }
975 }
976
977 /* give each of them a different number */
978 for(t=0;t<UF_MAXCHAN;t++)
979 if(!remap[t])
980 remap[t]=of.numchn++;
981
982 of.numtrk = of.numpat*of.numchn;
983 if(of.numvoices)
984 if (of.numvoices<of.numchn) of.numvoices=of.numchn;
985
986 if(!AllocPatterns()) return 0;
987 if(!AllocTracks()) return 0;
988
989 for(t=0;t<of.numpat;t++) {
990 UWORD packlen;
991
992 /* seek to pattern position */
993 if(!paraptr[mh->insnum+mh->smpnum+t]) { /* 0 -> empty 64 row pattern */
994 of.pattrows[t]=64;
995 for(u=0;u<of.numchn;u++) {
996 int k;
997
998 UniReset();
999 for(k=0;k<64;k++) UniNewline();
1000 of.tracks[numtrk++]=UniDup();
1001 }
1002 } else {
1003 _mm_fseek(modreader,((long)paraptr[mh->insnum+mh->smpnum+t]),SEEK_SET);
1004 packlen=_mm_read_I_UWORD(modreader);
1005 (void)packlen; /* unused */
1006 of.pattrows[t]=_mm_read_I_UWORD(modreader);
1007 _mm_read_I_ULONG(modreader);
1008 if(!IT_ReadPattern(of.pattrows[t])) return 0;
1009 }
1010 }
1011
1012 return 1;
1013 }
1014
IT_LoadTitle(void)1015 static CHAR *IT_LoadTitle(void)
1016 {
1017 CHAR s[26];
1018
1019 _mm_fseek(modreader,4,SEEK_SET);
1020 if(!_mm_read_UBYTES(s,26,modreader)) return NULL;
1021
1022 return(DupStr(s,26,0));
1023 }
1024
1025 /*========== Loader information */
1026
1027 MIKMODAPI MLOADER load_it={
1028 NULL,
1029 "IT",
1030 "IT (Impulse Tracker)",
1031 IT_Init,
1032 IT_Test,
1033 IT_Load,
1034 IT_Cleanup,
1035 IT_LoadTitle
1036 };
1037
1038 /* ex:set ts=4: */
1039