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