/* 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_dsm.c,v 1.1.1.1 2004/06/01 12:16:17 raph Exp $

DSIK internal format (DSM) 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 */

#define DSM_MAXCHAN (16)

#define DSM_MAXORDERS (128)

typedef struct DSMSONG {

} DSMSONG;

typedef struct DSMINST {

} DSMINST;

typedef struct DSMNOTE {

UBYTE note,ins,vol,cmd,inf;

} DSMNOTE;

#define DSM_SURROUND (0xa4)

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

static const CHAR* SONGID="SONG";

static const CHAR* INSTID="INST";

static const CHAR* PATTID="PATT";

static UBYTE blockid[4];

static ULONG blockln;

static ULONG blocklp;

static DSMSONG* mh=NULL;

static DSMNOTE* dsmbuf=NULL;

static CHAR DSM_Version[]="DSIK DSM-format";

static const unsigned char DSMSIG[4+4]={'R','I','F','F','D','S','M','F'};

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

static BOOL DSM_Test(void)

{

UBYTE id[12];

if(!_mm_read_UBYTES(id,12,modreader)) return 0;

if(!memcmp(id,DSMSIG,4) && !memcmp(id+8,DSMSIG+4,4)) return 1;

return 0;

}

static BOOL DSM_Init(void)

{

if(!(dsmbuf=(DSMNOTE *)_mm_malloc(DSM_MAXCHAN*64*sizeof(DSMNOTE)))) return 0;

if(!(mh=(DSMSONG *)_mm_calloc(1,sizeof(DSMSONG)))) return 0;

return 1;

}

static void DSM_Cleanup(void)

{

_mm_free(dsmbuf);

_mm_free(mh);

}

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;

}

static UBYTE *DSM_ConvertTrack(DSMNOTE *tr)

{

int t;

UBYTE note,ins,vol,cmd,inf;

UniReset();

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

note=tr[t].note;

ins=tr[t].ins;

vol=tr[t].vol;

cmd=tr[t].cmd;

inf=tr[t].inf;

if(ins!=0 && ins!=255) UniInstrument(ins-1);

if(note!=255) UniNote(note-1); /* normal note */

if(vol<65) UniPTEffect(0xc,vol);

if(cmd!=255) {

if(cmd==0x8) {

if(inf==DSM_SURROUND)

UniEffect(UNI_ITEFFECTS0,0x91);

else

if(inf<=0x80) {

inf=(inf<0x80)?inf<<1:255;

UniPTEffect(cmd,inf);

}

} else

if(cmd==0xb) {

if(inf<=0x7f) UniPTEffect(cmd,inf);

} else {

/* Convert pattern jump from Dec to Hex */

if(cmd == 0xd)

inf = (((inf&0xf0)>>4)*10)+(inf&0xf);

UniPTEffect(cmd,inf);

}

}

UniNewline();

}

return UniDup();

}

static BOOL DSM_Load(BOOL curious)

{

int t;

DSMINST s;

SAMPLE *q;

int cursmp=0,curpat=0,track=0;

blocklp=0;

blockln=12;

if(!GetBlockHeader()) return 0;

if(memcmp(blockid,SONGID,4)) {

_mm_errno = MMERR_LOADING_HEADER;

return 0;

}

_mm_read_UBYTES(mh->songname,28,modreader);

mh->version=_mm_read_I_UWORD(modreader);

mh->flags=_mm_read_I_UWORD(modreader);

mh->reserved2=_mm_read_I_ULONG(modreader);

mh->numord=_mm_read_I_UWORD(modreader);

mh->numsmp=_mm_read_I_UWORD(modreader);

mh->numpat=_mm_read_I_UWORD(modreader);

mh->numtrk=_mm_read_I_UWORD(modreader);

mh->globalvol=_mm_read_UBYTE(modreader);

mh->mastervol=_mm_read_UBYTE(modreader);

mh->speed=_mm_read_UBYTE(modreader);

mh->bpm=_mm_read_UBYTE(modreader);

_mm_read_UBYTES(mh->panpos,DSM_MAXCHAN,modreader);

_mm_read_UBYTES(mh->orders,DSM_MAXORDERS,modreader);

/* set module variables */

of.initspeed=mh->speed;

of.inittempo=mh->bpm;

of.modtype=_mm_strdup(DSM_Version);

of.numchn=mh->numtrk;

of.numpat=mh->numpat;

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

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

of.reppos=0;

of.flags |= UF_PANNING;

/* XXX whenever possible, we should try to determine the original format.

Here we assume it was S3M-style wrt bpmlimit... */

of.bpmlimit = 32;

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

of.panning[t]=mh->panpos[t]==DSM_SURROUND?PAN_SURROUND:

mh->panpos[t]<0x80?(mh->panpos[t]<<1):255;

if(!AllocPositions(mh->numord)) return 0;

of.numpos=0;

for(t=0;t<mh->numord;t++) {

int order=mh->orders[t];

if(order==255) order=LAST_PATTERN;

of.positions[of.numpos]=order;

if(mh->orders[t]<254) of.numpos++;

}

of.numins=of.numsmp=mh->numsmp;

if(!AllocSamples()) return 0;

if(!AllocTracks()) return 0;

if(!AllocPatterns()) return 0;

while(cursmp<of.numins||curpat<of.numpat) {

if(!GetBlockHeader()) return 0;

if(!memcmp(blockid,INSTID,4) && cursmp<of.numins) {

q=&of.samples[cursmp];

/* try to read sample info */

_mm_read_UBYTES(s.filename,13,modreader);

s.flags=_mm_read_I_UWORD(modreader);

s.volume=_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.reserved1=_mm_read_I_ULONG(modreader);

s.c2spd=_mm_read_I_UWORD(modreader);

s.period=_mm_read_I_UWORD(modreader);

_mm_read_UBYTES(s.samplename,28,modreader);

q->samplename=DupStr(s.samplename,28,1);

q->seekpos=_mm_ftell(modreader);

q->speed=s.c2spd;

q->length=s.length;

q->loopstart=s.loopstart;

q->loopend=s.loopend;

q->volume=s.volume;

if(s.flags&1) q->flags|=SF_LOOP;

if(s.flags&2) q->flags|=SF_SIGNED;

/* (s.flags&4) means packed sample,

but did they really exist in dsm ?*/

cursmp++;

} else

if(!memcmp(blockid,PATTID,4) && curpat<of.numpat) {

DSM_ReadPattern();

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

if(!(of.tracks[track++]=DSM_ConvertTrack(&dsmbuf[t*64]))) return 0;

curpat++;

}

}

return 1;

}

static CHAR *DSM_LoadTitle(void)

{

CHAR s[28];

_mm_fseek(modreader,12,SEEK_SET);

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

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

}

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

MIKMODAPI MLOADER load_dsm={

NULL,

"DSM",

"DSM (DSIK internal format)",

DSM_Init,

DSM_Test,

DSM_Load,

DSM_Cleanup,

DSM_LoadTitle

};

/* ex:set ts=4: */