/* MikMod sound library

(c) 1998, 1999, 2000, 2001, 2002 Miodrag Vallat and others - see file

AUTHORS for complete list.

This library is free software; you can redistribute it and/or modify

it under the terms of the GNU Library General Public License as

published by the Free Software Foundation; either version 2 of

the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,

but WITHOUT ANY WARRANTY; without even the implied warranty of

MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

GNU Library General Public License for more details.

You should have received a copy of the GNU Library General Public

License along with this library; if not, write to the Free Software

Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA

02111-1307, USA.

*/

/*==============================================================================

$Id: load_stm.c,v 1.1.1.1 2004/06/01 12:16:17 raph Exp $

Screamtracker 2 (STM) module loader

==============================================================================*/

#ifdef HAVE_CONFIG_H

#include "config.h"

#endif

#ifdef HAVE_UNISTD_H

#include <unistd.h>

#endif

#include <stdio.h>

#ifdef HAVE_MEMORY_H

#include <memory.h>

#endif

#include <string.h>

#include "mikmod_internals.h"

#ifdef SUNOS

extern int fprintf(FILE *, const char *, ...);

#endif

/*========== Module structure */

/* sample information */

typedef struct STMSAMPLE {

} STMSAMPLE;

/* header */

typedef struct STMHEADER {

} STMHEADER;

typedef struct STMNOTE {

UBYTE note,insvol,volcmd,cmdinf;

} STMNOTE;

/*========== Loader variables */

static STMNOTE *stmbuf = NULL;

static STMHEADER *mh = NULL;

/* tracker identifiers */

static const CHAR * STM_Version[STM_NTRACKERS] = {

"Screamtracker 2",

"Converted by MOD2STM (STM format)",

"Wuzamod (STM format)"

};

/*========== Loader code */

static BOOL STM_Test(void)

{

UBYTE str[44];

int t;

memset(str,0,44);

_mm_fseek(modreader,20,SEEK_SET);

_mm_read_UBYTES(str,44,modreader);

if(str[9]!=2) return 0; /* STM Module = filetype 2 */

/* Prevent false positives for S3M files */

if(!memcmp(str+40,"SCRM",4))

return 0;

for (t=0;t<STM_NTRACKERS;t++)

if(!memcmp(str,STM_Signatures[t],8))

return 1;

return 0;

}

static BOOL STM_Init(void)

{

if(!(mh=(STMHEADER*)_mm_malloc(sizeof(STMHEADER)))) return 0;

if(!(stmbuf=(STMNOTE*)_mm_calloc(64U*4,sizeof(STMNOTE)))) return 0;

return 1;

}

static void STM_Cleanup(void)

{

_mm_free(mh);

_mm_free(stmbuf);

}

static void STM_ConvertNote(STMNOTE *n)

{

UBYTE note,ins,vol,cmd,inf;

/* extract the various information from the 4 bytes that make up a note */

note = n->note;

ins = n->insvol>>3;

vol = (n->insvol&7)+((n->volcmd&0x70)>>1);

cmd = n->volcmd&15;

inf = n->cmdinf;

if((ins)&&(ins<32)) UniInstrument(ins-1);

/* special values of [SBYTE0] are handled here

we have no idea if these strange values will ever be encountered.

but it appears as those stms sound correct. */

if((note==254)||(note==252)) {

UniPTEffect(0xc,0); /* note cut */

n->volcmd|=0x80;

} else

/* if note < 251, then all three bytes are stored in the file */

if(note<251) UniNote((((note>>4)+2)*OCTAVE)+(note&0xf));

if((!(n->volcmd&0x80))&&(vol<65)) UniPTEffect(0xc,vol);

if(cmd!=255)

switch(cmd) {

case 1: /* Axx set speed to xx */

UniPTEffect(0xf,inf>>4);

break;

case 2: /* Bxx position jump */

UniPTEffect(0xb,inf);

break;

case 3: /* Cxx patternbreak to row xx */

UniPTEffect(0xd,(((inf&0xf0)>>4)*10)+(inf&0xf));

break;

case 4: /* Dxy volumeslide */

UniEffect(UNI_S3MEFFECTD,inf);

break;

case 5: /* Exy toneslide down */

UniEffect(UNI_S3MEFFECTE,inf);

break;

case 6: /* Fxy toneslide up */

UniEffect(UNI_S3MEFFECTF,inf);

break;

case 7: /* Gxx Tone portamento,speed xx */

UniPTEffect(0x3,inf);

break;

case 8: /* Hxy vibrato */

UniPTEffect(0x4,inf);

break;

case 9: /* Ixy tremor, ontime x, offtime y */

UniEffect(UNI_S3MEFFECTI,inf);

break;

case 0: /* protracker arpeggio */

if(!inf) break;

/* fall through */

case 0xa: /* Jxy arpeggio */

UniPTEffect(0x0,inf);

break;

case 0xb: /* Kxy Dual command H00 & Dxy */

UniPTEffect(0x4,0);

UniEffect(UNI_S3MEFFECTD,inf);

break;

case 0xc: /* Lxy Dual command G00 & Dxy */

UniPTEffect(0x3,0);

UniEffect(UNI_S3MEFFECTD,inf);

break;

/* Support all these above, since ST2 can LOAD these values but can

actually only play up to J - and J is only half-way implemented

in ST2 */

case 0x18: /* Xxx amiga panning command 8xx */

UniPTEffect(0x8,inf);

of.flags |= UF_PANNING;

break;

}

}

static UBYTE *STM_ConvertTrack(STMNOTE *n)

{

int t;

UniReset();

for(t=0;t<64;t++) {

STM_ConvertNote(n);

UniNewline();

n+=of.numchn;

}

return UniDup();

}

static BOOL STM_LoadPatterns(void)

{

int t,s,tracks=0;

if(!AllocPatterns()) return 0;

if(!AllocTracks()) return 0;

/* Allocate temporary buffer for loading and converting the patterns */

for(t=0;t<of.numpat;t++) {

for(s=0;s<(64U*of.numchn);s++) {

stmbuf[s].note = _mm_read_UBYTE(modreader);

stmbuf[s].insvol = _mm_read_UBYTE(modreader);

stmbuf[s].volcmd = _mm_read_UBYTE(modreader);

stmbuf[s].cmdinf = _mm_read_UBYTE(modreader);

}

if(_mm_eof(modreader)) {

_mm_errno = MMERR_LOADING_PATTERN;

return 0;

}

for(s=0;s<of.numchn;s++)

if(!(of.tracks[tracks++]=STM_ConvertTrack(stmbuf+s))) return 0;

}

return 1;

}

static BOOL STM_Load(BOOL curious)

{

int t;

ULONG MikMod_ISA; /* We must generate our own ISA, it's not stored in stm */

SAMPLE *q;

/* try to read stm header */

_mm_read_string(mh->songname,20,modreader);

_mm_read_string(mh->trackername,8,modreader);

mh->unused =_mm_read_UBYTE(modreader);

mh->filetype =_mm_read_UBYTE(modreader);

mh->ver_major =_mm_read_UBYTE(modreader);

mh->ver_minor =_mm_read_UBYTE(modreader);

mh->inittempo =_mm_read_UBYTE(modreader);

if(!mh->inittempo) {

_mm_errno=MMERR_NOT_A_MODULE;

return 0;

}

mh->numpat =_mm_read_UBYTE(modreader);

mh->globalvol =_mm_read_UBYTE(modreader);

_mm_read_UBYTES(mh->reserved,13,modreader);

if(mh->numpat > 128) {

_mm_errno = MMERR_NOT_A_MODULE;

return 0;

}

for(t=0;t<31;t++) {

STMSAMPLE *s=&mh->sample[t]; /* STM sample data */

_mm_read_string(s->filename,12,modreader);

s->unused =_mm_read_UBYTE(modreader);

s->instdisk =_mm_read_UBYTE(modreader);

s->reserved =_mm_read_I_UWORD(modreader);

s->length =_mm_read_I_UWORD(modreader);

s->loopbeg =_mm_read_I_UWORD(modreader);

s->loopend =_mm_read_I_UWORD(modreader);

s->volume =_mm_read_UBYTE(modreader);

s->reserved2=_mm_read_UBYTE(modreader);

s->c2spd =_mm_read_I_UWORD(modreader);

s->reserved3=_mm_read_I_ULONG(modreader);

s->isa =_mm_read_I_UWORD(modreader);

}

_mm_read_UBYTES(mh->patorder,128,modreader);

if(_mm_eof(modreader)) {

_mm_errno = MMERR_LOADING_HEADER;

return 0;

}

/* set module variables */

for(t=0;t<STM_NTRACKERS;t++)

if(!memcmp(mh->trackername,STM_Signatures[t],8)) break;

of.modtype = _mm_strdup(STM_Version[t]);

of.songname = DupStr(mh->songname,20,1); /* make a cstr of songname */

of.numpat = mh->numpat;

of.inittempo = 125; /* mh->inittempo+0x1c; */

of.initspeed = mh->inittempo>>4;

of.numchn = 4; /* get number of channels */

of.reppos = 0;

of.flags |= UF_S3MSLIDES;

of.bpmlimit = 32;

t=0;

if(!AllocPositions(0x80)) return 0;

/* 99 terminates the patorder list */

while((mh->patorder[t]<=99)&&(mh->patorder[t]<mh->numpat)) {

of.positions[t]=mh->patorder[t];

if(++t == 0x80) {

_mm_errno = MMERR_NOT_A_MODULE;

return 0;

}

}

if(mh->patorder[t]<=99) t++;

of.numpos=t;

of.numtrk=of.numpat*of.numchn;

of.numins=of.numsmp=31;

if(!AllocSamples()) return 0;

if(!STM_LoadPatterns()) return 0;

MikMod_ISA=_mm_ftell(modreader);

MikMod_ISA=(MikMod_ISA+15)&0xfffffff0; /* normalize */

for(q=of.samples,t=0;t<of.numsmp;t++,q++) {

/* load sample info */

q->samplename = DupStr(mh->sample[t].filename,12,1);

q->speed = (mh->sample[t].c2spd * 8363) / 8448;

q->volume = mh->sample[t].volume;

q->length = mh->sample[t].length;

if (/*!mh->sample[t].volume || */q->length==1) q->length=0;

q->loopstart = mh->sample[t].loopbeg;

q->loopend = mh->sample[t].loopend;

q->seekpos = MikMod_ISA;

MikMod_ISA+=q->length;

MikMod_ISA=(MikMod_ISA+15)&0xfffffff0; /* normalize */

/* contrary to the STM specs, sample data is signed */

q->flags = SF_SIGNED;

if(q->loopend && q->loopend != 0xffff)

q->flags|=SF_LOOP;

}

return 1;

}

static CHAR *STM_LoadTitle(void)

{

CHAR s[20];

_mm_fseek(modreader,0,SEEK_SET);

if(!_mm_read_UBYTES(s,20,modreader)) return NULL;

return(DupStr(s,20,1));

}

/*========== Loader information */

MIKMODAPI MLOADER load_stm={

NULL,

"STM",

"STM (Scream Tracker)",

STM_Init,

STM_Test,

STM_Load,

STM_Cleanup,

STM_LoadTitle

};

/* ex:set ts=4: */