static BOOL
GetBlockHeader (void)
{
/* make sure we're at the right position for reading the
next riff block, no matter how many bytes read */
_mm_fseek (modreader, blocklp + blockln, SEEK_SET);
while (1)
{
_mm_read_UBYTES (blockid, 4, modreader);
blockln = _mm_read_I_ULONG (modreader);
if (_mm_eof (modreader))
{
_mm_errno = MMERR_LOADING_HEADER;
return 0;
}
if (memcmp (blockid, SONGID, 4) && memcmp (blockid, INSTID, 4) &&
memcmp (blockid, PATTID, 4))
{
#ifdef MIKMOD_DEBUG
fprintf (stderr, "\rDSM: Skipping unknown block type %4.4s\n", blockid);
#endif
_mm_fseek (modreader, blockln, SEEK_CUR);
}
else
break;
}
blocklp = _mm_ftell (modreader);
return 1;
}
static BOOL DSM_ReadPattern(void)
{
int flag,row=0;
SWORD length;
DSMNOTE *n;
/* clear pattern data */
memset(dsmbuf,255,DSM_MAXCHAN*64*sizeof(DSMNOTE));
length=_mm_read_I_SWORD(modreader);
while(row<64) {
flag=_mm_read_UBYTE(modreader);
if((_mm_eof(modreader))||(--length<0)) {
_mm_errno = MMERR_LOADING_PATTERN;
return 0;
}
if(flag) {
n=&dsmbuf[((flag&0xf)*64)+row];
if(flag&0x80) n->note=_mm_read_UBYTE(modreader);
if(flag&0x40) n->ins=_mm_read_UBYTE(modreader);
if(flag&0x20) n->vol=_mm_read_UBYTE(modreader);
if(flag&0x10) {
n->cmd=_mm_read_UBYTE(modreader);
n->inf=_mm_read_UBYTE(modreader);
}
} else
row++;
}
return 1;
}
BOOL S3M_Load(BOOL curious)
{
int t,u,track = 0;
SAMPLE *q;
UBYTE pan[32];
/* try to read module header */
_mm_read_string(mh->songname,28,modreader);
mh->t1a =_mm_read_UBYTE(modreader);
mh->type =_mm_read_UBYTE(modreader);
_mm_read_UBYTES(mh->unused1,2,modreader);
mh->ordnum =_mm_read_I_UWORD(modreader);
mh->insnum =_mm_read_I_UWORD(modreader);
mh->patnum =_mm_read_I_UWORD(modreader);
mh->flags =_mm_read_I_UWORD(modreader);
mh->tracker =_mm_read_I_UWORD(modreader);
mh->fileformat =_mm_read_I_UWORD(modreader);
_mm_read_string(mh->scrm,4,modreader);
mh->mastervol =_mm_read_UBYTE(modreader);
mh->initspeed =_mm_read_UBYTE(modreader);
mh->inittempo =_mm_read_UBYTE(modreader);
mh->mastermult =_mm_read_UBYTE(modreader);
mh->ultraclick =_mm_read_UBYTE(modreader);
mh->pantable =_mm_read_UBYTE(modreader);
_mm_read_UBYTES(mh->unused2,8,modreader);
mh->special =_mm_read_I_UWORD(modreader);
_mm_read_UBYTES(mh->channels,32,modreader);
if(_mm_eof(modreader)) {
_mm_errno = MMERR_LOADING_HEADER;
return 0;
}
/* then we can decide the module type */
tracker=mh->tracker>>12;
if((!tracker)||(tracker>=NUMTRACKERS))
tracker=NUMTRACKERS-1; /* unknown tracker */
else {
if(mh->tracker>=0x3217)
tracker=NUMTRACKERS+1; /* IT 2.14p4 */
else if(mh->tracker>=0x3216)
tracker=NUMTRACKERS; /* IT 2.14p3 */
else tracker--;
}
of.modtype = strdup(S3M_Version[tracker]);
if(tracker<NUMTRACKERS) {
of.modtype[numeric[tracker]] = ((mh->tracker>>8) &0xf)+'0';
of.modtype[numeric[tracker]+2] = ((mh->tracker>>4)&0xf)+'0';
of.modtype[numeric[tracker]+3] = ((mh->tracker)&0xf)+'0';
}
/* Read sample information */
static BOOL OKT_doSAMP(int len)
{
int t;
SAMPLE *q;
OKTSAMPLE s;
of.numins = of.numsmp = (len / 0x20);
if (!AllocSamples())
return 0;
for (t = 0, q = of.samples; t < of.numins; t++, q++) {
_mm_read_UBYTES(s.sampname, 20, modreader);
s.len = _mm_read_M_ULONG(modreader);
s.loopbeg = _mm_read_M_UWORD(modreader);
s.looplen = _mm_read_M_UWORD(modreader);
_mm_read_UBYTE(modreader);
s.volume = _mm_read_UBYTE(modreader);
_mm_read_M_UWORD(modreader);
if (_mm_eof(modreader)) {
_mm_errno = MMERR_LOADING_SAMPLEINFO;
return 0;
}
if (!s.len)
q->seekpos = q->length = q->loopstart = q->loopend = q->flags = 0;
else {
s.len--;
/* sanity checks */
if (s.loopbeg > s.len)
s.loopbeg = s.len;
if (s.loopbeg + s.looplen > s.len)
s.looplen = s.len - s.loopbeg;
if (s.looplen < 2)
s.looplen = 0;
q->length = s.len;
q->loopstart = s.loopbeg;
q->loopend = s.looplen + q->loopstart;
q->volume = s.volume;
q->flags = SF_SIGNED;
if (s.looplen)
q->flags |= SF_LOOP;
}
q->samplename = DupStr(s.sampname, 20, 1);
q->speed = 8363;
}
return 1;
}
static BOOL IMF_ReadPattern(SLONG size,UWORD rows)
{
int row=0,flag,ch;
IMFNOTE *n,dummy;
/* clear pattern data */
memset(imfpat,255,32*256*sizeof(IMFNOTE));
while((size>0)&&(row<rows)) {
flag=_mm_read_UBYTE(modreader);size--;
if(_mm_eof(modreader)) {
_mm_errno=MMERR_LOADING_PATTERN;
return 0;
}
if(flag) {
ch=remap[flag&31];
if(ch!=-1)
n=&imfpat[256*ch+row];
else
n=&dummy;
if(flag&32) {
n->note=_mm_read_UBYTE(modreader);
if(n->note>=0xa0) n->note=0xa0; /* note off */
n->ins =_mm_read_UBYTE(modreader);
size-=2;
}
if(flag&64) {
size-=2;
n->eff2=_mm_read_UBYTE(modreader);
n->dat2=_mm_read_UBYTE(modreader);
}
if(flag&128) {
n->eff1=_mm_read_UBYTE(modreader);
n->dat1=_mm_read_UBYTE(modreader);
size-=2;
}
} else row++;
}
if((size)||(row!=rows)) {
_mm_errno=MMERR_LOADING_PATTERN;
return 0;
}
return 1;
}
static BOOL OKT_doPBOD(int patnum)
{
char *patbuf;
int rows, i;
int u;
if (!patnum) {
of.numtrk = of.numpat * of.numchn;
if (!AllocTracks() || !AllocPatterns())
return 0;
}
/* Read pattern */
of.pattrows[patnum] = rows = _mm_read_M_UWORD(modreader);
if (!(okttrk = (OKTNOTE *) _mm_calloc(rows, sizeof(OKTNOTE))) ||
!(patbuf = (char *)_mm_calloc(rows * of.numchn, sizeof(OKTNOTE))))
return 0;
_mm_read_UBYTES(patbuf, rows * of.numchn * sizeof(OKTNOTE), modreader);
if (_mm_eof(modreader)) {
_mm_errno = MMERR_LOADING_PATTERN;
return 0;
}
for (i = 0; i < of.numchn; i++) {
for (u = 0; u < rows; u++) {
okttrk[u].note = patbuf[(u * of.numchn + i) * sizeof(OKTNOTE)];
okttrk[u].ins = patbuf[(u * of.numchn + i) * sizeof(OKTNOTE) + 1];
okttrk[u].eff = patbuf[(u * of.numchn + i) * sizeof(OKTNOTE) + 2];
okttrk[u].dat = patbuf[(u * of.numchn + i) * sizeof(OKTNOTE) + 3];
}
if (!(of.tracks[patnum * of.numchn + i] = OKT_ConvertTrack(rows)))
return 0;
}
_mm_free(patbuf);
_mm_free(okttrk);
return 1;
}
static BOOL S3M_ReadPattern(void)
{
int row=0,flag,ch;
S3MNOTE *n,dummy;
/* clear pattern data */
memset(s3mbuf,255,32*64*sizeof(S3MNOTE));
while(row<64) {
flag=_mm_read_UBYTE(modreader);
if(_mm_eof(modreader)) {
_mm_errno = MMERR_LOADING_PATTERN;
return 0;
}
if(flag) {
ch=remap[flag&31];
if(ch!=-1)
n=&s3mbuf[(64U*ch)+row];
else
n=&dummy;
if(flag&32) {
n->note=_mm_read_UBYTE(modreader);
n->ins=_mm_read_UBYTE(modreader);
}
if(flag&64) {
n->vol=_mm_read_UBYTE(modreader);
if (n->vol>64) n->vol=64;
}
if(flag&128) {
n->cmd=_mm_read_UBYTE(modreader);
n->inf=_mm_read_UBYTE(modreader);
}
} else row++;
}
return 1;
}
/* Because so many s3m files have 16 channels as the set number used, but really
only use far less (usually 8 to 12 still), I had to make this function, which
determines the number of channels that are actually USED by a pattern.
For every channel that's used, it sets the appropriate array entry of the
global variable 'remap'
NOTE: You must first seek to the file location of the pattern before calling
this procedure.
Returns 1 on fail. */
static BOOL S3M_GetNumChannels(void)
{
int row=0,flag,ch;
while(row<64) {
flag=_mm_read_UBYTE(modreader);
if(_mm_eof(modreader)) {
_mm_errno = MMERR_LOADING_PATTERN;
return 1;
}
if(flag) {
ch=flag&31;
if(mh->channels[ch]<32) remap[ch] = 0;
if(flag&32) {_mm_read_UBYTE(modreader);_mm_read_UBYTE(modreader);}
if(flag&64) _mm_read_UBYTE(modreader);
if(flag&128){_mm_read_UBYTE(modreader);_mm_read_UBYTE(modreader);}
} else row++;
}
return 0;
}
static BOOL S69_LoadPatterns(void)
{
int track,row,channel;
UBYTE note,inst,vol,effect,lastfx,lastval;
S69NOTE *cur;
int tracks=0;
if(!AllocPatterns()) return 0;
if(!AllocTracks()) return 0;
for(track=0;track<of.numpat;track++) {
/* set pattern break locations */
of.pattrows[track]=mh->breaks[track]+1;
/* load the 669 pattern */
cur=s69pat;
for(row=0;row<64;row++) {
for(channel=0;channel<8;channel++,cur++) {
cur->a = _mm_read_UBYTE(modreader);
cur->b = _mm_read_UBYTE(modreader);
cur->c = _mm_read_UBYTE(modreader);
}
}
if(_mm_eof(modreader)) {
_mm_errno = MMERR_LOADING_PATTERN;
return 0;
}
/* translate the pattern */
for(channel=0;channel<8;channel++) {
UniReset();
/* set pattern tempo */
UniPTEffect(0xf,78);
UniPTEffect(0xf,mh->tempos[track]);
lastfx=0xff,lastval=0;
for(row=0;row<=mh->breaks[track];row++) {
int a,b,c;
/* fetch the encoded note */
a=s69pat[(row*8)+channel].a;
b=s69pat[(row*8)+channel].b;
c=s69pat[(row*8)+channel].c;
/* decode it */
note=a>>2;
inst=((a&0x3)<<4)|((b&0xf0)>>4);
vol=b&0xf;
if (a<0xff) {
if (a<0xfe) {
UniInstrument(inst);
UniNote(note+2*OCTAVE);
lastfx=0xff; /* reset background effect memory */
}
UniPTEffect(0xc,vol<<2);
}
if ((c!=0xff)||(lastfx!=0xff)) {
if(c==0xff)
c=lastfx,effect=lastval;
else
effect=c&0xf;
switch(c>>4) {
case 0: /* porta up */
UniPTEffect(0x1,effect);
lastfx=c,lastval=effect;
break;
case 1: /* porta down */
UniPTEffect(0x2,effect);
lastfx=c,lastval=effect;
break;
case 2: /* porta to note */
UniPTEffect(0x3,effect);
lastfx=c,lastval=effect;
break;
case 3: /* frequency adjust */
/* DMP converts this effect to S3M FF1. Why not ? */
UniEffect(UNI_S3MEFFECTF,0xf0|effect);
break;
case 4: /* vibrato */
UniPTEffect(0x4,effect);
lastfx=c,lastval=effect;
break;
case 5: /* set speed */
if (effect)
UniPTEffect(0xf,effect);
else
if(mh->marker[0]!=0x69) {
#ifdef MIKMOD_DEBUG
fprintf(stderr,"\r669: unsupported super fast tempo at pat=%d row=%d chan=%d\n",
track,row,channel);
#endif
}
break;
}
}
UniNewline();
}
if(!(of.tracks[tracks++]=UniDup())) return 0;
}
}
return 1;
}
static BOOL ASY_Load(BOOL curious)
{
int t;
SAMPLE *q;
MSAMPINFO *s;
CHAR *descr=asylum;
ULONG seekpos;
// no title in asylum amf files :(
strcpy(mh->songname, "");
_mm_fseek(modreader, 0x23, SEEK_SET);
mh->num_patterns = _mm_read_UBYTE(modreader);
mh->num_orders = _mm_read_UBYTE(modreader);
// skip unknown byte
_mm_skip_BYTE(modreader);
_mm_read_UBYTES(mh->positions, 256, modreader);
/* read samples headers*/
for (t = 0; t < 64; t++) {
s = &mh->samples[t];
_mm_fseek(modreader, 0x126 + (t*37), SEEK_SET);
_mm_read_string(s->samplename, 22, modreader);
s->samplename[21] = 0; /* just in case */
s->finetune = _mm_read_UBYTE(modreader);
s->volume = _mm_read_UBYTE(modreader);
_mm_skip_BYTE(modreader); // skip unknown byte
s->length = _mm_read_I_ULONG(modreader);
s->reppos = _mm_read_I_ULONG(modreader);
s->replen = _mm_read_I_ULONG(modreader);
}
if (_mm_eof(modreader)) {
_mm_errno = MMERR_LOADING_HEADER;
return 0;
}
/* set module variables */
of.initspeed = 6;
of.inittempo = 125;
of.numchn = 8;
modtype = 0;
of.songname = DupStr(mh->songname, 21, 1);
of.numpos = mh->num_orders;
of.reppos = 0;
of.numpat = mh->num_patterns;
of.numtrk = of.numpat * of.numchn;
/* Copy positions (orders) */
if (!AllocPositions(of.numpos))
return 0;
for (t = 0; t < of.numpos; t++) {
of.positions[t] = mh->positions[t];
}
/* Finally, init the sampleinfo structures */
of.numins = 31;
of.numsmp = 31;
if (!AllocSamples())
return 0;
s = mh->samples;
q = of.samples;
seekpos = 2662+(2048*(of.numpat));
for (t = 0; t < of.numins; t++) {
/* convert the samplename */
q->samplename = DupStr(s->samplename, 23, 1);
/* init the sampleinfo variables */
q->speed = finetune[s->finetune & 0xf];
q->volume = s->volume & 0x7f;
q->loopstart = (ULONG)s->reppos;
q->loopend = (ULONG)q->loopstart + (s->replen);
q->length = (ULONG)s->length;
q->flags = SF_SIGNED;
q->seekpos = seekpos;
seekpos += q->length;
if ((s->replen) > 2) {
q->flags |= SF_LOOP;
}
/* fix replen if repend > length */
if (q->loopend > q->length)
q->loopend = q->length;
s++;
q++;
}
of.modtype = StrDup(descr);
if (!ML_LoadPatterns())
return 0;
return 1;
}
static BOOL loadsmp6(void)
{
int t;
SAMPLE *sptr;
sptr=of.samples;
for(t=0;t<of.numsmp;t++,sptr++) {
int flags;
flags = _mm_read_M_UWORD(modreader);
sptr->flags=0;
if(flags&0x0004) sptr->flags|=SF_STEREO;
if(flags&0x0002) sptr->flags|=SF_SIGNED;
if(flags&0x0001) sptr->flags|=SF_16BITS;
/* convert flags */
if(universion>=0x104) {
if(flags&0x2000) sptr->flags|=SF_UST_LOOP;
if(flags&0x1000) sptr->flags|=SF_OWNPAN;
if(flags&0x0800) sptr->flags|=SF_SUSTAIN;
if(flags&0x0400) sptr->flags|=SF_REVERSE;
if(flags&0x0200) sptr->flags|=SF_BIDI;
if(flags&0x0100) sptr->flags|=SF_LOOP;
if(flags&0x0020) sptr->flags|=SF_ITPACKED;
if(flags&0x0010) sptr->flags|=SF_DELTA;
if(flags&0x0008) sptr->flags|=SF_BIG_ENDIAN;
} else if(universion>=0x102) {
if(flags&0x0800) sptr->flags|=SF_UST_LOOP;
if(flags&0x0400) sptr->flags|=SF_OWNPAN;
if(flags&0x0200) sptr->flags|=SF_SUSTAIN;
if(flags&0x0100) sptr->flags|=SF_REVERSE;
if(flags&0x0080) sptr->flags|=SF_BIDI;
if(flags&0x0040) sptr->flags|=SF_LOOP;
if(flags&0x0020) sptr->flags|=SF_ITPACKED;
if(flags&0x0010) sptr->flags|=SF_DELTA;
if(flags&0x0008) sptr->flags|=SF_BIG_ENDIAN;
} else {
if(flags&0x400) sptr->flags|=SF_UST_LOOP;
if(flags&0x200) sptr->flags|=SF_OWNPAN;
if(flags&0x100) sptr->flags|=SF_REVERSE;
if(flags&0x080) sptr->flags|=SF_SUSTAIN;
if(flags&0x040) sptr->flags|=SF_BIDI;
if(flags&0x020) sptr->flags|=SF_LOOP;
if(flags&0x010) sptr->flags|=SF_BIG_ENDIAN;
if(flags&0x008) sptr->flags|=SF_DELTA;
}
sptr->speed = _mm_read_M_ULONG(modreader);
sptr->volume = _mm_read_UBYTE(modreader);
sptr->panning = _mm_read_M_UWORD(modreader);
sptr->length = _mm_read_M_ULONG(modreader);
sptr->loopstart = _mm_read_M_ULONG(modreader);
sptr->loopend = _mm_read_M_ULONG(modreader);
sptr->susbegin = _mm_read_M_ULONG(modreader);
sptr->susend = _mm_read_M_ULONG(modreader);
sptr->globvol = _mm_read_UBYTE(modreader);
sptr->vibflags = _mm_read_UBYTE(modreader);
sptr->vibtype = _mm_read_UBYTE(modreader);
sptr->vibsweep = _mm_read_UBYTE(modreader);
sptr->vibdepth = _mm_read_UBYTE(modreader);
sptr->vibrate = _mm_read_UBYTE(modreader);
sptr->samplename=readstring();
if(_mm_eof(modreader)) {
_mm_errno = MMERR_LOADING_SAMPLEINFO;
return 0;
}
}
return 1;
}
static int MTM_Load(int curious)
{
int t,u;
MTMSAMPLE s;
SAMPLE *q;
(void)curious;
/* try to read module header */
_mm_read_UBYTES(mh->id,3,modreader);
mh->version =_mm_read_UBYTE(modreader);
_mm_read_string(mh->songname,20,modreader);
mh->numtracks =_mm_read_I_UWORD(modreader);
mh->lastpattern =_mm_read_UBYTE(modreader);
mh->lastorder =_mm_read_UBYTE(modreader);
mh->commentsize =_mm_read_I_UWORD(modreader);
mh->numsamples =_mm_read_UBYTE(modreader);
mh->attribute =_mm_read_UBYTE(modreader);
mh->beatspertrack=_mm_read_UBYTE(modreader);
mh->numchannels =_mm_read_UBYTE(modreader);
_mm_read_UBYTES(mh->panpos,32,modreader);
if(_mm_eof(modreader)) {
_mm_errno = MMERR_LOADING_HEADER;
return 0;
}
/* set module variables */
of.initspeed = 6;
of.inittempo = 125;
of.modtype = StrDup(MTM_Version);
of.numchn = mh->numchannels;
of.numtrk = mh->numtracks+1; /* get number of channels */
of.songname = DupStr(mh->songname,20,1); /* make a cstr of songname */
of.numpos = mh->lastorder+1; /* copy the songlength */
of.numpat = mh->lastpattern+1;
of.reppos = 0;
of.flags |= UF_PANNING;
for(t=0;t<32;t++) of.panning[t]=mh->panpos[t]<< 4;
of.numins=of.numsmp=mh->numsamples;
if(!AllocSamples()) return 0;
q=of.samples;
for(t=0;t<of.numins;t++) {
/* try to read sample info */
_mm_read_string(s.samplename,22,modreader);
s.length =_mm_read_I_ULONG(modreader);
s.reppos =_mm_read_I_ULONG(modreader);
s.repend =_mm_read_I_ULONG(modreader);
s.finetune =_mm_read_UBYTE(modreader);
s.volume =_mm_read_UBYTE(modreader);
s.attribute =_mm_read_UBYTE(modreader);
if(_mm_eof(modreader)) {
_mm_errno = MMERR_LOADING_SAMPLEINFO;
return 0;
}
q->samplename = DupStr(s.samplename,22,1);
q->seekpos = 0;
q->speed = finetune[s.finetune];
q->length = s.length;
q->loopstart = s.reppos;
q->loopend = s.repend;
q->volume = s.volume;
if((s.repend-s.reppos)>2) q->flags |= SF_LOOP;
if(s.attribute&1) {
/* If the sample is 16-bits, convert the length and replen
byte-values into sample-values */
q->flags|=SF_16BITS;
q->length>>=1;
q->loopstart>>=1;
q->loopend>>=1;
}
q++;
}
BOOL S3M_Load(BOOL curious)
{
int t,u,track = 0;
SAMPLE *q;
UBYTE pan[32];
/* try to read module header */
_mm_read_string(mh->songname,28,modreader);
mh->t1a =_mm_read_UBYTE(modreader);
mh->type =_mm_read_UBYTE(modreader);
_mm_read_UBYTES(mh->unused1,2,modreader);
mh->ordnum =_mm_read_I_UWORD(modreader);
mh->insnum =_mm_read_I_UWORD(modreader);
mh->patnum =_mm_read_I_UWORD(modreader);
mh->flags =_mm_read_I_UWORD(modreader);
mh->tracker =_mm_read_I_UWORD(modreader);
mh->fileformat =_mm_read_I_UWORD(modreader);
_mm_read_string(mh->scrm,4,modreader);
mh->mastervol =_mm_read_UBYTE(modreader);
mh->initspeed =_mm_read_UBYTE(modreader);
mh->inittempo =_mm_read_UBYTE(modreader);
mh->mastermult =_mm_read_UBYTE(modreader);
mh->ultraclick =_mm_read_UBYTE(modreader);
mh->pantable =_mm_read_UBYTE(modreader);
_mm_read_UBYTES(mh->unused2,8,modreader);
mh->special =_mm_read_I_UWORD(modreader);
_mm_read_UBYTES(mh->channels,32,modreader);
if(_mm_eof(modreader)) {
_mm_errno = MMERR_LOADING_HEADER;
return 0;
}
/* set module variables */
of.songname = DupStr(mh->songname,28,0);
of.numpat = mh->patnum;
of.reppos = 0;
of.numins = of.numsmp = mh->insnum;
of.initspeed = mh->initspeed;
of.inittempo = mh->inittempo;
of.initvolume = mh->mastervol<<1;
of.flags |= UF_ARPMEM;
if((mh->tracker==0x1300)||(mh->flags&64))
of.flags|=UF_S3MSLIDES;
/* read the order data */
if(!AllocPositions(mh->ordnum)) return 0;
if(!(origpositions=_mm_calloc(mh->ordnum,sizeof(UWORD)))) return 0;
for(t=0;t<mh->ordnum;t++) {
origpositions[t]=_mm_read_UBYTE(modreader);
if((origpositions[t]>=mh->patnum)&&(origpositions[t]<254))
origpositions[t]=255/*mh->patnum-1*/;
}
if(_mm_eof(modreader)) {
_mm_errno = MMERR_LOADING_HEADER;
return 0;
}
poslookupcnt=(UBYTE)mh->ordnum;
S3MIT_CreateOrders(curious);
if(!(paraptr=(UWORD*)_mm_malloc((of.numins+of.numpat)*sizeof(UWORD))))
return 0;
/* read the instrument+pattern parapointers */
_mm_read_I_UWORDS(paraptr,of.numins+of.numpat,modreader);
if(mh->pantable==252) {
/* read the panning table (ST 3.2 addition. See below for further
portions of channel panning [past reampper]). */
_mm_read_UBYTES(pan,32,modreader);
}
if(_mm_eof(modreader)) {
_mm_errno = MMERR_LOADING_HEADER;
return 0;
}
/* load samples */
if(!AllocSamples()) return 0;
q = of.samples;
for(t=0;t<of.numins;t++) {
S3MSAMPLE s;
/* seek to instrument position */
_mm_fseek(modreader,((long)paraptr[t])<<4,SEEK_SET);
/* and load sample info */
s.type =_mm_read_UBYTE(modreader);
_mm_read_string(s.filename,12,modreader);
s.memsegh =_mm_read_UBYTE(modreader);
s.memsegl =_mm_read_I_UWORD(modreader);
s.length =_mm_read_I_ULONG(modreader);
s.loopbeg =_mm_read_I_ULONG(modreader);
s.loopend =_mm_read_I_ULONG(modreader);
s.volume =_mm_read_UBYTE(modreader);
s.dsk =_mm_read_UBYTE(modreader);
s.pack =_mm_read_UBYTE(modreader);
s.flags =_mm_read_UBYTE(modreader);
s.c2spd =_mm_read_I_ULONG(modreader);
_mm_read_UBYTES(s.unused,12,modreader);
_mm_read_string(s.sampname,28,modreader);
_mm_read_string(s.scrs,4,modreader);
if(_mm_eof(modreader)) {
_mm_errno = MMERR_LOADING_SAMPLEINFO;
return 0;
}
q->samplename = DupStr(s.sampname,28,0);
q->speed = s.c2spd;
q->length = s.length;
q->loopstart = s.loopbeg>s.length?s.length:s.loopbeg;
q->loopend = s.loopend>s.length?s.length:s.loopend;
q->volume = s.volume;
q->seekpos = (((long)s.memsegh)<<16|s.memsegl)<<4;
if(s.flags&1) q->flags |= SF_LOOP;
if(s.flags&4) q->flags |= SF_16BITS;
if(mh->fileformat==1) q->flags |= SF_SIGNED;
/* don't load sample if it doesn't have the SCRS tag */
if(memcmp(s.scrs,"SCRS",4)) q->length = 0;
q++;
}
/* determine the number of channels actually used. */
of.numchn = 0;
memset(remap,-1,32*sizeof(UBYTE));
for(t=0;t<of.numpat;t++) {
/* seek to pattern position (+2 skip pattern length) */
_mm_fseek(modreader,(long)((paraptr[of.numins+t])<<4)+2,SEEK_SET);
if(S3M_GetNumChannels()) return 0;
}
/* then we can decide the module type */
t=mh->tracker>>12;
if((!t)||(t>3))
t=NUMTRACKERS-1; /* unknown tracker */
else {
if(mh->tracker>=0x3217)
t=NUMTRACKERS+1; /* IT 2.14p4 */
else if(mh->tracker>=0x3216)
t=NUMTRACKERS; /* IT 2.14p3 */
else t--;
}
of.modtype = strdup(S3M_Version[t]);
if(t<NUMTRACKERS) {
of.modtype[numeric[t]] = ((mh->tracker>>8) &0xf)+'0';
of.modtype[numeric[t]+2] = ((mh->tracker>>4)&0xf)+'0';
of.modtype[numeric[t]+3] = ((mh->tracker)&0xf)+'0';
}
BOOL IT_Load(BOOL curious)
{
int t,u,lp;
INSTRUMENT *d;
SAMPLE *q;
BOOL compressed=0;
numtrk=0;
filters=0;
/* try to read module header */
_mm_read_I_ULONG(modreader); /* kill the 4 byte header */
_mm_read_string(mh->songname,26,modreader);
_mm_read_UBYTES(mh->blank01,2,modreader);
mh->ordnum =_mm_read_I_UWORD(modreader);
mh->insnum =_mm_read_I_UWORD(modreader);
mh->smpnum =_mm_read_I_UWORD(modreader);
mh->patnum =_mm_read_I_UWORD(modreader);
mh->cwt =_mm_read_I_UWORD(modreader);
mh->cmwt =_mm_read_I_UWORD(modreader);
mh->flags =_mm_read_I_UWORD(modreader);
mh->special =_mm_read_I_UWORD(modreader);
mh->globvol =_mm_read_UBYTE(modreader);
mh->mixvol =_mm_read_UBYTE(modreader);
mh->initspeed =_mm_read_UBYTE(modreader);
mh->inittempo =_mm_read_UBYTE(modreader);
mh->pansep =_mm_read_UBYTE(modreader);
mh->zerobyte =_mm_read_UBYTE(modreader);
mh->msglength =_mm_read_I_UWORD(modreader);
mh->msgoffset =_mm_read_I_ULONG(modreader);
_mm_read_UBYTES(mh->blank02,4,modreader);
_mm_read_UBYTES(mh->pantable,64,modreader);
_mm_read_UBYTES(mh->voltable,64,modreader);
if(_mm_eof(modreader)) {
_mm_errno=MMERR_LOADING_HEADER;
return 0;
}
/* set module variables */
of.songname = DupStr(mh->songname,26,0); /* make a cstr of songname */
of.reppos = 0;
of.numpat = mh->patnum;
of.numins = mh->insnum;
of.numsmp = mh->smpnum;
of.initspeed = mh->initspeed;
of.inittempo = mh->inittempo;
of.initvolume = mh->globvol;
of.flags |= UF_BGSLIDES|UF_ARPMEM;
if(mh->songname[25]) {
of.numvoices=1+mh->songname[25];
#ifdef MIKMOD_DEBUG
fprintf(stderr,"Embedded IT limitation to %d voices\n",of.numvoices);
#endif
}
/* set the module type */
/* 2.17 : IT 2.14p4 */
/* 2.16 : IT 2.14p3 with resonant filters */
/* 2.15 : IT 2.14p3 (improved compression) */
if((mh->cwt<=0x219)&&(mh->cwt>=0x217))
of.modtype=strdup(IT_Version[mh->cmwt<0x214?4:5]);
else if (mh->cwt>=0x215)
of.modtype=strdup(IT_Version[mh->cmwt<0x214?2:3]);
else {
of.modtype = strdup(IT_Version[mh->cmwt<0x214?0:1]);
of.modtype[mh->cmwt<0x214?15:26] = (mh->cwt>>8)+'0';
of.modtype[mh->cmwt<0x214?17:28] = ((mh->cwt>>4)&0xf)+'0';
of.modtype[mh->cmwt<0x214?18:29] = ((mh->cwt)&0xf)+'0';
}
if(mh->flags&8)
of.flags|=(UF_XMPERIODS | UF_LINEAR);
if((mh->cwt>=0x106)&&(mh->flags&16))
old_effect=1;
else
old_effect=0;
/* set panning positions */
for(t=0;t<64;t++) {
mh->pantable[t]&=0x7f;
if(mh->pantable[t]<64)
of.panning[t]=mh->pantable[t]<<2;
else if(mh->pantable[t]==64)
of.panning[t]=255;
else if(mh->pantable[t]==100)
of.panning[t]=PAN_SURROUND;
else if(mh->pantable[t]==127)
of.panning[t]=PAN_CENTER;
else {
_mm_errno=MMERR_LOADING_HEADER;
return 0;
}
}
/* set channel volumes */
memcpy(of.chanvol,mh->voltable,64);
/* read the order data */
if(!AllocPositions(mh->ordnum)) return 0;
if(!(origpositions=_mm_calloc(mh->ordnum,sizeof(UWORD)))) return 0;
for(t=0;t<mh->ordnum;t++) {
origpositions[t]=_mm_read_UBYTE(modreader);
if((origpositions[t]>mh->patnum)&&(origpositions[t]<254))
origpositions[t]=255;
}
if(_mm_eof(modreader)) {
_mm_errno = MMERR_LOADING_HEADER;
return 0;
}
poslookupcnt=(UBYTE)mh->ordnum;
S3MIT_CreateOrders(curious);
if(!(paraptr=(ULONG*)_mm_malloc((mh->insnum+mh->smpnum+of.numpat)*
sizeof(ULONG)))) return 0;
/* read the instrument, sample, and pattern parapointers */
_mm_read_I_ULONGS(paraptr,mh->insnum+mh->smpnum+of.numpat,modreader);
if(_mm_eof(modreader)) {
_mm_errno = MMERR_LOADING_HEADER;
return 0;
}
/* Check for and load midi information for resonant filters */
if(mh->cmwt>=0x216) {
if(mh->special&8) {
IT_LoadMidiConfiguration(modreader);
if(_mm_eof(modreader)) {
_mm_errno = MMERR_LOADING_HEADER;
return 0;
}
} else
IT_LoadMidiConfiguration(NULL);
filters=1;
}
/* Check for and load song comment */
if((mh->special&1)&&(mh->cwt>=0x104)&&(mh->msglength)) {
_mm_fseek(modreader,(long)(mh->msgoffset),SEEK_SET);
if(!ReadComment(mh->msglength)) return 0;
}
if(!(mh->flags&4)) of.numins=of.numsmp;
if(!AllocSamples()) return 0;
if(!AllocLinear()) return 0;
/* Load all samples */
q = of.samples;
for(t=0;t<mh->smpnum;t++) {
ITSAMPLE s;
/* seek to sample position */
_mm_fseek(modreader,(long)(paraptr[mh->insnum+t]+4),SEEK_SET);
/* load sample info */
_mm_read_string(s.filename,12,modreader);
s.zerobyte = _mm_read_UBYTE(modreader);
s.globvol = _mm_read_UBYTE(modreader);
s.flag = _mm_read_UBYTE(modreader);
s.volume = _mm_read_UBYTE(modreader);
_mm_read_string(s.sampname,26,modreader);
s.convert = _mm_read_UBYTE(modreader);
s.panning = _mm_read_UBYTE(modreader);
s.length = _mm_read_I_ULONG(modreader);
s.loopbeg = _mm_read_I_ULONG(modreader);
s.loopend = _mm_read_I_ULONG(modreader);
s.c5spd = _mm_read_I_ULONG(modreader);
s.susbegin = _mm_read_I_ULONG(modreader);
s.susend = _mm_read_I_ULONG(modreader);
s.sampoffset = _mm_read_I_ULONG(modreader);
s.vibspeed = _mm_read_UBYTE(modreader);
s.vibdepth = _mm_read_UBYTE(modreader);
s.vibrate = _mm_read_UBYTE(modreader);
s.vibwave = _mm_read_UBYTE(modreader);
/* Generate an error if c5spd is > 512k, or samplelength > 256 megs
(nothing would EVER be that high) */
if(_mm_eof(modreader)||(s.c5spd>0x7ffffL)||(s.length>0xfffffffUL)||
(s.loopbeg>0xfffffffUL)||(s.loopend>0xfffffffUL)) {
_mm_errno = MMERR_LOADING_SAMPLEINFO;
return 0;
}
q->samplename = DupStr(s.sampname,26,0);
q->speed = s.c5spd / 2;
q->panning = ((s.panning&127)==64)?255:(s.panning&127)<<2;
q->length = s.length;
q->loopstart = s.loopbeg;
q->loopend = s.loopend;
q->volume = s.volume;
q->globvol = s.globvol;
q->seekpos = s.sampoffset;
/* Convert speed to XM linear finetune */
if(of.flags&UF_LINEAR)
q->speed=speed_to_finetune(s.c5spd,t);
if(s.panning&128) q->flags|=SF_OWNPAN;
if(s.vibrate) {
q->vibflags |= AV_IT;
q->vibtype = s.vibwave;
q->vibsweep = s.vibrate * 2;
q->vibdepth = s.vibdepth;
q->vibrate = s.vibspeed;
}
if(s.flag&2) q->flags|=SF_16BITS;
if((s.flag&8)&&(mh->cwt>=0x214)) {
q->flags|=SF_ITPACKED;
compressed=1;
}
if(s.flag&16) q->flags|=SF_LOOP;
if(s.flag&64) q->flags|=SF_BIDI;
if(mh->cwt>=0x200) {
if(s.convert&1) q->flags|=SF_SIGNED;
if(s.convert&4) q->flags|=SF_DELTA;
}
q++;
}
/* Load instruments if instrument mode flag enabled */
if(mh->flags&4) {
if(!AllocInstruments()) return 0;
d=of.instruments;
of.flags|=UF_NNA|UF_INST;
for(t=0;t<mh->insnum;t++) {
ITINSTHEADER ih;
/* seek to instrument position */
_mm_fseek(modreader,paraptr[t]+4,SEEK_SET);
/* load instrument info */
_mm_read_string(ih.filename,12,modreader);
ih.zerobyte = _mm_read_UBYTE(modreader);
if(mh->cwt<0x200) {
/* load IT 1.xx inst header */
ih.volflg = _mm_read_UBYTE(modreader);
ih.volbeg = _mm_read_UBYTE(modreader);
ih.volend = _mm_read_UBYTE(modreader);
ih.volsusbeg = _mm_read_UBYTE(modreader);
ih.volsusend = _mm_read_UBYTE(modreader);
_mm_read_I_UWORD(modreader);
ih.fadeout = _mm_read_I_UWORD(modreader);
ih.nna = _mm_read_UBYTE(modreader);
ih.dnc = _mm_read_UBYTE(modreader);
} else {
/* Read IT200+ header */
ih.nna = _mm_read_UBYTE(modreader);
ih.dct = _mm_read_UBYTE(modreader);
ih.dca = _mm_read_UBYTE(modreader);
ih.fadeout = _mm_read_I_UWORD(modreader);
ih.ppsep = _mm_read_UBYTE(modreader);
ih.ppcenter = _mm_read_UBYTE(modreader);
ih.globvol = _mm_read_UBYTE(modreader);
ih.chanpan = _mm_read_UBYTE(modreader);
ih.rvolvar = _mm_read_UBYTE(modreader);
ih.rpanvar = _mm_read_UBYTE(modreader);
}
ih.trkvers = _mm_read_I_UWORD(modreader);
ih.numsmp = _mm_read_UBYTE(modreader);
_mm_read_UBYTE(modreader);
_mm_read_string(ih.name,26,modreader);
_mm_read_UBYTES(ih.blank01,6,modreader);
_mm_read_I_UWORDS(ih.samptable,ITNOTECNT,modreader);
if(mh->cwt<0x200) {
/* load IT 1xx volume envelope */
_mm_read_UBYTES(ih.volenv,200,modreader);
for(lp=0;lp<ITENVCNT;lp++) {
ih.oldvoltick[lp] = _mm_read_UBYTE(modreader);
ih.volnode[lp] = _mm_read_UBYTE(modreader);
}
} else {
/* load IT 2xx volume, pan and pitch envelopes */
ih.volflg =_mm_read_UBYTE(modreader);
ih.volpts =_mm_read_UBYTE(modreader);
ih.volbeg =_mm_read_UBYTE(modreader);
ih.volend =_mm_read_UBYTE(modreader);
ih.volsusbeg=_mm_read_UBYTE(modreader);
ih.volsusend=_mm_read_UBYTE(modreader);
for(lp=0;lp<ITENVCNT;lp++) {
ih.volnode[lp]=_mm_read_UBYTE(modreader);
ih.voltick[lp]=_mm_read_I_UWORD(modreader);
}
_mm_read_UBYTE(modreader);
ih.panflg =_mm_read_UBYTE(modreader);
ih.panpts =_mm_read_UBYTE(modreader);
ih.panbeg =_mm_read_UBYTE(modreader);
ih.panend =_mm_read_UBYTE(modreader);
ih.pansusbeg=_mm_read_UBYTE(modreader);
ih.pansusend=_mm_read_UBYTE(modreader);
for(lp=0;lp<ITENVCNT;lp++) {
ih.pannode[lp]=_mm_read_SBYTE(modreader);
ih.pantick[lp]=_mm_read_I_UWORD(modreader);
}
_mm_read_UBYTE(modreader);
ih.pitflg =_mm_read_UBYTE(modreader);
ih.pitpts =_mm_read_UBYTE(modreader);
ih.pitbeg =_mm_read_UBYTE(modreader);
ih.pitend =_mm_read_UBYTE(modreader);
ih.pitsusbeg=_mm_read_UBYTE(modreader);
ih.pitsusend=_mm_read_UBYTE(modreader);
for(lp=0;lp < ITENVCNT; lp++) {
ih.pitnode[lp]=_mm_read_SBYTE(modreader);
ih.pittick[lp]=_mm_read_I_UWORD(modreader);
}
_mm_read_UBYTE(modreader);
}
if(_mm_eof(modreader)) {
_mm_errno = MMERR_LOADING_SAMPLEINFO;
return 0;
}
d->volflg|=EF_VOLENV;
d->insname = DupStr(ih.name,26,0);
d->nnatype = ih.nna & NNA_MASK;
if(mh->cwt<0x200) {
d->volfade=ih.fadeout<< 6;
if(ih.dnc) {
d->dct=DCT_NOTE;
d->dca=DCA_CUT;
}
if(ih.volflg&1) d->volflg|=EF_ON;
if(ih.volflg&2) d->volflg|=EF_LOOP;
if(ih.volflg&4) d->volflg|=EF_SUSTAIN;
/* XM conversion of IT envelope Array */
d->volbeg = ih.volbeg;
d->volend = ih.volend;
d->volsusbeg = ih.volsusbeg;
d->volsusend = ih.volsusend;
if(ih.volflg&1) {
for(u=0;u<ITENVCNT;u++)
if(ih.oldvoltick[d->volpts]!=0xff) {
d->volenv[d->volpts].val=(ih.volnode[d->volpts]<<2);
d->volenv[d->volpts].pos=ih.oldvoltick[d->volpts];
d->volpts++;
} else
break;
}
} else {
d->panning=((ih.chanpan&127)==64)?255:(ih.chanpan&127)<<2;
if(!(ih.chanpan&128)) d->flags|=IF_OWNPAN;
if(!(ih.ppsep & 128)) {
d->pitpansep=ih.ppsep<<2;
d->pitpancenter=ih.ppcenter;
d->flags|=IF_PITCHPAN;
}
d->globvol=ih.globvol>>1;
d->volfade=ih.fadeout<<5;
d->dct =ih.dct;
d->dca =ih.dca;
if(mh->cwt>=0x204) {
d->rvolvar = ih.rvolvar;
d->rpanvar = ih.rpanvar;
}
if(ih.volflg&1) d->volflg|=EF_ON;
if(ih.volflg&2) d->volflg|=EF_LOOP;
if(ih.volflg&4) d->volflg|=EF_SUSTAIN;
d->volpts=ih.volpts;
d->volbeg=ih.volbeg;
d->volend=ih.volend;
d->volsusbeg=ih.volsusbeg;
d->volsusend=ih.volsusend;
for(u=0;u<ih.volpts;u++)
d->volenv[u].pos=ih.voltick[u]; if((d->volflg&EF_ON)&&(d->volpts<2))
d->volflg&=~EF_ON;
for(u=0;u<ih.volpts;u++)
d->volenv[u].val=(ih.volnode[u]<<2);
if(ih.panflg&1) d->panflg|=EF_ON;
if(ih.panflg&2) d->panflg|=EF_LOOP;
if(ih.panflg&4) d->panflg|=EF_SUSTAIN;
d->panpts=ih.panpts;
d->panbeg=ih.panbeg;
d->panend=ih.panend;
d->pansusbeg=ih.pansusbeg;
d->pansusend=ih.pansusend;
for(u=0;u<ih.panpts;u++)
d->panenv[u].pos=ih.pantick[u];
if((d->panflg&EF_ON)&&(d->panpts<2))
d->panflg&=~EF_ON;
for(u=0;u<ih.panpts;u++)
d->panenv[u].val=ih.pannode[u]==32?255:(ih.pannode[u]+32)<<2;
if(ih.pitflg&1) d->pitflg|=EF_ON;
if(ih.pitflg&2) d->pitflg|=EF_LOOP;
if(ih.pitflg&4) d->pitflg|=EF_SUSTAIN;
d->pitpts=ih.pitpts;
d->pitbeg=ih.pitbeg;
d->pitend=ih.pitend;
d->pitsusbeg=ih.pitsusbeg;
d->pitsusend=ih.pitsusend;
for(u=0;u<ih.pitpts;u++)
d->pitenv[u].pos=ih.pittick[u];
if((d->pitflg&EF_ON)&&(d->pitpts<2))
d->pitflg&=~EF_ON;
for(u=0;u<ih.pitpts;u++)
d->pitenv[u].val=ih.pitnode[u]+32;
if(ih.pitflg&0x80) {
/* filter envelopes not supported yet */
d->pitflg&=~EF_ON;
ih.pitpts=ih.pitbeg=ih.pitend=0;
#ifdef MIKMOD_DEBUG
{
static int warn=0;
if(!warn)
fputs("\rFilter envelopes not supported yet\n",stderr);
warn=1;
}
#endif
}
}
for(u=0;u<ITNOTECNT;u++) {
d->samplenote[u]=(ih.samptable[u]&255);
d->samplenumber[u]=
(ih.samptable[u]>>8)?((ih.samptable[u]>>8)-1):0xffff;
if(d->samplenumber[u]>=of.numsmp)
d->samplenote[u]=255;
else if (of.flags&UF_LINEAR) {
int note=(int)d->samplenote[u]+noteindex[d->samplenumber[u]];
d->samplenote[u]=(note<0)?0:(note>255?255:note);
}
}
d++;
}
} else if(of.flags & UF_LINEAR) {
static BOOL loadinstr6(void)
{
int t,w;
INSTRUMENT *i;
i=of.instruments;
for(t=0;t<of.numins;t++,i++) {
i->flags = _mm_read_UBYTE(modreader);
i->nnatype = _mm_read_UBYTE(modreader);
i->dca = _mm_read_UBYTE(modreader);
i->dct = _mm_read_UBYTE(modreader);
i->globvol = _mm_read_UBYTE(modreader);
i->panning = _mm_read_M_UWORD(modreader);
i->pitpansep = _mm_read_UBYTE(modreader);
i->pitpancenter = _mm_read_UBYTE(modreader);
i->rvolvar = _mm_read_UBYTE(modreader);
i->rpanvar = _mm_read_UBYTE(modreader);
i->volfade = _mm_read_M_UWORD(modreader);
#if defined __STDC__ || defined _MSC_VER || defined MPW_C
#define UNI_LoadEnvelope6(name) \
i-> name##flg=_mm_read_UBYTE(modreader); \
i-> name##pts=_mm_read_UBYTE(modreader); \
i-> name##susbeg=_mm_read_UBYTE(modreader); \
i-> name##susend=_mm_read_UBYTE(modreader); \
i-> name##beg=_mm_read_UBYTE(modreader); \
i-> name##end=_mm_read_UBYTE(modreader); \
for(w=0;w<(universion>=0x100?32:i-> name##pts);w++) { \
i-> name##env[w].pos=_mm_read_M_SWORD(modreader); \
i-> name##env[w].val=_mm_read_M_SWORD(modreader); \
}
#else
#define UNI_LoadEnvelope6(name) \
i-> name/**/flg=_mm_read_UBYTE(modreader); \
i-> name/**/pts=_mm_read_UBYTE(modreader); \
i-> name/**/susbeg=_mm_read_UBYTE(modreader); \
i-> name/**/susend=_mm_read_UBYTE(modreader); \
i-> name/**/beg=_mm_read_UBYTE(modreader); \
i-> name/**/end=_mm_read_UBYTE(modreader); \
for (w=0;w<(universion>=0x100?32:i-> name/**/pts);w++) { \
i-> name/**/env[w].pos=_mm_read_M_SWORD(modreader); \
i-> name/**/env[w].val=_mm_read_M_SWORD(modreader); \
}
#endif
UNI_LoadEnvelope6(vol);
UNI_LoadEnvelope6(pan);
UNI_LoadEnvelope6(pit);
#undef UNI_LoadEnvelope6
if(universion>=0x103)
_mm_read_M_UWORDS(i->samplenumber,120,modreader);
else
for(w=0;w<120;w++)
i->samplenumber[w]=_mm_read_UBYTE(modreader);
_mm_read_UBYTES(i->samplenote,120,modreader);
i->insname=readstring();
if(_mm_eof(modreader)) {
_mm_errno = MMERR_LOADING_SAMPLEINFO;
return 0;
}
}
return 1;
}
static BOOL loadinstr5(void)
{
INSTRUMENT *i;
int t;
UWORD wavcnt=0;
UBYTE vibtype,vibsweep,vibdepth,vibrate;
i=of.instruments;
for(of.numsmp=t=0;t<of.numins;t++,i++) {
int u,numsmp;
numsmp=_mm_read_UBYTE(modreader);
memset(i->samplenumber,0xff,INSTNOTES*sizeof(UWORD));
for(u=0;u<96;u++)
i->samplenumber[u]=of.numsmp+_mm_read_UBYTE(modreader);
#if defined __STDC__ || defined _MSC_VER || defined MPW_C
#define UNI_LoadEnvelope5(name) \
i-> name##flg=_mm_read_UBYTE(modreader); \
i-> name##pts=_mm_read_UBYTE(modreader); \
i-> name##susbeg=_mm_read_UBYTE(modreader); \
i-> name##susend=i-> name##susbeg; \
i-> name##beg=_mm_read_UBYTE(modreader); \
i-> name##end=_mm_read_UBYTE(modreader); \
for(u=0;u<12;u++) { \
i-> name##env[u].pos=_mm_read_I_SWORD(modreader); \
i-> name##env[u].val=_mm_read_I_SWORD(modreader); \
}
#else
#define UNI_LoadEnvelope5(name) \
i-> name/**/flg=_mm_read_UBYTE(modreader); \
i-> name/**/pts=_mm_read_UBYTE(modreader); \
i-> name/**/susbeg=_mm_read_UBYTE(modreader); \
i-> name/**/susend=i-> name/**/susbeg; \
i-> name/**/beg=_mm_read_UBYTE(modreader); \
i-> name/**/end=_mm_read_UBYTE(modreader); \
for(u=0;u<12;u++) { \
i-> name/**/env[u].pos=_mm_read_I_SWORD(modreader); \
i-> name/**/env[u].val=_mm_read_I_SWORD(modreader); \
}
#endif
UNI_LoadEnvelope5(vol);
UNI_LoadEnvelope5(pan);
#undef UNI_LoadEnvelope5
vibtype =_mm_read_UBYTE(modreader);
vibsweep =_mm_read_UBYTE(modreader);
vibdepth =_mm_read_UBYTE(modreader);
vibrate =_mm_read_UBYTE(modreader);
i->volfade=_mm_read_I_UWORD(modreader);
i->insname=readstring();
for(u=0;u<numsmp;u++,s++,of.numsmp++) {
/* Allocate more room for sample information if necessary */
if(of.numsmp+u==wavcnt) {
wavcnt+=UNI_SMPINCR;
if(!(wh=(UNISMP05*)MikMod_realloc(wh,wavcnt*sizeof(UNISMP05)))) {
_mm_errno=MMERR_OUT_OF_MEMORY;
return 0;
}
s=wh+(wavcnt-UNI_SMPINCR);
}
s->c2spd =_mm_read_I_UWORD(modreader);
s->transpose=_mm_read_SBYTE(modreader);
s->volume =_mm_read_UBYTE(modreader);
s->panning =_mm_read_UBYTE(modreader);
s->length =_mm_read_I_ULONG(modreader);
s->loopstart=_mm_read_I_ULONG(modreader);
s->loopend =_mm_read_I_ULONG(modreader);
s->flags =_mm_read_I_UWORD(modreader);
s->samplename=readstring();
s->vibtype =vibtype;
s->vibsweep=vibsweep;
s->vibdepth=vibdepth;
s->vibrate =vibrate;
if(_mm_eof(modreader)) {
MikMod_free(wh);wh=NULL;
_mm_errno=MMERR_LOADING_SAMPLEINFO;
return 0;
}
}
}
/* sanity check */
if(!of.numsmp) {
MikMod_free(wh);wh=NULL;
_mm_errno=MMERR_LOADING_SAMPLEINFO;
return 0;
}
return 1;
}
static BOOL UNI_Load(BOOL curious)
{
int t;
char *modtype,*oldtype=NULL;
INSTRUMENT *d;
SAMPLE *q;
/* read module header */
_mm_read_UBYTES(mh.id,4,modreader);
if(mh.id[3]!='N')
universion=mh.id[3]-'0';
else
universion=0x100;
if(universion>=6) {
if (universion==6) {
_mm_skip_BYTE(modreader);
} else {
universion=_mm_read_M_UWORD(modreader);
}
mh.flags =_mm_read_M_UWORD(modreader);
mh.numchn =_mm_read_UBYTE(modreader);
mh.numvoices =_mm_read_UBYTE(modreader);
mh.numpos =_mm_read_M_UWORD(modreader);
mh.numpat =_mm_read_M_UWORD(modreader);
mh.numtrk =_mm_read_M_UWORD(modreader);
mh.numins =_mm_read_M_UWORD(modreader);
mh.numsmp =_mm_read_M_UWORD(modreader);
mh.reppos =_mm_read_M_UWORD(modreader);
mh.initspeed =_mm_read_UBYTE(modreader);
mh.inittempo =_mm_read_UBYTE(modreader);
mh.initvolume=_mm_read_UBYTE(modreader);
/* I expect this to show up soon in APlayer 1.06 format */
if (universion >= 0x106)
mh.bpmlimit=_mm_read_M_UWORD(modreader);
else
mh.bpmlimit=32;
mh.flags &= UF_XMPERIODS | UF_LINEAR | UF_INST | UF_NNA;
mh.flags |= UF_PANNING;
} else {
mh.numchn =_mm_read_UBYTE(modreader);
mh.numpos =_mm_read_I_UWORD(modreader);
mh.reppos =(universion==5)?_mm_read_I_UWORD(modreader):0;
mh.numpat =_mm_read_I_UWORD(modreader);
mh.numtrk =_mm_read_I_UWORD(modreader);
mh.numins =_mm_read_I_UWORD(modreader);
mh.initspeed =_mm_read_UBYTE(modreader);
mh.inittempo =_mm_read_UBYTE(modreader);
_mm_read_UBYTES(mh.positions,256,modreader);
_mm_read_UBYTES(mh.panning,32,modreader);
mh.flags =_mm_read_UBYTE(modreader);
mh.bpmlimit =32;
mh.flags &= UF_XMPERIODS | UF_LINEAR;
mh.flags |= UF_INST | UF_NOWRAP | UF_PANNING;
}
/* set module parameters */
of.flags =mh.flags;
of.numchn =mh.numchn;
of.numpos =mh.numpos;
of.numpat =mh.numpat;
of.numtrk =mh.numtrk;
of.numins =mh.numins;
of.reppos =mh.reppos;
of.initspeed =mh.initspeed;
of.inittempo =mh.inittempo;
if(mh.bpmlimit)
of.bpmlimit=mh.bpmlimit;
else
/* be bug-compatible with older releases */
of.bpmlimit=32;
of.songname=readstring();
if(universion<0x102)
oldtype=readstring();
if(oldtype) {
size_t len=strlen(oldtype)+20;
if(!(modtype=(char*)MikMod_malloc(len))) return 0;
#ifdef HAVE_SNPRINTF
snprintf(modtype,len,"%s (was %s)",(universion>=0x100)?"APlayer":"MikCvt2",oldtype);
#else
sprintf(modtype,"%s (was %s)",(universion>=0x100)?"APlayer":"MikCvt2",oldtype);
#endif
} else {
if(!(modtype=(char*)MikMod_malloc(10))) return 0;
#ifdef HAVE_SNPRINTF
snprintf(modtype,10,"%s",(universion>=0x100)?"APlayer":"MikCvt3");
#else
sprintf(modtype,"%s",(universion>=0x100)?"APlayer":"MikCvt3");
#endif
}
of.modtype=MikMod_strdup(modtype);
MikMod_free(modtype);MikMod_free(oldtype);
of.comment=readstring();
if(universion>=6) {
of.numvoices=mh.numvoices;
of.initvolume=mh.initvolume;
}
if(_mm_eof(modreader)) {
_mm_errno=MMERR_LOADING_HEADER;
return 0;
}
/* positions */
if(!AllocPositions(of.numpos)) return 0;
if(universion>=6) {
if(universion>=0x100)
_mm_read_M_UWORDS(of.positions,of.numpos,modreader);
else
for(t=0;t<of.numpos;t++) of.positions[t]=_mm_read_UBYTE(modreader);
_mm_read_M_UWORDS(of.panning,of.numchn,modreader);
_mm_read_UBYTES(of.chanvol,of.numchn,modreader);
} else {
if((mh.numpos>256)||(mh.numchn>32)) {
_mm_errno=MMERR_LOADING_HEADER;
return 0;
}
for(t=0;t<of.numpos;t++) of.positions[t]=mh.positions[t];
for(t=0;t<of.numchn;t++) of.panning[t]=mh.panning[t];
}
/* convert the ``end of song'' pattern code if necessary */
if(universion<0x106)
for(t=0;t<of.numpos;t++)
if(of.positions[t]==255) of.positions[t]=LAST_PATTERN;
/* instruments and samples */
if(universion>=6) {
of.numsmp=mh.numsmp;
if(!AllocSamples()) return 0;
if(!loadsmp6()) return 0;
if(of.flags&UF_INST) {
if(!AllocInstruments()) return 0;
if(!loadinstr6()) return 0;
}
} else {
if(!AllocInstruments()) return 0;
if(!loadinstr5()) return 0;
if(!AllocSamples()) {
MikMod_free(wh);wh=NULL;
return 0;
}
if(!loadsmp5()) return 0;
/* check if the original file had no instruments */
if(of.numsmp==of.numins) {
for(t=0,d=of.instruments;t<of.numins;t++,d++) {
int u;
if((d->volpts)||(d->panpts)||(d->globvol!=64)) break;
for(u=0;u<96;u++)
if((d->samplenumber[u]!=t)||(d->samplenote[u]!=u)) break;
if(u!=96) break;
}
if(t==of.numins) {
of.flags&=~UF_INST;
of.flags&=~UF_NOWRAP;
for(t=0,d=of.instruments,q=of.samples;t<of.numins;t++,d++,q++) {
q->samplename=d->insname;
d->insname=NULL;
}
}
}
}
/* patterns */
if(!AllocPatterns()) return 0;
if(universion>=6) {
_mm_read_M_UWORDS(of.pattrows,of.numpat,modreader);
_mm_read_M_UWORDS(of.patterns,of.numpat*of.numchn,modreader);
} else {
_mm_read_I_UWORDS(of.pattrows,of.numpat,modreader);
_mm_read_I_UWORDS(of.patterns,of.numpat*of.numchn,modreader);
}
/* tracks */
if(!AllocTracks()) return 0;
for(t=0;t<of.numtrk;t++)
if(!(of.tracks[t]=readtrack())) {
_mm_errno=MMERR_LOADING_TRACK;
return 0;
}
return 1;
}
BOOL
FAR_Load (BOOL curious)
{
int t, u, tracks = 0;
SAMPLE *q;
FARSAMPLE s;
FARNOTE *crow;
UBYTE smap[8];
/* try to read module header (first part) */
_mm_read_UBYTES (mh1->id, 4, modreader);
_mm_read_SBYTES (mh1->songname, 40, modreader);
_mm_read_SBYTES (mh1->blah, 3, modreader);
mh1->headerlen = _mm_read_I_UWORD (modreader);
mh1->version = _mm_read_UBYTE (modreader);
_mm_read_UBYTES (mh1->onoff, 16, modreader);
_mm_read_UBYTES (mh1->edit1, 9, modreader);
mh1->speed = _mm_read_UBYTE (modreader);
_mm_read_UBYTES (mh1->panning, 16, modreader);
_mm_read_UBYTES (mh1->edit2, 4, modreader);
mh1->stlen = _mm_read_I_UWORD (modreader);
/* init modfile data */
of.modtype = strdup (FAR_Version);
of.songname = DupStr (mh1->songname, 40, 1);
of.numchn = 16;
of.initspeed = mh1->speed;
of.inittempo = 80;
of.reppos = 0;
for (t = 0; t < 16; t++)
of.panning[t] = mh1->panning[t] << 4;
/* read songtext into comment field */
if (mh1->stlen)
if (!ReadComment (mh1->stlen))
return 0;
/* try to read module header (second part) */
_mm_read_UBYTES (mh2->orders, 256, modreader);
mh2->numpat = _mm_read_UBYTE (modreader);
mh2->snglen = _mm_read_UBYTE (modreader);
mh2->loopto = _mm_read_UBYTE (modreader);
_mm_read_I_UWORDS (mh2->patsiz, 256, modreader);
of.numpos = mh2->snglen;
if (!AllocPositions (of.numpos))
return 0;
for (t = 0; t < of.numpos; t++)
{
if (mh2->orders[t] == 0xff)
break;
of.positions[t] = mh2->orders[t];
}
/* count number of patterns stored in file */
of.numpat = 0;
for (t = 0; t < 256; t++)
if (mh2->patsiz[t])
if ((t + 1) > of.numpat)
of.numpat = t + 1;
of.numtrk = of.numpat * of.numchn;
/* seek across eventual new data */
_mm_fseek (modreader, mh1->headerlen - (869 + mh1->stlen), SEEK_CUR);
/* alloc track and pattern structures */
if (!AllocTracks ())
return 0;
if (!AllocPatterns ())
return 0;
for (t = 0; t < of.numpat; t++)
{
UBYTE rows = 0;
memset (pat, 0, 256 * 16 * 4 * sizeof (FARNOTE));
if (mh2->patsiz[t])
{
rows = _mm_read_UBYTE (modreader);
/* tempo = */ _mm_read_UBYTE (modreader);
crow = pat;
/* file often allocates 64 rows even if there are less in pattern */
if (mh2->patsiz[t] < 2 + (rows * 16 * 4))
{
_mm_errno = MMERR_LOADING_PATTERN;
return 0;
}
for (u = (mh2->patsiz[t] - 2) / 4; u; u--, crow++)
{
crow->note = _mm_read_UBYTE (modreader);
crow->ins = _mm_read_UBYTE (modreader);
crow->vol = _mm_read_UBYTE (modreader);
crow->eff = _mm_read_UBYTE (modreader);
}
if (_mm_eof (modreader))
{
_mm_errno = MMERR_LOADING_PATTERN;
return 0;
}
crow = pat;
of.pattrows[t] = rows;
for (u = 16; u; u--, crow++)
if (!(of.tracks[tracks++] = FAR_ConvertTrack (crow, rows)))
{
_mm_errno = MMERR_LOADING_PATTERN;
return 0;
}
}
else
tracks += 16;
}
/* read sample map */
if (!_mm_read_UBYTES (smap, 8, modreader))
{
_mm_errno = MMERR_LOADING_HEADER;
return 0;
}
/* count number of samples used */
of.numins = 0;
for (t = 0; t < 64; t++)
if (smap[t >> 3] & (1 << (t & 7)))
of.numins = t + 1;
of.numsmp = of.numins;
/* alloc sample structs */
if (!AllocSamples ())
return 0;
q = of.samples;
for (t = 0; t < of.numsmp; t++)
{
q->speed = 8363;
q->flags = SF_SIGNED;
if (smap[t >> 3] & (1 << (t & 7)))
{
_mm_read_SBYTES (s.samplename, 32, modreader);
s.length = _mm_read_I_ULONG (modreader);
s.finetune = _mm_read_UBYTE (modreader);
s.volume = _mm_read_UBYTE (modreader);
s.reppos = _mm_read_I_ULONG (modreader);
s.repend = _mm_read_I_ULONG (modreader);
s.type = _mm_read_UBYTE (modreader);
s.loop = _mm_read_UBYTE (modreader);
q->samplename = DupStr (s.samplename, 32, 1);
q->length = s.length;
q->loopstart = s.reppos;
q->loopend = s.repend;
q->volume = s.volume << 2;
if (s.type & 1)
q->flags |= SF_16BITS;
if (s.loop & 8)
q->flags |= SF_LOOP;
q->seekpos = _mm_ftell (modreader);
_mm_fseek (modreader, q->length, SEEK_CUR);
}
else
q->samplename = DupStr (NULL, 0, 0);
q++;
}
BOOL OKT_Load(BOOL curious)
{
UBYTE id[4];
ULONG len;
ULONG fp;
BOOL seen_cmod = 0, seen_samp = 0, seen_slen = 0, seen_plen = 0, seen_patt
= 0, seen_spee = 0;
int patnum = 0, insnum = 0;
/* skip OKTALYZER header */
_mm_fseek(modreader, 8, SEEK_SET);
of.songname = strdup("");
of.modtype = strdup("Amiga Oktalyzer");
of.numpos = of.reppos = 0;
/* default values */
of.initspeed = 6;
of.inittempo = 125;
while (1) {
/* read block header */
_mm_read_UBYTES(id, 4, modreader);
len = _mm_read_M_ULONG(modreader);
if (_mm_eof(modreader))
break;
fp = _mm_ftell(modreader);
if (!memcmp(id, "CMOD", 4)) {
if (!seen_cmod) {
OKT_doCMOD();
seen_cmod = 1;
} else {
_mm_errno = MMERR_LOADING_HEADER;
return 0;
}
} else if (!memcmp(id, "SAMP", 4)) {
if (!seen_samp && OKT_doSAMP(len))
seen_samp = 1;
else {
_mm_errno = MMERR_LOADING_HEADER;
return 0;
}
} else if (!memcmp(id, "SPEE", 4)) {
if (!seen_spee) {
OKT_doSPEE();
seen_spee = 1;
} else {
_mm_errno = MMERR_LOADING_HEADER;
return 0;
}
} else if (!memcmp(id, "SLEN", 4)) {
if (!seen_slen) {
OKT_doSLEN();
seen_slen = 1;
} else {
_mm_errno = MMERR_LOADING_HEADER;
return 0;
}
} else if (!memcmp(id, "PLEN", 4)) {
if (!seen_plen) {
OKT_doPLEN();
seen_plen = 1;
} else {
_mm_errno = MMERR_LOADING_HEADER;
return 0;
}
} else if (!memcmp(id, "PATT", 4)) {
if (!seen_plen) {
_mm_errno = MMERR_LOADING_HEADER;
return 0;
}
if (!seen_patt && OKT_doPATT())
seen_patt = 1;
else {
_mm_errno = MMERR_LOADING_HEADER;
return 0;
}
} else if (!memcmp(id,"PBOD", 4)) {
/* need to know numpat and numchn */
if (!seen_slen || !seen_cmod || (patnum >= of.numpat)) {
_mm_errno = MMERR_LOADING_HEADER;
return 0;
}
if (!OKT_doPBOD(patnum++)) {
_mm_errno = MMERR_LOADING_PATTERN;
return 0;
}
} else if (!memcmp(id,"SBOD",4)) {
/* need to know numsmp */
if (!seen_samp) {
_mm_errno = MMERR_LOADING_HEADER;
return 0;
}
while ((insnum < of.numins) && !of.samples[insnum].length)
insnum++;
if (insnum >= of.numins) {
_mm_errno = MMERR_LOADING_HEADER;
return 0;
}
OKT_doSBOD(insnum++);
}
/* goto next block start position */
_mm_fseek(modreader, fp + len, SEEK_SET);
}
if (!seen_cmod || !seen_samp || !seen_patt ||
!seen_slen || !seen_plen || (patnum != of.numpat)) {
_mm_errno = MMERR_LOADING_HEADER;
return 0;
}
return 1;
}
static BOOL ULT_Load(BOOL curious)
{
int t,u,tracks=0;
SAMPLE *q;
ULTSAMPLE s;
ULTHEADER mh;
UBYTE nos,noc,nop;
/* try to read module header */
_mm_read_string(mh.id,15,modreader);
_mm_read_string(mh.songtitle,32,modreader);
mh.reserved=_mm_read_UBYTE(modreader);
if(_mm_eof(modreader)) {
_mm_errno = MMERR_LOADING_HEADER;
return 0;
}
ULT_Version[ULT_VERSION_LEN-1]='3'+(mh.id[14]-'1');
of.modtype = DupStr(ULT_Version,ULT_VERSION_LEN,1);
of.initspeed = 6;
of.inittempo = 125;
of.reppos = 0;
/* read songtext */
if ((mh.id[14]>'1')&&(mh.reserved))
if(!ReadLinedComment(mh.reserved * 32, 32)) return 0;
nos=_mm_read_UBYTE(modreader);
if(_mm_eof(modreader)) {
_mm_errno = MMERR_LOADING_HEADER;
return 0;
}
of.songname=DupStr(mh.songtitle,32,1);
of.numins=of.numsmp=nos;
if(!AllocSamples()) return 0;
q = of.samples;
for(t=0; t<nos; t++) {
/* try to read sample info */
_mm_read_string(s.samplename,32,modreader);
_mm_read_string(s.dosname,12,modreader);
s.loopstart =_mm_read_I_ULONG(modreader);
s.loopend =_mm_read_I_ULONG(modreader);
s.sizestart =_mm_read_I_ULONG(modreader);
s.sizeend =_mm_read_I_ULONG(modreader);
s.volume =_mm_read_UBYTE(modreader);
s.flags =_mm_read_UBYTE(modreader);
s.speed =(mh.id[14]>='4')?_mm_read_I_UWORD(modreader):8363;
s.finetune =_mm_read_I_SWORD(modreader);
if(_mm_eof(modreader)) {
_mm_errno = MMERR_LOADING_SAMPLEINFO;
return 0;
}
q->samplename=DupStr(s.samplename,32,1);
/* The correct formula for the coefficient would be
pow(2,(double)s.finetume/OCTAVE/32768), but to avoid floating point
here, we'll use a first order approximation here.
1/567290 == Ln(2)/OCTAVE/32768 */
q->speed=s.speed+s.speed*(((SLONG)s.speed*(SLONG)s.finetune)/567290);
q->length = s.sizeend-s.sizestart;
q->volume = s.volume>>2;
q->loopstart = s.loopstart;
q->loopend = s.loopend;
q->flags = SF_SIGNED;
if(s.flags&ULTS_LOOP) q->flags|=SF_LOOP;
if(s.flags&ULTS_16BITS) {
s.sizeend+=(s.sizeend-s.sizestart);
s.sizestart<<=1;
q->flags|=SF_16BITS;
q->loopstart>>=1;
q->loopend>>=1;
}
q++;
}
static BOOL STX_Load(BOOL curious)
{
int t,u,track = 0;
int version = 0;
SAMPLE *q;
/* try to read module header */
_mm_read_string(mh->songname,20,modreader);
_mm_read_string(mh->trackername,8,modreader);
mh->patsize =_mm_read_I_UWORD(modreader);
mh->unknown1 =_mm_read_I_UWORD(modreader);
mh->patptr =_mm_read_I_UWORD(modreader);
mh->insptr =_mm_read_I_UWORD(modreader);
mh->chnptr =_mm_read_I_UWORD(modreader);
mh->unknown2 =_mm_read_I_UWORD(modreader);
mh->unknown3 =_mm_read_I_UWORD(modreader);
mh->mastermult =_mm_read_UBYTE(modreader);
mh->initspeed =_mm_read_UBYTE(modreader)>>4;
mh->unknown4 =_mm_read_I_UWORD(modreader);
mh->unknown5 =_mm_read_I_UWORD(modreader);
mh->patnum =_mm_read_I_UWORD(modreader);
mh->insnum =_mm_read_I_UWORD(modreader);
mh->ordnum =_mm_read_I_UWORD(modreader);
mh->unknown6 =_mm_read_I_UWORD(modreader);
mh->unknown7 =_mm_read_I_UWORD(modreader);
mh->unknown8 =_mm_read_I_UWORD(modreader);
_mm_read_string(mh->scrm,4,modreader);
if(_mm_eof(modreader)) {
_mm_errno = MMERR_LOADING_HEADER;
return 0;
}
/* set module variables */
of.songname = DupStr(mh->songname,20,1);
of.numpat = mh->patnum;
of.reppos = 0;
of.numins = of.numsmp = mh->insnum;
of.initspeed = mh->initspeed;
of.inittempo = 125;
of.numchn = 4;
of.flags |= UF_S3MSLIDES;
of.bpmlimit = 32;
if(!(paraptr=(UWORD*)MikMod_malloc((of.numins+of.numpat)*sizeof(UWORD))))
return 0;
/* read the instrument+pattern parapointers */
_mm_fseek(modreader,mh->insptr<<4,SEEK_SET);
_mm_read_I_UWORDS(paraptr,of.numins,modreader);
_mm_fseek(modreader,mh->patptr<<4,SEEK_SET);
_mm_read_I_UWORDS(paraptr+of.numins,of.numpat,modreader);
/* check module version */
_mm_fseek(modreader,paraptr[of.numins]<<4,SEEK_SET);
version=_mm_read_I_UWORD(modreader);
if(version==mh->patsize) {
version = 0x10;
of.modtype = MikMod_strdup("STMIK 0.2 (STM2STX 1.0)");
} else {
version = 0x11;
of.modtype = MikMod_strdup("STMIK 0.2 (STM2STX 1.1)");
}
/* read the order data */
_mm_fseek(modreader,(mh->chnptr<<4)+32,SEEK_SET);
if(!AllocPositions(mh->ordnum)) return 0;
for(t=0;t<mh->ordnum;t++) {
of.positions[t]=_mm_read_UBYTE(modreader);
_mm_fseek(modreader,4,SEEK_CUR);
}
of.numpos=0;poslookupcnt=mh->ordnum;
for(t=0;t<mh->ordnum;t++) {
int order=of.positions[t];
if(order==255) order=LAST_PATTERN;
of.positions[of.numpos]=order;
poslookup[t]=of.numpos; /* bug fix for freaky S3Ms */
if(of.positions[t]<254) of.numpos++;
else
/* special end of song pattern */
if((order==LAST_PATTERN)&&(!curious)) break;
}
if(_mm_eof(modreader)) {
_mm_errno = MMERR_LOADING_HEADER;
return 0;
}
/* load samples */
if(!AllocSamples()) return 0;
for(q=of.samples,t=0;t<of.numins;t++,q++) {
STXSAMPLE s;
/* seek to instrument position */
_mm_fseek(modreader,((long)paraptr[t])<<4,SEEK_SET);
/* and load sample info */
s.type =_mm_read_UBYTE(modreader);
_mm_read_string(s.filename,12,modreader);
s.memsegh =_mm_read_UBYTE(modreader);
s.memsegl =_mm_read_I_UWORD(modreader);
s.length =_mm_read_I_ULONG(modreader);
s.loopbeg =_mm_read_I_ULONG(modreader);
s.loopend =_mm_read_I_ULONG(modreader);
s.volume =_mm_read_UBYTE(modreader);
s.dsk =_mm_read_UBYTE(modreader);
s.pack =_mm_read_UBYTE(modreader);
s.flags =_mm_read_UBYTE(modreader);
s.c2spd =_mm_read_I_ULONG(modreader);
_mm_read_UBYTES(s.unused,12,modreader);
_mm_read_string(s.sampname,28,modreader);
_mm_read_string(s.scrs,4,modreader);
if(_mm_eof(modreader)) {
_mm_errno = MMERR_LOADING_SAMPLEINFO;
return 0;
}
q->samplename = DupStr(s.sampname,28,1);
q->speed = (s.c2spd * 8363) / 8448;
q->length = s.length;
q->loopstart = s.loopbeg;
q->loopend = s.loopend;
q->volume = s.volume;
q->seekpos = (((long)s.memsegh)<<16|s.memsegl)<<4;
q->flags |= SF_SIGNED;
if(s.flags&1) q->flags |= SF_LOOP;
if(s.flags&4) q->flags |= SF_16BITS;
}
/* load pattern info */
of.numtrk=of.numpat*of.numchn;
if(!AllocTracks()) return 0;
if(!AllocPatterns()) return 0;
for(t=0;t<of.numpat;t++) {
/* seek to pattern position (+2 skip pattern length) */
_mm_fseek(modreader,(((long)paraptr[of.numins+t])<<4)+
(version==0x10?2:0),SEEK_SET);
if(!STX_ReadPattern()) return 0;
for(u=0;u<of.numchn;u++)
if(!(of.tracks[track++]=STX_ConvertTrack(&stxbuf[u*64]))) return 0;
}
return 1;
}
