--- /dev/null
+/* 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$
+
+ Generic MOD loader (Protracker, StarTracker, FastTracker, etc)
+
+==============================================================================*/
+
+#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"
+#include "mikmod_ctype.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))) &&
+ (mik_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)) && (mik_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)))
+ && (mik_isdigit(id[0])) && (mik_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 *)MikMod_malloc(sizeof(MODULEHEADER))))
+ return 0;
+ return 1;
+}
+
+static void MOD_Cleanup(void)
+{
+ MikMod_free(mh);
+ MikMod_free(patbuf);
+ mh=NULL;
+ patbuf=NULL;
+}
+
+/*
+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 *)MikMod_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 = MikMod_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: */
projects / dosdemo / blobdiff