19 files changed, 9993 insertions, 0 deletions

diff --git a/apps/plugins/mikmod/loaders/load_669.c b/apps/plugins/mikmod/loaders/load_669.c
new file mode 100644
index 0000000..1991e75
--- /dev/null
+++ b/apps/plugins/mikmod/loaders/load_669.c
@@ -0,0 +1,369 @@
+/*	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_669.c,v 1.1.1.1 2004/01/21 01:36:35 raph Exp $

+

+  Composer 669 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 */

+

+/* header */

+typedef struct S69HEADER {   

+	UBYTE	marker[2];

+	CHAR	message[108];

+	UBYTE	nos;

+	UBYTE	nopa;

+	UBYTE	looporder;

+	UBYTE	orders[0x80];

+	UBYTE	tempos[0x80];

+	UBYTE	breaks[0x80];

+} S69HEADER;

+

+/* sample information */

+typedef struct S69SAMPLE {

+	CHAR	filename[13];

+	SLONG	length;

+	SLONG	loopbeg;

+	SLONG	loopend;

+} S69SAMPLE;

+

+/* encoded note */

+typedef struct S69NOTE {

+	UBYTE	a,b,c;

+} S69NOTE;

+

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

+

+/* current pattern */

+static	S69NOTE* s69pat=NULL;

+/* Module header */

+static	S69HEADER* mh=NULL;

+

+/* file type identification */

+static	CHAR* S69_Version[]={

+	"Composer 669",

+	"Extended 669"

+};

+

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

+

+BOOL S69_Test(void)

+{

+	UBYTE buf[0x80];

+

+	if(!_mm_read_UBYTES(buf,2,modreader))

+		return 0;

+	/* look for id */

+	if(!memcmp(buf,"if",2) || !memcmp(buf,"JN",2)) {

+		int i;

+

+		/* skip song message */

+		_mm_fseek(modreader,108,SEEK_CUR);

+		/* sanity checks */

+		if(_mm_read_UBYTE(modreader) > 64) return 0;

+		if(_mm_read_UBYTE(modreader) > 128) return 0;

+		if(_mm_read_UBYTE(modreader) > 127) return 0;

+		/* check order table */

+		if(!_mm_read_UBYTES(buf,0x80,modreader)) return 0;

+		for(i=0;i<0x80;i++)

+			if((buf[i]>=0x80)&&(buf[i]!=0xff)) return 0;

+		/* check tempos table */

+		if(!_mm_read_UBYTES(buf,0x80,modreader)) return 0;

+		for(i=0;i<0x80;i++)

+			if((!buf[i])||(buf[i]>32)) return 0;

+		/* check pattern length table */

+		if(!_mm_read_UBYTES(buf,0x80,modreader)) return 0;

+		for(i=0;i<0x80;i++)

+			if(buf[i]>0x3f) return 0;

+	} else

+		return 0;

+

+	return 1;

+}

+

+BOOL S69_Init(void)

+{

+	if(!(s69pat=(S69NOTE *)_mm_malloc(64*8*sizeof(S69NOTE)))) return 0;

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

+

+	return 1;

+}

+

+void S69_Cleanup(void)

+{

+	_mm_free(s69pat);

+	_mm_free(mh);

+}

+

+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;

+}

+

+BOOL S69_Load(BOOL curious)

+{

+	int i;

+	SAMPLE *current;

+	S69SAMPLE sample;

+	(void)curious;

+

+	/* module header */

+	_mm_read_UBYTES(mh->marker,2,modreader);

+	_mm_read_UBYTES(mh->message,108,modreader);

+	mh->nos=_mm_read_UBYTE(modreader);

+	mh->nopa=_mm_read_UBYTE(modreader);

+	mh->looporder=_mm_read_UBYTE(modreader);

+	_mm_read_UBYTES(mh->orders,0x80,modreader);

+	for(i=0;i<0x80;i++)

+		if ((mh->orders[i]>=0x80)&&(mh->orders[i]!=0xff)) {

+			_mm_errno=MMERR_NOT_A_MODULE;

+			return 1;

+		}

+	_mm_read_UBYTES(mh->tempos,0x80,modreader);

+	for(i=0;i<0x80;i++)

+		if ((!mh->tempos[i])||(mh->tempos[i]>32)) {

+			_mm_errno=MMERR_NOT_A_MODULE;

+			return 1;

+		}

+	_mm_read_UBYTES(mh->breaks,0x80,modreader);

+	for(i=0;i<0x80;i++)

+		if (mh->breaks[i]>0x3f) {

+			_mm_errno=MMERR_NOT_A_MODULE;

+			return 1;

+		}

+

+	/* set module variables */

+	of.initspeed=4;

+	of.inittempo=78;

+	of.songname=DupStr(mh->message,36,1);

+	of.modtype=strdup(S69_Version[memcmp(mh->marker,"JN",2)==0]);

+	of.numchn=8;

+	of.numpat=mh->nopa;

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

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

+	of.flags=UF_XMPERIODS|UF_LINEAR;

+

+	for(i=   35;(i>=   0)&&(mh->message[i]==' ');i--) mh->message[i]=0;

+	for(i=36+35;(i>=36+0)&&(mh->message[i]==' ');i--) mh->message[i]=0;

+	for(i=72+35;(i>=72+0)&&(mh->message[i]==' ');i--) mh->message[i]=0;

+	if((mh->message[0])||(mh->message[36])||(mh->message[72]))

+		if((of.comment=(CHAR*)_mm_malloc(3*(36+1)+1))) {

+			strncpy(of.comment,mh->message,36);

+			strcat(of.comment,"\r");

+			if (mh->message[36]) strncat(of.comment,mh->message+36,36);

+			strcat(of.comment,"\r");

+			if (mh->message[72]) strncat(of.comment,mh->message+72,36);

+			strcat(of.comment,"\r");

+			of.comment[3*(36+1)]=0;

+		}

+

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

+	for(i=0;i<0x80;i++) {

+		if(mh->orders[i]>=mh->nopa) break;

+		of.positions[i]=mh->orders[i];

+	}

+	of.numpos=i;

+	of.reppos=mh->looporder<of.numpos?mh->looporder:0;

+

+	if(!AllocSamples()) return 0;

+	current=of.samples;

+

+	for(i=0;i<of.numins;i++) {

+		/* sample information */

+		_mm_read_UBYTES((UBYTE*)sample.filename,13,modreader);

+		sample.length=_mm_read_I_SLONG(modreader);

+		sample.loopbeg=_mm_read_I_SLONG(modreader);

+		sample.loopend=_mm_read_I_SLONG(modreader);

+		if (sample.loopend==0xfffff) sample.loopend=0;

+

+		if((sample.length<0)||(sample.loopbeg<-1)||(sample.loopend<-1)) {

+			_mm_errno = MMERR_LOADING_HEADER;

+			return 0;

+		}

+

+		current->samplename=DupStr(sample.filename,13,1);

+		current->seekpos=0;

+		current->speed=0;

+		current->length=sample.length;

+		current->loopstart=sample.loopbeg;

+		current->loopend=sample.loopend;

+		current->flags=(sample.loopbeg<sample.loopend)?SF_LOOP:0;

+		current->volume=64;

+

+		current++;

+	}

+

+	if(!S69_LoadPatterns()) return 0;

+

+	return 1;

+}

+

+CHAR *S69_LoadTitle(void)

+{

+	CHAR s[36];

+

+	_mm_fseek(modreader,2,SEEK_SET);

+	if(!_mm_read_UBYTES(s,36,modreader)) return NULL;

+

+	return(DupStr(s,36,1));

+}

+

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

+

+MIKMODAPI MLOADER load_669={

+	NULL,

+	"669",

+	"669 (Composer 669, Unis 669)",

+	S69_Init,

+	S69_Test,

+	S69_Load,

+	S69_Cleanup,

+	S69_LoadTitle

+};

+

+/* ex:set ts=4: */

diff --git a/apps/plugins/mikmod/loaders/load_amf.c b/apps/plugins/mikmod/loaders/load_amf.c
new file mode 100644
index 0000000..f53d2ee
--- /dev/null
+++ b/apps/plugins/mikmod/loaders/load_amf.c
@@ -0,0 +1,570 @@
+/*	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_amf.c,v 1.1.1.1 2004/01/21 01:36:35 raph Exp $

+

+  DMP Advanced Module Format 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 */

+

+typedef struct AMFHEADER {

+	UBYTE id[3];			/* AMF file marker */

+	UBYTE version;			/* upper major, lower nibble minor version number */

+	CHAR  songname[32];		/* ASCIIZ songname */

+	UBYTE numsamples;		/* number of samples saved */

+	UBYTE numorders;

+	UWORD numtracks;		/* number of tracks saved */

+	UBYTE numchannels;		/* number of channels used  */

+	SBYTE panpos[32];		/* voice pan positions */

+	UBYTE songbpm;

+	UBYTE songspd;

+} AMFHEADER;

+

+typedef struct AMFSAMPLE {

+	UBYTE type;

+	CHAR  samplename[32];

+	CHAR  filename[13];

+	ULONG offset;

+	ULONG length;

+	UWORD c2spd;

+	UBYTE volume;

+	ULONG reppos;

+	ULONG repend;

+} AMFSAMPLE;

+

+typedef struct AMFNOTE {

+	UBYTE note,instr,volume,fxcnt;

+	UBYTE effect[3];

+	SBYTE parameter[3];

+} AMFNOTE;

+

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

+

+static AMFHEADER *mh = NULL;

+#define AMFTEXTLEN 22

+static CHAR AMF_Version[AMFTEXTLEN+1] = "DSMI Module Format 0.0";

+static AMFNOTE *track = NULL;

+

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

+

+BOOL AMF_Test(void)

+{

+	UBYTE id[3],ver;

+

+	if(!_mm_read_UBYTES(id,3,modreader)) return 0;

+	if(memcmp(id,"AMF",3)) return 0;

+

+	ver=_mm_read_UBYTE(modreader);

+	if((ver>=10)&&(ver<=14)) return 1;

+	return 0;

+}

+

+BOOL AMF_Init(void)

+{

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

+	if(!(track=(AMFNOTE*)_mm_calloc(64,sizeof(AMFNOTE)))) return 0;

+

+	return 1;

+}

+

+void AMF_Cleanup(void)

+{

+	_mm_free(mh);

+	_mm_free(track);

+}

+

+static BOOL AMF_UnpackTrack(MREADER* modreader)

+{

+	ULONG tracksize;

+	UBYTE row,cmd;

+	SBYTE arg;

+

+	/* empty track */

+	memset(track,0,64*sizeof(AMFNOTE));

+

+	/* read packed track */

+	if (modreader) {

+		tracksize=_mm_read_I_UWORD(modreader);

+		tracksize+=((ULONG)_mm_read_UBYTE(modreader))<<16;

+		if (tracksize)

+			while(tracksize--) {

+				row=_mm_read_UBYTE(modreader);

+				cmd=_mm_read_UBYTE(modreader);

+				arg=_mm_read_SBYTE(modreader);

+				/* unexpected end of track */

+				if(!tracksize) {

+					if((row==0xff)&&(cmd==0xff)&&(arg==-1))

+						break;

+					/* the last triplet should be FF FF FF, but this is not

+					   always the case... maybe a bug in m2amf ? 

+					else

+						return 0;

+					*/

+

+				}

+				/* invalid row (probably unexpected end of row) */

+				if (row>=64)

+					return 0;

+				if (cmd<0x7f) {

+					/* note, vol */

+					track[row].note=cmd;

+					track[row].volume=(UBYTE)arg+1;

+				} else

+				  if (cmd==0x7f) {

+					/* duplicate row */

+					if ((arg<0)&&(row+arg>=0)) {

+						memcpy(track+row,track+(row+arg),sizeof(AMFNOTE));

+					}

+				} else

+				  if (cmd==0x80) {

+					/* instr */

+					track[row].instr=arg+1;

+				} else

+				  if (cmd==0x83) {

+					/* volume without note */

+					track[row].volume=(UBYTE)arg+1;

+				} else 

+				  if (cmd==0xff) {

+					/* apparently, some M2AMF version fail to estimate the

+					   size of the compressed patterns correctly, and end

+					   up with blanks, i.e. dead triplets. Those are marked

+					   with cmd == 0xff. Let's ignore them. */

+				} else

+				  if(track[row].fxcnt<3) {

+					/* effect, param */

+					if(cmd>0x97)

+						return 0;

+					track[row].effect[track[row].fxcnt]=cmd&0x7f;

+					track[row].parameter[track[row].fxcnt]=arg;

+					track[row].fxcnt++;

+				} else

+					return 0;

+			}

+	}

+	return 1;

+}

+

+static UBYTE* AMF_ConvertTrack(void)

+{

+	int row,fx4memory=0;

+

+	/* convert track */

+	UniReset();

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

+		if (track[row].instr)  UniInstrument(track[row].instr-1);

+		if (track[row].note>OCTAVE) UniNote(track[row].note-OCTAVE);

+

+		/* AMF effects */

+		while(track[row].fxcnt--) {

+			SBYTE inf=track[row].parameter[track[row].fxcnt];

+

+			switch(track[row].effect[track[row].fxcnt]) {

+				case 1: /* Set speed */

+					UniEffect(UNI_S3MEFFECTA,inf);

+					break;

+				case 2: /* Volume slide */

+					if(inf) {

+						UniWriteByte(UNI_S3MEFFECTD);

+						if (inf>=0)

+							UniWriteByte((inf&0xf)<<4);

+						else

+							UniWriteByte((-inf)&0xf);

+					}

+					break;

+				/* effect 3, set channel volume, done in UnpackTrack */

+				case 4: /* Porta up/down */

+					if(inf) {

+						if(inf>0) {

+							UniEffect(UNI_S3MEFFECTE,inf);

+							fx4memory=UNI_S3MEFFECTE;

+						} else {

+							UniEffect(UNI_S3MEFFECTF,-inf);

+							fx4memory=UNI_S3MEFFECTF;

+						}

+					} else if(fx4memory)

+						UniEffect(fx4memory,0);

+					break;

+				/* effect 5, "Porta abs", not supported */

+				case 6: /* Porta to note */

+					UniEffect(UNI_ITEFFECTG,inf);

+					break;

+				case 7: /* Tremor */

+					UniEffect(UNI_S3MEFFECTI,inf);

+					break;

+				case 8: /* Arpeggio */

+					UniPTEffect(0x0,inf);

+					break;

+				case 9: /* Vibrato */

+					UniPTEffect(0x4,inf);

+					break;

+				case 0xa: /* Porta + Volume slide */

+					UniPTEffect(0x3,0);

+					if(inf) {

+						UniWriteByte(UNI_S3MEFFECTD);

+						if (inf>=0)

+							UniWriteByte((inf&0xf)<<4);

+						else

+							UniWriteByte((-inf)&0xf);

+					}

+					break;

+				case 0xb: /* Vibrato + Volume slide */

+					UniPTEffect(0x4,0);

+					if(inf) {

+						UniWriteByte(UNI_S3MEFFECTD);

+						if (inf>=0)

+							UniWriteByte((inf&0xf)<<4);

+						else

+							UniWriteByte((-inf)&0xf);

+					}

+					break;

+				case 0xc: /* Pattern break (in hex) */

+					UniPTEffect(0xd,inf);

+					break;

+				case 0xd: /* Pattern jump */

+					UniPTEffect(0xb,inf);

+					break;

+				/* effect 0xe, "Sync", not supported */

+				case 0xf: /* Retrig */

+					UniEffect(UNI_S3MEFFECTQ,inf&0xf);

+					break;

+				case 0x10: /* Sample offset */

+					UniPTEffect(0x9,inf);

+					break;

+				case 0x11: /* Fine volume slide */

+					if(inf) {

+						UniWriteByte(UNI_S3MEFFECTD);

+						if (inf>=0)

+							UniWriteByte((inf&0xf)<<4|0xf);

+						else

+							UniWriteByte(0xf0|((-inf)&0xf));

+					}

+					break;

+				case 0x12: /* Fine portamento */

+					if(inf) {

+						if(inf>0) {

+							UniEffect(UNI_S3MEFFECTE,0xf0|(inf&0xf));

+							fx4memory=UNI_S3MEFFECTE;

+						} else {

+							UniEffect(UNI_S3MEFFECTF,0xf0|((-inf)&0xf));

+							fx4memory=UNI_S3MEFFECTF;

+						}

+					} else if(fx4memory)

+						UniEffect(fx4memory,0);

+					break;

+				case 0x13: /* Delay note */

+					UniPTEffect(0xe,0xd0|(inf&0xf));

+					break;

+				case 0x14: /* Note cut */

+					UniPTEffect(0xc,0);

+					track[row].volume=0;

+					break;

+				case 0x15: /* Set tempo */

+					UniEffect(UNI_S3MEFFECTT,inf);

+					break;

+				case 0x16: /* Extra fine portamento */

+					if(inf) {

+						if(inf>0) {

+							UniEffect(UNI_S3MEFFECTE,0xe0|((inf>>2)&0xf));

+							fx4memory=UNI_S3MEFFECTE;

+						} else {

+							UniEffect(UNI_S3MEFFECTF,0xe0|(((-inf)>>2)&0xf));

+							fx4memory=UNI_S3MEFFECTF;

+						}

+					} else if(fx4memory)

+						UniEffect(fx4memory,0);

+					break;

+				case 0x17: /* Panning */

+					if (inf>64)

+						UniEffect(UNI_ITEFFECTS0,0x91); /* surround */

+					else

+						UniPTEffect(0x8,(inf==64)?255:(inf+64)<<1);

+					of.flags |= UF_PANNING;

+					break;

+			}

+			

+		}

+		if (track[row].volume) UniVolEffect(VOL_VOLUME,track[row].volume-1);

+		UniNewline();

+	}

+	return UniDup();

+}

+

+BOOL AMF_Load(BOOL curious)

+{

+	int t,u,realtrackcnt,realsmpcnt,defaultpanning;

+	AMFSAMPLE s;

+	SAMPLE *q;

+	UWORD *track_remap;

+	ULONG samplepos;

+	int channel_remap[16];

+	(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,32,modreader);

+	mh->numsamples  =_mm_read_UBYTE(modreader);

+	mh->numorders   =_mm_read_UBYTE(modreader);

+	mh->numtracks   =_mm_read_I_UWORD(modreader);

+	mh->numchannels =_mm_read_UBYTE(modreader);

+	if((!mh->numchannels)||(mh->numchannels>(mh->version>=12?32:16))) {

+		_mm_errno=MMERR_NOT_A_MODULE;

+		return 0;

+	}

+

+	if(mh->version>=11) {

+		memset(mh->panpos,0,32);

+		_mm_read_SBYTES(mh->panpos,(mh->version>=13)?32:16,modreader);

+	} else

+		_mm_read_UBYTES(channel_remap,16,modreader);

+

+	if (mh->version>=13) {

+		mh->songbpm=_mm_read_UBYTE(modreader);

+		if(mh->songbpm<32) {

+			_mm_errno=MMERR_NOT_A_MODULE;

+			return 0;

+		}

+		mh->songspd=_mm_read_UBYTE(modreader);

+		if(mh->songspd>32) {

+			_mm_errno=MMERR_NOT_A_MODULE;

+			return 0;

+		}

+	} else {

+		mh->songbpm=125;

+		mh->songspd=6;

+	}

+

+	if(_mm_eof(modreader)) {

+		_mm_errno = MMERR_LOADING_HEADER;

+		return 0;

+	}

+

+	/* set module variables */

+	of.initspeed = mh->songspd;

+	of.inittempo = mh->songbpm;

+	AMF_Version[AMFTEXTLEN-3]='0'+(mh->version/10);

+	AMF_Version[AMFTEXTLEN-1]='0'+(mh->version%10);

+	of.modtype   = strdup(AMF_Version);

+	of.numchn    = mh->numchannels;

+	of.numtrk    = mh->numorders*mh->numchannels;

+	if (mh->numtracks>of.numtrk)

+		of.numtrk=mh->numtracks;

+	of.numtrk++;	/* add room for extra, empty track */

+	of.songname  = DupStr(mh->songname,32,1);

+	of.numpos    = mh->numorders;

+	of.numpat    = mh->numorders;

+	of.reppos    = 0;

+	of.flags    |= UF_S3MSLIDES;

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

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

+	of.bpmlimit = 32;

+	

+	/*

+	 * Play with the panning table. Although the AMF format embeds a

+	 * panning table, if the module was a MOD or an S3M with default

+	 * panning and didn't use any panning commands, don't flag

+	 * UF_PANNING, to use our preferred panning table for this case.

+	 */

+	defaultpanning = 1;

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

+		if (mh->panpos[t] > 64) {

+			of.panning[t] = PAN_SURROUND;

+			defaultpanning = 0;

+		} else

+			if (mh->panpos[t] == 64)

+				of.panning[t] = PAN_RIGHT;

+			else

+				of.panning[t] = (mh->panpos[t] + 64) << 1;

+	}

+	if (defaultpanning) {

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

+			if (of.panning[t] == (((t + 1) & 2) ? PAN_RIGHT : PAN_LEFT)) {

+				defaultpanning = 0;	/* not MOD canonical panning */

+				break;

+			}

+	}

+	if (defaultpanning)

+		of.flags |= UF_PANNING;

+

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

+

+	if(!AllocPositions(of.numpos)) return 0;

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

+		of.positions[t]=t;

+

+	if(!AllocTracks()) return 0;

+	if(!AllocPatterns()) return 0;

+

+	/* read AMF order table */

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

+		if (mh->version>=14)

+			/* track size */

+			of.pattrows[t]=_mm_read_I_UWORD(modreader);

+		if (mh->version>=10)

+			_mm_read_I_UWORDS(of.patterns+(t*of.numchn),of.numchn,modreader);

+		else

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

+				of.patterns[t*of.numchn+channel_remap[u]]=_mm_read_I_UWORD(modreader);

+	}

+	if(_mm_eof(modreader)) {

+		_mm_errno = MMERR_LOADING_HEADER;

+		return 0;

+	}

+

+	/* read sample information */

+	if(!AllocSamples()) return 0;

+	q=of.samples;

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

+		/* try to read sample info */

+		s.type=_mm_read_UBYTE(modreader);

+		_mm_read_string(s.samplename,32,modreader);

+		_mm_read_string(s.filename,13,modreader);

+		s.offset    =_mm_read_I_ULONG(modreader);

+		s.length    =_mm_read_I_ULONG(modreader);

+		s.c2spd     =_mm_read_I_UWORD(modreader);

+		if(s.c2spd==8368) s.c2spd=8363;

+		s.volume    =_mm_read_UBYTE(modreader);

+		if(mh->version>=11) {

+			s.reppos    =_mm_read_I_ULONG(modreader);

+			s.repend    =_mm_read_I_ULONG(modreader);

+		} else {

+			s.reppos    =_mm_read_I_UWORD(modreader);

+			s.repend    =s.length;

+		}

+

+		if(_mm_eof(modreader)) {

+			_mm_errno = MMERR_LOADING_SAMPLEINFO; 

+			return 0;

+		}

+

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

+		q->speed     = s.c2spd;

+		q->volume    = s.volume;

+		if (s.type) {

+			q->seekpos   = s.offset;

+			q->length    = s.length;

+			q->loopstart = s.reppos;

+			q->loopend   = s.repend;

+			if((s.repend-s.reppos)>2) q->flags |= SF_LOOP;

+		}

+		q++;

+	}

+

+	/* read track table */

+	if(!(track_remap=_mm_calloc(mh->numtracks+1,sizeof(UWORD))))

+		return 0;

+	_mm_read_I_UWORDS(track_remap+1,mh->numtracks,modreader);

+	if(_mm_eof(modreader)) {

+		free(track_remap);

+		_mm_errno=MMERR_LOADING_TRACK;

+		return 0;

+	}

+

+	for(realtrackcnt=t=0;t<=mh->numtracks;t++)

+		if (realtrackcnt<track_remap[t])

+			realtrackcnt=track_remap[t];

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

+		of.patterns[t]=(of.patterns[t]<=mh->numtracks)?

+		               track_remap[of.patterns[t]]-1:realtrackcnt;

+

+	free(track_remap);

+

+	/* unpack tracks */

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

+		if(_mm_eof(modreader)) {

+			_mm_errno = MMERR_LOADING_TRACK;

+			return 0;

+		}

+		if (!AMF_UnpackTrack(modreader)) {

+			_mm_errno = MMERR_LOADING_TRACK;

+			return 0;

+		}

+		if(!(of.tracks[t]=AMF_ConvertTrack()))

+			return 0;

+	}

+	/* add an extra void track */

+	UniReset();

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

+	of.tracks[realtrackcnt++]=UniDup();

+	for(t=realtrackcnt;t<of.numtrk;t++) of.tracks[t]=NULL;

+

+	/* compute sample offsets */

+	samplepos=_mm_ftell(modreader);

+	for(realsmpcnt=t=0;t<of.numsmp;t++)

+		if(realsmpcnt<of.samples[t].seekpos)

+			realsmpcnt=of.samples[t].seekpos;

+	for(t=1;t<=realsmpcnt;t++) {

+		q=of.samples;

+		while(q->seekpos!=t) q++;

+		q->seekpos=samplepos;

+		samplepos+=q->length;

+	}

+		

+	return 1;

+}

+

+CHAR *AMF_LoadTitle(void)

+{

+	CHAR s[32];

+

+	_mm_fseek(modreader,4,SEEK_SET);

+	if(!_mm_read_UBYTES(s,32,modreader)) return NULL;

+

+	return(DupStr(s,32,1));

+}

+

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

+

+MIKMODAPI MLOADER load_amf={

+	NULL,

+	"AMF",

+	"AMF (DSMI Advanced Module Format)",

+	AMF_Init,

+	AMF_Test,

+	AMF_Load,

+	AMF_Cleanup,

+	AMF_LoadTitle

+};

+

+/* ex:set ts=4: */

diff --git a/apps/plugins/mikmod/loaders/load_asy.c b/apps/plugins/mikmod/loaders/load_asy.c
new file mode 100644
index 0000000..6b78e31
--- /dev/null
+++ b/apps/plugins/mikmod/loaders/load_asy.c
@@ -0,0 +1,399 @@
+/*	MikMod sound library

+	(c) 2004, Raphael Assenat 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_asy.c,v 1.3 2004/01/28 01:18:22 raph Exp $

+

+  ASYLUM Music Format v1.0 (.amf) loader

+  adapted from load_mod.c by Raphael Assenat <raph@raphnet.net>,

+  with the help of the AMF2MOD utility sourcecode,

+  written to convert crusader's amf files into 8

+  channels mod file in 1995 by Mr. P / Powersource

+  mrp@fish.share.net, ac054@sfn.saskatoon.sk.ca 

+  

+

+==============================================================================*/

+

+#ifdef HAVE_CONFIG_H

+#include "config.h"

+#endif

+

+#ifdef HAVE_UNISTD_H

+#include <unistd.h>

+#endif

+

+//#include <ctype.h>

+#include <string.h>

+

+#include "mikmod_internals.h"

+

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

+

+typedef struct MSAMPINFO {

+	CHAR samplename[24];

+	UBYTE finetune;

+	UBYTE volume;

+	ULONG length;

+	ULONG reppos;

+	ULONG replen;

+} MSAMPINFO;

+

+typedef struct MODULEHEADER {

+	CHAR songname[21];

+	UBYTE num_patterns;	/* number of patterns used */

+	UBYTE num_orders;

+	UBYTE positions[256];	/* which pattern to play at pos */

+	MSAMPINFO samples[64];	/* all sampleinfo */

+} MODULEHEADER;

+

+typedef struct MODTYPE {

+	CHAR id[5];

+	UBYTE channels;

+	CHAR *name;

+} MODTYPE;

+

+typedef struct MODNOTE {

+	UBYTE a, b, c, d;

+} MODNOTE;

+

+/* This table is taken from AMF2MOD.C

+ * written in 1995 by Mr. P / Powersource

+ * mrp@fish.share.net, ac054@sfn.saskatoon.sk.ca */ 

+UWORD periodtable[]={6848,6464,6096,5760,5424,5120,4832,4560,4304,

+	4064,3840,3628,3424,3232,3048,2880,2712,2560,

+	2416,2280,2152,2032,1920,1814,1712,1616,1524,

+	1440,1356,1280,1208,1140,1076,1016, 960, 907,

+	856, 808, 762, 720, 678, 640, 604, 570, 538,

+	508, 480, 453, 428, 404, 381, 360, 339, 320,

+	302, 285, 269, 254, 240, 226, 214, 202, 190,

+	180, 170, 160, 151, 143, 135, 127, 120, 113,

+	107, 101,  95,  90,  85,  80,  75,  71,  67,

+	63,  60,  56,  53,  50,  47,  45,  42,  40,

+	37,  35,  33,  31,  30,  28};

+

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

+

+static CHAR asylum[] = "Asylum 1.0";

+

+static MODULEHEADER *mh = NULL;

+static MODNOTE *patbuf = NULL;

+static int modtype = 0;

+

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

+

+static BOOL ASY_CheckType(UBYTE *id, UBYTE *numchn, CHAR **descr)

+{

+	if (!memcmp(id, "ASYLUM Music Format V1.0", 24))

+	{

+		*descr = asylum;

+		*numchn = 8;

+		modtype = 1;

+		return 1;

+	}

+	

+	return 0;

+}

+

+static BOOL ASY_Test(void)

+{

+	UBYTE namestring[24], numchn;

+	CHAR *descr;

+

+	/* Read the magic string */

+	_mm_fseek(modreader, 0, SEEK_SET);

+	if (!_mm_read_UBYTES(namestring, 24, modreader))

+		return 0;

+

+	/* Test if the string is what we expect */

+	if (ASY_CheckType(namestring, &numchn, &descr))

+		return 1;

+

+	return 0;

+}

+

+static BOOL ASY_Init(void)

+{

+	if (!(mh = (MODULEHEADER *)_mm_malloc(sizeof(MODULEHEADER))))

+		return 0;

+	return 1;

+}

+

+static void ASY_Cleanup(void)

+{

+	_mm_free(mh);

+	_mm_free(patbuf);

+}

+

+static void ConvertNote(MODNOTE *n)

+{

+	UBYTE instrument, effect, effdat, note;

+	UWORD period;

+	UBYTE lastnote = 0;

+	

+	instrument = n->b&0x1f;

+	effect = n->c;

+	effdat = n->d;

+

+	/* convert amf note to mod period */

+	if (n->a) {

+		period = periodtable[n->a];

+	} else {

+		period = 0;

+	}

+	

+	/* Convert the period to a note number */

+	note = 0;

+	if (period) 

+	{

+		for (note = 0; note < 7 * OCTAVE; note++)

+			if (period >= npertab[note])

+				break;

+		if (note == 7 * OCTAVE)

+			note = 0;

+		else

+			note++;

+	}

+

+	if (instrument) {

+		/* if instrument does not exist, note cut */

+		if ((instrument > 31) || (!mh->samples[instrument - 1].length)) {

+			UniPTEffect(0xc, 0);

+			if (effect == 0xc)

+				effect = effdat = 0;

+		} else {

+			/* Protracker handling */

+			if (!modtype) {

+				/* if we had a note, then change instrument...*/

+				if (note)

+					UniInstrument(instrument - 1);

+				/* ...otherwise, only adjust volume... */

+				else {

+					/* ...unless an effect was specified, 

+					 * which forces a new note to be 

+					 * played */

+					if (effect || effdat) {

+						UniInstrument(instrument - 1);

+						note = lastnote;

+					} else

+						UniPTEffect(0xc,

+							mh->samples[instrument -

+							1].volume & 0x7f);

+				}

+			} else {

+				/* Fasttracker handling */

+				UniInstrument(instrument - 1);

+				if (!note)

+					note = lastnote;

+			}

+		}

+	}

+	if (note) {

+		UniNote(note + 2 * OCTAVE - 1);

+		lastnote = note;

+	}

+

+	/* Convert pattern jump from Dec to Hex */

+	if (effect == 0xd)

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

+

+	/* Volume slide, up has priority */

+	if ((effect == 0xa) && (effdat & 0xf) && (effdat & 0xf0))

+		effdat &= 0xf0;

+

+	UniPTEffect(effect, effdat);

+}

+

+static UBYTE *ConvertTrack(MODNOTE *n)

+{

+	int t;

+

+	UniReset();

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

+		ConvertNote(n);

+		UniNewline();

+		n += of.numchn;

+	}

+	return UniDup();

+}

+

+/* Loads all patterns of a modfile and converts them into the 3 byte format. */

+static BOOL ML_LoadPatterns(void)

+{

+	int t, s, tracks = 0;

+

+	if (!AllocPatterns()) {

+		return 0;

+	}

+	if (!AllocTracks()) {

+		return 0;

+	}

+	

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

+	if (!(patbuf = (MODNOTE *)_mm_calloc(64U * of.numchn, sizeof(MODNOTE))))

+		return 0;

+

+

+	/* patterns start here */

+	_mm_fseek(modreader, 0xA66, SEEK_SET);

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

+		/* Load the pattern into the temp buffer and convert it */

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

+			patbuf[s].a = _mm_read_UBYTE(modreader);

+			patbuf[s].b = _mm_read_UBYTE(modreader);

+			patbuf[s].c = _mm_read_UBYTE(modreader);

+			patbuf[s].d = _mm_read_UBYTE(modreader);

+		}

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

+			if (!(of.tracks[tracks++] = ConvertTrack(patbuf + s))) {

+				return 0;

+			}

+		}

+	}

+	return 1;

+}

+

+static BOOL ASY_Load(BOOL curious)

+{

+	int t;

+	SAMPLE *q;

+	MSAMPINFO *s;

+	CHAR *descr=asylum;

+	ULONG seekpos;

+	(void)curious;

+

+	// 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_read_UBYTE(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_read_UBYTE(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 CHAR *ASY_LoadTitle(void)

+{

+	CHAR *s = ""; // no titles

+

+	return (DupStr(s, 21, 1));

+}

+

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

+

+MLOADER load_asy = {

+	NULL,

+	"AMF",

+	"AMF (ASYLUM Music Format V1.0)",

+	ASY_Init,

+	ASY_Test,

+	ASY_Load,

+	ASY_Cleanup,

+	ASY_LoadTitle

+};

+

+/* ex:set ts=4: */

diff --git a/apps/plugins/mikmod/loaders/load_dsm.c b/apps/plugins/mikmod/loaders/load_dsm.c
new file mode 100644
index 0000000..0eace5f
--- /dev/null
+++ b/apps/plugins/mikmod/loaders/load_dsm.c
@@ -0,0 +1,365 @@
+/*	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/01/21 01:36:35 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 {

+	CHAR	songname[28];

+	UWORD	version;

+	UWORD	flags;

+	ULONG	reserved2;

+	UWORD	numord;

+	UWORD	numsmp;

+	UWORD	numpat;

+	UWORD	numtrk;

+	UBYTE	globalvol;

+	UBYTE	mastervol;

+	UBYTE	speed;

+	UBYTE	bpm;

+	UBYTE	panpos[DSM_MAXCHAN];

+	UBYTE	orders[DSM_MAXORDERS];

+} DSMSONG;

+

+typedef struct DSMINST {

+	CHAR	filename[13];

+	UWORD	flags;

+	UBYTE	volume;

+	ULONG	length;

+	ULONG	loopstart;

+	ULONG	loopend;

+	ULONG	reserved1;

+	UWORD	c2spd;

+	UWORD	period;

+	CHAR	samplename[28];

+} DSMINST;

+

+typedef struct DSMNOTE {

+	UBYTE	note,ins,vol,cmd,inf;

+} DSMNOTE;

+

+#define DSM_SURROUND (0xa4)

+

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

+

+static	CHAR* SONGID="SONG";

+static	CHAR* INSTID="INST";

+static	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	unsigned char DSMSIG[4+4]={'R','I','F','F','D','S','M','F'};

+

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

+

+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;

+}

+

+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;

+}

+

+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();

+}

+

+BOOL DSM_Load(BOOL curious)

+{

+	int t;

+	DSMINST s;

+	SAMPLE *q;

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

+

+	blocklp=0;

+	blockln=12;

+	(void)curious;

+

+	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=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;

+}

+

+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: */

diff --git a/apps/plugins/mikmod/loaders/load_far.c b/apps/plugins/mikmod/loaders/load_far.c
new file mode 100644
index 0000000..a66bf8f
--- /dev/null
+++ b/apps/plugins/mikmod/loaders/load_far.c
@@ -0,0 +1,347 @@
+/*	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_far.c,v 1.1.1.1 2004/01/21 01:36:35 raph Exp $

+

+  Farandole (FAR) 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 */

+

+typedef struct FARHEADER1 {

+	UBYTE id[4];			/* file magic */

+	CHAR  songname[40];		/* songname */

+	CHAR  blah[3];			/* 13,10,26 */

+	UWORD headerlen;		/* remaining length of header in bytes */

+	UBYTE version;

+	UBYTE onoff[16];

+	UBYTE edit1[9];

+	UBYTE speed;

+	UBYTE panning[16];

+	UBYTE edit2[4];

+	UWORD stlen;

+} FARHEADER1;

+

+typedef struct FARHEADER2 {

+	UBYTE orders[256];

+	UBYTE numpat;

+	UBYTE snglen;

+	UBYTE loopto;

+	UWORD patsiz[256];

+} FARHEADER2;

+

+typedef struct FARSAMPLE {

+	CHAR  samplename[32];

+	ULONG length;

+	UBYTE finetune;

+	UBYTE volume;

+	ULONG reppos;

+	ULONG repend;

+	UBYTE type;

+	UBYTE loop;

+} FARSAMPLE;

+

+typedef struct FARNOTE {

+	UBYTE note,ins,vol,eff;

+} FARNOTE;

+

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

+

+static	CHAR FAR_Version[] = "Farandole";

+static	FARHEADER1 *mh1 = NULL;

+static	FARHEADER2 *mh2 = NULL;

+static	FARNOTE *pat = NULL;

+

+static	unsigned char FARSIG[4+3]={'F','A','R',0xfe,13,10,26};

+

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

+

+BOOL FAR_Test(void)

+{

+	UBYTE id[47];

+

+	if(!_mm_read_UBYTES(id,47,modreader)) return 0;

+	if((memcmp(id,FARSIG,4))||(memcmp(id+44,FARSIG+4,3))) return 0;

+	return 1;

+}

+

+BOOL FAR_Init(void)

+{

+	if(!(mh1 = (FARHEADER1*)_mm_malloc(sizeof(FARHEADER1)))) return 0;

+	if(!(mh2 = (FARHEADER2*)_mm_malloc(sizeof(FARHEADER2)))) return 0;

+	if(!(pat = (FARNOTE*)_mm_malloc(256*16*4*sizeof(FARNOTE)))) return 0;

+

+	return 1;

+}

+

+void FAR_Cleanup(void)

+{

+	_mm_free(mh1);

+	_mm_free(mh2);

+	_mm_free(pat);

+}

+

+static UBYTE *FAR_ConvertTrack(FARNOTE* n,int rows)

+{

+	int t,vibdepth=1;

+

+	UniReset();

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

+		if(n->note) {

+			UniInstrument(n->ins);

+			UniNote(n->note+3*OCTAVE-1);

+		}

+		if (n->vol&0xf) UniPTEffect(0xc,(n->vol&0xf)<<2);

+		if (n->eff)

+			switch(n->eff>>4) {

+				case 0x3: /* porta to note */

+					UniPTEffect(0x3,(n->eff&0xf)<<4);

+					break;

+				case 0x4: /* retrigger */

+					UniPTEffect(0x0e, 0x90 | (n->eff & 0x0f));

+					break;

+				case 0x5: /* set vibrato depth */

+					vibdepth=n->eff&0xf;

+					break;

+				case 0x6: /* vibrato */

+					UniPTEffect(0x4,((n->eff&0xf)<<4)|vibdepth);

+					break;

+				case 0x7: /* volume slide up */

+					UniPTEffect(0xa,(n->eff&0xf)<<4);

+					break;

+				case 0x8: /* volume slide down */

+					UniPTEffect(0xa,n->eff&0xf);

+					break;

+				case 0xb: /* panning */

+					UniPTEffect(0xe,0x80|(n->eff&0xf));

+					break;

+				case 0xf: /* set speed */

+					UniPTEffect(0xf,n->eff&0xf);

+					break;

+

+				/* others not yet implemented */

+				default:

+#ifdef MIKMOD_DEBUG

+					fprintf(stderr,"\rFAR: unsupported effect %02X\n",n->eff);

+#endif

+					break;

+			}

+

+		UniNewline();

+		n+=16;

+	}

+	return UniDup();

+}

+

+BOOL FAR_Load(BOOL curious)

+{

+	int t,u,tracks=0;

+	SAMPLE *q;

+	FARSAMPLE s;

+	FARNOTE *crow;

+	UBYTE smap[8];

+	(void)curious;

+

+	/* 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;

+	of.flags    |= UF_PANNING;

+	for(t=0;t<16;t++) of.panning[t]=mh1->panning[t]<<4;

+

+	/* read songtext into comment field */

+	if(mh1->stlen)

+		if (!ReadLinedComment(mh1->stlen, 66)) 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,tempo;

+

+		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++;

+	}

+	return 1;

+}

+

+CHAR *FAR_LoadTitle(void)

+{

+	CHAR s[40];

+

+	_mm_fseek(modreader,4,SEEK_SET);

+	if(!_mm_read_UBYTES(s,40,modreader)) return NULL;

+   

+	return(DupStr(s,40,1));

+}

+

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

+

+MIKMODAPI MLOADER load_far={

+	NULL,

+	"FAR",

+	"FAR (Farandole Composer)",

+	FAR_Init,

+	FAR_Test,

+	FAR_Load,

+	FAR_Cleanup,

+	FAR_LoadTitle

+};

+

+/* ex:set ts=4: */

diff --git a/apps/plugins/mikmod/loaders/load_gdm.c b/apps/plugins/mikmod/loaders/load_gdm.c
new file mode 100644
index 0000000..d65c2f8
--- /dev/null
+++ b/apps/plugins/mikmod/loaders/load_gdm.c
@@ -0,0 +1,559 @@
+/*	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_gdm.c,v 1.1.1.1 2004/01/21 01:36:35 raph Exp $

+

+  General DigiMusic (GDM) module loader

+

+==============================================================================*/

+

+/*

+

+	Written by Kev Vance<kvance@zeux.org>

+	based on the file format description written by 'MenTaLguY'

+	                                                        <mental@kludge.org>

+

+*/

+

+#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

+

+typedef struct GDMNOTE {

+	UBYTE note;

+	UBYTE samp;

+	struct {

+		UBYTE effect;

+		UBYTE param;

+	} effect[4];

+} GDMNOTE;

+

+typedef GDMNOTE GDMTRACK[64];

+

+typedef struct GDMHEADER {

+	CHAR  id1[4];

+	CHAR  songname[32];

+	CHAR  author[32];

+	CHAR  eofmarker[3];

+	CHAR  id2[4];

+

+	UBYTE majorver;

+	UBYTE minorver;

+	UWORD trackerid;

+	UBYTE t_majorver;

+	UBYTE t_minorver;

+	UBYTE pantable[32];

+	UBYTE mastervol;

+	UBYTE mastertempo;

+	UBYTE masterbpm;

+	UWORD flags;

+

+	ULONG orderloc;

+	UBYTE ordernum;

+	ULONG patternloc;

+	UBYTE patternnum;

+	ULONG samhead;

+	ULONG samdata;

+	UBYTE samnum;

+	ULONG messageloc;

+	ULONG messagelen;

+	ULONG scrollyloc;

+	UWORD scrollylen;

+	ULONG graphicloc;

+	UWORD graphiclen;

+} GDMHEADER;

+

+typedef struct GDMSAMPLE {

+	CHAR  sampname[32];

+	CHAR  filename[13];

+	UBYTE ems;

+	ULONG length;

+	ULONG loopbeg;

+	ULONG loopend;

+	UBYTE flags;

+	UWORD c4spd;

+	UBYTE vol;

+	UBYTE pan;

+} GDMSAMPLE;

+

+static GDMHEADER *mh=NULL;	/* pointer to GDM header */

+static GDMNOTE *gdmbuf=NULL;	/* pointer to a complete GDM pattern */

+

+CHAR GDM_Version[]="General DigiMusic 1.xx";

+

+BOOL GDM_Test(void)

+{

+	/* test for gdm magic numbers */

+	UBYTE id[4];

+

+	_mm_fseek(modreader,0x00,SEEK_SET);

+	if (!_mm_read_UBYTES(id,4,modreader))

+		return 0;

+	if (!memcmp(id,"GDM\xfe",4)) {

+		_mm_fseek(modreader,71,SEEK_SET);

+		if (!_mm_read_UBYTES(id,4,modreader))

+			return 0;

+		if (!memcmp(id,"GMFS",4))

+			return 1;

+	}

+	return 0;

+}

+

+BOOL GDM_Init(void)

+{

+	if (!(gdmbuf=(GDMNOTE*)_mm_malloc(32*64*sizeof(GDMNOTE)))) return 0;

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

+

+	return 1;

+}

+

+void GDM_Cleanup(void)

+{

+	_mm_free(mh);

+	_mm_free(gdmbuf);

+}

+

+BOOL GDM_ReadPattern(void)

+{

+	int pos,flag,ch,i,maxch;

+	GDMNOTE n;

+	UWORD length,x=0;

+

+	/* get pattern length */

+	length=_mm_read_I_UWORD(modreader)-2;

+

+	/* clear pattern data */

+	memset(gdmbuf,255,32*64*sizeof(GDMNOTE));

+	pos=0;

+	maxch=0;

+

+	while (x<length) {

+		memset(&n,255,sizeof(GDMNOTE));

+		flag=_mm_read_UBYTE(modreader);

+		x++;

+

+		if (_mm_eof(modreader)) {

+			_mm_errno=MMERR_LOADING_PATTERN;

+			return 0;

+		}

+

+		ch=flag&31;

+		if (ch>maxch) maxch=ch;

+		if (!flag) {

+			pos++;

+			continue;

+		}

+		if (flag&0x60) {

+			if (flag&0x20) {

+				/* new note */

+				n.note=_mm_read_UBYTE(modreader)&127;

+				n.samp=_mm_read_UBYTE(modreader);

+				x +=2;

+			}

+			if (flag&0x40) {

+				do {

+					/* effect channel set */

+					i=_mm_read_UBYTE(modreader);

+					n.effect[i>>6].effect=i&31;

+					n.effect[i>>6].param=_mm_read_UBYTE(modreader);

+					x +=2;

+				} while (i&32);

+			}

+			memcpy(gdmbuf+(64U*ch)+pos,&n,sizeof(GDMNOTE));

+		}

+	}

+	return 1;

+}

+

+UBYTE *GDM_ConvertTrack(GDMNOTE*tr)

+{

+	int t,i=0;

+	UBYTE note,ins,inf;

+

+	UniReset();

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

+		note=tr[t].note;

+		ins=tr[t].samp;

+

+		if ((ins)&&(ins!=255))

+			UniInstrument(ins-1);

+		if (note!=255) {

+			UniNote(((note>>4)*OCTAVE)+(note&0xf)-1);

+		}

+		for (i=0;i<4;i++) {

+			inf = tr[t].effect[i].param;

+			switch (tr[t].effect[i].effect) {

+				case 1:	/* toneslide up */

+					UniEffect(UNI_S3MEFFECTF,inf);

+					break;

+				case 2:	/* toneslide down */

+					UniEffect(UNI_S3MEFFECTE,inf);

+					break;

+				case 3:	/* glissando to note */

+					UniEffect(UNI_ITEFFECTG,inf);

+					break;

+				case 4:	/* vibrato */

+					UniEffect(UNI_ITEFFECTH,inf);

+					break;

+				case 5:	/* portamento+volslide */

+					UniEffect(UNI_ITEFFECTG,0);

+					UniEffect(UNI_S3MEFFECTD,inf);

+					break;

+				case 6:	/* vibrato+volslide */

+					UniEffect(UNI_ITEFFECTH,0);

+					UniEffect(UNI_S3MEFFECTD,inf);

+					break;

+				case 7:	/* tremolo */

+					UniEffect(UNI_S3MEFFECTR,inf);

+					break;

+				case 8:	/* tremor */

+					UniEffect(UNI_S3MEFFECTI,inf);

+					break;

+				case 9:	/* offset */

+					UniPTEffect(0x09,inf);

+					break;

+				case 0x0a:	/* volslide */

+					UniEffect(UNI_S3MEFFECTD,inf);

+					break;

+				case 0x0b:	/* jump to order */

+					UniPTEffect(0x0b,inf);

+					break;

+				case 0x0c:	/* volume set */

+					UniPTEffect(0x0c,inf);

+					break;

+				case 0x0d:	/* pattern break */

+					UniPTEffect(0x0d,inf);

+					break;

+				case 0x0e:	/* extended */

+					switch (inf&0xf0) {

+						case 0x10:	/* fine portamento up */

+							UniEffect(UNI_S3MEFFECTF, 0x0f|((inf<<4)&0x0f));

+							break;

+						case 0x20:	/* fine portamento down */

+							UniEffect(UNI_S3MEFFECTE, 0xf0|(inf&0x0f));

+							break;

+						case 0x30:	/* glissando control */

+							UniEffect(SS_GLISSANDO, inf&0x0f);

+							break;

+						case 0x40:	/* vibrato waveform */

+							UniEffect(SS_VIBWAVE, inf&0x0f);

+							break;

+						case 0x50:	/* set c4spd */

+							UniEffect(SS_FINETUNE, inf&0x0f);

+							break;

+						case 0x60:	/* loop fun */

+							UniEffect(UNI_ITEFFECTS0, (inf&0x0f)|0xb0);

+							break;

+						case 0x70:	/* tremolo waveform */

+							UniEffect(SS_TREMWAVE, inf&0x0f);

+							break;

+						case 0x80:	/* extra fine porta up */

+							UniEffect(UNI_S3MEFFECTF, 0x0e|((inf<<4)&0x0f));

+							break;

+						case 0x90:	/* extra fine porta down */

+							UniEffect(UNI_S3MEFFECTE, 0xe0|(inf&0x0f));

+							break;

+						case 0xa0:	/* fine volslide up */

+							UniEffect(UNI_S3MEFFECTD, 0x0f|((inf<<4)&0x0f));

+							break;

+						case 0xb0:	/* fine volslide down */

+							UniEffect(UNI_S3MEFFECTE, 0xf0|(inf&0x0f));

+							break;

+						case 0xc0:	/* note cut */

+						case 0xd0:	/* note delay */

+						case 0xe0:	/* extend row */

+							UniPTEffect(0xe,inf);

+							break;

+					}

+					break;

+				case 0x0f:	/* set tempo */

+					UniEffect(UNI_S3MEFFECTA,inf);

+					break;

+				case 0x10:	/* arpeggio */

+					UniPTEffect(0x0,inf);

+					break;

+				case 0x12:	/* retrigger */

+					UniEffect(UNI_S3MEFFECTQ,inf);

+					break;

+				case 0x13:	/* set global volume */

+					UniEffect(UNI_XMEFFECTG,inf<<1);

+					break;

+				case 0x14:	/* fine vibrato */

+					UniEffect(UNI_ITEFFECTU,inf);

+					break;

+				case 0x1e:	/* special */

+					switch (inf&0xf0) {

+						case 8:	/* set pan position */

+							if (inf >=128)

+								UniPTEffect(0x08,255);

+							else

+								UniPTEffect(0x08,inf<<1);

+							break;

+					}

+					break;

+				case 0x1f:	/* set bpm */

+					if (inf >=0x20)

+						UniEffect(UNI_S3MEFFECTT,inf);

+					break;

+			}

+		}

+		UniNewline();

+	}

+	return UniDup();

+}

+

+BOOL GDM_Load(BOOL curious)

+{

+	int i,x,u,track;

+	SAMPLE *q;

+	GDMSAMPLE s;

+	ULONG position;

+	(void)curious;

+

+	/* read header */

+	_mm_read_string(mh->id1,4,modreader);

+	_mm_read_string(mh->songname,32,modreader);

+	_mm_read_string(mh->author,32,modreader);

+	_mm_read_string(mh->eofmarker,3,modreader);

+	_mm_read_string(mh->id2,4,modreader);

+

+	mh->majorver=_mm_read_UBYTE(modreader);

+	mh->minorver=_mm_read_UBYTE(modreader);

+	mh->trackerid=_mm_read_I_UWORD(modreader);

+	mh->t_majorver=_mm_read_UBYTE(modreader);

+	mh->t_minorver=_mm_read_UBYTE(modreader);

+	_mm_read_UBYTES(mh->pantable,32,modreader);

+	mh->mastervol=_mm_read_UBYTE(modreader);

+	mh->mastertempo=_mm_read_UBYTE(modreader);

+	mh->masterbpm=_mm_read_UBYTE(modreader);

+	mh->flags=_mm_read_I_UWORD(modreader);

+

+	mh->orderloc=_mm_read_I_ULONG(modreader);

+	mh->ordernum=_mm_read_UBYTE(modreader);

+	mh->patternloc=_mm_read_I_ULONG(modreader);

+	mh->patternnum=_mm_read_UBYTE(modreader);

+	mh->samhead=_mm_read_I_ULONG(modreader);

+	mh->samdata=_mm_read_I_ULONG(modreader);

+	mh->samnum=_mm_read_UBYTE(modreader);

+	mh->messageloc=_mm_read_I_ULONG(modreader);

+	mh->messagelen=_mm_read_I_ULONG(modreader);

+	mh->scrollyloc=_mm_read_I_ULONG(modreader);

+	mh->scrollylen=_mm_read_I_UWORD(modreader);

+	mh->graphicloc=_mm_read_I_ULONG(modreader);

+	mh->graphiclen=_mm_read_I_UWORD(modreader);

+

+	/* have we ended abruptly? */

+	if (_mm_eof(modreader)) {

+		_mm_errno=MMERR_LOADING_HEADER;

+		return 0;

+	}

+

+	/* any orders? */

+	if(mh->ordernum==255) {

+		_mm_errno=MMERR_LOADING_PATTERN;

+		return 0;

+	}

+

+	/* now we fill */

+	of.modtype=strdup(GDM_Version);

+	of.modtype[18]=mh->majorver+'0';

+	of.modtype[20]=mh->minorver/10+'0';

+	of.modtype[21]=mh->minorver%10+'0';

+	of.songname=DupStr(mh->songname,32,0);

+	of.numpat=mh->patternnum+1;

+	of.reppos=0;

+	of.numins=of.numsmp=mh->samnum+1;

+	of.initspeed=mh->mastertempo;

+	of.inittempo=mh->masterbpm;

+	of.initvolume=mh->mastervol<<1;

+	of.flags|=UF_S3MSLIDES | 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;

+

+	/* read the order data */

+	if (!AllocPositions(mh->ordernum+1)) {

+		_mm_errno=MMERR_OUT_OF_MEMORY;

+		return 0;

+	}

+

+	_mm_fseek(modreader,mh->orderloc,SEEK_SET);

+	for (i=0;i<mh->ordernum+1;i++)

+		of.positions[i]=_mm_read_UBYTE(modreader);

+

+	of.numpos=0;

+	for (i=0;i<mh->ordernum+1;i++) {

+		int order=of.positions[i];

+		if(order==255) order=LAST_PATTERN;

+		of.positions[of.numpos]=order;

+		if (of.positions[i]<254) of.numpos++;

+	}

+

+	/* have we ended abruptly yet? */

+	if (_mm_eof(modreader)) {

+		_mm_errno=MMERR_LOADING_HEADER;

+		return 0;

+	}

+

+	/* time to load the samples */

+	if (!AllocSamples()) {

+		_mm_errno=MMERR_OUT_OF_MEMORY;

+		return 0;

+	}

+

+	q=of.samples;

+	position=mh->samdata;

+

+	/* seek to instrument position */

+	_mm_fseek(modreader,mh->samhead,SEEK_SET);

+

+	for (i=0;i<of.numins;i++) {

+		/* load sample info */

+		_mm_read_UBYTES(s.sampname,32,modreader);

+		_mm_read_UBYTES(s.filename,12,modreader);

+		s.ems=_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.flags=_mm_read_UBYTE(modreader);

+		s.c4spd=_mm_read_I_UWORD(modreader);

+		s.vol=_mm_read_UBYTE(modreader);

+		s.pan=_mm_read_UBYTE(modreader);

+

+		if (_mm_eof(modreader)) {

+			_mm_errno=MMERR_LOADING_SAMPLEINFO;

+			return 0;

+		}

+		q->samplename=DupStr(s.sampname,32,0);

+		q->speed=s.c4spd;

+		q->length=s.length;

+		q->loopstart=s.loopbeg;

+		q->loopend=s.loopend;

+		q->volume=s.vol;

+		q->panning=s.pan;

+		q->seekpos=position;

+

+		position +=s.length;

+

+		if (s.flags&1)

+			q->flags |=SF_LOOP;

+		if (s.flags&2)

+			q->flags |=SF_16BITS;

+		if (s.flags&16)

+			q->flags |=SF_STEREO;

+		q++;

+	}

+

+	/* set the panning */

+	for (i=x=0;i<32;i++) {

+		of.panning[i]=mh->pantable[i];

+		if (!of.panning[i])

+			of.panning[i]=PAN_LEFT;

+		else if (of.panning[i]==8)

+			of.panning[i]=PAN_CENTER;

+		else if (of.panning[i]==15)

+			of.panning[i]=PAN_RIGHT;

+		else if (of.panning[i]==16)

+			of.panning[i]=PAN_SURROUND;

+		else if (of.panning[i]==255)

+			of.panning[i]=128;

+		else

+			of.panning[i]<<=3;

+		if (mh->pantable[i]!=255)

+			x=i;

+	}

+

+	of.numchn=x+1;

+	if (of.numchn<1)

+		of.numchn=1;	/* for broken counts */

+

+	/* load the pattern info */

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

+

+	/* jump to patterns */

+	_mm_fseek(modreader,mh->patternloc,SEEK_SET);

+

+	if (!AllocTracks()) {

+		_mm_errno=MMERR_OUT_OF_MEMORY;

+		return 0;

+	}

+

+	if (!AllocPatterns()) {

+		_mm_errno=MMERR_OUT_OF_MEMORY;

+		return 0;

+	}

+

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

+		if (!GDM_ReadPattern()) {

+			_mm_errno=MMERR_LOADING_PATTERN;

+			return 0;

+		}

+		for (u=0;u<of.numchn;u++,track++) {

+			of.tracks[track]=GDM_ConvertTrack(&gdmbuf[u<<6]);

+			if (!of.tracks[track]) {

+				_mm_errno=MMERR_LOADING_TRACK;

+				return 0;

+			}

+		}

+	}

+	return 1;

+}

+

+CHAR *GDM_LoadTitle(void)

+{

+	CHAR s[32];

+

+	_mm_fseek(modreader,4,SEEK_SET);

+	if (!_mm_read_UBYTES(s,32,modreader)) return NULL;

+

+	return DupStr(s,28,0);

+}

+

+MIKMODAPI MLOADER load_gdm=

+{

+	NULL,

+	"GDM",

+	"GDM (General DigiMusic)",

+	GDM_Init,

+	GDM_Test,

+	GDM_Load,

+	GDM_Cleanup,

+	GDM_LoadTitle

+};

+

+/* ex:set ts=4: */

diff --git a/apps/plugins/mikmod/loaders/load_imf.c b/apps/plugins/mikmod/loaders/load_imf.c
new file mode 100644
index 0000000..dbc2177
--- /dev/null
+++ b/apps/plugins/mikmod/loaders/load_imf.c
@@ -0,0 +1,739 @@
+/*	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_imf.c,v 1.2 2004/02/06 19:29:03 raph Exp $

+

+  Imago Orpheus (IMF) 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 */

+

+/* module header */

+typedef struct IMFHEADER {

+	CHAR  songname[32];

+	UWORD ordnum;

+	UWORD patnum;

+	UWORD insnum;

+	UWORD flags;

+	UBYTE initspeed;

+	UBYTE inittempo;

+	UBYTE mastervol;

+	UBYTE mastermult;

+	UBYTE orders[256];

+} IMFHEADER;

+

+/* channel settings */

+typedef struct IMFCHANNEL {

+	CHAR  name[12];

+	UBYTE chorus;

+	UBYTE reverb;

+	UBYTE pan;

+	UBYTE status;

+} IMFCHANNEL;

+

+/* instrument header */

+#define IMFNOTECNT (10*OCTAVE)

+#define IMFENVCNT (16*2)

+typedef struct IMFINSTHEADER {

+	CHAR  name[32];

+	UBYTE what[IMFNOTECNT];

+	UWORD volenv[IMFENVCNT];

+	UWORD panenv[IMFENVCNT];

+	UWORD pitenv[IMFENVCNT];

+	UBYTE volpts;

+	UBYTE volsus;

+	UBYTE volbeg;

+	UBYTE volend;

+	UBYTE volflg;

+	UBYTE panpts;

+	UBYTE pansus;

+	UBYTE panbeg;

+	UBYTE panend;

+	UBYTE panflg;

+	UBYTE pitpts;

+	UBYTE pitsus;

+	UBYTE pitbeg;

+	UBYTE pitend;

+	UBYTE pitflg;

+	UWORD volfade;

+	UWORD numsmp;

+	ULONG signature;

+} IMFINSTHEADER;

+

+/* sample header */

+typedef struct IMFWAVHEADER {

+	CHAR  samplename[13];

+	ULONG length;

+	ULONG loopstart;

+	ULONG loopend;

+	ULONG samplerate;

+	UBYTE volume;

+	UBYTE pan;

+	UBYTE flags;

+} IMFWAVHEADER;

+

+typedef struct IMFNOTE {

+	UBYTE note,ins,eff1,dat1,eff2,dat2;

+} IMFNOTE;

+

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

+

+static	CHAR IMF_Version[]="Imago Orpheus";

+

+static	IMFNOTE *imfpat=NULL;

+static	IMFHEADER *mh=NULL;

+

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

+

+BOOL IMF_Test(void)

+{

+	UBYTE id[4];

+

+	_mm_fseek(modreader,0x3c,SEEK_SET);

+	if(!_mm_read_UBYTES(id,4,modreader)) return 0;

+	if(!memcmp(id,"IM10",4)) return 1;

+	return 0;

+}

+

+BOOL IMF_Init(void)

+{

+	if(!(imfpat=(IMFNOTE*)_mm_malloc(32*256*sizeof(IMFNOTE)))) return 0;

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

+

+	return 1;

+}

+

+void IMF_Cleanup(void)

+{

+	FreeLinear();

+

+	_mm_free(imfpat);

+	_mm_free(mh);

+}

+

+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 void IMF_ProcessCmd(UBYTE eff,UBYTE inf)

+{

+	if((eff)&&(eff!=255))

+		switch (eff) {

+			case 0x01:	/* set tempo */

+				UniEffect(UNI_S3MEFFECTA,inf);

+				break;

+			case 0x02:	/* set BPM */

+				if(inf>=0x20) UniEffect(UNI_S3MEFFECTT,inf);

+				break;

+			case 0x03:	/* tone portamento */

+				UniEffect(UNI_ITEFFECTG,inf);

+				break;

+			case 0x04:	/* porta + volslide */

+				UniEffect(UNI_ITEFFECTG,inf);

+				UniEffect(UNI_S3MEFFECTD,0);

+				break;

+			case 0x05:	/* vibrato */

+				UniEffect(UNI_XMEFFECT4,inf);

+				break;

+			case 0x06:	/* vibrato + volslide */

+				UniEffect(UNI_XMEFFECT6,inf);

+				break;

+			case 0x07:	/* fine vibrato */

+				UniEffect(UNI_ITEFFECTU,inf);

+				break;

+			case 0x08:	/* tremolo */

+				UniEffect(UNI_S3MEFFECTR,inf);

+				break;

+			case 0x09:	/* arpeggio */

+				UniPTEffect(0x0,inf);

+				break;

+			case 0x0a:	/* panning */

+				UniPTEffect(0x8,(inf>=128)?255:(inf<<1));

+				break;

+			case 0x0b:	/* pan slide */

+				UniEffect(UNI_XMEFFECTP,inf);

+				break;

+			case 0x0c:	/* set channel volume */

+				if(inf<=64) UniPTEffect(0xc,inf);

+				break;

+			case 0x0d:	/* volume slide */

+				UniEffect(UNI_S3MEFFECTD,inf);

+				break;

+			case 0x0e:	/* fine volume slide */

+				if(inf) {

+					if(inf>>4)

+						UniEffect(UNI_S3MEFFECTD,0x0f|inf);

+					else

+						UniEffect(UNI_S3MEFFECTD,0xf0|inf);

+				} else

+					UniEffect(UNI_S3MEFFECTD,0);

+				break;

+			case 0x0f:	/* set finetune */

+				UniPTEffect(0xe,0x50|(inf>>4));

+				break;

+#ifdef MIKMOD_DEBUG

+			case 0x10:	/* note slide up */

+			case 0x11:	/* not slide down */

+				fprintf(stderr,"\rIMF effect 0x10/0x11 (note slide)"

+				               " not implemented (eff=%2X inf=%2X)\n",eff,inf);

+				break;

+#endif

+			case 0x12:	/* slide up */

+				UniEffect(UNI_S3MEFFECTF,inf);

+				break;

+			case 0x13:	/* slide down */

+				UniEffect(UNI_S3MEFFECTE,inf);

+				break;

+			case 0x14:	/* fine slide up */

+				if (inf) {

+					if (inf<0x40)

+						UniEffect(UNI_S3MEFFECTF,0xe0|(inf>>2));

+					else

+						UniEffect(UNI_S3MEFFECTF,0xf0|(inf>>4));

+				} else

+					UniEffect(UNI_S3MEFFECTF,0);

+				break;

+			case 0x15:	/* fine slide down */

+				if (inf) {

+					if (inf<0x40)

+						UniEffect(UNI_S3MEFFECTE,0xe0|(inf>>2));

+					else

+						UniEffect(UNI_S3MEFFECTE,0xf0|(inf>>4));

+				} else

+					UniEffect(UNI_S3MEFFECTE,0);

+				break;

+			/* 0x16 set filter cutoff (awe32) */

+			/* 0x17 filter side + resonance (awe32) */

+			case 0x18:	/* sample offset */

+				UniPTEffect(0x9,inf);

+				break;

+#ifdef MIKMOD_DEBUG

+			case 0x19:	/* set fine sample offset */

+				fprintf(stderr,"\rIMF effect 0x19 (fine sample offset)"

+				               " not implemented (inf=%2X)\n",inf);

+				break;

+#endif

+			case 0x1a:	/* keyoff */

+				UniWriteByte(UNI_KEYOFF);

+				break;

+			case 0x1b:	/* retrig */

+				UniEffect(UNI_S3MEFFECTQ,inf);

+				break;

+			case 0x1c:	/* tremor */

+				UniEffect(UNI_S3MEFFECTI,inf);

+				break;

+			case 0x1d:	/* position jump */

+				UniPTEffect(0xb,inf);

+				break;

+			case 0x1e:	/* pattern break */

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

+				break;

+			case 0x1f:	/* set master volume */

+				if(inf<=64) UniEffect(UNI_XMEFFECTG,inf<<1);

+				break;

+			case 0x20:	/* master volume slide */

+				UniEffect(UNI_XMEFFECTH,inf);

+				break;

+			case 0x21:	/* extended effects */

+				switch(inf>>4) {

+					case 0x1:	/* set filter */

+					case 0x5:	/* vibrato waveform */

+					case 0x8:	/* tremolo waveform */

+						UniPTEffect(0xe,inf-0x10);

+						break;

+					case 0xa:	/* pattern loop */

+						UniPTEffect(0xe,0x60|(inf&0xf));

+						break;

+					case 0xb:	/* pattern delay */

+						UniPTEffect(0xe,0xe0|(inf&0xf));

+						break;

+					case 0x3:	/* glissando */

+					case 0xc:	/* note cut */

+					case 0xd:	/* note delay */

+					case 0xf:	/* invert loop */

+						UniPTEffect(0xe,inf);

+						break;

+					case 0xe:	/* ignore envelope */

+						UniEffect(UNI_ITEFFECTS0, 0x77);    /* vol */

+						UniEffect(UNI_ITEFFECTS0, 0x79);    /* pan */

+						UniEffect(UNI_ITEFFECTS0, 0x7b);    /* pit */

+						break;

+				}

+				break;

+			/* 0x22 chorus (awe32) */

+			/* 0x23 reverb (awe32) */

+		}

+}

+

+static UBYTE* IMF_ConvertTrack(IMFNOTE* tr,UWORD rows)

+{

+	int t;

+	UBYTE note,ins;

+

+	UniReset();

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

+		note=tr[t].note;

+		ins=tr[t].ins;

+

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

+		if(note!=255) {

+			if(note==0xa0) {

+				UniPTEffect(0xc,0); /* Note cut */

+				if(tr[t].eff1==0x0c) tr[t].eff1=0;

+				if(tr[t].eff2==0x0c) tr[t].eff2=0;

+			} else

+				UniNote(((note>>4)*OCTAVE)+(note&0xf));

+		}

+

+		IMF_ProcessCmd(tr[t].eff1,tr[t].dat1);

+		IMF_ProcessCmd(tr[t].eff2,tr[t].dat2);

+		UniNewline();

+	}

+	return UniDup();

+}

+

+BOOL IMF_Load(BOOL curious)

+{

+#define IMF_SMPINCR 64

+	int t,u,track=0,oldnumsmp;

+	IMFCHANNEL channels[32];

+	INSTRUMENT *d;

+	SAMPLE *q;

+	IMFWAVHEADER *wh=NULL,*s=NULL;

+	ULONG *nextwav=NULL;

+	UWORD wavcnt=0;

+	UBYTE id[4];

+	(void)curious;

+

+	/* try to read the module header */

+	_mm_read_string(mh->songname,32,modreader);

+	mh->ordnum=_mm_read_I_UWORD(modreader);

+	mh->patnum=_mm_read_I_UWORD(modreader);

+	mh->insnum=_mm_read_I_UWORD(modreader);

+	mh->flags =_mm_read_I_UWORD(modreader);

+	_mm_fseek(modreader,8,SEEK_CUR);

+	mh->initspeed =_mm_read_UBYTE(modreader);

+	mh->inittempo =_mm_read_UBYTE(modreader);

+	mh->mastervol =_mm_read_UBYTE(modreader);

+	mh->mastermult=_mm_read_UBYTE(modreader);

+	_mm_fseek(modreader,64,SEEK_SET);

+

+	if(_mm_eof(modreader)) {

+		_mm_errno = MMERR_LOADING_HEADER;

+		return 0;

+	}

+

+	/* set module variables */

+	of.songname=DupStr(mh->songname,31,1);

+	of.modtype=strdup(IMF_Version);

+	of.numpat=mh->patnum;

+	of.numins=mh->insnum;

+	of.reppos=0;

+	of.initspeed=mh->initspeed;

+	of.inittempo=mh->inittempo;

+	of.initvolume=mh->mastervol<<1;

+	of.flags |= UF_INST | UF_ARPMEM | UF_PANNING;

+	if(mh->flags&1) of.flags |= UF_LINEAR;

+	of.bpmlimit=32;

+

+	/* read channel information */

+	of.numchn=0;

+	memset(remap,-1,32*sizeof(UBYTE));

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

+		_mm_read_string(channels[t].name,12,modreader);

+		channels[t].chorus=_mm_read_UBYTE(modreader);

+		channels[t].reverb=_mm_read_UBYTE(modreader);

+		channels[t].pan   =_mm_read_UBYTE(modreader);

+		channels[t].status=_mm_read_UBYTE(modreader);

+	}

+	/* bug in Imago Orpheus ? If only channel 1 is enabled, in fact we have to

+	   enable 16 channels */

+	if(!channels[0].status) {

+		for(t=1;t<16;t++) if(channels[t].status!=1) break;

+		if(t==16) for(t=1;t<16;t++) channels[t].status=0;

+	}

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

+		if(channels[t].status!=2)

+			remap[t]=of.numchn++;

+		else

+			remap[t]=-1;

+	}

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

+		if(remap[t]!=-1) {

+			of.panning[remap[t]]=channels[t].pan;

+			of.chanvol[remap[t]]=channels[t].status?0:64;

+		}

+

+	if(_mm_eof(modreader)) {

+		_mm_errno = MMERR_LOADING_HEADER;

+		return 0;

+	}

+

+	/* read order list */

+	_mm_read_UBYTES(mh->orders,256,modreader);

+	if(_mm_eof(modreader)) {

+		_mm_errno = MMERR_LOADING_HEADER;

+		return 0;

+	}

+

+	of.numpos=0;

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

+		if(mh->orders[t]!=0xff) of.numpos++;

+	if(!AllocPositions(of.numpos)) return 0;

+	for(t=u=0;t<mh->ordnum;t++)

+		if(mh->orders[t]!=0xff) of.positions[u++]=mh->orders[t];

+

+	/* load pattern info */

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

+	if(!AllocTracks()) return 0;

+	if(!AllocPatterns()) return 0;

+

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

+		SLONG size;

+		UWORD rows;

+

+		size=(SLONG)_mm_read_I_UWORD(modreader);

+		rows=_mm_read_I_UWORD(modreader);

+		if((rows>256)||(size<4)) {

+			_mm_errno=MMERR_LOADING_PATTERN;

+			return 0;

+		}

+

+		of.pattrows[t]=rows;

+		if(!IMF_ReadPattern(size-4,rows)) return 0;

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

+			if(!(of.tracks[track++]=IMF_ConvertTrack(&imfpat[u*256],rows)))

+				return 0;

+	}

+

+	/* load instruments */

+	if(!AllocInstruments()) return 0;

+	d=of.instruments;

+

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

+		IMFINSTHEADER ih;

+

+		memset(d->samplenumber,0xff,INSTNOTES*sizeof(UWORD));

+

+		/* read instrument header */

+		_mm_read_string(ih.name,32,modreader);

+		d->insname=DupStr(ih.name,31,1);

+		_mm_read_UBYTES(ih.what,IMFNOTECNT,modreader);

+		_mm_fseek(modreader,8,SEEK_CUR);

+		_mm_read_I_UWORDS(ih.volenv,IMFENVCNT,modreader);

+		_mm_read_I_UWORDS(ih.panenv,IMFENVCNT,modreader);

+		_mm_read_I_UWORDS(ih.pitenv,IMFENVCNT,modreader);

+

+#if defined __STDC__ || defined _MSC_VER || defined MPW_C

+#define IMF_FinishLoadingEnvelope(name)					\

+		ih. name##pts=_mm_read_UBYTE(modreader);		\

+		ih. name##sus=_mm_read_UBYTE(modreader);		\

+		ih. name##beg=_mm_read_UBYTE(modreader);		\

+		ih. name##end=_mm_read_UBYTE(modreader);		\

+		ih. name##flg=_mm_read_UBYTE(modreader);		\

+		_mm_read_UBYTE(modreader);						\

+		_mm_read_UBYTE(modreader);						\

+		_mm_read_UBYTE(modreader)

+#else

+#define IMF_FinishLoadingEnvelope(name)				\

+		ih. name/**/pts=_mm_read_UBYTE(modreader);	\

+		ih. name/**/sus=_mm_read_UBYTE(modreader);	\

+		ih. name/**/beg=_mm_read_UBYTE(modreader);	\

+		ih. name/**/end=_mm_read_UBYTE(modreader);	\

+		ih. name/**/flg=_mm_read_UBYTE(modreader);	\

+		_mm_read_UBYTE(modreader);					\

+		_mm_read_UBYTE(modreader);					\

+		_mm_read_UBYTE(modreader)

+#endif

+

+		IMF_FinishLoadingEnvelope(vol);

+		IMF_FinishLoadingEnvelope(pan);

+		IMF_FinishLoadingEnvelope(pit);

+

+		ih.volfade=_mm_read_I_UWORD(modreader);

+		ih.numsmp =_mm_read_I_UWORD(modreader);

+

+		_mm_read_UBYTES(id,4,modreader);

+		/* Looks like Imago Orpheus forgets the signature for empty

+		   instruments following a multi-sample instrument... */

+		if(memcmp(id,"II10",4) && 

+		   (oldnumsmp && memcmp(id,"\x0\x0\x0\x0",4))) {

+			if(nextwav) free(nextwav);

+			if(wh) free(wh);

+			_mm_errno=MMERR_LOADING_SAMPLEINFO;

+			return 0;

+		}

+		oldnumsmp=ih.numsmp;

+

+		if((ih.numsmp>16)||(ih.volpts>IMFENVCNT/2)||(ih.panpts>IMFENVCNT/2)||

+		   (ih.pitpts>IMFENVCNT/2)||(_mm_eof(modreader))) {

+			if(nextwav) free(nextwav);

+			if(wh) free(wh);

+			_mm_errno=MMERR_LOADING_SAMPLEINFO;

+			return 0;

+		}

+

+		for(u=0;u<IMFNOTECNT;u++)

+			d->samplenumber[u]=ih.what[u]>ih.numsmp?0xffff:ih.what[u]+of.numsmp;

+		d->volfade=ih.volfade;

+

+#if defined __STDC__ || defined _MSC_VER || defined MPW_C

+#define IMF_ProcessEnvelope(name) 									\

+		for (u = 0; u < (IMFENVCNT >> 1); u++) {					\

+			d-> name##env[u].pos = ih. name##env[u << 1];			\

+			d-> name##env[u].val = ih. name##env[(u << 1)+ 1];		\

+		}															\

+		if (ih. name##flg&1) d-> name##flg|=EF_ON;					\

+		if (ih. name##flg&2) d-> name##flg|=EF_SUSTAIN;				\

+		if (ih. name##flg&4) d-> name##flg|=EF_LOOP;				\

+		d-> name##susbeg=d-> name##susend=ih. name##sus;			\

+		d-> name##beg=ih. name##beg;								\

+		d-> name##end=ih. name##end;								\

+		d-> name##pts=ih. name##pts;								\

+																	\

+		if ((d-> name##flg&EF_ON)&&(d-> name##pts<2))				\

+			d-> name##flg&=~EF_ON

+#else

+#define IMF_ProcessEnvelope(name) 									\

+		for (u = 0; u < (IMFENVCNT >> 1); u++) {					\

+			d-> name/**/env[u].pos = ih. name/**/env[u << 1];		\

+			d-> name/**/env[u].val = ih. name/**/env[(u << 1)+ 1];	\

+		}															\

+		if (ih. name/**/flg&1) d-> name/**/flg|=EF_ON;				\

+		if (ih. name/**/flg&2) d-> name/**/flg|=EF_SUSTAIN;			\

+		if (ih. name/**/flg&4) d-> name/**/flg|=EF_LOOP;			\

+		d-> name/**/susbeg=d-> name/**/susend=ih. name/**/sus;		\

+		d-> name/**/beg=ih. name/**/beg;							\

+		d-> name/**/end=ih. name/**/end;							\

+		d-> name/**/pts=ih. name/**/pts;							\

+																	\

+		if ((d-> name/**/flg&EF_ON)&&(d-> name/**/pts<2))			\

+			d-> name/**/flg&=~EF_ON

+#endif

+

+		IMF_ProcessEnvelope(vol);

+		IMF_ProcessEnvelope(pan);

+		IMF_ProcessEnvelope(pit);

+#undef IMF_ProcessEnvelope

+

+		if(ih.pitflg&1) {

+			d->pitflg&=~EF_ON;

+#ifdef MIKMOD_DEBUG

+			fprintf(stderr, "\rFilter envelopes not supported yet\n");

+#endif

+		}

+

+		/* gather sample information */

+		for(u=0;u<ih.numsmp;u++,s++) {

+			/* allocate more room for sample information if necessary */

+			if(of.numsmp+u==wavcnt) {

+				wavcnt+=IMF_SMPINCR;

+				if(!(nextwav=realloc(nextwav,wavcnt*sizeof(ULONG)))) {

+					if(wh) free(wh);

+					_mm_errno=MMERR_OUT_OF_MEMORY;

+					return 0;

+				}

+				if(!(wh=realloc(wh,wavcnt*sizeof(IMFWAVHEADER)))) {

+					free(nextwav);

+					_mm_errno=MMERR_OUT_OF_MEMORY;

+					return 0;

+				}

+				s=wh+(wavcnt-IMF_SMPINCR);

+			}

+

+			_mm_read_string(s->samplename,13,modreader);

+			_mm_read_UBYTE(modreader);_mm_read_UBYTE(modreader);_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->samplerate=_mm_read_I_ULONG(modreader);

+			s->volume    =_mm_read_UBYTE(modreader)&0x7f;

+			s->pan       =_mm_read_UBYTE(modreader);

+			_mm_fseek(modreader,14,SEEK_CUR);

+			s->flags     =_mm_read_UBYTE(modreader);

+			_mm_fseek(modreader,11,SEEK_CUR);

+			_mm_read_UBYTES(id,4,modreader);

+			if(((memcmp(id,"IS10",4))&&(memcmp(id,"IW10",4)))||

+			   (_mm_eof(modreader))) {

+				free(nextwav);free(wh);

+				_mm_errno=MMERR_LOADING_SAMPLEINFO;

+				return 0;

+			}

+			nextwav[of.numsmp+u]=_mm_ftell(modreader);

+			_mm_fseek(modreader,s->length,SEEK_CUR);

+		}

+

+		of.numsmp+=ih.numsmp;

+		d++;

+	}

+

+	/* sanity check */

+	if(!of.numsmp) {

+		if(nextwav) free(nextwav);

+		if(wh) free(wh);

+		_mm_errno=MMERR_LOADING_SAMPLEINFO;

+		return 0;

+	}

+

+	/* load samples */

+	if(!AllocSamples()) {

+		free(nextwav);free(wh);

+		return 0;

+	}

+	if(!AllocLinear()) {

+		free(nextwav);free(wh);

+		return 0;

+	}

+	q=of.samples;

+	s=wh;

+	for(u=0;u<of.numsmp;u++,s++,q++) {

+		q->samplename=DupStr(s->samplename,12,1);

+		q->length   =s->length;

+		q->loopstart=s->loopstart;

+		q->loopend  =s->loopend;

+		q->volume   =s->volume;

+		q->speed    =s->samplerate;

+		if(of.flags&UF_LINEAR)

+			q->speed=speed_to_finetune(s->samplerate<<1,u);

+		q->panning  =s->pan;

+		q->seekpos  =nextwav[u];

+

+		q->flags|=SF_SIGNED;

+		if(s->flags&0x1) q->flags|=SF_LOOP;

+		if(s->flags&0x2) q->flags|=SF_BIDI;

+		if(s->flags&0x8) q->flags|=SF_OWNPAN;

+		if(s->flags&0x4) {

+			q->flags|=SF_16BITS;

+			q->length   >>=1;

+			q->loopstart>>=1;

+			q->loopend  >>=1;

+		}

+	}

+

+	d=of.instruments;

+	s=wh;

+	for(u=0;u<of.numins;u++,d++) {

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

+			if(d->samplenumber[t]>=of.numsmp)

+				d->samplenote[t]=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);

+			} else

+				d->samplenote[t]=t;

+		}

+	}

+

+	free(wh);free(nextwav);

+	return 1;

+}

+

+CHAR *IMF_LoadTitle(void)

+{

+	CHAR s[31];

+

+	_mm_fseek(modreader,0,SEEK_SET);

+	if(!_mm_read_UBYTES(s,31,modreader)) return NULL;

+

+	return(DupStr(s,31,1));

+}

+

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

+

+MIKMODAPI MLOADER load_imf={

+	NULL,

+	"IMF",

+	"IMF (Imago Orpheus)",

+	IMF_Init,

+	IMF_Test,

+	IMF_Load,

+	IMF_Cleanup,

+	IMF_LoadTitle

+};

+

+/* ex:set ts=4: */

diff --git a/apps/plugins/mikmod/loaders/load_it.c b/apps/plugins/mikmod/loaders/load_it.c
new file mode 100644
index 0000000..d115af5
--- /dev/null
+++ b/apps/plugins/mikmod/loaders/load_it.c
@@ -0,0 +1,1008 @@
+/*	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_it.c,v 1.2 2004/02/06 19:29:03 raph Exp $

+

+  Impulse tracker (IT) module loader

+

+==============================================================================*/

+

+#ifdef HAVE_CONFIG_H

+#include "config.h"

+#endif

+

+#ifdef HAVE_UNISTD_H

+#include <unistd.h>

+#endif

+

+//#include <ctype.h>

+#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 *, ...);

+extern int toupper(int);

+#endif

+

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

+

+/* header */

+typedef struct ITHEADER {

+	CHAR	songname[26];

+	UBYTE	blank01[2];

+	UWORD	ordnum;

+	UWORD	insnum;

+	UWORD	smpnum;

+	UWORD	patnum;

+	UWORD	cwt;		/* Created with tracker (y.xx = 0x0yxx) */

+	UWORD	cmwt;		/* Compatible with tracker ver > than val. */

+	UWORD	flags;

+	UWORD	special;	/* bit 0 set = song message attached */

+	UBYTE	globvol;

+	UBYTE	mixvol;		/* mixing volume [ignored] */

+	UBYTE	initspeed;

+	UBYTE	inittempo;

+	UBYTE	pansep;		/* panning separation between channels */

+	UBYTE	zerobyte;       

+	UWORD	msglength;

+	ULONG	msgoffset;

+	UBYTE	blank02[4];

+	UBYTE	pantable[64];

+	UBYTE	voltable[64];

+} ITHEADER;

+

+/* sample information */

+typedef struct ITSAMPLE {

+	CHAR	filename[12];

+	UBYTE	zerobyte;

+	UBYTE	globvol;

+	UBYTE	flag;

+	UBYTE	volume;

+	UBYTE	panning;

+	CHAR	sampname[28];

+	UWORD	convert;	/* sample conversion flag */

+	ULONG	length;

+	ULONG	loopbeg;

+	ULONG	loopend;

+	ULONG	c5spd;

+	ULONG	susbegin;

+	ULONG	susend;

+	ULONG	sampoffset;

+	UBYTE	vibspeed;

+	UBYTE	vibdepth;

+	UBYTE	vibrate;

+	UBYTE	vibwave;	/* 0=sine, 1=rampdown, 2=square, 3=random (speed ignored) */

+} ITSAMPLE;

+

+/* instrument information */

+

+#define ITENVCNT 25

+#define ITNOTECNT 120

+typedef struct ITINSTHEADER {

+	ULONG	size;			/* (dword) Instrument size */

+	CHAR	filename[12];	/* (char) Instrument filename */

+	UBYTE	zerobyte;		/* (byte) Instrument type (always 0) */

+	UBYTE	volflg;

+	UBYTE	volpts;   

+	UBYTE	volbeg;			/* (byte) Volume loop start (node) */

+	UBYTE	volend;			/* (byte) Volume loop end (node) */

+	UBYTE	volsusbeg;		/* (byte) Volume sustain begin (node) */

+	UBYTE	volsusend;		/* (byte) Volume Sustain end (node) */

+	UBYTE	panflg;

+	UBYTE	panpts;  

+	UBYTE	panbeg;			/* (byte) channel loop start (node) */

+	UBYTE	panend;			/* (byte) channel loop end (node) */

+	UBYTE	pansusbeg;		/* (byte) channel sustain begin (node) */

+	UBYTE	pansusend;		/* (byte) channel Sustain end (node) */

+	UBYTE	pitflg;

+	UBYTE	pitpts;   

+	UBYTE	pitbeg;			/* (byte) pitch loop start (node) */

+	UBYTE	pitend;			/* (byte) pitch loop end (node) */

+	UBYTE	pitsusbeg;		/* (byte) pitch sustain begin (node) */

+	UBYTE	pitsusend;		/* (byte) pitch Sustain end (node) */

+	UWORD	blank;

+	UBYTE	globvol;

+	UBYTE	chanpan;

+	UWORD	fadeout;		/* Envelope end / NNA volume fadeout */

+	UBYTE	dnc;			/* Duplicate note check */

+	UBYTE	dca;			/* Duplicate check action */

+	UBYTE	dct;			/* Duplicate check type */

+	UBYTE	nna;			/* New Note Action [0,1,2,3] */

+	UWORD	trkvers;		/* tracker version used to save [files only] */

+	UBYTE	ppsep;			/* Pitch-pan Separation */

+	UBYTE	ppcenter;		/* Pitch-pan Center */

+	UBYTE	rvolvar;		/* random volume varations */

+	UBYTE	rpanvar;		/* random panning varations */

+	UWORD	numsmp;			/* Number of samples in instrument [files only] */

+	CHAR	name[26];		/* Instrument name */

+	UBYTE	blank01[6];

+	UWORD	samptable[ITNOTECNT];/* sample for each note [note / samp pairs] */

+	UBYTE	volenv[200];	     /* volume envelope (IT 1.x stuff) */

+	UBYTE	oldvoltick[ITENVCNT];/* volume tick position (IT 1.x stuff) */

+	UBYTE	volnode[ITENVCNT];   /* amplitude of volume nodes */

+	UWORD	voltick[ITENVCNT];   /* tick value of volume nodes */

+	SBYTE	pannode[ITENVCNT];   /* panenv - node points */

+	UWORD	pantick[ITENVCNT];   /* tick value of panning nodes */

+	SBYTE	pitnode[ITENVCNT];   /* pitchenv - node points */

+	UWORD	pittick[ITENVCNT];   /* tick value of pitch nodes */

+} ITINSTHEADER;                       

+

+/* unpacked note */

+

+typedef struct ITNOTE {

+	UBYTE note,ins,volpan,cmd,inf;

+} ITNOTE;

+

+/*========== Loader data */

+

+static ULONG *paraptr=NULL;	/* parapointer array (see IT docs) */

+static ITHEADER *mh=NULL;

+static ITNOTE *itpat=NULL;	/* allocate to space for one full pattern */

+static UBYTE *mask=NULL;	/* arrays allocated to 64 elements and used for */

+static ITNOTE *last=NULL;	/* uncompressing IT's pattern information */

+static int numtrk=0;

+static unsigned int old_effect;		/* if set, use S3M old-effects stuffs */

+   

+static CHAR* IT_Version[]={

+	"ImpulseTracker  .  ",

+	"Compressed ImpulseTracker  .  ",

+	"ImpulseTracker 2.14p3",

+	"Compressed ImpulseTracker 2.14p3",

+	"ImpulseTracker 2.14p4",

+	"Compressed ImpulseTracker 2.14p4",

+};

+

+/* table for porta-to-note command within volume/panning column */

+static UBYTE portatable[10]= {0,1,4,8,16,32,64,96,128,255};

+

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

+

+BOOL IT_Test(void)

+{

+	UBYTE id[4];

+

+	if(!_mm_read_UBYTES(id,4,modreader)) return 0;

+	if(!memcmp(id,"IMPM",4)) return 1;

+	return 0;

+}

+

+BOOL IT_Init(void)

+{

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

+	if(!(poslookup=(UBYTE*)_mm_malloc(256*sizeof(UBYTE)))) return 0;

+	if(!(itpat=(ITNOTE*)_mm_malloc(200*64*sizeof(ITNOTE)))) return 0;

+	if(!(mask=(UBYTE*)_mm_malloc(64*sizeof(UBYTE)))) return 0;

+	if(!(last=(ITNOTE*)_mm_malloc(64*sizeof(ITNOTE)))) return 0;

+

+	return 1;

+}

+

+void IT_Cleanup(void)

+{

+	FreeLinear();

+

+	_mm_free(mh);

+	_mm_free(poslookup);

+	_mm_free(itpat);

+	_mm_free(mask);

+	_mm_free(last);

+	_mm_free(paraptr);

+	_mm_free(origpositions);

+}

+

+/* Because so many IT files have 64 channels as the set number used, but really

+   only use far less (usually from 8 to 24 still), I had to make this function,

+   which determines the number of channels that are actually USED by a pattern.

+ 

+   NOTE: You must first seek to the file location of the pattern before calling

+         this procedure.

+

+   Returns 1 on error

+*/

+static BOOL IT_GetNumChannels(UWORD patrows)

+{

+	int row=0,flag,ch;

+

+	do {

+		if((flag=_mm_read_UBYTE(modreader))==EOF) {

+			_mm_errno=MMERR_LOADING_PATTERN;

+			return 1;

+		}

+		if(!flag)

+			row++;

+		else {

+			ch=(flag-1)&63;

+			remap[ch]=0;

+			if(flag & 128) mask[ch]=_mm_read_UBYTE(modreader);

+			if(mask[ch]&1)   _mm_read_UBYTE(modreader);

+			if(mask[ch]&2)   _mm_read_UBYTE(modreader);

+			if(mask[ch]&4)   _mm_read_UBYTE(modreader);

+			if(mask[ch]&8) { _mm_read_UBYTE(modreader);_mm_read_UBYTE(modreader); }

+		}

+	} while(row<patrows);

+

+	return 0;

+}

+

+static UBYTE* IT_ConvertTrack(ITNOTE* tr,UWORD numrows)

+{

+	int t;

+	UBYTE note,ins,volpan;

+

+	UniReset();

+

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

+		note=tr[t*of.numchn].note;

+		ins=tr[t*of.numchn].ins;

+		volpan=tr[t*of.numchn].volpan;

+

+		if(note!=255) {

+			if(note==253)

+				UniWriteByte(UNI_KEYOFF);

+			else if(note==254) {

+				UniPTEffect(0xc,-1);	/* note cut command */

+				volpan=255;

+			} else

+				UniNote(note);

+		}

+

+		if((ins)&&(ins<100))

+			UniInstrument(ins-1);

+		else if(ins==253)

+			UniWriteByte(UNI_KEYOFF);

+		else if(ins!=255) { /* crap */

+			_mm_errno=MMERR_LOADING_PATTERN;

+			return NULL;

+		}

+

+		/* process volume / panning column

+		   volume / panning effects do NOT all share the same memory address

+		   yet. */

+		if(volpan<=64) 

+			UniVolEffect(VOL_VOLUME,volpan);

+		else if(volpan==65) /* fine volume slide up (65-74) - A0 case */

+			UniVolEffect(VOL_VOLSLIDE,0);

+		else if(volpan<=74)	{ /* fine volume slide up (65-74) - general case */

+			UniVolEffect(VOL_VOLSLIDE,0x0f+((volpan-65)<<4));

+		} else if(volpan==75)	/* fine volume slide down (75-84) - B0 case */

+			UniVolEffect(VOL_VOLSLIDE,0);

+		else if(volpan<=84) {	/* fine volume slide down (75-84) - general case*/

+			UniVolEffect(VOL_VOLSLIDE,0xf0+(volpan-75));

+		} else if(volpan<=94)	/* volume slide up (85-94) */

+			UniVolEffect(VOL_VOLSLIDE,((volpan-85)<<4));

+		else if(volpan<=104)/* volume slide down (95-104) */

+			UniVolEffect(VOL_VOLSLIDE,(volpan-95));

+		else if(volpan<=114)/* pitch slide down (105-114) */

+			UniVolEffect(VOL_PITCHSLIDEDN,(volpan-105));

+		else if(volpan<=124)/* pitch slide up (115-124) */

+			UniVolEffect(VOL_PITCHSLIDEUP,(volpan-115));

+		else if(volpan<=127) { /* crap */

+			_mm_errno=MMERR_LOADING_PATTERN;

+			return NULL;

+		} else if(volpan<=192)

+			UniVolEffect(VOL_PANNING,((volpan-128)==64)?255:((volpan-128)<<2));

+		else if(volpan<=202)/* portamento to note */

+			UniVolEffect(VOL_PORTAMENTO,portatable[volpan-193]);

+		else if(volpan<=212)/* vibrato */

+			UniVolEffect(VOL_VIBRATO,(volpan-203));

+		else if((volpan!=239)&&(volpan!=255)) { /* crap */

+			_mm_errno=MMERR_LOADING_PATTERN;

+			return NULL;

+		}

+

+		S3MIT_ProcessCmd(tr[t*of.numchn].cmd,tr[t*of.numchn].inf,

+		    old_effect|S3MIT_IT);

+

+		UniNewline();

+	}

+	return UniDup();

+}

+

+static BOOL IT_ReadPattern(UWORD patrows)

+{

+	int row=0,flag,ch,blah;

+	ITNOTE *itt=itpat,dummy,*n,*l;

+

+	memset(itt,255,200*64*sizeof(ITNOTE));

+

+	do {

+		if((flag=_mm_read_UBYTE(modreader))==EOF) {

+			_mm_errno = MMERR_LOADING_PATTERN;

+			return 0;

+		}

+		if(!flag) {

+			itt=&itt[of.numchn];

+			row++;

+		} else {

+			ch=remap[(flag-1)&63];

+			if(ch!=-1) {

+				n=&itt[ch];

+				l=&last[ch];

+			} else 

+				n=l=&dummy;

+

+			if(flag&128) mask[ch]=_mm_read_UBYTE(modreader);

+			if(mask[ch]&1)

+				/* convert IT note off to internal note off */

+				if((l->note=n->note=_mm_read_UBYTE(modreader))==255) 

+					l->note=n->note=253;

+			if(mask[ch]&2)

+				l->ins=n->ins=_mm_read_UBYTE(modreader);

+			if(mask[ch]&4)

+				l->volpan=n->volpan=_mm_read_UBYTE(modreader);

+			if(mask[ch]&8) {

+				l->cmd=n->cmd=_mm_read_UBYTE(modreader);

+				l->inf=n->inf=_mm_read_UBYTE(modreader);

+			}

+			if(mask[ch]&16)

+				n->note=l->note;

+			if(mask[ch]&32)

+				n->ins=l->ins;

+			if(mask[ch]&64)

+				n->volpan=l->volpan;

+			if(mask[ch]&128) {

+				n->cmd=l->cmd;

+				n->inf=l->inf;

+			}

+		}

+	} while(row<patrows);

+

+	for(blah=0;blah<of.numchn;blah++) {

+		if(!(of.tracks[numtrk++]=IT_ConvertTrack(&itpat[blah],patrows)))

+			return 0;

+	}

+

+	return 1;

+}

+

+static void LoadMidiString(MREADER* modreader,CHAR* dest)

+{

+	CHAR *cur,*last;

+

+	_mm_read_UBYTES(dest,32,modreader);

+	cur=last=dest;

+	/* remove blanks and uppercase all */

+	while(*last) {

+		if(isalnum((int)*last)) *(cur++)=toupper((int)*last);

+		last++;

+	}

+	*cur=0;

+}

+

+/* Load embedded midi information for resonant filters */

+static void IT_LoadMidiConfiguration(MREADER* modreader)

+{

+	int i;

+

+	memset(filtermacros,0,sizeof(filtermacros));

+	memset(filtersettings,0,sizeof(filtersettings));

+

+	if (modreader) { /* information is embedded in file */

+		UWORD dat;

+		CHAR midiline[33];

+

+		dat=_mm_read_I_UWORD(modreader);

+		_mm_fseek(modreader,8*dat+0x120,SEEK_CUR);

+

+		/* read midi macros */

+		for(i=0;i<UF_MAXMACRO;i++) {

+			LoadMidiString(modreader,midiline);

+			if((!strncmp(midiline,"F0F00",5))&&

+			   ((midiline[5]=='0')||(midiline[5]=='1')))

+					filtermacros[i]=(midiline[5]-'0')|0x80;

+		}

+

+		/* read standalone filters */

+		for(i=0x80;i<0x100;i++) {

+			LoadMidiString(modreader,midiline);

+			if((!strncmp(midiline,"F0F00",5))&&

+			   ((midiline[5]=='0')||(midiline[5]=='1'))) {

+				filtersettings[i].filter=(midiline[5]-'0')|0x80;

+				dat=(midiline[6])?(midiline[6]-'0'):0;

+				if(midiline[7])dat=(dat<<4)|(midiline[7]-'0');

+				filtersettings[i].inf=dat;

+			}

+		}

+	} else { /* use default information */

+		filtermacros[0]=FILT_CUT;

+		for(i=0x80;i<0x90;i++) {

+			filtersettings[i].filter=FILT_RESONANT;

+			filtersettings[i].inf=(i&0x7f)<<3;

+		}

+	}

+	activemacro=0;

+	for(i=0;i<0x80;i++) {

+		filtersettings[i].filter=filtermacros[0];

+		filtersettings[i].inf=i;

+	}

+}

+

+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->flags & 1))

+			of.flags |= UF_PANNING;

+	of.bpmlimit=32;

+

+	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=S3MIT_OLDSTYLE;

+	else

+		old_effect=0;

+

+	/* set panning positions */

+	if (mh->flags & 1)

+		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;

+			}

+		}

+	else

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

+			of.panning[t]=PAN_CENTER;

+

+	/* 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=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)) {

+			_mm_errno = MMERR_LOADING_SAMPLEINFO;

+			return 0;

+		}

+

+		/* Reality check for sample loop information */

+		if((s.flag&16)&&

+		   ((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 */

+#if defined __STDC__ || defined _MSC_VER || defined MPW_C

+#define IT_LoadEnvelope(name,type) 										\

+				ih. name##flg   =_mm_read_UBYTE(modreader);				\

+				ih. name##pts   =_mm_read_UBYTE(modreader);				\

+				ih. name##beg   =_mm_read_UBYTE(modreader);				\

+				ih. name##end   =_mm_read_UBYTE(modreader);				\

+				ih. name##susbeg=_mm_read_UBYTE(modreader);				\

+				ih. name##susend=_mm_read_UBYTE(modreader);				\

+				for(lp=0;lp<ITENVCNT;lp++) {							\

+					ih. name##node[lp]=_mm_read_##type (modreader);		\

+					ih. name##tick[lp]=_mm_read_I_UWORD(modreader);		\

+				}														\

+				_mm_read_UBYTE(modreader)

+#else

+#define IT_LoadEnvelope(name,type) 										\

+				ih. name/**/flg   =_mm_read_UBYTE(modreader);			\

+				ih. name/**/pts   =_mm_read_UBYTE(modreader);			\

+				ih. name/**/beg   =_mm_read_UBYTE(modreader);			\

+				ih. name/**/end   =_mm_read_UBYTE(modreader);			\

+				ih. name/**/susbeg=_mm_read_UBYTE(modreader);			\

+				ih. name/**/susend=_mm_read_UBYTE(modreader);			\

+				for(lp=0;lp<ITENVCNT;lp++) {							\

+					ih. name/**/node[lp]=_mm_read_/**/type (modreader);	\

+					ih. name/**/tick[lp]=_mm_read_I_UWORD(modreader);	\

+				}														\

+				_mm_read_UBYTE(modreader)

+#endif

+

+				IT_LoadEnvelope(vol,UBYTE);

+				IT_LoadEnvelope(pan,SBYTE);

+				IT_LoadEnvelope(pit,SBYTE);

+#undef IT_LoadEnvelope

+			}

+ 

+			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 defined __STDC__ || defined _MSC_VER || defined MPW_C

+#define IT_ProcessEnvelope(name) 										\

+				if(ih. name##flg&1) d-> name##flg|=EF_ON;				\

+				if(ih. name##flg&2) d-> name##flg|=EF_LOOP;				\

+				if(ih. name##flg&4) d-> name##flg|=EF_SUSTAIN;			\

+				d-> name##pts=ih. name##pts;							\

+				d-> name##beg=ih. name##beg;							\

+				d-> name##end=ih. name##end;							\

+				d-> name##susbeg=ih. name##susbeg;						\

+				d-> name##susend=ih. name##susend;						\

+																		\

+				for(u=0;u<ih. name##pts;u++)							\

+					d-> name##env[u].pos=ih. name##tick[u];				\

+																		\

+				if((d-> name##flg&EF_ON)&&(d-> name##pts<2))			\

+					d-> name##flg&=~EF_ON

+#else

+#define IT_ProcessEnvelope(name) 									\

+				if(ih. name/**/flg&1) d-> name/**/flg|=EF_ON;		\

+				if(ih. name/**/flg&2) d-> name/**/flg|=EF_LOOP;		\

+				if(ih. name/**/flg&4) d-> name/**/flg|=EF_SUSTAIN;	\

+				d-> name/**/pts=ih. name/**/pts;					\

+				d-> name/**/beg=ih. name/**/beg;					\

+				d-> name/**/end=ih. name/**/end;					\

+				d-> name/**/susbeg=ih. name/**/susbeg;				\

+				d-> name/**/susend=ih. name/**/susend;				\

+																	\

+				for(u=0;u<ih. name/**/pts;u++)						\

+					d-> name/**/env[u].pos=ih. name/**/tick[u];		\

+																	\

+				if((d-> name/**/flg&EF_ON)&&(d-> name/**/pts<2))	\

+					d-> name/**/flg&=~EF_ON

+#endif

+

+				IT_ProcessEnvelope(vol);

+				for(u=0;u<ih.volpts;u++)

+					d->volenv[u].val=(ih.volnode[u]<<2);

+

+				IT_ProcessEnvelope(pan);

+				for(u=0;u<ih.panpts;u++)

+					d->panenv[u].val=

+					  ih.pannode[u]==32?255:(ih.pannode[u]+32)<<2;

+

+				IT_ProcessEnvelope(pit);

+				for(u=0;u<ih.pitpts;u++)

+					d->pitenv[u].val=ih.pitnode[u]+32;

+#undef IT_ProcessEnvelope

+

+				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)

+							fprintf(stderr, "\rFilter envelopes not supported yet\n");

+						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) {

+		if(!AllocInstruments()) return 0;

+		d=of.instruments;

+		of.flags|=UF_INST;

+

+		for(t=0;t<mh->smpnum;t++,d++)

+			for(u=0;u<ITNOTECNT;u++) {

+				if(d->samplenumber[u]>=of.numsmp)

+					d->samplenote[u]=255;

+				else {

+					int note=(int)d->samplenote[u]+noteindex[d->samplenumber[u]];

+					d->samplenote[u]=(note<0)?0:(note>255?255:note);

+				}

+			}

+	}

+

+	/* Figure out how many channels this song actually uses */

+	of.numchn=0;

+	memset(remap,-1,UF_MAXCHAN*sizeof(UBYTE));

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

+		UWORD packlen;

+

+		/* seek to pattern position */

+		if(paraptr[mh->insnum+mh->smpnum+t]) { /* 0 -> empty 64 row pattern */

+			_mm_fseek(modreader,((long)paraptr[mh->insnum+mh->smpnum+t]),SEEK_SET);

+			_mm_read_I_UWORD(modreader);

+			/* read pattern length (# of rows)

+			   Impulse Tracker never creates patterns with less than 32 rows,

+			   but some other trackers do, so we only check for more than 256

+			   rows */

+			packlen=_mm_read_I_UWORD(modreader);

+			if(packlen>256) {

+				_mm_errno=MMERR_LOADING_PATTERN;

+				return 0;

+			}

+			_mm_read_I_ULONG(modreader);

+			if(IT_GetNumChannels(packlen)) return 0;

+		}

+	}

+

+	/* give each of them a different number */

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

+		if(!remap[t])

+			remap[t]=of.numchn++;

+

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

+	if(of.numvoices)

+		if (of.numvoices<of.numchn) of.numvoices=of.numchn;

+

+	if(!AllocPatterns()) return 0;

+	if(!AllocTracks()) return 0;

+

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

+		UWORD packlen;

+

+		/* seek to pattern position */

+		if(!paraptr[mh->insnum+mh->smpnum+t]) { /* 0 -> empty 64 row pattern */

+			of.pattrows[t]=64;

+			for(u=0;u<of.numchn;u++) {

+				int k;

+

+				UniReset();

+				for(k=0;k<64;k++) UniNewline();

+				of.tracks[numtrk++]=UniDup();

+			}

+		} else {

+			_mm_fseek(modreader,((long)paraptr[mh->insnum+mh->smpnum+t]),SEEK_SET);

+			packlen=_mm_read_I_UWORD(modreader);

+			of.pattrows[t]=_mm_read_I_UWORD(modreader);

+			_mm_read_I_ULONG(modreader);

+			if(!IT_ReadPattern(of.pattrows[t])) return 0;

+		}

+	}

+

+	return 1;

+}

+

+CHAR *IT_LoadTitle(void)

+{

+	CHAR s[26];

+

+	_mm_fseek(modreader,4,SEEK_SET);

+	if(!_mm_read_UBYTES(s,26,modreader)) return NULL;

+   

+	return(DupStr(s,26,0));

+}

+

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

+

+MIKMODAPI MLOADER load_it={

+	NULL,

+	"IT",

+	"IT (Impulse Tracker)",

+	IT_Init,

+	IT_Test,

+	IT_Load,

+	IT_Cleanup,

+	IT_LoadTitle

+};

+

+/* ex:set ts=4: */

diff --git a/apps/plugins/mikmod/loaders/load_m15.c b/apps/plugins/mikmod/loaders/load_m15.c
new file mode 100644
index 0000000..6adae0e
--- /dev/null
+++ b/apps/plugins/mikmod/loaders/load_m15.c
@@ -0,0 +1,505 @@
+/*	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_m15.c,v 1.1.1.1 2004/01/21 01:36:35 raph Exp $

+

+  15 instrument MOD loader

+  Also supports Ultimate Sound Tracker (old M15 format)

+

+==============================================================================*/

+

+#ifdef HAVE_CONFIG_H

+#include "config.h"

+#endif

+

+#ifdef HAVE_UNISTD_H

+#include <unistd.h>

+#endif

+

+//#include <ctype.h>

+#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 */

+

+typedef struct MSAMPINFO {

+	CHAR  samplename[23];	/* 22 in module, 23 in memory */

+	UWORD length;

+	UBYTE finetune;

+	UBYTE volume;

+	UWORD reppos;

+	UWORD replen;

+} MSAMPINFO;

+

+typedef struct MODULEHEADER {

+	CHAR      songname[21];		/* the songname.., 20 in module, 21 in memory */

+	MSAMPINFO samples[15];		/* all sampleinfo */

+	UBYTE     songlength;		/* number of patterns used */

+	UBYTE     magic1;       	/* should be 127 */

+	UBYTE     positions[128];	/* which pattern to play at pos */

+} MODULEHEADER;

+

+typedef struct MODNOTE {

+	UBYTE a,b,c,d;

+} MODNOTE;

+

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

+

+static MODULEHEADER *mh = NULL;

+static MODNOTE *patbuf = NULL;

+static BOOL ust_loader = 0;		/* if TRUE, load as an ust module. */

+

+/* known file formats which can confuse the loader */

+#define REJECT 2

+static char *signatures[REJECT]={

+	"CAKEWALK",	/* cakewalk midi files */

+	"SZDD"		/* Microsoft compressed files */

+};

+static int siglen[REJECT]={8,4};

+

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

+

+static BOOL LoadModuleHeader(MODULEHEADER *mh)

+{

+	int t,u;

+

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

+	mh->songname[20]=0;	/* just in case */

+

+	/* sanity check : title should contain printable characters and a bunch

+	   of null chars */

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

+		if((mh->songname[t])&&(mh->songname[t]<32)) return 0;

+	for(t=0;(mh->songname[t])&&(t<20);t++);

+	if(t<20) for(;t<20;t++) if(mh->songname[t]) return 0;

+

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

+		MSAMPINFO *s=&mh->samples[t];

+

+		_mm_read_string(s->samplename,22,modreader);

+		s->samplename[22]=0;	/* just in case */

+		s->length   =_mm_read_M_UWORD(modreader);

+		s->finetune =_mm_read_UBYTE(modreader);

+		s->volume   =_mm_read_UBYTE(modreader);

+		s->reppos   =_mm_read_M_UWORD(modreader);

+		s->replen   =_mm_read_M_UWORD(modreader);

+

+		/* sanity check : sample title should contain printable characters and

+		   a bunch of null chars */

+		for(u=0;u<20;u++)

+			if((s->samplename[u])&&(s->samplename[u]</*32*/14)) return 0;

+		for(u=0;(s->samplename[u])&&(u<20);u++);

+		if(u<20) for(;u<20;u++) if(s->samplename[u]) return 0;

+

+		/* sanity check : finetune values */

+		if(s->finetune>>4) return 0;

+	}

+

+	mh->songlength  =_mm_read_UBYTE(modreader);

+	mh->magic1      =_mm_read_UBYTE(modreader);	/* should be 127 */

+

+	/* sanity check : no more than 128 positions, restart position in range */

+	if((!mh->songlength)||(mh->songlength>128)) return 0;

+	/* values encountered so far are 0x6a and 0x78 */

+	if(((mh->magic1&0xf8)!=0x78)&&(mh->magic1!=0x6a)&&(mh->magic1>mh->songlength)) return 0;

+

+	_mm_read_UBYTES(mh->positions,128,modreader);

+

+	/* sanity check : pattern range is 0..63 */

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

+		if(mh->positions[t]>63) return 0;

+

+	return(!_mm_eof(modreader));

+}

+

+/* Checks the patterns in the modfile for UST / 15-inst indications.

+   For example, if an effect 3xx is found, it is assumed that the song 

+   is 15-inst.  If a 1xx effect has dat greater than 0x20, it is UST.   

+

+   Returns:  0 indecisive; 1 = UST; 2 = 15-inst                               */

+static int CheckPatternType(int numpat)

+{

+	int t;

+	UBYTE eff, dat;

+

+	for(t=0;t<numpat*(64U*4);t++) {

+		/* Load the pattern into the temp buffer and scan it */

+		_mm_read_UBYTE(modreader);_mm_read_UBYTE(modreader);

+		eff = _mm_read_UBYTE(modreader);

+		dat = _mm_read_UBYTE(modreader);

+

+		switch(eff) {

+			case 1:

+				if(dat>0x1f) return 1;

+				if(dat<0x3)  return 2;

+				break;

+			case 2:

+				if(dat>0x1f) return 1;

+				return 2;

+			case 3:

+				if (dat) return 2;

+				break;

+			default:

+				return 2;

+		}

+	}

+	return 0;

+}

+

+static BOOL M15_Test(void)

+{

+	int t, numpat;

+	MODULEHEADER mh;

+

+	ust_loader = 0;

+	if(!LoadModuleHeader(&mh)) return 0;

+

+	/* reject other file types */

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

+		if(!memcmp(mh.songname,signatures[t],siglen[t])) return 0;

+

+	if(mh.magic1>127) return 0;

+	if((!mh.songlength)||(mh.songlength>mh.magic1)) return 0;

+

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

+		/* all finetunes should be zero */

+		if(mh.samples[t].finetune) return 0;

+

+		/* all volumes should be <= 64 */

+		if(mh.samples[t].volume>64) return 0;

+

+		/* all instrument names should begin with s, st-, or a number */

+		if((mh.samples[t].samplename[0]=='s')||

+		   (mh.samples[t].samplename[0]=='S')) {

+			if((memcmp(mh.samples[t].samplename,"st-",3)) &&

+			   (memcmp(mh.samples[t].samplename,"ST-",3)) &&

+			   (*mh.samples[t].samplename))

+				ust_loader = 1;

+		} else

+		  if(!isdigit((int)mh.samples[t].samplename[0]))

+				ust_loader = 1;

+

+		if(mh.samples[t].length>4999||mh.samples[t].reppos>9999) {

+			ust_loader = 0;

+			if(mh.samples[t].length>32768) return 0;

+		}

+

+		/* if loop information is incorrect as words, but correct as bytes,

+		   this is likely to be an ust-style module */

+		if((mh.samples[t].reppos+mh.samples[t].replen>mh.samples[t].length)&&

+		   (mh.samples[t].reppos+mh.samples[t].replen<(mh.samples[t].length<<1))){

+			ust_loader = 1;

+			return 1;

+		}

+

+		if(!ust_loader) return 1; 

+	}

+

+	for(numpat=0,t=0;t<mh.songlength;t++) 

+		if(mh.positions[t]>numpat)

+			numpat = mh.positions[t];

+	numpat++;

+	switch(CheckPatternType(numpat)) {

+		case 0:   /* indecisive, so check more clues... */

+			break;

+		case 1:

+			ust_loader = 1;

+			break;

+		case 2:

+			ust_loader = 0;

+			break;

+	}

+	return 1;

+}

+

+static BOOL M15_Init(void)

+{

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

+	return 1;

+}

+

+static void M15_Cleanup(void)

+{

+	_mm_free(mh);

+	_mm_free(patbuf);

+}

+

+/*

+Old (amiga) noteinfo:

+

+ _____byte 1_____   byte2_    _____byte 3_____   byte4_

+/                \ /      \  /                \ /      \

+0000          0000-00000000  0000          0000-00000000

+

+Upper four    12 bits for    Lower four    Effect command.

+bits of sam-  note period.   bits of sam-

+ple number.                  ple number.

+*/

+

+static UBYTE M15_ConvertNote(MODNOTE* n, UBYTE lasteffect)

+{

+	UBYTE instrument,effect,effdat,note;

+	UWORD period;

+	UBYTE lastnote=0;

+

+	/* decode the 4 bytes that make up a single note */

+	instrument = n->c>>4;

+	period     = (((UWORD)n->a&0xf)<<8)+n->b;

+	effect     = n->c&0xf;

+	effdat     = n->d;

+

+	/* Convert the period to a note number */

+	note=0;

+	if(period) {

+		for(note=0;note<7*OCTAVE;note++)

+			if(period>=npertab[note]) break;

+		if(note==7*OCTAVE) note=0;

+		else note++;

+	}

+

+	if(instrument) {

+		/* if instrument does not exist, note cut */

+		if((instrument>15)||(!mh->samples[instrument-1].length)) {

+			UniPTEffect(0xc,0);

+			if(effect==0xc) effect=effdat=0;

+		} else {

+			/* if we had a note, then change instrument... */

+			if(note)

+				UniInstrument(instrument-1);

+			/* ...otherwise, only adjust volume... */

+			else {

+				/* ...unless an effect was specified, which forces a new note

+				   to be played */

+				if(effect||effdat) {

+					UniInstrument(instrument-1);

+					note=lastnote;

+				} else

+					UniPTEffect(0xc,mh->samples[instrument-1].volume&0x7f);

+			}

+		}

+	}

+	if(note) {

+		UniNote(note+2*OCTAVE-1);

+		lastnote=note;

+	}

+

+	/* Convert pattern jump from Dec to Hex */

+	if(effect == 0xd)

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

+

+	/* Volume slide, up has priority */

+	if((effect==0xa)&&(effdat&0xf)&&(effdat&0xf0))

+		effdat&=0xf0;

+

+	/* Handle ``heavy'' volumes correctly */

+	if ((effect == 0xc) && (effdat > 0x40))

+		effdat = 0x40;

+

+	if(ust_loader) {

+		switch(effect) {

+			case 0:

+			case 3:

+				break;

+			case 1:

+				UniPTEffect(0,effdat);

+				break;

+			case 2:  

+				if(effdat&0xf) UniPTEffect(1,effdat&0xf);

+				else if(effdat>>2)  UniPTEffect(2,effdat>>2);

+				break;

+			default:

+				UniPTEffect(effect,effdat);

+				break;

+		}

+	} else {

+		/* An isolated 100, 200 or 300 effect should be ignored (no

+		   "standalone" porta memory in mod files). However, a sequence

+		   such as 1XX, 100, 100, 100 is fine. */

+		if ((!effdat) && ((effect == 1)||(effect == 2)||(effect ==3)) &&

+			(lasteffect < 0x10) && (effect != lasteffect))

+			effect = 0;

+

+		UniPTEffect(effect,effdat);

+	}

+	if (effect == 8)

+		of.flags |= UF_PANNING;

+	

+	return effect;

+}

+

+static UBYTE *M15_ConvertTrack(MODNOTE* n)

+{

+	int t;

+	UBYTE lasteffect = 0x10;	/* non existant effect */

+

+	UniReset();

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

+		lasteffect = M15_ConvertNote(n,lasteffect);

+		UniNewline();

+		n+=4;

+	}

+	return UniDup();

+}

+

+/* Loads all patterns of a modfile and converts them into the 3 byte format. */

+static BOOL M15_LoadPatterns(void)

+{

+	int t,s,tracks=0;

+

+	if(!AllocPatterns()) return 0;

+	if(!AllocTracks()) return 0;

+

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

+	if(!(patbuf=(MODNOTE*)_mm_calloc(64U*4,sizeof(MODNOTE)))) return 0;

+

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

+		/* Load the pattern into the temp buffer and convert it */

+		for(s=0;s<(64U*4);s++) {

+			patbuf[s].a=_mm_read_UBYTE(modreader);

+			patbuf[s].b=_mm_read_UBYTE(modreader);

+			patbuf[s].c=_mm_read_UBYTE(modreader);

+			patbuf[s].d=_mm_read_UBYTE(modreader);

+		}

+

+		for(s=0;s<4;s++)

+			if(!(of.tracks[tracks++]=M15_ConvertTrack(patbuf+s))) return 0;

+	}

+	return 1;

+}

+

+static BOOL M15_Load(BOOL curious)

+{

+	int t,scan;

+	SAMPLE *q;

+	MSAMPINFO *s;

+

+	/* try to read module header */

+	if(!LoadModuleHeader(mh)) {

+		_mm_errno = MMERR_LOADING_HEADER;

+		return 0;

+	}

+

+	if(ust_loader)

+		of.modtype = strdup("Ultimate Soundtracker");

+	else

+		of.modtype = strdup("Soundtracker");

+

+	/* set module variables */

+	of.initspeed = 6;

+	of.inittempo = 125;

+	of.numchn    = 4;				

+	of.songname  = DupStr(mh->songname,21,1);

+	of.numpos    = mh->songlength;

+	of.reppos    = 0;

+

+	/* Count the number of patterns */

+	of.numpat = 0;

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

+		if(mh->positions[t]>of.numpat)

+			of.numpat=mh->positions[t];

+	/* since some old modules embed extra patterns, we have to check the

+	   whole list to get the samples' file offsets right - however we can find

+	   garbage here, so check carefully */

+	scan=1;

+	for(t=of.numpos;t<128;t++)

+		if(mh->positions[t]>=0x80) scan=0;

+	if (scan)

+		for(t=of.numpos;t<128;t++) {

+			if(mh->positions[t]>of.numpat)

+				of.numpat=mh->positions[t];

+			if((curious)&&(mh->positions[t])) of.numpos=t+1;

+		}

+	of.numpat++;

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

+

+	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=of.numsmp=15;

+	if(!AllocSamples()) return 0;

+

+	s = mh->samples;

+	q = of.samples;

+

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

+		/* convert the samplename */

+		q->samplename = DupStr(s->samplename,23,1);

+

+		/* init the sampleinfo variables and convert the size pointers */

+		q->speed     = finetune[s->finetune&0xf];

+		q->volume    = s->volume;

+		if(ust_loader)

+			q->loopstart = s->reppos;

+		else

+			q->loopstart = s->reppos<<1;

+		q->loopend   = q->loopstart+(s->replen<<1);

+		q->length    = s->length<<1;

+

+		q->flags = SF_SIGNED;

+	   	if(ust_loader) q->flags |= SF_UST_LOOP;

+		if(s->replen>2) q->flags |= SF_LOOP;

+

+		s++;

+		q++;

+	}

+

+	if(!M15_LoadPatterns()) return 0;

+	ust_loader = 0;

+

+	return 1;

+}

+

+static CHAR *M15_LoadTitle(void)

+{

+	CHAR s[21];

+

+	_mm_fseek(modreader,0,SEEK_SET);

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

+	s[20]=0;	/* just in case */

+	return(DupStr(s,21,1));

+}

+

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

+

+MIKMODAPI MLOADER load_m15={

+	NULL,

+	"15-instrument module",

+	"MOD (15 instrument)",

+	M15_Init,

+	M15_Test,

+	M15_Load,

+	M15_Cleanup,

+	M15_LoadTitle

+};

+

+/* ex:set ts=4: */

diff --git a/apps/plugins/mikmod/loaders/load_med.c b/apps/plugins/mikmod/loaders/load_med.c
new file mode 100644
index 0000000..3078dd2
--- /dev/null
+++ b/apps/plugins/mikmod/loaders/load_med.c
@@ -0,0 +1,719 @@
+/*	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_med.c,v 1.1.1.1 2004/01/21 01:36:35 raph Exp $

+

+  Amiga MED 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 information */

+

+typedef struct MEDHEADER {

+	ULONG id;

+	ULONG modlen;

+	ULONG MEDSONGP;				/* struct MEDSONG *song; */

+	UWORD psecnum;				/* for the player routine, MMD2 only */

+	UWORD pseq;					/*  "   "   "   " */

+	ULONG MEDBlockPP;			/* struct MEDBlock **blockarr; */

+	ULONG reserved1;

+	ULONG MEDINSTHEADERPP;		/* struct MEDINSTHEADER **smplarr; */

+	ULONG reserved2;

+	ULONG MEDEXPP;				/* struct MEDEXP *expdata; */

+	ULONG reserved3;

+	UWORD pstate;				/* some data for the player routine */

+	UWORD pblock;

+	UWORD pline;

+	UWORD pseqnum;

+	SWORD actplayline;

+	UBYTE counter;

+	UBYTE extra_songs;			/* number of songs - 1 */

+} MEDHEADER;

+

+typedef struct MEDSAMPLE {

+	UWORD rep, replen;			/* offs: 0(s), 2(s) */

+	UBYTE midich;				/* offs: 4(s) */

+	UBYTE midipreset;			/* offs: 5(s) */

+	UBYTE svol;					/* offs: 6(s) */

+	SBYTE strans;				/* offs: 7(s) */

+} MEDSAMPLE;

+

+typedef struct MEDSONG {

+	MEDSAMPLE sample[63];		/* 63 * 8 bytes = 504 bytes */

+	UWORD numblocks;			/* offs: 504 */

+	UWORD songlen;				/* offs: 506 */

+	UBYTE playseq[256];			/* offs: 508 */

+	UWORD deftempo;				/* offs: 764 */

+	SBYTE playtransp;			/* offs: 766 */

+	UBYTE flags;				/* offs: 767 */

+	UBYTE flags2;				/* offs: 768 */

+	UBYTE tempo2;				/* offs: 769 */

+	UBYTE trkvol[16];			/* offs: 770 */

+	UBYTE mastervol;			/* offs: 786 */

+	UBYTE numsamples;			/* offs: 787 */

+} MEDSONG;

+

+typedef struct MEDEXP {

+	ULONG nextmod;				/* pointer to next module */

+	ULONG exp_smp;				/* pointer to MEDINSTEXT array */

+	UWORD s_ext_entries;

+	UWORD s_ext_entrsz;

+	ULONG annotxt;				/* pointer to annotation text */

+	ULONG annolen;

+	ULONG iinfo;				/* pointer to MEDINSTINFO array */

+	UWORD i_ext_entries;

+	UWORD i_ext_entrsz;

+	ULONG jumpmask;

+	ULONG rgbtable;

+	ULONG channelsplit;

+	ULONG n_info;

+	ULONG songname;				/* pointer to songname */

+	ULONG songnamelen;

+	ULONG dumps;

+	ULONG reserved2[7];

+} MEDEXP;

+

+typedef struct MMD0NOTE {

+	UBYTE a, b, c;

+} MMD0NOTE;

+

+typedef struct MMD1NOTE {

+	UBYTE a, b, c, d;

+} MMD1NOTE;

+

+typedef struct MEDINSTHEADER {

+	ULONG length;

+	SWORD type;

+	/* Followed by actual data */

+} MEDINSTHEADER;

+

+typedef struct MEDINSTEXT {

+	UBYTE hold;

+	UBYTE decay;

+	UBYTE suppress_midi_off;

+	SBYTE finetune;

+} MEDINSTEXT;

+

+typedef struct MEDINSTINFO {

+	UBYTE name[40];

+} MEDINSTINFO;

+

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

+

+#define MMD0_string 0x4D4D4430

+#define MMD1_string 0x4D4D4431

+

+static MEDHEADER *mh = NULL;

+static MEDSONG *ms = NULL;

+static MEDEXP *me = NULL;

+static ULONG *ba = NULL;

+static MMD0NOTE *mmd0pat = NULL;

+static MMD1NOTE *mmd1pat = NULL;

+

+static BOOL decimalvolumes;

+static BOOL bpmtempos;

+

+#define d0note(row,col) mmd0pat[((row)*(UWORD)of.numchn)+(col)]

+#define d1note(row,col) mmd1pat[((row)*(UWORD)of.numchn)+(col)]

+

+static CHAR MED_Version[] = "OctaMED (MMDx)";

+

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

+

+BOOL MED_Test(void)

+{

+	UBYTE id[4];

+

+	if (!_mm_read_UBYTES(id, 4, modreader))

+		return 0;

+	if ((!memcmp(id, "MMD0", 4)) || (!memcmp(id, "MMD1", 4)))

+		return 1;

+	return 0;

+}

+

+BOOL MED_Init(void)

+{

+	if (!(me = (MEDEXP *)_mm_malloc(sizeof(MEDEXP))))

+		return 0;

+	if (!(mh = (MEDHEADER *)_mm_malloc(sizeof(MEDHEADER))))

+		return 0;

+	if (!(ms = (MEDSONG *)_mm_malloc(sizeof(MEDSONG))))

+		return 0;

+	return 1;

+}

+

+void MED_Cleanup(void)

+{

+	_mm_free(me);

+	_mm_free(mh);

+	_mm_free(ms);

+	_mm_free(ba);

+	_mm_free(mmd0pat);

+	_mm_free(mmd1pat);

+}

+

+static void EffectCvt(UBYTE eff, UBYTE dat)

+{

+	switch (eff) {

+		/* 0x0 0x1 0x2 0x3 0x4 PT effects */

+	  case 0x5:				/* PT vibrato with speed/depth nibbles swapped */

+		UniPTEffect(0x4, (dat >> 4) | ((dat & 0xf) << 4));

+		break;

+		/* 0x6 0x7 not used */

+	  case 0x6:

+	  case 0x7:

+		break;

+	  case 0x8:				/* midi hold/decay */

+		break;

+	  case 0x9:

+		if (bpmtempos) {

+			if (!dat)

+				dat = of.initspeed;

+			UniEffect(UNI_S3MEFFECTA, dat);

+		} else {

+			if (dat <= 0x20) {

+				if (!dat)

+					dat = of.initspeed;

+				else

+					dat /= 4;

+				UniPTEffect(0xf, dat);

+			} else

+				UniEffect(UNI_MEDSPEED, ((UWORD)dat * 125) / (33 * 4));

+		}

+		break;

+		/* 0xa 0xb PT effects */

+	  case 0xc:

+		if (decimalvolumes)

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

+		UniPTEffect(0xc, dat);

+		break;

+	  case 0xd:				/* same as PT volslide */

+		UniPTEffect(0xa, dat);

+		break;

+	  case 0xe:				/* synth jmp - midi */

+		break;

+	  case 0xf:

+		switch (dat) {

+		  case 0:				/* patternbreak */

+			UniPTEffect(0xd, 0);

+			break;

+		  case 0xf1:			/* play note twice */

+			UniWriteByte(UNI_MEDEFFECTF1);

+			break;

+		  case 0xf2:			/* delay note */

+			UniWriteByte(UNI_MEDEFFECTF2);

+			break;

+		  case 0xf3:			/* play note three times */

+			UniWriteByte(UNI_MEDEFFECTF3);

+			break;

+		  case 0xfe:			/* stop playing */

+			UniPTEffect(0xb, of.numpat);

+			break;

+		  case 0xff:			/* note cut */

+			UniPTEffect(0xc, 0);

+			break;

+		  default:

+			if (dat <= 10)

+				UniPTEffect(0xf, dat);

+			else if (dat <= 240) {

+				if (bpmtempos)

+					UniPTEffect(0xf, (dat < 32) ? 32 : dat);

+				else

+					UniEffect(UNI_MEDSPEED, ((UWORD)dat * 125) / 33);

+			}

+		}

+		break;

+	  default:					/* all normal PT effects are handled here */

+		UniPTEffect(eff, dat);

+		break;

+	}

+}

+

+static UBYTE *MED_Convert1(int count, int col)

+{

+	int t;

+	UBYTE inst, note, eff, dat;

+	MMD1NOTE *n;

+

+	UniReset();

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

+		n = &d1note(t, col);

+

+		note = n->a & 0x7f;

+		inst = n->b & 0x3f;

+		eff = n->c & 0xf;

+		dat = n->d;

+

+		if (inst)

+			UniInstrument(inst - 1);

+		if (note)

+			UniNote(note + 3 * OCTAVE - 1);

+		EffectCvt(eff, dat);

+		UniNewline();

+	}

+	return UniDup();

+}

+

+static UBYTE *MED_Convert0(int count, int col)

+{

+	int t;

+	UBYTE a, b, inst, note, eff, dat;

+	MMD0NOTE *n;

+

+	UniReset();

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

+		n = &d0note(t, col);

+		a = n->a;

+		b = n->b;

+

+		note = a & 0x3f;

+		a >>= 6;

+		a = ((a & 1) << 1) | (a >> 1);

+		inst = (b >> 4) | (a << 4);

+		eff = b & 0xf;

+		dat = n->c;

+

+		if (inst)

+			UniInstrument(inst - 1);

+		if (note)

+			UniNote(note + 3 * OCTAVE - 1);

+		EffectCvt(eff, dat);

+		UniNewline();

+	}

+	return UniDup();

+}

+

+static BOOL LoadMEDPatterns(void)

+{

+	int t, row, col;

+	UWORD numtracks, numlines, maxlines = 0, track = 0;

+	MMD0NOTE *mmdp;

+

+	/* first, scan patterns to see how many channels are used */

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

+		_mm_fseek(modreader, ba[t], SEEK_SET);

+		numtracks = _mm_read_UBYTE(modreader);

+		numlines = _mm_read_UBYTE(modreader);

+

+		if (numtracks > of.numchn)

+			of.numchn = numtracks;

+		if (numlines > maxlines)

+			maxlines = numlines;

+	}

+

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

+	if (!AllocTracks())

+		return 0;

+	if (!AllocPatterns())

+		return 0;

+

+	if (!

+		(mmd0pat =

+		 (MMD0NOTE *)_mm_calloc(of.numchn * (maxlines + 1),

+								sizeof(MMD0NOTE)))) return 0;

+

+	/* second read: read and convert patterns */

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

+		_mm_fseek(modreader, ba[t], SEEK_SET);

+		numtracks = _mm_read_UBYTE(modreader);

+		numlines = _mm_read_UBYTE(modreader);

+

+		of.pattrows[t] = ++numlines;

+		memset(mmdp = mmd0pat, 0, of.numchn * maxlines * sizeof(MMD0NOTE));

+		for (row = numlines; row; row--) {

+			for (col = numtracks; col; col--, mmdp++) {

+				mmdp->a = _mm_read_UBYTE(modreader);

+				mmdp->b = _mm_read_UBYTE(modreader);

+				mmdp->c = _mm_read_UBYTE(modreader);

+			}

+		}

+

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

+			of.tracks[track++] = MED_Convert0(numlines, col);

+	}

+	return 1;

+}

+

+static BOOL LoadMMD1Patterns(void)

+{

+	int t, row, col;

+	UWORD numtracks, numlines, maxlines = 0, track = 0;

+	MMD1NOTE *mmdp;

+

+	/* first, scan patterns to see how many channels are used */

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

+		_mm_fseek(modreader, ba[t], SEEK_SET);

+		numtracks = _mm_read_M_UWORD(modreader);

+		numlines = _mm_read_M_UWORD(modreader);

+		if (numtracks > of.numchn)

+			of.numchn = numtracks;

+		if (numlines > maxlines)

+			maxlines = numlines;

+	}

+

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

+	if (!AllocTracks())

+		return 0;

+	if (!AllocPatterns())

+		return 0;

+

+	if (!

+		(mmd1pat =

+		 (MMD1NOTE *)_mm_calloc(of.numchn * (maxlines + 1),

+								sizeof(MMD1NOTE)))) return 0;

+

+	/* second read: really read and convert patterns */

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

+		_mm_fseek(modreader, ba[t], SEEK_SET);

+		numtracks = _mm_read_M_UWORD(modreader);

+		numlines = _mm_read_M_UWORD(modreader);

+

+		_mm_fseek(modreader, sizeof(ULONG), SEEK_CUR);

+		of.pattrows[t] = ++numlines;

+		memset(mmdp = mmd1pat, 0, of.numchn * maxlines * sizeof(MMD1NOTE));

+

+		for (row = numlines; row; row--) {

+			for (col = numtracks; col; col--, mmdp++) {

+				mmdp->a = _mm_read_UBYTE(modreader);

+				mmdp->b = _mm_read_UBYTE(modreader);

+				mmdp->c = _mm_read_UBYTE(modreader);

+				mmdp->d = _mm_read_UBYTE(modreader);

+			}

+		}

+

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

+			of.tracks[track++] = MED_Convert1(numlines, col);

+	}

+	return 1;

+}

+

+BOOL MED_Load(BOOL curious)

+{

+	int t;

+	ULONG sa[64];

+	MEDINSTHEADER s;

+	SAMPLE *q;

+	MEDSAMPLE *mss;

+

+	/* try to read module header */

+	mh->id = _mm_read_M_ULONG(modreader);

+	mh->modlen = _mm_read_M_ULONG(modreader);

+	mh->MEDSONGP = _mm_read_M_ULONG(modreader);

+	mh->psecnum = _mm_read_M_UWORD(modreader);

+	mh->pseq = _mm_read_M_UWORD(modreader);

+	mh->MEDBlockPP = _mm_read_M_ULONG(modreader);

+	mh->reserved1 = _mm_read_M_ULONG(modreader);

+	mh->MEDINSTHEADERPP = _mm_read_M_ULONG(modreader);

+	mh->reserved2 = _mm_read_M_ULONG(modreader);

+	mh->MEDEXPP = _mm_read_M_ULONG(modreader);

+	mh->reserved3 = _mm_read_M_ULONG(modreader);

+	mh->pstate = _mm_read_M_UWORD(modreader);

+	mh->pblock = _mm_read_M_UWORD(modreader);

+	mh->pline = _mm_read_M_UWORD(modreader);

+	mh->pseqnum = _mm_read_M_UWORD(modreader);

+	mh->actplayline = _mm_read_M_SWORD(modreader);

+	mh->counter = _mm_read_UBYTE(modreader);

+	mh->extra_songs = _mm_read_UBYTE(modreader);

+

+	/* Seek to MEDSONG struct */

+	_mm_fseek(modreader, mh->MEDSONGP, SEEK_SET);

+

+	/* Load the MED Song Header */

+	mss = ms->sample;			/* load the sample data first */

+	for (t = 63; t; t--, mss++) {

+		mss->rep = _mm_read_M_UWORD(modreader);

+		mss->replen = _mm_read_M_UWORD(modreader);

+		mss->midich = _mm_read_UBYTE(modreader);

+		mss->midipreset = _mm_read_UBYTE(modreader);

+		mss->svol = _mm_read_UBYTE(modreader);

+		mss->strans = _mm_read_SBYTE(modreader);

+	}

+

+	ms->numblocks = _mm_read_M_UWORD(modreader);

+	ms->songlen = _mm_read_M_UWORD(modreader);

+	_mm_read_UBYTES(ms->playseq, 256, modreader);

+	ms->deftempo = _mm_read_M_UWORD(modreader);

+	ms->playtransp = _mm_read_SBYTE(modreader);

+	ms->flags = _mm_read_UBYTE(modreader);

+	ms->flags2 = _mm_read_UBYTE(modreader);

+	ms->tempo2 = _mm_read_UBYTE(modreader);

+	_mm_read_UBYTES(ms->trkvol, 16, modreader);

+	ms->mastervol = _mm_read_UBYTE(modreader);

+	ms->numsamples = _mm_read_UBYTE(modreader);

+

+	/* check for a bad header */

+	if (_mm_eof(modreader)) {

+		_mm_errno = MMERR_LOADING_HEADER;

+		return 0;

+	}

+

+	/* load extension structure */

+	if (mh->MEDEXPP) {

+		_mm_fseek(modreader, mh->MEDEXPP, SEEK_SET);

+		me->nextmod = _mm_read_M_ULONG(modreader);

+		me->exp_smp = _mm_read_M_ULONG(modreader);

+		me->s_ext_entries = _mm_read_M_UWORD(modreader);

+		me->s_ext_entrsz = _mm_read_M_UWORD(modreader);

+		me->annotxt = _mm_read_M_ULONG(modreader);

+		me->annolen = _mm_read_M_ULONG(modreader);

+		me->iinfo = _mm_read_M_ULONG(modreader);

+		me->i_ext_entries = _mm_read_M_UWORD(modreader);

+		me->i_ext_entrsz = _mm_read_M_UWORD(modreader);

+		me->jumpmask = _mm_read_M_ULONG(modreader);

+		me->rgbtable = _mm_read_M_ULONG(modreader);

+		me->channelsplit = _mm_read_M_ULONG(modreader);

+		me->n_info = _mm_read_M_ULONG(modreader);

+		me->songname = _mm_read_M_ULONG(modreader);

+		me->songnamelen = _mm_read_M_ULONG(modreader);

+		me->dumps = _mm_read_M_ULONG(modreader);

+	}

+

+	/* seek to and read the samplepointer array */

+	_mm_fseek(modreader, mh->MEDINSTHEADERPP, SEEK_SET);

+	if (!_mm_read_M_ULONGS(sa, ms->numsamples, modreader)) {

+		_mm_errno = MMERR_LOADING_HEADER;

+		return 0;

+	}

+

+	/* alloc and read the blockpointer array */

+	if (!(ba = (ULONG *)_mm_calloc(ms->numblocks, sizeof(ULONG))))

+		return 0;

+	_mm_fseek(modreader, mh->MEDBlockPP, SEEK_SET);

+	if (!_mm_read_M_ULONGS(ba, ms->numblocks, modreader)) {

+		_mm_errno = MMERR_LOADING_HEADER;

+		return 0;

+	}

+

+	/* copy song positions */

+	if (!AllocPositions(ms->songlen))

+		return 0;

+	for (t = 0; t < ms->songlen; t++)

+		of.positions[t] = ms->playseq[t];

+

+	decimalvolumes = (ms->flags & 0x10) ? 0 : 1;

+	bpmtempos = (ms->flags2 & 0x20) ? 1 : 0;

+

+	if (bpmtempos) {

+		int bpmlen = (ms->flags2 & 0x1f) + 1;

+		of.initspeed = ms->tempo2;

+		of.inittempo = ms->deftempo * bpmlen / 4;

+

+		if (bpmlen != 4) {

+			/* Let's do some math : compute GCD of BPM beat length and speed */

+			int a, b;

+

+			a = bpmlen;

+			b = ms->tempo2;

+

+			if (a > b) {

+				t = b;

+				b = a;

+				a = t;

+			}

+			while ((a != b) && (a)) {

+				t = a;

+				a = b - a;

+				b = t;

+				if (a > b) {

+					t = b;

+					b = a;

+					a = t;

+				}

+			}

+

+			of.initspeed /= b;

+			of.inittempo = ms->deftempo * bpmlen / (4 * b);

+		}

+	} else {

+		of.initspeed = ms->tempo2;

+		of.inittempo = ms->deftempo ? ((UWORD)ms->deftempo * 125) / 33 : 128;

+		if ((ms->deftempo <= 10) && (ms->deftempo))

+			of.inittempo = (of.inittempo * 33) / 6;

+		of.flags |= UF_HIGHBPM;

+	}

+	MED_Version[12] = mh->id;

+	of.modtype = strdup(MED_Version);

+	of.numchn = 0;				/* will be counted later */

+	of.numpat = ms->numblocks;

+	of.numpos = ms->songlen;

+	of.numins = ms->numsamples;

+	of.numsmp = of.numins;

+	of.reppos = 0;

+	if ((mh->MEDEXPP) && (me->songname) && (me->songnamelen)) {

+		char *name;

+

+		_mm_fseek(modreader, me->songname, SEEK_SET);

+		name = _mm_malloc(me->songnamelen);

+		_mm_read_UBYTES(name, me->songnamelen, modreader);

+		of.songname = DupStr(name, me->songnamelen, 1);

+		free(name);

+	} else

+		of.songname = DupStr(NULL, 0, 0);

+	if ((mh->MEDEXPP) && (me->annotxt) && (me->annolen)) {

+		_mm_fseek(modreader, me->annotxt, SEEK_SET);

+		ReadComment(me->annolen);

+	}

+

+	if (!AllocSamples())

+		return 0;

+	q = of.samples;

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

+		q->flags = SF_SIGNED;

+		q->volume = 64;

+		if (sa[t]) {

+			_mm_fseek(modreader, sa[t], SEEK_SET);

+			s.length = _mm_read_M_ULONG(modreader);

+			s.type = _mm_read_M_SWORD(modreader);

+

+			if (s.type) {

+#ifdef MIKMOD_DEBUG

+				fprintf(stderr, "\rNon-sample instruments not supported in MED loader yet\n");

+#endif

+				if (!curious) {

+					_mm_errno = MMERR_MED_SYNTHSAMPLES;

+					return 0;

+				}

+				s.length = 0;

+			}

+

+			if (_mm_eof(modreader)) {

+				_mm_errno = MMERR_LOADING_SAMPLEINFO;

+				return 0;

+			}

+

+			q->length = s.length;

+			q->seekpos = _mm_ftell(modreader);

+			q->loopstart = ms->sample[t].rep << 1;

+			q->loopend = q->loopstart + (ms->sample[t].replen << 1);

+

+			if (ms->sample[t].replen > 1)

+				q->flags |= SF_LOOP;

+

+			/* don't load sample if length>='MMD0'...

+			   such kluges make libmikmod's code unique !!! */

+			if (q->length >= MMD0_string)

+				q->length = 0;

+		} else

+			q->length = 0;

+

+		if ((mh->MEDEXPP) && (me->exp_smp) &&

+			(t < me->s_ext_entries) && (me->s_ext_entrsz >= 4)) {

+			MEDINSTEXT ie;

+

+			_mm_fseek(modreader, me->exp_smp + t * me->s_ext_entrsz,

+					  SEEK_SET);

+			ie.hold = _mm_read_UBYTE(modreader);

+			ie.decay = _mm_read_UBYTE(modreader);

+			ie.suppress_midi_off = _mm_read_UBYTE(modreader);

+			ie.finetune = _mm_read_SBYTE(modreader);

+

+			q->speed = finetune[ie.finetune & 0xf];

+		} else

+			q->speed = 8363;

+

+		if ((mh->MEDEXPP) && (me->iinfo) &&

+			(t < me->i_ext_entries) && (me->i_ext_entrsz >= 40)) {

+			MEDINSTINFO ii;

+

+			_mm_fseek(modreader, me->iinfo + t * me->i_ext_entrsz, SEEK_SET);

+			_mm_read_UBYTES(ii.name, 40, modreader);

+			q->samplename = DupStr((char*)ii.name, 40, 1);

+		} else

+			q->samplename = NULL;

+

+		q++;

+	}

+

+	if (mh->id == MMD0_string) {

+		if (!LoadMEDPatterns()) {

+			_mm_errno = MMERR_LOADING_PATTERN;

+			return 0;

+		}

+	} else if (mh->id == MMD1_string) {

+		if (!LoadMMD1Patterns()) {

+			_mm_errno = MMERR_LOADING_PATTERN;

+			return 0;

+		}

+	} else {

+		_mm_errno = MMERR_NOT_A_MODULE;

+		return 0;

+	}

+	return 1;

+}

+

+CHAR *MED_LoadTitle(void)

+{

+	ULONG posit, namelen;

+	CHAR *name, *retvalue = NULL;

+	

+	_mm_fseek(modreader, 0x20, SEEK_SET);

+	posit = _mm_read_M_ULONG(modreader);

+	

+	if (posit) {

+		_mm_fseek(modreader, posit + 0x2C, SEEK_SET);

+		posit = _mm_read_M_ULONG(modreader);

+		namelen = _mm_read_M_ULONG(modreader);

+

+		_mm_fseek(modreader, posit, SEEK_SET);

+		name = _mm_malloc(namelen);

+		_mm_read_UBYTES(name, namelen, modreader);

+		retvalue = DupStr(name, namelen, 1);

+		free(name);

+	}

+

+	return retvalue;

+}

+

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

+

+MIKMODAPI MLOADER load_med = {

+	NULL,

+	"MED",

+	"MED (OctaMED)",

+	MED_Init,

+	MED_Test,

+	MED_Load,

+	MED_Cleanup,

+	MED_LoadTitle

+};

+

+/* ex:set ts=4: */

diff --git a/apps/plugins/mikmod/loaders/load_mod.c b/apps/plugins/mikmod/loaders/load_mod.c
new file mode 100644
index 0000000..5166234
--- /dev/null
+++ b/apps/plugins/mikmod/loaders/load_mod.c
@@ -0,0 +1,512 @@
+/*	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_mod.c,v 1.2 2004/01/21 13:33:11 raph Exp $

+

+  Generic MOD loader (Protracker, StarTracker, FastTracker, etc)

+

+==============================================================================*/

+

+#ifdef HAVE_CONFIG_H

+#include "config.h"

+#endif

+

+#ifdef HAVE_UNISTD_H

+#include <unistd.h>

+#endif

+

+//#include <ctype.h>

+#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 */

+

+typedef struct MSAMPINFO {

+	CHAR samplename[23];		/* 22 in module, 23 in memory */

+	UWORD length;

+	UBYTE finetune;

+	UBYTE volume;

+	UWORD reppos;

+	UWORD replen;

+} MSAMPINFO;

+

+typedef struct MODULEHEADER {

+	CHAR songname[21];			/* the songname.. 20 in module, 21 in memory */

+	MSAMPINFO samples[31];		/* all sampleinfo */

+	UBYTE songlength;			/* number of patterns used */

+	UBYTE magic1;				/* should be 127 */

+	UBYTE positions[128];		/* which pattern to play at pos */

+	UBYTE magic2[4];			/* string "M.K." or "FLT4" or "FLT8" */

+} MODULEHEADER;

+

+typedef struct MODTYPE {

+	CHAR id[5];

+	UBYTE channels;

+	CHAR *name;

+} MODTYPE;

+

+typedef struct MODNOTE {

+	UBYTE a, b, c, d;

+} MODNOTE;

+

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

+

+#define MODULEHEADERSIZE 0x438

+

+static CHAR protracker[] = "Protracker";

+static CHAR startrekker[] = "Startrekker";

+static CHAR fasttracker[] = "Fasttracker";

+static CHAR oktalyser[] = "Oktalyser";

+static CHAR oktalyzer[] = "Oktalyzer";

+static CHAR taketracker[] = "TakeTracker";

+static CHAR orpheus[] = "Imago Orpheus (MOD format)";

+

+static MODULEHEADER *mh = NULL;

+static MODNOTE *patbuf = NULL;

+static int modtype, trekker;

+

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

+

+/* given the module ID, determine the number of channels and the tracker

+   description ; also alters modtype */

+static BOOL MOD_CheckType(UBYTE *id, UBYTE *numchn, CHAR **descr)

+{

+	modtype = trekker = 0;

+

+	/* Protracker and variants */

+	if ((!memcmp(id, "M.K.", 4)) || (!memcmp(id, "M!K!", 4))) {

+		*descr = protracker;

+		modtype = 0;

+		*numchn = 4;

+		return 1;

+	}

+	

+	/* Star Tracker */

+	if (((!memcmp(id, "FLT", 3)) || (!memcmp(id, "EXO", 3))) &&

+		(isdigit(id[3]))) {

+		*descr = startrekker;

+		modtype = trekker = 1;

+		*numchn = id[3] - '0';

+		if (*numchn == 4 || *numchn == 8)

+			return 1;

+#ifdef MIKMOD_DEBUG

+		else

+			fprintf(stderr, "\rUnknown FLT%d module type\n", *numchn);

+#endif

+		return 0;

+	}

+

+	/* Oktalyzer (Amiga) */

+	if (!memcmp(id, "OKTA", 4)) {

+		*descr = oktalyzer;

+		modtype = 1;

+		*numchn = 8;

+		return 1;

+	}

+

+	/* Oktalyser (Atari) */

+	if (!memcmp(id, "CD81", 4)) {

+		*descr = oktalyser;

+		modtype = 1;

+		*numchn = 8;

+		return 1;

+	}

+

+	/* Fasttracker */

+	if ((!memcmp(id + 1, "CHN", 3)) && (isdigit(id[0]))) {

+		*descr = fasttracker;

+		modtype = 1;

+		*numchn = id[0] - '0';

+		return 1;

+	}

+	/* Fasttracker or Taketracker */

+	if (((!memcmp(id + 2, "CH", 2)) || (!memcmp(id + 2, "CN", 2)))

+		&& (isdigit(id[0])) && (isdigit(id[1]))) {

+		if (id[3] == 'H') {

+			*descr = fasttracker;

+			modtype = 2;		/* this can also be Imago Orpheus */

+		} else {

+			*descr = taketracker;

+			modtype = 1;

+		}

+		*numchn = (id[0] - '0') * 10 + (id[1] - '0');

+		return 1;

+	}

+

+	return 0;

+}

+

+static BOOL MOD_Test(void)

+{

+	UBYTE id[4], numchn;

+	CHAR *descr;

+

+	_mm_fseek(modreader, MODULEHEADERSIZE, SEEK_SET);

+	if (!_mm_read_UBYTES(id, 4, modreader))

+		return 0;

+

+	if (MOD_CheckType(id, &numchn, &descr))

+		return 1;

+

+	return 0;

+}

+

+static BOOL MOD_Init(void)

+{

+	if (!(mh = (MODULEHEADER *)_mm_malloc(sizeof(MODULEHEADER))))

+		return 0;

+	return 1;

+}

+

+static void MOD_Cleanup(void)

+{

+	_mm_free(mh);

+	_mm_free(patbuf);

+}

+

+/*

+Old (amiga) noteinfo:

+

+_____byte 1_____   byte2_    _____byte 3_____   byte4_

+/                \ /      \  /                \ /      \

+0000          0000-00000000  0000          0000-00000000

+

+Upper four    12 bits for    Lower four    Effect command.

+bits of sam-  note period.   bits of sam-

+ple number.                  ple number.

+

+*/

+

+static UBYTE ConvertNote(MODNOTE *n, UBYTE lasteffect)

+{

+	UBYTE instrument, effect, effdat, note;

+	UWORD period;

+	UBYTE lastnote = 0;

+

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

+	instrument = (n->a & 0x10) | (n->c >> 4);

+	period = (((UWORD)n->a & 0xf) << 8) + n->b;

+	effect = n->c & 0xf;

+	effdat = n->d;

+

+	/* Convert the period to a note number */

+	note = 0;

+	if (period) {

+		for (note = 0; note < 7 * OCTAVE; note++)

+			if (period >= npertab[note])

+				break;

+		if (note == 7 * OCTAVE)

+			note = 0;

+		else

+			note++;

+	}

+

+	if (instrument) {

+		/* if instrument does not exist, note cut */

+		if ((instrument > 31) || (!mh->samples[instrument - 1].length)) {

+			UniPTEffect(0xc, 0);

+			if (effect == 0xc)

+				effect = effdat = 0;

+		} else {

+			/* Protracker handling */

+			if (!modtype) {

+				/* if we had a note, then change instrument... */

+				if (note)

+					UniInstrument(instrument - 1);

+				/* ...otherwise, only adjust volume... */

+				else {

+					/* ...unless an effect was specified, which forces a new

+					   note to be played */

+					if (effect || effdat) {

+						UniInstrument(instrument - 1);

+						note = lastnote;

+					} else

+						UniPTEffect(0xc,

+									mh->samples[instrument -

+												1].volume & 0x7f);

+				}

+			} else {

+				/* Fasttracker handling */

+				UniInstrument(instrument - 1);

+				if (!note)

+					note = lastnote;

+			}

+		}

+	}

+	if (note) {

+		UniNote(note + 2 * OCTAVE - 1);

+		lastnote = note;

+	}

+

+	/* Convert pattern jump from Dec to Hex */

+	if (effect == 0xd)

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

+

+	/* Volume slide, up has priority */

+	if ((effect == 0xa) && (effdat & 0xf) && (effdat & 0xf0))

+		effdat &= 0xf0;

+

+	/* Handle ``heavy'' volumes correctly */

+	if ((effect == 0xc) && (effdat > 0x40))

+		effdat = 0x40;

+	

+	/* An isolated 100, 200 or 300 effect should be ignored (no

+	   "standalone" porta memory in mod files). However, a sequence such

+	   as 1XX, 100, 100, 100 is fine. */

+	if ((!effdat) && ((effect == 1)||(effect == 2)||(effect ==3)) &&

+		(lasteffect < 0x10) && (effect != lasteffect))

+		effect = 0;

+

+	UniPTEffect(effect, effdat);

+	if (effect == 8)

+		of.flags |= UF_PANNING;

+	

+	return effect;

+}

+

+static UBYTE *ConvertTrack(MODNOTE *n, int numchn)

+{

+	int t;

+	UBYTE lasteffect = 0x10;	/* non existant effect */

+

+	UniReset();

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

+		lasteffect = ConvertNote(n,lasteffect);

+		UniNewline();

+		n += numchn;

+	}

+	return UniDup();

+}

+

+/* Loads all patterns of a modfile and converts them into the 3 byte format. */

+static BOOL ML_LoadPatterns(void)

+{

+	int t, s, tracks = 0;

+

+	if (!AllocPatterns())

+		return 0;

+	if (!AllocTracks())

+		return 0;

+	

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

+	if (!(patbuf = (MODNOTE *)_mm_calloc(64U * of.numchn, sizeof(MODNOTE))))

+		return 0;

+

+	if (trekker && of.numchn == 8) {

+		/* Startrekker module dual pattern */

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

+			for (s = 0; s < (64U * 4); s++) {

+				patbuf[s].a = _mm_read_UBYTE(modreader);

+				patbuf[s].b = _mm_read_UBYTE(modreader);

+				patbuf[s].c = _mm_read_UBYTE(modreader);

+				patbuf[s].d = _mm_read_UBYTE(modreader);

+			}

+			for (s = 0; s < 4; s++)

+				if (!(of.tracks[tracks++] = ConvertTrack(patbuf + s, 4)))

+					return 0;

+			for (s = 0; s < (64U * 4); s++) {

+				patbuf[s].a = _mm_read_UBYTE(modreader);

+				patbuf[s].b = _mm_read_UBYTE(modreader);

+				patbuf[s].c = _mm_read_UBYTE(modreader);

+				patbuf[s].d = _mm_read_UBYTE(modreader);

+			}

+			for (s = 0; s < 4; s++)

+				if (!(of.tracks[tracks++] = ConvertTrack(patbuf + s, 4)))

+					return 0;

+		}

+	} else {

+		/* Generic module pattern */

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

+			/* Load the pattern into the temp buffer and convert it */

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

+				patbuf[s].a = _mm_read_UBYTE(modreader);

+				patbuf[s].b = _mm_read_UBYTE(modreader);

+				patbuf[s].c = _mm_read_UBYTE(modreader);

+				patbuf[s].d = _mm_read_UBYTE(modreader);

+			}

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

+				if (!(of.tracks[tracks++] = ConvertTrack(patbuf + s, of.numchn)))

+					return 0;

+		}

+	}

+	return 1;

+}

+

+static BOOL MOD_Load(BOOL curious)

+{

+	int t, scan;

+	SAMPLE *q;

+	MSAMPINFO *s;

+	CHAR *descr;

+

+	/* try to read module header */

+	_mm_read_string((CHAR *)mh->songname, 20, modreader);

+	mh->songname[20] = 0;		/* just in case */

+

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

+		s = &mh->samples[t];

+		_mm_read_string(s->samplename, 22, modreader);

+		s->samplename[22] = 0;	/* just in case */

+		s->length = _mm_read_M_UWORD(modreader);

+		s->finetune = _mm_read_UBYTE(modreader);

+		s->volume = _mm_read_UBYTE(modreader);

+		s->reppos = _mm_read_M_UWORD(modreader);

+		s->replen = _mm_read_M_UWORD(modreader);

+	}

+

+	mh->songlength = _mm_read_UBYTE(modreader);

+

+	/* this fixes mods which declare more than 128 positions. 

+	 * eg: beatwave.mod */

+	if (mh->songlength > 128) { mh->songlength = 128; }

+	

+	mh->magic1 = _mm_read_UBYTE(modreader);

+	_mm_read_UBYTES(mh->positions, 128, modreader);

+	_mm_read_UBYTES(mh->magic2, 4, modreader);

+

+	if (_mm_eof(modreader)) {

+		_mm_errno = MMERR_LOADING_HEADER;

+		return 0;

+	}

+

+	/* set module variables */

+	of.initspeed = 6;

+	of.inittempo = 125;

+	if (!(MOD_CheckType(mh->magic2, &of.numchn, &descr))) {

+		_mm_errno = MMERR_NOT_A_MODULE;

+		return 0;

+	}

+	if (trekker && of.numchn == 8)

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

+			/* if module pretends to be FLT8, yet the order table

+			   contains odd numbers, chances are it's a lying FLT4... */

+			if (mh->positions[t] & 1) {

+				of.numchn = 4;

+				break;

+			}

+	if (trekker && of.numchn == 8)

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

+			mh->positions[t] >>= 1;

+

+	of.songname = DupStr(mh->songname, 21, 1);

+	of.numpos = mh->songlength;

+	of.reppos = 0;

+

+	/* Count the number of patterns */

+	of.numpat = 0;

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

+		if (mh->positions[t] > of.numpat)

+			of.numpat = mh->positions[t];

+

+	/* since some old modules embed extra patterns, we have to check the

+	   whole list to get the samples' file offsets right - however we can find

+	   garbage here, so check carefully */

+	scan = 1;

+	for (t = of.numpos; t < 128; t++)

+		if (mh->positions[t] >= 0x80)

+			scan = 0;

+	if (scan)

+		for (t = of.numpos; t < 128; t++) {

+			if (mh->positions[t] > of.numpat)

+				of.numpat = mh->positions[t];

+			if ((curious) && (mh->positions[t]))

+				of.numpos = t + 1;

+		}

+	of.numpat++;

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

+

+	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 = of.numsmp = 31;

+	if (!AllocSamples())

+		return 0;

+	s = mh->samples;

+	q = of.samples;

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

+		/* convert the samplename */

+		q->samplename = DupStr(s->samplename, 23, 1);

+		/* init the sampleinfo variables and convert the size pointers */

+		q->speed = finetune[s->finetune & 0xf];

+		q->volume = s->volume & 0x7f;

+		q->loopstart = (ULONG)s->reppos << 1;

+		q->loopend = q->loopstart + ((ULONG)s->replen << 1);

+		q->length = (ULONG)s->length << 1;

+		q->flags = SF_SIGNED;

+		/* Imago Orpheus creates MODs with 16 bit samples, check */

+		if ((modtype == 2) && (s->volume & 0x80)) {

+			q->flags |= SF_16BITS;

+			descr = orpheus;

+		}

+		if (s->replen > 2)

+			q->flags |= SF_LOOP;

+

+		s++;

+		q++;

+	}

+

+	of.modtype = strdup(descr);

+

+	if (!ML_LoadPatterns())

+		return 0;

+	

+	return 1;

+}

+

+static CHAR *MOD_LoadTitle(void)

+{

+	CHAR s[21];

+

+	_mm_fseek(modreader, 0, SEEK_SET);

+	if (!_mm_read_UBYTES(s, 20, modreader))

+		return NULL;

+	s[20] = 0;					/* just in case */

+

+	return (DupStr(s, 21, 1));

+}

+

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

+

+MIKMODAPI MLOADER load_mod = {

+	NULL,

+	"Standard module",

+	"MOD (31 instruments)",

+	MOD_Init,

+	MOD_Test,

+	MOD_Load,

+	MOD_Cleanup,

+	MOD_LoadTitle

+};

+

+/* ex:set ts=4: */

diff --git a/apps/plugins/mikmod/loaders/load_mtm.c b/apps/plugins/mikmod/loaders/load_mtm.c
new file mode 100644
index 0000000..3da7b28
--- /dev/null
+++ b/apps/plugins/mikmod/loaders/load_mtm.c
@@ -0,0 +1,286 @@
+/*	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_mtm.c,v 1.1.1.1 2004/01/21 01:36:35 raph Exp $

+

+  MTM 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 */

+

+typedef struct MTMHEADER {

+	UBYTE id[3];			/* MTM file marker */

+	UBYTE version;			/* upper major, lower nibble minor version number */

+	CHAR  songname[20];		/* ASCIIZ songname */

+	UWORD numtracks;		/* number of tracks saved */

+	UBYTE lastpattern;		/* last pattern number saved */

+	UBYTE lastorder;		/* last order number to play (songlength-1) */

+	UWORD commentsize;		/* length of comment field */

+	UBYTE numsamples;		/* number of samples saved  */

+	UBYTE attribute;		/* attribute byte (unused) */

+	UBYTE beatspertrack;

+	UBYTE numchannels;		/* number of channels used  */

+	UBYTE panpos[32];		/* voice pan positions */

+} MTMHEADER;

+

+typedef struct MTMSAMPLE {

+	CHAR  samplename[22];

+	ULONG length;

+	ULONG reppos;

+	ULONG repend;

+	UBYTE finetune;

+	UBYTE volume;

+	UBYTE attribute;

+} MTMSAMPLE;

+

+typedef struct MTMNOTE {

+	UBYTE a,b,c;

+} MTMNOTE;

+

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

+

+static MTMHEADER *mh = NULL;

+static MTMNOTE *mtmtrk = NULL;

+static UWORD pat[32];

+

+static CHAR MTM_Version[] = "MTM";

+

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

+

+BOOL MTM_Test(void)

+{

+	UBYTE id[3];

+

+	if(!_mm_read_UBYTES(id,3,modreader)) return 0;

+	if(!memcmp(id,"MTM",3)) return 1;

+	return 0;

+}

+

+BOOL MTM_Init(void)

+{

+	if(!(mtmtrk=(MTMNOTE*)_mm_calloc(64,sizeof(MTMNOTE)))) return 0;

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

+

+	return 1;

+}

+

+void MTM_Cleanup(void)

+{

+	_mm_free(mtmtrk);

+	_mm_free(mh);

+}

+

+static UBYTE* MTM_Convert(void)

+{

+	int t;

+	UBYTE a,b,inst,note,eff,dat;

+

+	UniReset();

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

+		a=mtmtrk[t].a;

+		b=mtmtrk[t].b;

+		inst=((a&0x3)<<4)|(b>>4);

+		note=a>>2;

+		eff=b&0xf;

+		dat=mtmtrk[t].c;

+

+		if(inst) UniInstrument(inst-1);

+		if(note) UniNote(note+2*OCTAVE);

+

+		/* MTM bug workaround : when the effect is volslide, slide-up *always*

+		   overrides slide-down. */

+		if(eff==0xa && (dat&0xf0)) dat&=0xf0;

+

+		/* Convert pattern jump from Dec to Hex */

+		if(eff==0xd)

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

+		UniPTEffect(eff,dat);

+		UniNewline();

+	}

+	return UniDup();

+}

+

+BOOL MTM_Load(BOOL 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++;

+	}

+

+	if(!AllocPositions(of.numpos)) return 0;

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

+		of.positions[t]=_mm_read_UBYTE(modreader);

+	for(;t<128;t++) _mm_read_UBYTE(modreader);

+	if(_mm_eof(modreader)) {

+		_mm_errno = MMERR_LOADING_HEADER;

+		return 0;

+	}

+

+	if(!AllocTracks()) return 0;

+	if(!AllocPatterns()) return 0;

+

+	of.tracks[0]=MTM_Convert();		/* track 0 is empty */

+	for(t=1;t<of.numtrk;t++) {

+		int s;

+

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

+			mtmtrk[s].a=_mm_read_UBYTE(modreader);

+			mtmtrk[s].b=_mm_read_UBYTE(modreader);

+			mtmtrk[s].c=_mm_read_UBYTE(modreader);

+		}

+

+		if(_mm_eof(modreader)) {

+			_mm_errno = MMERR_LOADING_TRACK;

+			return 0;

+		}

+

+		if(!(of.tracks[t]=MTM_Convert())) return 0;

+	}

+

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

+		_mm_read_I_UWORDS(pat,32,modreader);

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

+			of.patterns[((long)t*of.numchn)+u]=pat[u];

+	}

+

+	/* read comment field */

+	if(mh->commentsize)

+		if(!ReadLinedComment(mh->commentsize, 40)) return 0;

+

+	return 1;

+}

+

+CHAR *MTM_LoadTitle(void)

+{

+	CHAR s[20];

+

+	_mm_fseek(modreader,4,SEEK_SET);

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

+

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

+}

+

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

+

+MIKMODAPI MLOADER load_mtm={

+	NULL,

+	"MTM",

+	"MTM (MultiTracker Module editor)",

+	MTM_Init,

+	MTM_Test,

+	MTM_Load,

+	MTM_Cleanup,

+	MTM_LoadTitle

+};

+

+/* ex:set ts=4: */

diff --git a/apps/plugins/mikmod/loaders/load_okt.c b/apps/plugins/mikmod/loaders/load_okt.c
new file mode 100644
index 0000000..e99837d
--- /dev/null
+++ b/apps/plugins/mikmod/loaders/load_okt.c
@@ -0,0 +1,461 @@
+/*	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_okt.c,v 1.1.1.1 2004/01/21 01:36:35 raph Exp $

+

+  Oktalyzer (OKT) module loader

+

+==============================================================================*/

+

+/*

+	Written by UFO <ufo303@poczta.onet.pl>

+	based on the file description compiled by Harald Zappe

+	                                                      <zappe@gaea.sietec.de>

+

+*/

+

+#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 blocks */

+

+/* sample information */

+typedef struct OKTSAMPLE {

+	CHAR sampname[20];

+	ULONG len;

+	UWORD loopbeg;

+	UWORD looplen;

+	UBYTE volume;

+} OKTSAMPLE;

+

+typedef struct OKTNOTE {

+	UBYTE note, ins, eff, dat;

+} OKTNOTE;

+

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

+

+static OKTNOTE *okttrk = NULL;

+

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

+

+BOOL OKT_Test(void)

+{

+	CHAR id[8];

+

+	if (!_mm_read_UBYTES(id, 8, modreader))

+		return 0;

+	if (!memcmp(id, "OKTASONG", 8))

+		return 1;

+

+	return 0;

+}

+

+/*	Pattern analysis routine.

+	Effects not implemented (yet) : (in decimal)

+	11 Arpeggio 4: Change note every 50Hz tick between N,H,N,L

+	12 Arpeggio 5: Change note every 50Hz tick between H,H,N

+                   N = normal note being played in this channel (1-36)

+                   L = normal note number minus upper four bits of 'data'.

+                   H = normal note number plus  lower four bits of 'data'.

+    13 Decrease note number by 'data' once per tick.

+    17 Increase note number by 'data' once per tick.

+    21 Decrease note number by 'data' once per line.

+    30 Increase note number by 'data' once per line.

+*/

+static UBYTE *OKT_ConvertTrack(UBYTE patrows)

+{

+	int t;

+	UBYTE ins, note, eff, dat;

+

+	UniReset();

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

+		note = okttrk[t].note;

+		ins = okttrk[t].ins;

+		eff = okttrk[t].eff;

+		dat = okttrk[t].dat;

+

+		if (note) {

+			UniNote(note + 3 * OCTAVE - 1);

+			UniInstrument(ins);

+		}

+

+		if (eff)

+			switch (eff) {

+			case 1:				/* Porta Up */

+				UniPTEffect(0x1, dat);

+				break;

+			case 2:				/* Portamento Down */

+				UniPTEffect(0x2, dat);

+				break;

+			/* case 9: what is this? */

+			case 10:			/* Arpeggio 3 */

+			case 11:			/* Arpeggio 4 */

+			case 12:			/* Arpeggio 5 */

+				UniWriteByte(UNI_OKTARP);

+				UniWriteByte(eff + 3 - 10);

+				UniWriteByte(dat);

+				break;

+			case 15:			/* Amiga filter toggle, ignored */

+				break;

+			case 25:			/* Pattern Jump */

+				dat = (dat >> 4) * 10 + (dat & 0x0f);

+				UniPTEffect(0xb, dat);

+				break;

+			case 27:			/* Release - similar to Keyoff */

+				UniWriteByte(UNI_KEYOFF);

+				break;

+			case 28:			/* Set Tempo */

+				UniPTEffect(0xf, dat & 0x0f);

+				break;

+			case 31:			/* volume Control */

+				if (dat <= 0x40)

+					UniPTEffect(0xc, dat);

+				else if (dat <= 0x50)

+					UniEffect(UNI_XMEFFECTA, (dat - 0x40));	/* fast fade out */

+				else if (dat <= 0x60)

+					UniEffect(UNI_XMEFFECTA, (dat - 0x50) << 4);	/* fast fade in */

+				else if (dat <= 0x70)

+					UniEffect(UNI_XMEFFECTEB, (dat - 0x60));	/* slow fade out */

+				else if (dat <= 0x80)

+					UniEffect(UNI_XMEFFECTEA, (dat - 0x70));	/* slow fade in */

+				break;

+#ifdef MIKMOD_DEBUG

+			default:

+				fprintf(stderr, "\rUnimplemented effect (%02d,%02x)\n",

+						eff, dat);

+#endif

+			}

+

+		UniNewline();

+	}

+	return UniDup();

+}

+

+/* Read "channel modes" i.e. channel number and panning information */

+static void OKT_doCMOD(void)

+{

+	/* amiga channel panning table */

+	UBYTE amigapan[4] = { 0x00, 0xff, 0xff, 0x00 };

+	int t;

+

+	of.numchn = 0;

+	of.flags |= UF_PANNING;

+

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

+		if (_mm_read_M_UWORD(modreader)) {

+			/* two channels tied to the same Amiga hardware voice */

+			of.panning[of.numchn++] = amigapan[t];

+			of.panning[of.numchn++] = amigapan[t];

+		} else

+			/* one channel tied to the Amiga hardware voice */

+			of.panning[of.numchn++] = amigapan[t];

+}

+

+/* 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) * 2;

+		s.looplen = _mm_read_M_UWORD(modreader) * 2;

+		_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 = 8287;

+	}

+	return 1;

+}

+

+/* Read speed information */

+static void OKT_doSPEE(void)

+{

+	int tempo = _mm_read_M_UWORD(modreader);

+

+	of.initspeed = tempo;

+}

+

+/* Read song length information */

+static void OKT_doSLEN(void)

+{

+	of.numpat = _mm_read_M_UWORD(modreader);

+}

+

+/* Read pattern length information */

+static void OKT_doPLEN(void)

+{

+	of.numpos = _mm_read_M_UWORD(modreader);

+}

+

+/* Read order table */

+static BOOL OKT_doPATT(void)

+{

+	int t;

+

+	if (!of.numpos || !AllocPositions(of.numpos))

+		return 0;

+

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

+		if (t < of.numpos)

+			of.positions[t] = _mm_read_UBYTE(modreader);

+		else

+			break;

+

+	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 void OKT_doSBOD(int insnum)

+{

+	of.samples[insnum].seekpos = _mm_ftell(modreader);

+}

+

+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;

+	(void)curious;

+

+	/* 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();  // gcc for ipod stucks here, saying it is a call to memcpy...

+				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;

+}

+

+CHAR *OKT_LoadTitle(void)

+{

+	return strdup("");

+}

+

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

+

+MIKMODAPI MLOADER load_okt = {

+	NULL,

+	"OKT",

+	"OKT (Amiga Oktalyzer)",

+	NULL,

+	OKT_Test,

+	OKT_Load,

+	NULL,

+	OKT_LoadTitle

+};

+

+/* ex:set ts=4: */

diff --git a/apps/plugins/mikmod/loaders/load_s3m.c b/apps/plugins/mikmod/loaders/load_s3m.c
new file mode 100644
index 0000000..11f691b
--- /dev/null
+++ b/apps/plugins/mikmod/loaders/load_s3m.c
@@ -0,0 +1,470 @@
+/*	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_s3m.c,v 1.1.1.1 2004/01/21 01:36:35 raph Exp $

+

+  Screamtracker (S3M) 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 */

+

+/* header */

+typedef struct S3MHEADER {

+	CHAR  songname[28];

+	UBYTE t1a;

+	UBYTE type;

+	UBYTE unused1[2];

+	UWORD ordnum;

+	UWORD insnum;

+	UWORD patnum;

+	UWORD flags;

+	UWORD tracker;

+	UWORD fileformat;

+	CHAR  scrm[4];

+	UBYTE mastervol;

+	UBYTE initspeed;

+	UBYTE inittempo;

+	UBYTE mastermult;

+	UBYTE ultraclick;

+	UBYTE pantable;

+	UBYTE unused2[8];

+	UWORD special;

+	UBYTE channels[32];

+} S3MHEADER;

+

+/* sample information */

+typedef struct S3MSAMPLE {

+	UBYTE type;

+	CHAR  filename[12];

+	UBYTE memsegh;

+	UWORD memsegl;

+	ULONG length;

+	ULONG loopbeg;

+	ULONG loopend;

+	UBYTE volume;

+	UBYTE dsk;

+	UBYTE pack;

+	UBYTE flags;

+	ULONG c2spd;

+	UBYTE unused[12];

+	CHAR  sampname[28];

+	CHAR  scrs[4];

+} S3MSAMPLE;

+

+typedef struct S3MNOTE {

+	UBYTE note,ins,vol,cmd,inf;

+} S3MNOTE;

+

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

+

+static S3MNOTE   *s3mbuf  = NULL; /* pointer to a complete S3M pattern */

+static S3MHEADER *mh      = NULL;

+static UWORD     *paraptr = NULL; /* parapointer array (see S3M docs) */

+static unsigned int tracker;	/* tracker id */

+

+/* tracker identifiers */

+#define NUMTRACKERS 4

+static CHAR* S3M_Version[] = {

+	"Screamtracker x.xx",

+	"Imago Orpheus x.xx (S3M format)",

+	"Impulse Tracker x.xx (S3M format)",

+	"Unknown tracker x.xx (S3M format)",

+	"Impulse Tracker 2.14p3 (S3M format)",

+	"Impulse Tracker 2.14p4 (S3M format)"

+};

+/* version number position in above array */

+static int numeric[NUMTRACKERS]={14,14,16,16};

+

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

+

+BOOL S3M_Test(void)

+{

+	UBYTE id[4];

+

+	_mm_fseek(modreader,0x2c,SEEK_SET);

+	if(!_mm_read_UBYTES(id,4,modreader)) return 0;

+	if(!memcmp(id,"SCRM",4)) return 1;

+	return 0;

+}

+

+BOOL S3M_Init(void)

+{

+	if(!(s3mbuf=(S3MNOTE*)_mm_malloc(32*64*sizeof(S3MNOTE)))) return 0;

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

+	if(!(poslookup=(UBYTE*)_mm_malloc(sizeof(UBYTE)*256))) return 0;

+	memset(poslookup,-1,256);

+

+	return 1;

+}

+

+void S3M_Cleanup(void)

+{

+	_mm_free(s3mbuf);

+	_mm_free(paraptr);

+	_mm_free(poslookup);

+	_mm_free(mh);

+	_mm_free(origpositions);

+}

+

+/* 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 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;

+}

+

+static UBYTE* S3M_ConvertTrack(S3MNOTE* tr)

+{

+	int t;

+

+	UniReset();

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

+		UBYTE note,ins,vol;

+

+		note=tr[t].note;

+		ins=tr[t].ins;

+		vol=tr[t].vol;

+

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

+		if(note!=255) {

+			if(note==254) {

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

+				vol=255;

+			} else

+				UniNote(((note>>4)*OCTAVE)+(note&0xf));	/* normal note */

+		}

+		if(vol<255) UniPTEffect(0xc,vol);

+

+		S3MIT_ProcessCmd(tr[t].cmd,tr[t].inf,

+			tracker == 1 ? S3MIT_OLDSTYLE | S3MIT_SCREAM : S3MIT_OLDSTYLE);

+		UniNewline();

+	}

+	return UniDup();

+}

+

+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';

+	}

+	/* 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 | UF_PANNING;

+	if((mh->tracker==0x1300)||(mh->flags&64))

+		of.flags|=UF_S3MSLIDES;

+	of.bpmlimit    = 32;

+

+	/* 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=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);

+

+		/* ScreamTracker imposes a 64000 bytes (not 64k !) limit */

+		if (s.length > 64000)

+			s.length = 64000;

+

+		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;

+		q->loopend    = 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;

+	}

+

+	/* build the remap array  */

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

+		if(!remap[t]) 

+			remap[t]=of.numchn++;

+

+	/* set panning positions after building remap chart! */

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

+		if((mh->channels[t]<32)&&(remap[t]!=-1)) {

+			if(mh->channels[t]<8)

+				of.panning[remap[t]]=0x30;

+			else

+				of.panning[remap[t]]=0xc0;

+		}

+	if(mh->pantable==252)

+		/* set panning positions according to panning table (new for st3.2) */

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

+			if((pan[t]&0x20)&&(mh->channels[t]<32)&&(remap[t]!=-1))

+				of.panning[remap[t]]=(pan[t]&0xf)<<4;

+

+	/* 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)+2,SEEK_SET);

+		if(!S3M_ReadPattern()) return 0;

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

+			if(!(of.tracks[track++]=S3M_ConvertTrack(&s3mbuf[u*64]))) return 0;

+	}

+

+	return 1;

+}

+

+CHAR *S3M_LoadTitle(void)

+{

+	CHAR s[28];

+

+	_mm_fseek(modreader,0,SEEK_SET);

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

+

+	return(DupStr(s,28,0));

+}

+

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

+

+MIKMODAPI MLOADER load_s3m={

+	NULL,

+	"S3M",

+	"S3M (Scream Tracker 3)",

+	S3M_Init,

+	S3M_Test,

+	S3M_Load,

+	S3M_Cleanup,

+	S3M_LoadTitle

+};

+

+/* ex:set ts=4: */

diff --git a/apps/plugins/mikmod/loaders/load_stm.c b/apps/plugins/mikmod/loaders/load_stm.c
new file mode 100644
index 0000000..6a60af0
--- /dev/null
+++ b/apps/plugins/mikmod/loaders/load_stm.c
@@ -0,0 +1,375 @@
+/*	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/01/21 01:36:35 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 {

+	CHAR  filename[12];

+	UBYTE unused;       /* 0x00 */

+	UBYTE instdisk;     /* Instrument disk */

+	UWORD reserved;

+	UWORD length;       /* Sample length */

+	UWORD loopbeg;      /* Loop start point */

+	UWORD loopend;      /* Loop end point */

+	UBYTE volume;       /* Volume */

+	UBYTE reserved2;

+	UWORD c2spd;        /* Good old c2spd */

+	ULONG reserved3;

+	UWORD isa;

+} STMSAMPLE;

+

+/* header */

+typedef struct STMHEADER {

+	CHAR  songname[20];

+	CHAR  trackername[8]; /* !Scream! for ST 2.xx  */

+	UBYTE unused;         /* 0x1A  */

+	UBYTE filetype;       /* 1=song, 2=module */

+	UBYTE ver_major;

+	UBYTE ver_minor;

+	UBYTE inittempo;      /* initspeed= stm inittempo>>4  */

+	UBYTE numpat;         /* number of patterns  */

+	UBYTE globalvol;     

+	UBYTE reserved[13];

+	STMSAMPLE sample[31]; /* STM sample data */

+	UBYTE patorder[128];  /* Docs say 64 - actually 128 */

+} STMHEADER;

+

+typedef struct STMNOTE {

+	UBYTE note,insvol,volcmd,cmdinf;

+} STMNOTE;

+

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

+

+static STMNOTE *stmbuf = NULL;

+static STMHEADER *mh = NULL;

+

+/* tracker identifiers */

+static CHAR* STM_Version[STM_NTRACKERS] = {

+	"Screamtracker 2",

+	"Converted by MOD2STM (STM format)",

+	"Wuzamod (STM format)"

+};

+

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

+

+BOOL STM_Test(void)

+{

+	UBYTE str[44];

+	int t;

+

+	_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;

+}

+

+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;

+}

+

+BOOL STM_Load(BOOL curious)

+{

+	int t; 

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

+	SAMPLE *q;

+	(void)curious;

+

+	/* 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);

+

+	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   = 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];

+		t++;

+	}

+	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;

+}

+

+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: */

diff --git a/apps/plugins/mikmod/loaders/load_stx.c b/apps/plugins/mikmod/loaders/load_stx.c
new file mode 100644
index 0000000..66e67f0
--- /dev/null
+++ b/apps/plugins/mikmod/loaders/load_stx.c
@@ -0,0 +1,439 @@
+/*	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_stx.c,v 1.1.1.1 2004/01/21 01:36:35 raph Exp $

+

+  STMIK 0.2 (STX) module loader

+

+==============================================================================*/

+

+/*

+

+	Written by Claudio Matsuoka <claudio@helllabs.org>

+

+*/

+

+#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 */

+

+/* header */

+typedef struct STXHEADER {

+	CHAR  songname[20];

+	CHAR  trackername[8];

+	UWORD patsize;

+	UWORD unknown1;

+	UWORD patptr;

+	UWORD insptr;

+	UWORD chnptr;	/* not sure */

+	UWORD unknown2;

+	UWORD unknown3;

+	UBYTE mastermult;

+	UBYTE initspeed;

+	UWORD unknown4;

+	UWORD unknown5;

+	UWORD patnum;

+	UWORD insnum;

+	UWORD ordnum;

+	UWORD unknown6;

+	UWORD unknown7;

+	UWORD unknown8;

+	CHAR  scrm[4];

+} STXHEADER;

+

+/* sample information */

+typedef struct STXSAMPLE {

+	UBYTE type;

+	CHAR  filename[12];

+	UBYTE memsegh;

+	UWORD memsegl;

+	ULONG length;

+	ULONG loopbeg;

+	ULONG loopend;

+	UBYTE volume;

+	UBYTE dsk;

+	UBYTE pack;

+	UBYTE flags;

+	ULONG c2spd;

+	UBYTE unused[12];

+	CHAR  sampname[28];

+	CHAR  scrs[4];

+} STXSAMPLE;

+

+typedef struct STXNOTE {

+	UBYTE note,ins,vol,cmd,inf;

+} STXNOTE;

+

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

+

+static STXNOTE   *stxbuf  = NULL; /* pointer to a complete STX pattern */

+static STXHEADER *mh      = NULL;

+static UWORD     *paraptr = NULL; /* parapointer array (see STX docs) */

+

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

+

+static BOOL STX_Test(void)

+{

+	UBYTE id[8];

+	int t;

+

+	_mm_fseek(modreader,0x3C,SEEK_SET);

+	if(!_mm_read_UBYTES(id,4,modreader)) return 0;

+	if(memcmp(id,"SCRM",4)) return 0;

+

+	_mm_fseek(modreader,0x14,SEEK_SET);

+	if(!_mm_read_UBYTES(id,8,modreader)) return 0;

+	

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

+		if(!memcmp(id,STM_Signatures[t],8)) return 1;

+

+	return 0;

+}

+

+static BOOL STX_Init(void)

+{

+	if(!(stxbuf=(STXNOTE*)_mm_malloc(4*64*sizeof(STXNOTE)))) return 0;

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

+	if(!(poslookup=(UBYTE*)_mm_malloc(sizeof(UBYTE)*256))) return 0;

+	memset(poslookup,-1,256);

+

+	return 1;

+}

+

+static void STX_Cleanup(void)

+{

+	_mm_free(stxbuf);

+	_mm_free(paraptr);

+	_mm_free(poslookup);

+	_mm_free(mh);

+}

+

+static BOOL STX_ReadPattern(void)

+{

+	int row=0,flag,ch;

+	STXNOTE *n,dummy;

+

+	/* clear pattern data */

+	memset(stxbuf,255,4*64*sizeof(STXNOTE));

+

+	while(row<64) {

+		flag=_mm_read_UBYTE(modreader);

+

+		if(_mm_eof(modreader)) {

+			_mm_errno = MMERR_LOADING_PATTERN;

+			return 0;

+		}

+

+		if(flag) {

+			ch=flag&31;

+

+			if((ch>=0)&&(ch<4))

+				n=&stxbuf[(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;

+}

+

+static UBYTE* STX_ConvertTrack(STXNOTE* tr)

+{

+	int t;

+

+	UniReset();

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

+		UBYTE note,ins,vol,cmd,inf;

+

+		note=tr[t].note;

+		ins=tr[t].ins;

+		vol=tr[t].vol;

+		cmd=tr[t].cmd;

+		inf=tr[t].inf;

+

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

+		if((note)&&(note!=255)) {

+			if(note==254) {

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

+				vol=255;

+			} else UniNote(24+((note>>4)*OCTAVE)+(note&0xf)); /* normal note */

+		}

+

+		if(vol<255) 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;

+		}

+		UniNewline();

+	}

+	return UniDup();

+}

+

+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*)_mm_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 = strdup("STMIK 0.2 (STM2STX 1.0)");

+	} else {

+		version    = 0x11;

+		of.modtype = 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;

+}

+

+static CHAR *STX_LoadTitle(void)

+{

+	CHAR s[28];

+

+	_mm_fseek(modreader,0,SEEK_SET);

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

+

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

+}

+

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

+

+MIKMODAPI MLOADER load_stx={

+	NULL,

+	"STX",

+	"STX (Scream Tracker Music Interface Kit)",

+	STX_Init,

+	STX_Test,

+	STX_Load,

+	STX_Cleanup,

+	STX_LoadTitle

+};

+

+/* ex:set ts=4: */

diff --git a/apps/plugins/mikmod/loaders/load_ult.c b/apps/plugins/mikmod/loaders/load_ult.c
new file mode 100644
index 0000000..5d8c76d
--- /dev/null
+++ b/apps/plugins/mikmod/loaders/load_ult.c
@@ -0,0 +1,336 @@
+/*	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_ult.c,v 1.1.1.1 2004/01/21 01:36:35 raph Exp $

+

+  Ultratracker (ULT) 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 */

+

+/* header */

+typedef struct ULTHEADER {

+	CHAR  id[16];

+	CHAR  songtitle[32];

+	UBYTE reserved;

+} ULTHEADER;

+

+/* sample information */

+typedef struct ULTSAMPLE {

+	CHAR  samplename[32];

+	CHAR  dosname[12];

+	SLONG loopstart;

+	SLONG loopend;

+	SLONG sizestart;

+	SLONG sizeend;

+	UBYTE volume;

+	UBYTE flags;

+	UWORD speed;

+	SWORD finetune;

+} ULTSAMPLE;

+

+typedef struct ULTEVENT {

+	UBYTE note,sample,eff,dat1,dat2;

+} ULTEVENT;

+

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

+

+#define ULTS_16BITS     4

+#define ULTS_LOOP       8

+#define ULTS_REVERSE    16

+

+#define ULT_VERSION_LEN 18

+static	CHAR ULT_Version[ULT_VERSION_LEN]="Ultra Tracker v1.x";

+

+static	ULTEVENT ev;

+

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

+

+BOOL ULT_Test(void)

+{

+	CHAR id[16];

+

+	if(!_mm_read_string(id,15,modreader)) return 0;

+	if(strncmp(id,"MAS_UTrack_V00",14)) return 0;

+	if((id[14]<'1')||(id[14]>'4')) return 0;

+	return 1;

+}

+

+BOOL ULT_Init(void)

+{

+	return 1;

+}

+

+void ULT_Cleanup(void)

+{

+}

+

+static UBYTE ReadUltEvent(ULTEVENT* event)

+{

+	UBYTE flag,rep=1;

+

+	flag = _mm_read_UBYTE(modreader);

+	if(flag==0xfc) {

+		rep = _mm_read_UBYTE(modreader);

+		event->note =_mm_read_UBYTE(modreader);

+	} else

+		event->note = flag;

+

+	event->sample   =_mm_read_UBYTE(modreader);

+	event->eff      =_mm_read_UBYTE(modreader);

+	event->dat1     =_mm_read_UBYTE(modreader);

+	event->dat2     =_mm_read_UBYTE(modreader);

+

+	return rep;

+}

+

+BOOL ULT_Load(BOOL curious)

+{

+	int t,u,tracks=0;

+	SAMPLE *q;

+	ULTSAMPLE s;

+	ULTHEADER mh;

+	UBYTE nos,noc,nopa;

+	(void)curious;

+

+	/* 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++;

+	}

+

+	if(!AllocPositions(256)) return 0;

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

+		of.positions[t]=_mm_read_UBYTE(modreader);

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

+		if(of.positions[t]==255) {

+			of.positions[t]=LAST_PATTERN;

+			break;

+		}

+	of.numpos=t;

+

+	noc=_mm_read_UBYTE(modreader);

+	nopa=_mm_read_UBYTE(modreader);

+

+	of.numchn=++noc;

+	of.numpat=++nopa;

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

+	if(!AllocTracks()) return 0;

+	if(!AllocPatterns()) return 0;

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

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

+			of.patterns[(t*of.numchn)+u]=tracks++;

+

+	/* read pan position table for v1.5 and higher */

+	if(mh.id[14]>='3') {

+		for(t=0;t<of.numchn;t++) of.panning[t]=_mm_read_UBYTE(modreader)<<4;

+		of.flags |= UF_PANNING;

+	}

+

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

+		int rep,row=0;

+

+		UniReset();

+		while(row<64) {

+			rep=ReadUltEvent(&ev);

+

+			if(_mm_eof(modreader)) {

+				_mm_errno = MMERR_LOADING_TRACK;

+				return 0;

+			}

+

+			while(rep--) {

+				UBYTE eff;

+				int offset;

+

+				if(ev.sample) UniInstrument(ev.sample-1);

+				if(ev.note)   UniNote(ev.note+2*OCTAVE-1);

+

+				/* first effect - various fixes by Alexander Kerkhove and

+				                  Thomas Neumann */

+				eff = ev.eff>>4;

+				switch(eff) {

+					case 0x3: /* tone portamento */

+						UniEffect(UNI_ITEFFECTG,ev.dat2);

+						break;

+					case 0x5:

+						break;

+					case 0x9: /* sample offset */

+						offset=(ev.dat2<<8)|((ev.eff&0xf)==9?ev.dat1:0);

+						UniEffect(UNI_ULTEFFECT9,offset);

+						break;

+					case 0xb: /* panning */

+						UniPTEffect(8,ev.dat2*0xf);

+						of.flags |= UF_PANNING;

+						break;

+					case 0xc: /* volume */

+						UniPTEffect(eff,ev.dat2>>2);

+						break;

+					default:

+						UniPTEffect(eff,ev.dat2);

+						break;

+				}

+

+				/* second effect */

+				eff=ev.eff&0xf;

+				switch(eff) {

+					case 0x3: /* tone portamento */

+						UniEffect(UNI_ITEFFECTG,ev.dat1);

+						break;

+					case 0x5:

+						break;

+					case 0x9: /* sample offset */

+						if((ev.eff>>4)!=9)

+							UniEffect(UNI_ULTEFFECT9,((UWORD)ev.dat1)<<8);

+						break;

+					case 0xb: /* panning */

+						UniPTEffect(8,ev.dat1*0xf);

+						of.flags |= UF_PANNING;

+						break;

+					case 0xc: /* volume */

+						UniPTEffect(eff,ev.dat1>>2);

+						break;

+					default:

+						UniPTEffect(eff,ev.dat1);

+						break;

+				}

+

+				UniNewline();

+				row++;

+			}

+		}

+		if(!(of.tracks[t]=UniDup())) return 0;

+	}

+	return 1;

+}

+

+CHAR *ULT_LoadTitle(void)

+{

+	CHAR s[32];

+

+	_mm_fseek(modreader,15,SEEK_SET);

+	if(!_mm_read_UBYTES(s,32,modreader)) return NULL;

+

+	return(DupStr(s,32,1));

+}

+

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

+

+MIKMODAPI MLOADER load_ult={

+	NULL,

+	"ULT",

+	"ULT (UltraTracker)",

+	ULT_Init,

+	ULT_Test,

+	ULT_Load,

+	ULT_Cleanup,

+	ULT_LoadTitle

+};

+

+

+/* ex:set ts=4: */

diff --git a/apps/plugins/mikmod/loaders/load_uni.c b/apps/plugins/mikmod/loaders/load_uni.c
new file mode 100644
index 0000000..ae33671
--- /dev/null
+++ b/apps/plugins/mikmod/loaders/load_uni.c
@@ -0,0 +1,718 @@
+/*	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_uni.c,v 1.2 2004/02/06 19:29:03 raph Exp $

+

+  UNIMOD (libmikmod's and APlayer's internal module format) 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 */

+

+typedef struct UNIHEADER {

+	CHAR  id[4];

+	UBYTE numchn;

+	UWORD numpos;

+	UWORD reppos;

+	UWORD numpat;

+	UWORD numtrk;

+	UWORD numins;

+	UWORD numsmp;

+	UBYTE initspeed;

+	UBYTE inittempo;

+	UBYTE initvolume;

+	UWORD flags;

+	UBYTE numvoices;

+	UWORD bpmlimit;

+

+	UBYTE positions[256];

+	UBYTE panning[32];

+} UNIHEADER;

+

+typedef struct UNISMP05 {

+	UWORD c2spd;

+	UWORD transpose;

+	UBYTE volume;

+	UBYTE panning;

+	ULONG length;

+	ULONG loopstart;

+	ULONG loopend;

+	UWORD flags;

+	CHAR* samplename;

+	UBYTE vibtype;

+	UBYTE vibsweep;

+	UBYTE vibdepth;

+	UBYTE vibrate;

+} UNISMP05;

+

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

+

+static UWORD universion;

+static UNIHEADER mh;

+

+#define UNI_SMPINCR 64

+static UNISMP05 *wh=NULL,*s=NULL;

+

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

+

+static char* readstring(void)

+{

+	char *s=NULL;

+	UWORD len;

+	

+	len=_mm_read_I_UWORD(modreader);

+	if(len) {

+		s=_mm_malloc(len+1);

+		_mm_read_UBYTES(s,len,modreader);

+		s[len]=0;

+	}

+	return s;

+}

+

+BOOL UNI_Test(void)

+{

+	char id[6];

+

+	if(!_mm_read_UBYTES(id,6,modreader)) return 0;

+

+	/* UNIMod created by MikCvt */

+	if(!(memcmp(id,"UN0",3))) {

+		if((id[3]>='4')&&(id[3]<='6')) return 1;

+	}

+	/* UNIMod created by APlayer */

+	if(!(memcmp(id,"APUN\01",5))) {

+		if((id[5]>=1)&&(id[5]<=6)) return 1;

+	}

+	return 0;

+}

+

+BOOL UNI_Init(void)

+{

+	return 1;

+}

+

+void UNI_Cleanup(void)

+{

+	_mm_free(wh);

+	s=NULL;

+}

+

+static UBYTE* readtrack(void)

+{

+	UBYTE *t;

+	UWORD len;

+	int cur=0,chunk;

+

+	if(universion>=6)

+		len=_mm_read_M_UWORD(modreader);

+	else

+		len=_mm_read_I_UWORD(modreader);

+

+	if(!len) return NULL;

+	if(!(t=_mm_malloc(len))) return NULL;

+	_mm_read_UBYTES(t,len,modreader);

+

+	/* Check if the track is correct */

+	while(1) {

+		chunk=t[cur++];

+		if(!chunk) break;

+		chunk=(chunk&0x1f)-1;

+		while(chunk>0) {

+			int opcode,oplen;

+

+			if(cur>=len) {

+				free(t);

+				return NULL;

+			}

+			opcode=t[cur];

+

+			/* Remap opcodes */

+			if (universion <= 5) {

+				if (opcode > 29) {

+					free(t);

+					return NULL;

+				}

+				switch (opcode) {

+					/* UNI_NOTE .. UNI_S3MEFFECTQ are the same */

+					case 25:

+						opcode = UNI_S3MEFFECTT;

+						break;

+					case 26:

+						opcode = UNI_XMEFFECTA;

+						break;

+					case 27:

+						opcode = UNI_XMEFFECTG;

+						break;

+					case 28:

+						opcode = UNI_XMEFFECTH;

+						break;

+					case 29:

+						opcode = UNI_XMEFFECTP;

+						break;

+				}

+			} else {

+				/* APlayer < 1.05 does not have XMEFFECT6 */

+				if (opcode >= UNI_XMEFFECT6 && universion < 0x105)

+					opcode++;

+				/* APlayer < 1.03 does not have ITEFFECTT */

+				if (opcode >= UNI_ITEFFECTT && universion < 0x103)

+					opcode++;

+				/* APlayer < 1.02 does not have ITEFFECTZ */

+				if (opcode >= UNI_ITEFFECTZ && universion < 0x102)

+					opcode++;

+			}

+

+			if((!opcode)||(opcode>=UNI_LAST)) {

+				free(t);

+				return NULL;

+			}

+			t[cur]=opcode;

+			oplen=unioperands[opcode]+1;

+			cur+=oplen;

+			chunk-=oplen;

+		}

+		if((chunk<0)||(cur>=len)) {

+			free(t);

+			return NULL;

+		}

+	}

+	return t;

+}

+

+static BOOL loadsmp6(void)

+{

+	int t;

+	SAMPLE *s;

+

+	s=of.samples;

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

+		int flags;

+

+		flags         = _mm_read_M_UWORD(modreader);

+		s->flags=0;

+		if(flags&0x0004) s->flags|=SF_STEREO;

+		if(flags&0x0002) s->flags|=SF_SIGNED;

+		if(flags&0x0001) s->flags|=SF_16BITS;

+		/* convert flags */

+		if(universion>=0x104) {

+			if(flags&0x2000) s->flags|=SF_UST_LOOP;

+			if(flags&0x1000) s->flags|=SF_OWNPAN;

+			if(flags&0x0800) s->flags|=SF_SUSTAIN;

+			if(flags&0x0400) s->flags|=SF_REVERSE;

+			if(flags&0x0200) s->flags|=SF_BIDI;

+			if(flags&0x0100) s->flags|=SF_LOOP;

+			if(flags&0x0020) s->flags|=SF_ITPACKED;

+			if(flags&0x0010) s->flags|=SF_DELTA;

+			if(flags&0x0008) s->flags|=SF_BIG_ENDIAN;

+		} else if(universion>=0x102) {

+			if(flags&0x0800) s->flags|=SF_UST_LOOP;

+			if(flags&0x0400) s->flags|=SF_OWNPAN;

+			if(flags&0x0200) s->flags|=SF_SUSTAIN;

+			if(flags&0x0100) s->flags|=SF_REVERSE;

+			if(flags&0x0080) s->flags|=SF_BIDI;

+			if(flags&0x0040) s->flags|=SF_LOOP;

+			if(flags&0x0020) s->flags|=SF_ITPACKED;

+			if(flags&0x0010) s->flags|=SF_DELTA;

+			if(flags&0x0008) s->flags|=SF_BIG_ENDIAN;

+		} else {

+			if(flags&0x400) s->flags|=SF_UST_LOOP;

+			if(flags&0x200) s->flags|=SF_OWNPAN;

+			if(flags&0x100) s->flags|=SF_REVERSE;

+			if(flags&0x080) s->flags|=SF_SUSTAIN;

+			if(flags&0x040) s->flags|=SF_BIDI;

+			if(flags&0x020) s->flags|=SF_LOOP;

+			if(flags&0x010) s->flags|=SF_BIG_ENDIAN;

+			if(flags&0x008) s->flags|=SF_DELTA;

+		}

+

+		s->speed      = _mm_read_M_ULONG(modreader);

+		s->volume     = _mm_read_UBYTE(modreader);

+		s->panning    = _mm_read_M_UWORD(modreader);

+		s->length     = _mm_read_M_ULONG(modreader);

+		s->loopstart  = _mm_read_M_ULONG(modreader);

+		s->loopend    = _mm_read_M_ULONG(modreader);

+		s->susbegin   = _mm_read_M_ULONG(modreader);

+		s->susend     = _mm_read_M_ULONG(modreader);

+		s->globvol    = _mm_read_UBYTE(modreader);

+		s->vibflags   = _mm_read_UBYTE(modreader);

+		s->vibtype    = _mm_read_UBYTE(modreader);

+		s->vibsweep   = _mm_read_UBYTE(modreader);

+		s->vibdepth   = _mm_read_UBYTE(modreader);

+		s->vibrate    = _mm_read_UBYTE(modreader);

+

+		s->samplename=readstring();

+

+		if(_mm_eof(modreader)) {

+			_mm_errno = MMERR_LOADING_SAMPLEINFO;

+			return 0;

+		}

+	}

+	return 1;

+}

+

+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=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)) {

+				free(wh);wh=NULL;

+				_mm_errno=MMERR_LOADING_SAMPLEINFO;

+				return 0;

+			}

+		}

+	}

+

+	/* sanity check */

+	if(!of.numsmp) {

+		if(wh) { free(wh);wh=NULL; }

+		_mm_errno=MMERR_LOADING_SAMPLEINFO;

+		return 0;

+	}

+	return 1;

+}

+

+static BOOL loadsmp5(void)

+{

+	int t,u;

+	SAMPLE *q;

+	INSTRUMENT *d;

+

+	q=of.samples;s=wh;

+	for(u=0;u<of.numsmp;u++,q++,s++) {

+		q->samplename=s->samplename;

+

+		q->length   =s->length;

+		q->loopstart=s->loopstart;

+		q->loopend  =s->loopend;

+		q->volume   =s->volume;

+		q->speed    =s->c2spd;

+		q->panning  =s->panning;

+		q->vibtype  =s->vibtype;

+		q->vibsweep =s->vibsweep;

+		q->vibdepth =s->vibdepth;

+		q->vibrate  =s->vibrate;

+

+		/* convert flags */

+		q->flags=0;

+		if(s->flags&128) q->flags|=SF_REVERSE;

+		if(s->flags& 64) q->flags|=SF_SUSTAIN;

+		if(s->flags& 32) q->flags|=SF_BIDI;

+		if(s->flags& 16) q->flags|=SF_LOOP;

+		if(s->flags&  8) q->flags|=SF_BIG_ENDIAN;

+		if(s->flags&  4) q->flags|=SF_DELTA;

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

+		if(s->flags&  1) q->flags|=SF_16BITS;

+	}

+

+	d=of.instruments;s=wh;

+	for(u=0;u<of.numins;u++,d++)

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

+			d->samplenote[t]=(d->samplenumber[t]>=of.numsmp)?

+			  255:(t+s[d->samplenumber[t]].transpose);

+

+	free(wh);wh=NULL;

+

+	return 1;

+}

+

+BOOL UNI_Load(BOOL curious)

+{

+	int t;

+	char *modtype,*oldtype=NULL;

+	INSTRUMENT *d;

+	SAMPLE *q;

+	(void)curious;

+	

+	/* 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_read_UBYTE(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) {

+		int len=strlen(oldtype)+20;

+		if(!(modtype=_mm_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=_mm_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=strdup(modtype);

+	free(modtype);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()) {

+			if(wh) { 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;

+}

+

+CHAR *UNI_LoadTitle(void)

+{

+	UBYTE ver;

+	int posit[3]={304,306,26};

+

+	_mm_fseek(modreader,3,SEEK_SET);

+	ver=_mm_read_UBYTE(modreader);

+	if(ver=='N') ver='6';

+

+	_mm_fseek(modreader,posit[ver-'4'],SEEK_SET);

+	return readstring();

+}

+

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

+

+MIKMODAPI MLOADER load_uni={

+	NULL,

+	"UNI",

+	"APUN (APlayer) and UNI (MikMod)",

+	UNI_Init,

+	UNI_Test,

+	UNI_Load,

+	UNI_Cleanup,

+	UNI_LoadTitle

+};

+

+/* ex:set ts=4: */

diff --git a/apps/plugins/mikmod/loaders/load_xm.c b/apps/plugins/mikmod/loaders/load_xm.c
new file mode 100644
index 0000000..fcf958d
--- /dev/null
+++ b/apps/plugins/mikmod/loaders/load_xm.c
@@ -0,0 +1,816 @@
+/*	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_xm.c,v 1.2 2004/02/06 19:29:03 raph Exp $

+

+  Fasttracker (XM) 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 */

+

+typedef struct XMHEADER {

+	CHAR  id[17];          /* ID text: 'Extended module: ' */

+	CHAR  songname[21];    /* Module name */

+	CHAR  trackername[20]; /* Tracker name */

+	UWORD version;         /* Version number */

+	ULONG headersize;      /* Header size */

+	UWORD songlength;      /* Song length (in patten order table) */

+	UWORD restart;         /* Restart position */

+	UWORD numchn;          /* Number of channels (2,4,6,8,10,...,32) */

+	UWORD numpat;          /* Number of patterns (max 256) */

+	UWORD numins;          /* Number of instruments (max 128) */

+	UWORD flags;       

+	UWORD tempo;           /* Default tempo */

+	UWORD bpm;             /* Default BPM */

+	UBYTE orders[256];     /* Pattern order table  */

+} XMHEADER;

+

+typedef struct XMINSTHEADER {

+	ULONG size;     /* Instrument size */

+	CHAR  name[22]; /* Instrument name */

+	UBYTE type;     /* Instrument type (always 0) */

+	UWORD numsmp;   /* Number of samples in instrument */

+	ULONG ssize;

+} XMINSTHEADER;

+

+#define XMENVCNT (12*2)

+#define XMNOTECNT (8*OCTAVE)

+typedef struct XMPATCHHEADER {

+	UBYTE what[XMNOTECNT];  /*  Sample number for all notes */

+	UWORD volenv[XMENVCNT]; /*  Points for volume envelope */

+	UWORD panenv[XMENVCNT]; /*  Points for panning envelope */

+	UBYTE volpts;      /*  Number of volume points */

+	UBYTE panpts;      /*  Number of panning points */

+	UBYTE volsus;      /*  Volume sustain point */

+	UBYTE volbeg;      /*  Volume loop start point */

+	UBYTE volend;      /*  Volume loop end point */

+	UBYTE pansus;      /*  Panning sustain point */

+	UBYTE panbeg;      /*  Panning loop start point */

+	UBYTE panend;      /*  Panning loop end point */

+	UBYTE volflg;      /*  Volume type: bit 0: On; 1: Sustain; 2: Loop */

+	UBYTE panflg;      /*  Panning type: bit 0: On; 1: Sustain; 2: Loop */

+	UBYTE vibflg;      /*  Vibrato type */

+	UBYTE vibsweep;    /*  Vibrato sweep */

+	UBYTE vibdepth;    /*  Vibrato depth */

+	UBYTE vibrate;     /*  Vibrato rate */

+	UWORD volfade;     /*  Volume fadeout */

+} XMPATCHHEADER;

+

+typedef struct XMWAVHEADER {

+	ULONG length;         /* Sample length */

+	ULONG loopstart;      /* Sample loop start */

+	ULONG looplength;     /* Sample loop length */

+	UBYTE volume;         /* Volume  */

+	SBYTE finetune;       /* Finetune (signed byte -128..+127) */

+	UBYTE type;           /* Loop type */

+	UBYTE panning;        /* Panning (0-255) */

+	SBYTE relnote;        /* Relative note number (signed byte) */

+	UBYTE reserved;

+	CHAR  samplename[22]; /* Sample name */

+	UBYTE vibtype;        /* Vibrato type */

+	UBYTE vibsweep;       /* Vibrato sweep */

+	UBYTE vibdepth;       /* Vibrato depth */

+	UBYTE vibrate;        /* Vibrato rate */

+} XMWAVHEADER;

+

+typedef struct XMPATHEADER {

+	ULONG size;     /* Pattern header length  */

+	UBYTE packing;  /* Packing type (always 0) */

+	UWORD numrows;  /* Number of rows in pattern (1..256) */

+	SWORD packsize; /* Packed patterndata size */

+} XMPATHEADER;

+

+typedef struct XMNOTE {

+	UBYTE note,ins,vol,eff,dat;

+} XMNOTE;

+

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

+

+static	XMNOTE *xmpat=NULL;

+static	XMHEADER *mh=NULL;

+

+/* increment unit for sample array reallocation */

+#define XM_SMPINCR 64

+static	ULONG *nextwav=NULL;

+static	XMWAVHEADER *wh=NULL,*s=NULL;

+

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

+

+BOOL XM_Test(void)

+{

+	UBYTE id[38];

+

+	if(!_mm_read_UBYTES(id,38,modreader)) return 0;

+	if(memcmp(id,"Extended Module: ",17)) return 0;

+	if(id[37]==0x1a) return 1;

+	return 0;

+}

+

+BOOL XM_Init(void)

+{

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

+	return 1;

+}

+

+void XM_Cleanup(void)

+{

+	_mm_free(mh);

+}

+

+static int XM_ReadNote(XMNOTE* n)

+{

+	UBYTE cmp,result=1;

+

+	memset(n,0,sizeof(XMNOTE));

+	cmp=_mm_read_UBYTE(modreader);

+

+	if(cmp&0x80) {

+		if(cmp&1)  { result++;n->note = _mm_read_UBYTE(modreader); }

+		if(cmp&2)  { result++;n->ins  = _mm_read_UBYTE(modreader); }

+		if(cmp&4)  { result++;n->vol  = _mm_read_UBYTE(modreader); }

+		if(cmp&8)  { result++;n->eff  = _mm_read_UBYTE(modreader); }

+		if(cmp&16) { result++;n->dat  = _mm_read_UBYTE(modreader); }

+	} else {

+		n->note = cmp;

+		n->ins  = _mm_read_UBYTE(modreader);

+		n->vol  = _mm_read_UBYTE(modreader);

+		n->eff  = _mm_read_UBYTE(modreader);

+		n->dat  = _mm_read_UBYTE(modreader);

+		result += 4;

+	}

+	return result;

+}

+

+static UBYTE* XM_Convert(XMNOTE* xmtrack,UWORD rows)

+{

+	int t;

+	UBYTE note,ins,vol,eff,dat;

+

+	UniReset();

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

+		note = xmtrack->note;

+		ins  = xmtrack->ins;

+		vol  = xmtrack->vol;

+		eff  = xmtrack->eff;

+		dat  = xmtrack->dat;

+

+		if(note) {

+			if(note>XMNOTECNT)

+				UniEffect(UNI_KEYFADE,0);

+			else

+				UniNote(note-1);

+		}

+		if(ins) UniInstrument(ins-1);

+

+		switch(vol>>4) {

+			case 0x6: /* volslide down */

+				if(vol&0xf) UniEffect(UNI_XMEFFECTA,vol&0xf);

+				break;

+			case 0x7: /* volslide up */

+				if(vol&0xf) UniEffect(UNI_XMEFFECTA,vol<<4);

+				break;

+

+				/* volume-row fine volume slide is compatible with protracker

+				   EBx and EAx effects i.e. a zero nibble means DO NOT SLIDE, as

+				   opposed to 'take the last sliding value'. */

+			case 0x8: /* finevol down */

+				UniPTEffect(0xe,0xb0|(vol&0xf));

+				break;

+			case 0x9: /* finevol up */

+				UniPTEffect(0xe,0xa0|(vol&0xf));

+				break;

+			case 0xa: /* set vibrato speed */

+				UniEffect(UNI_XMEFFECT4,vol<<4);

+				break;

+			case 0xb: /* vibrato */

+				UniEffect(UNI_XMEFFECT4,vol&0xf);

+				break;

+			case 0xc: /* set panning */

+				UniPTEffect(0x8,vol<<4);

+				break;

+			case 0xd: /* panning slide left (only slide when data not zero) */

+				if(vol&0xf) UniEffect(UNI_XMEFFECTP,vol&0xf);

+				break;

+			case 0xe: /* panning slide right (only slide when data not zero) */

+				if(vol&0xf) UniEffect(UNI_XMEFFECTP,vol<<4);

+				break;

+			case 0xf: /* tone porta */

+				UniPTEffect(0x3,vol<<4);

+				break;

+			default:

+				if((vol>=0x10)&&(vol<=0x50))

+					UniPTEffect(0xc,vol-0x10);

+		}

+

+		switch(eff) {

+			case 0x4:

+				UniEffect(UNI_XMEFFECT4,dat);

+				break;

+			case 0x6:

+				UniEffect(UNI_XMEFFECT6,dat);

+				break;

+			case 0xa:

+				UniEffect(UNI_XMEFFECTA,dat);

+				break;

+			case 0xe: /* Extended effects */

+				switch(dat>>4) {

+					case 0x1: /* XM fine porta up */

+						UniEffect(UNI_XMEFFECTE1,dat&0xf);

+						break;

+					case 0x2: /* XM fine porta down */

+						UniEffect(UNI_XMEFFECTE2,dat&0xf);

+						break;

+					case 0xa: /* XM fine volume up */

+						UniEffect(UNI_XMEFFECTEA,dat&0xf);

+						break;

+					case 0xb: /* XM fine volume down */

+						UniEffect(UNI_XMEFFECTEB,dat&0xf);

+						break;

+					default:

+						UniPTEffect(eff,dat);

+				}

+				break;

+			case 'G'-55: /* G - set global volume */

+				UniEffect(UNI_XMEFFECTG,dat>64?128:dat<<1);

+				break;

+			case 'H'-55: /* H - global volume slide */

+				UniEffect(UNI_XMEFFECTH,dat);

+				break;

+			case 'K'-55: /* K - keyOff and KeyFade */

+				UniEffect(UNI_KEYFADE,dat);

+				break;

+			case 'L'-55: /* L - set envelope position */

+				UniEffect(UNI_XMEFFECTL,dat);

+				break;

+			case 'P'-55: /* P - panning slide */

+				UniEffect(UNI_XMEFFECTP,dat);

+				break;

+			case 'R'-55: /* R - multi retrig note */

+				UniEffect(UNI_S3MEFFECTQ,dat);

+				break;

+			case 'T'-55: /* T - Tremor */

+				UniEffect(UNI_S3MEFFECTI,dat);

+				break;

+			case 'X'-55:

+				switch(dat>>4) {

+					case 1: /* X1 - Extra Fine Porta up */

+						UniEffect(UNI_XMEFFECTX1,dat&0xf);

+						break;

+					case 2: /* X2 - Extra Fine Porta down */

+						UniEffect(UNI_XMEFFECTX2,dat&0xf);

+						break;

+				}

+				break;

+			default:

+				if(eff<=0xf) {

+					/* the pattern jump destination is written in decimal,

+					   but it seems some poor tracker software writes them

+					   in hexadecimal... (sigh) */

+					if (eff==0xd)

+						/* don't change anything if we're sure it's in hexa */

+						if ((((dat&0xf0)>>4)<=9)&&((dat&0xf)<=9))

+							/* otherwise, convert from dec to hex */

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

+					UniPTEffect(eff,dat);

+				}

+				break;

+		}

+		UniNewline();

+		xmtrack++;

+	}

+	return UniDup();

+}

+

+static BOOL LoadPatterns(BOOL dummypat)

+{

+	int t,u,v,numtrk;

+

+	if(!AllocTracks()) return 0;

+	if(!AllocPatterns()) return 0;

+

+	numtrk=0;

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

+		XMPATHEADER ph;

+

+		ph.size     =_mm_read_I_ULONG(modreader);

+		if (ph.size<(mh->version==0x0102?8:9)) {

+			_mm_errno=MMERR_LOADING_PATTERN;

+			return 0;

+		}

+		ph.packing  =_mm_read_UBYTE(modreader);

+		if(ph.packing) {

+			_mm_errno=MMERR_LOADING_PATTERN;

+			return 0;

+		}

+		if(mh->version==0x0102)

+			ph.numrows  =_mm_read_UBYTE(modreader)+1;

+		else

+			ph.numrows  =_mm_read_I_UWORD(modreader);

+		ph.packsize =_mm_read_I_UWORD(modreader);

+

+		ph.size-=(mh->version==0x0102?8:9);

+		if(ph.size)

+			_mm_fseek(modreader,ph.size,SEEK_CUR);

+

+		of.pattrows[t]=ph.numrows;

+

+		if(ph.numrows) {

+			if(!(xmpat=(XMNOTE*)_mm_calloc(ph.numrows*of.numchn,sizeof(XMNOTE))))

+				return 0;

+

+			/* when packsize is 0, don't try to load a pattern.. it's empty. */

+			if(ph.packsize) 

+				for(u=0;u<ph.numrows;u++) 

+					for(v=0;v<of.numchn;v++) {

+						if(!ph.packsize) break;

+

+						ph.packsize-=XM_ReadNote(&xmpat[(v*ph.numrows)+u]);

+						if(ph.packsize<0) {

+							free(xmpat);xmpat=NULL;

+							_mm_errno=MMERR_LOADING_PATTERN;

+							return 0;

+						}

+					}

+

+			if(ph.packsize) {

+				_mm_fseek(modreader,ph.packsize,SEEK_CUR);

+			}

+

+			if(_mm_eof(modreader)) {

+				free(xmpat);xmpat=NULL;

+				_mm_errno=MMERR_LOADING_PATTERN;

+				return 0;

+			}

+

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

+				of.tracks[numtrk++]=XM_Convert(&xmpat[v*ph.numrows],ph.numrows);

+

+			free(xmpat);xmpat=NULL;

+		} else {

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

+				of.tracks[numtrk++]=XM_Convert(NULL,ph.numrows);

+		}

+	}

+

+	if(dummypat) {

+		of.pattrows[t]=64;

+		if(!(xmpat=(XMNOTE*)_mm_calloc(64*of.numchn,sizeof(XMNOTE)))) return 0;

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

+			of.tracks[numtrk++]=XM_Convert(&xmpat[v*64],64);

+		free(xmpat);xmpat=NULL;

+	}

+

+	return 1;

+}

+

+static void FixEnvelope(ENVPT *cur, int pts)

+{

+		int u, old, tmp;

+		ENVPT *prev;

+

+		/* Some broken XM editing program will only save the low byte

+		   of the position value. Try to compensate by adding the

+		   missing high byte. */

+

+		prev = cur++;

+		old = prev->pos;

+

+		for (u = 1; u < pts; u++, prev++, cur++) {

+			if (cur->pos < prev->pos) {

+				if (cur->pos < 0x100) {

+					if (cur->pos > old)	/* same hex century */

+							tmp = cur->pos + (prev->pos - old);

+					else

+							tmp = cur->pos | ((prev->pos + 0x100) & 0xff00);

+					old = cur->pos;

+					cur->pos = tmp;

+#ifdef MIKMOD_DEBUG

+					fprintf(stderr, "\rbroken envelope position(%d/%d), %d %d -> %d\n",

+					    u, pts, prev->pos, old, cur->pos);

+#endif

+				} else {

+#ifdef MIKMOD_DEBUG

+					/* different brokenness style... fix unknown */

+					fprintf(stderr, "\rbroken envelope position(%d/%d), %d %d\n",

+					    u, pts, old, cur->pos);

+#endif

+					old = cur->pos;

+				}

+			} else

+				old = cur->pos;

+		}

+}

+

+static BOOL LoadInstruments(void)

+{

+	int t,u;

+	INSTRUMENT *d;

+	ULONG next=0;

+	UWORD wavcnt=0;

+

+	if(!AllocInstruments()) return 0;

+	d=of.instruments;

+	for(t=0;t<of.numins;t++,d++) {

+		XMINSTHEADER ih;

+		long headend;

+

+		memset(d->samplenumber,0xff,INSTNOTES*sizeof(UWORD));

+

+		/* read instrument header */

+		headend     = _mm_ftell(modreader);

+		ih.size     = _mm_read_I_ULONG(modreader);

+		headend    += ih.size;

+		_mm_read_string(ih.name, 22, modreader);

+		ih.type     = _mm_read_UBYTE(modreader);

+		ih.numsmp   = _mm_read_I_UWORD(modreader);

+

+		d->insname  = DupStr(ih.name,22,1);

+

+		if((SWORD)ih.size>29) {

+			ih.ssize    = _mm_read_I_ULONG(modreader);

+			if(((SWORD)ih.numsmp>0)&&(ih.numsmp<=XMNOTECNT)) {

+				XMPATCHHEADER pth;

+				int p;

+

+				_mm_read_UBYTES (pth.what,XMNOTECNT,modreader);

+				_mm_read_I_UWORDS (pth.volenv, XMENVCNT, modreader);

+				_mm_read_I_UWORDS (pth.panenv, XMENVCNT, modreader);

+				pth.volpts      =  _mm_read_UBYTE(modreader);

+				pth.panpts      =  _mm_read_UBYTE(modreader);

+				pth.volsus      =  _mm_read_UBYTE(modreader);

+				pth.volbeg      =  _mm_read_UBYTE(modreader);

+				pth.volend      =  _mm_read_UBYTE(modreader);

+				pth.pansus      =  _mm_read_UBYTE(modreader);

+				pth.panbeg      =  _mm_read_UBYTE(modreader);

+				pth.panend      =  _mm_read_UBYTE(modreader);

+				pth.volflg      =  _mm_read_UBYTE(modreader);

+				pth.panflg      =  _mm_read_UBYTE(modreader);

+				pth.vibflg      =  _mm_read_UBYTE(modreader);

+				pth.vibsweep    =  _mm_read_UBYTE(modreader);

+				pth.vibdepth    =  _mm_read_UBYTE(modreader);

+				pth.vibrate     =  _mm_read_UBYTE(modreader);

+				pth.volfade     =  _mm_read_I_UWORD(modreader);

+

+				/* read the remainder of the header

+				   (2 bytes for 1.03, 22 for 1.04) */

+				for(u=headend-_mm_ftell(modreader);u;u--) _mm_read_UBYTE(modreader);

+

+				/* we can't trust the envelope point count here, as some

+				   modules have incorrect values (K_OSPACE.XM reports 32 volume

+				   points, for example). */

+				if(pth.volpts>XMENVCNT/2) pth.volpts=XMENVCNT/2;

+				if(pth.panpts>XMENVCNT/2) pth.panpts=XMENVCNT/2;

+

+				if((_mm_eof(modreader))||(pth.volpts>XMENVCNT/2)||(pth.panpts>XMENVCNT/2)) {

+					if(nextwav) { free(nextwav);nextwav=NULL; }

+					if(wh) { free(wh);wh=NULL; }

+					_mm_errno = MMERR_LOADING_SAMPLEINFO;

+					return 0;

+				}

+

+				for(u=0;u<XMNOTECNT;u++)

+					d->samplenumber[u]=pth.what[u]+of.numsmp;

+				d->volfade = pth.volfade;

+

+#if defined __STDC__ || defined _MSC_VER || defined MPW_C

+#define XM_ProcessEnvelope(name) 										\

+				for (u = 0; u < (XMENVCNT >> 1); u++) {					\

+					d-> name##env[u].pos = pth. name##env[u << 1];		\

+					d-> name##env[u].val = pth. name##env[(u << 1)+ 1];	\

+				}														\

+				if (pth. name##flg&1) d-> name##flg|=EF_ON;				\

+				if (pth. name##flg&2) d-> name##flg|=EF_SUSTAIN;		\

+				if (pth. name##flg&4) d-> name##flg|=EF_LOOP;			\

+				d-> name##susbeg=d-> name##susend=pth. name##sus;		\

+				d-> name##beg=pth. name##beg;							\

+				d-> name##end=pth. name##end;							\

+				d-> name##pts=pth. name##pts;							\

+																		\

+				/* scale envelope */									\

+				for (p=0;p<XMENVCNT/2;p++)								\

+					d-> name##env[p].val<<=2;							\

+																		\

+				if ((d-> name##flg&EF_ON)&&(d-> name##pts<2))			\

+					d-> name##flg&=~EF_ON

+#else

+#define XM_ProcessEnvelope(name) 											\

+				for (u = 0; u < (XMENVCNT >> 1); u++) {						\

+					d-> name/**/env[u].pos = pth. name/**/env[u << 1];		\

+					d-> name/**/env[u].val = pth. name/**/env[(u << 1)+ 1];	\

+				}															\

+				if (pth. name/**/flg&1) d-> name/**/flg|=EF_ON;				\

+				if (pth. name/**/flg&2) d-> name/**/flg|=EF_SUSTAIN;		\

+				if (pth. name/**/flg&4) d-> name/**/flg|=EF_LOOP;			\

+				d-> name/**/susbeg=d-> name/**/susend=						\

+				                      pth. name/**/sus;						\

+				d-> name/**/beg=pth. name/**/beg;							\

+				d-> name/**/end=pth. name/**/end;							\

+				d-> name/**/pts=pth. name/**/pts;							\

+																			\

+				/* scale envelope */										\

+				for (p=0;p<XMENVCNT/2;p++)									\

+					d-> name/**/env[p].val<<=2;								\

+																			\

+				if ((d-> name/**/flg&EF_ON)&&(d-> name/**/pts<2))			\

+					d-> name/**/flg&=~EF_ON

+#endif			

+

+				XM_ProcessEnvelope(vol);

+				XM_ProcessEnvelope(pan);

+#undef XM_ProcessEnvelope

+

+				if (d->volflg & EF_ON)

+					FixEnvelope(d->volenv, d->volpts);

+				if (d->panflg & EF_ON)

+					FixEnvelope(d->panenv, d->panpts);

+

+				/* Samples are stored outside the instrument struct now, so we

+				   have to load them all into a temp area, count the of.numsmp

+				   along the way and then do an AllocSamples() and move

+				   everything over */

+				if(mh->version>0x0103) next = 0;

+				for(u=0;u<ih.numsmp;u++,s++) {

+					/* Allocate more room for sample information if necessary */

+					if(of.numsmp+u==wavcnt) {

+						wavcnt+=XM_SMPINCR;

+						if(!(nextwav=realloc(nextwav,wavcnt*sizeof(ULONG)))){

+							if(wh) { free(wh);wh=NULL; }

+							_mm_errno = MMERR_OUT_OF_MEMORY;

+							return 0;

+						}

+						if(!(wh=realloc(wh,wavcnt*sizeof(XMWAVHEADER)))) {

+							free(nextwav);nextwav=NULL;

+							_mm_errno = MMERR_OUT_OF_MEMORY;

+							return 0;

+						}

+						s=wh+(wavcnt-XM_SMPINCR);

+					}

+

+					s->length       =_mm_read_I_ULONG (modreader);

+					s->loopstart    =_mm_read_I_ULONG (modreader);

+					s->looplength   =_mm_read_I_ULONG (modreader);

+					s->volume       =_mm_read_UBYTE (modreader);

+					s->finetune     =_mm_read_SBYTE (modreader);

+					s->type         =_mm_read_UBYTE (modreader);

+					s->panning      =_mm_read_UBYTE (modreader);

+					s->relnote      =_mm_read_SBYTE (modreader);

+					s->vibtype      = pth.vibflg;

+					s->vibsweep     = pth.vibsweep;

+					s->vibdepth     = pth.vibdepth*4;

+					s->vibrate      = pth.vibrate;

+					s->reserved     =_mm_read_UBYTE (modreader);

+					_mm_read_string(s->samplename, 22, modreader);

+

+					nextwav[of.numsmp+u]=next;

+					next+=s->length;

+

+					if(_mm_eof(modreader)) {

+						free(nextwav);free(wh);

+						nextwav=NULL;wh=NULL;

+						_mm_errno = MMERR_LOADING_SAMPLEINFO;

+						return 0;

+					}

+				}

+

+				if(mh->version>0x0103) {

+					for(u=0;u<ih.numsmp;u++)

+						nextwav[of.numsmp++]+=_mm_ftell(modreader);

+					_mm_fseek(modreader,next,SEEK_CUR);

+				} else

+					of.numsmp+=ih.numsmp;

+			} else {

+				/* read the remainder of the header */

+				for(u=headend-_mm_ftell(modreader);u;u--) _mm_read_UBYTE(modreader);

+

+				if(_mm_eof(modreader)) {

+					free(nextwav);free(wh);

+					nextwav=NULL;wh=NULL;

+					_mm_errno = MMERR_LOADING_SAMPLEINFO;

+					return 0;

+				}

+			}

+		}

+	}

+

+	/* sanity check */

+	if(!of.numsmp) {

+		if(nextwav) { free(nextwav);nextwav=NULL; }

+		if(wh) { free(wh);wh=NULL; }

+		_mm_errno = MMERR_LOADING_SAMPLEINFO;

+		return 0;

+	}

+

+	return 1;

+}

+

+BOOL XM_Load(BOOL curious)

+{

+	INSTRUMENT *d;

+	SAMPLE *q;

+	int t,u;

+	BOOL dummypat=0;

+	char tracker[21],modtype[60];

+	(void)curious;

+

+	/* try to read module header */

+	_mm_read_string(mh->id,17,modreader);

+	_mm_read_string(mh->songname,21,modreader);

+	_mm_read_string(mh->trackername,20,modreader);

+	mh->version     =_mm_read_I_UWORD(modreader);

+	if((mh->version<0x102)||(mh->version>0x104)) {

+		_mm_errno=MMERR_NOT_A_MODULE;

+		return 0;

+	}

+	mh->headersize  =_mm_read_I_ULONG(modreader);

+	mh->songlength  =_mm_read_I_UWORD(modreader);

+	mh->restart     =_mm_read_I_UWORD(modreader);

+	mh->numchn      =_mm_read_I_UWORD(modreader);

+	mh->numpat      =_mm_read_I_UWORD(modreader);

+	mh->numins      =_mm_read_I_UWORD(modreader);

+	mh->flags       =_mm_read_I_UWORD(modreader);

+	mh->tempo       =_mm_read_I_UWORD(modreader);

+	mh->bpm         =_mm_read_I_UWORD(modreader);

+	if(!mh->bpm) {

+		_mm_errno=MMERR_NOT_A_MODULE;

+		return 0;

+	}

+	_mm_read_UBYTES(mh->orders,256,modreader);

+

+	if(_mm_eof(modreader)) {

+		_mm_errno = MMERR_LOADING_HEADER;

+		return 0;

+	}

+

+	/* set module variables */

+	of.initspeed = mh->tempo;         

+	of.inittempo = mh->bpm;

+	strncpy(tracker,mh->trackername,20);tracker[20]=0;

+	for(t=20;(tracker[t]<=' ')&&(t>=0);t--) tracker[t]=0;

+	

+	/* some modules have the tracker name empty */

+	if (!tracker[0])

+		strcpy(tracker,"Unknown tracker");

+

+#ifdef HAVE_SNPRINTF

+	snprintf(modtype,60,"%s (XM format %d.%02d)",

+	                    tracker,mh->version>>8,mh->version&0xff);

+#else

+	sprintf(modtype,"%s (XM format %d.%02d)",

+	                tracker,mh->version>>8,mh->version&0xff);

+#endif

+	of.modtype   = strdup(modtype);

+	of.numchn    = mh->numchn;

+	of.numpat    = mh->numpat;

+	of.numtrk    = (UWORD)of.numpat*of.numchn;   /* get number of channels */

+	of.songname  = DupStr(mh->songname,20,1);

+	of.numpos    = mh->songlength;               /* copy the songlength */

+	of.reppos    = mh->restart<mh->songlength?mh->restart:0;

+	of.numins    = mh->numins;

+	of.flags    |= UF_XMPERIODS | UF_INST | UF_NOWRAP | UF_FT2QUIRKS |

+				   UF_PANNING;

+	if(mh->flags&1) of.flags |= UF_LINEAR;

+	of.bpmlimit  = 32;

+

+	memset(of.chanvol,64,of.numchn);             /* store channel volumes */

+

+	if(!AllocPositions(of.numpos+1)) return 0;

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

+		of.positions[t]=mh->orders[t];

+

+	/* We have to check for any pattern numbers in the order list greater than

+	   the number of patterns total. If one or more is found, we set it equal to

+	   the pattern total and make a dummy pattern to workaround the problem */

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

+		if(of.positions[t]>=of.numpat) {

+			of.positions[t]=of.numpat;

+			dummypat=1;

+		}

+	}

+	if(dummypat) {

+		of.numpat++;of.numtrk+=of.numchn;

+	}

+

+	if(mh->version<0x0104) {

+		if(!LoadInstruments()) return 0;

+		if(!LoadPatterns(dummypat)) return 0;

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

+			nextwav[t]+=_mm_ftell(modreader);

+	} else {

+		if(!LoadPatterns(dummypat)) return 0;

+		if(!LoadInstruments()) return 0;

+	}

+

+	if(!AllocSamples()) {

+		free(nextwav);free(wh);

+		nextwav=NULL;wh=NULL;

+		return 0;

+	}

+	q = of.samples;

+	s = wh;

+	for(u=0;u<of.numsmp;u++,q++,s++) {

+		q->samplename   = DupStr(s->samplename,22,1);

+		q->length       = s->length;

+		q->loopstart    = s->loopstart;

+		q->loopend      = s->loopstart+s->looplength;

+		q->volume       = s->volume;

+		q->speed        = s->finetune+128;

+		q->panning      = s->panning;

+		q->seekpos      = nextwav[u];

+		q->vibtype      = s->vibtype;

+		q->vibsweep     = s->vibsweep;

+		q->vibdepth     = s->vibdepth;

+		q->vibrate      = s->vibrate;

+

+		if(s->type & 0x10) {

+			q->length    >>= 1;

+			q->loopstart >>= 1;

+			q->loopend   >>= 1;

+		}

+

+		q->flags|=SF_OWNPAN|SF_DELTA|SF_SIGNED;

+		if(s->type&0x3) q->flags|=SF_LOOP;

+		if(s->type&0x2) q->flags|=SF_BIDI;

+		if(s->type&0x10) q->flags|=SF_16BITS;

+	}

+

+	d=of.instruments;

+	s=wh;

+	for(u=0;u<of.numins;u++,d++)

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

+			if (d->samplenumber[t]>=of.numsmp)

+				d->samplenote[t]=255;

+			else {

+				int note=t+s[d->samplenumber[t]].relnote;

+				d->samplenote[t]=(note<0)?0:note;

+			}

+		}

+

+	free(wh);free(nextwav);

+	wh=NULL;nextwav=NULL;

+	return 1;

+}

+

+CHAR *XM_LoadTitle(void)

+{

+	CHAR s[21];

+

+	_mm_fseek(modreader,17,SEEK_SET);

+	if(!_mm_read_UBYTES(s,21,modreader)) return NULL;

+

+	return(DupStr(s,21,1));

+}

+

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

+

+MIKMODAPI MLOADER load_xm={

+	NULL,

+	"XM",

+	"XM (FastTracker 2)",

+	XM_Init,

+	XM_Test,

+	XM_Load,

+	XM_Cleanup,

+	XM_LoadTitle

+};

+

+/* ex:set ts=4: */