git.mutantstargoat.com Git - dosrtxon/blob - libs/mikmod/loaders/load_mod.c

   1 /*      MikMod sound library
   2         (c) 1998, 1999, 2000, 2001, 2002 Miodrag Vallat and others - see file
   3         AUTHORS for complete list.
   4
   5         This library is free software; you can redistribute it and/or modify
   6         it under the terms of the GNU Library General Public License as
   7         published by the Free Software Foundation; either version 2 of
   8         the License, or (at your option) any later version.
   9
  10         This program is distributed in the hope that it will be useful,
  11         but WITHOUT ANY WARRANTY; without even the implied warranty of
  12         MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13         GNU Library General Public License for more details.
  14
  15         You should have received a copy of the GNU Library General Public
  16         License along with this library; if not, write to the Free Software
  17         Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  18         02111-1307, USA.
  19 */
  20
  21 /*==============================================================================
  22
  23   $Id$
  24
  25   Generic MOD loader (Protracker, StarTracker, FastTracker, etc)
  26
  27 ==============================================================================*/
  28
  29 #ifdef HAVE_CONFIG_H
  30 #include "config.h"
  31 #endif
  32
  33 #ifdef HAVE_UNISTD_H
  34 #include <unistd.h>
  35 #endif
  36
  37 #include <stdio.h>
  38 #ifdef HAVE_MEMORY_H
  39 #include <memory.h>
  40 #endif
  41 #include <string.h>
  42
  43 #include "mikmod_internals.h"
  44 #include "mikmod_ctype.h"
  45
  46 #ifdef SUNOS
  47 extern int fprintf(FILE *, const char *, ...);
  48 #endif
  49
  50 /*========== Module structure */
  51
  52 typedef struct MSAMPINFO {
  53         CHAR samplename[23];            /* 22 in module, 23 in memory */
  54         UWORD length;
  55         UBYTE finetune;
  56         UBYTE volume;
  57         UWORD reppos;
  58         UWORD replen;
  59 } MSAMPINFO;
  60
  61 typedef struct MODULEHEADER {
  62         CHAR songname[21];                      /* the songname.. 20 in module, 21 in memory */
  63         MSAMPINFO samples[31];          /* all sampleinfo */
  64         UBYTE songlength;                       /* number of patterns used */
  65         UBYTE magic1;                           /* should be 127 */
  66         UBYTE positions[128];           /* which pattern to play at pos */
  67         UBYTE magic2[4];                        /* string "M.K." or "FLT4" or "FLT8" */
  68 } MODULEHEADER;
  69
  70 typedef struct MODTYPE {
  71         CHAR id[5];
  72         UBYTE channels;
  73         CHAR *name;
  74 } MODTYPE;
  75
  76 typedef struct MODNOTE {
  77         UBYTE a, b, c, d;
  78 } MODNOTE;
  79
  80 /*========== Loader variables */
  81
  82 #define MODULEHEADERSIZE 0x438
  83
  84 static CHAR protracker[] = "Protracker";
  85 static CHAR startrekker[] = "Startrekker";
  86 static CHAR fasttracker[] = "Fasttracker";
  87 static CHAR oktalyser[] = "Oktalyser";
  88 static CHAR oktalyzer[] = "Oktalyzer";
  89 static CHAR taketracker[] = "TakeTracker";
  90 static CHAR orpheus[] = "Imago Orpheus (MOD format)";
  91
  92 static MODULEHEADER *mh = NULL;
  93 static MODNOTE *patbuf = NULL;
  94 static int modtype, trekker;
  95
  96 /*========== Loader code */
  97
  98 /* given the module ID, determine the number of channels and the tracker
  99    description ; also alters modtype */
 100 static BOOL MOD_CheckType(UBYTE *id, UBYTE *numchn, CHAR **descr)
 101 {
 102         modtype = trekker = 0;
 103
 104         /* Protracker and variants */
 105         if ((!memcmp(id, "M.K.", 4)) || (!memcmp(id, "M!K!", 4))) {
 106                 *descr = protracker;
 107                 modtype = 0;
 108                 *numchn = 4;
 109                 return 1;
 110         }
 111
 112         /* Star Tracker */
 113         if (((!memcmp(id, "FLT", 3)) || (!memcmp(id, "EXO", 3))) &&
 114                 (mik_isdigit(id[3]))) {
 115                 *descr = startrekker;
 116                 modtype = trekker = 1;
 117                 *numchn = id[3] - '0';
 118                 if (*numchn == 4 || *numchn == 8)
 119                         return 1;
 120 #ifdef MIKMOD_DEBUG
 121                 else
 122                         fprintf(stderr, "\rUnknown FLT%d module type\n", *numchn);
 123 #endif
 124                 return 0;
 125         }
 126
 127         /* Oktalyzer (Amiga) */
 128         if (!memcmp(id, "OKTA", 4)) {
 129                 *descr = oktalyzer;
 130                 modtype = 1;
 131                 *numchn = 8;
 132                 return 1;
 133         }
 134
 135         /* Oktalyser (Atari) */
 136         if (!memcmp(id, "CD81", 4)) {
 137                 *descr = oktalyser;
 138                 modtype = 1;
 139                 *numchn = 8;
 140                 return 1;
 141         }
 142
 143         /* Fasttracker */
 144         if ((!memcmp(id + 1, "CHN", 3)) && (mik_isdigit(id[0]))) {
 145                 *descr = fasttracker;
 146                 modtype = 1;
 147                 *numchn = id[0] - '0';
 148                 return 1;
 149         }
 150         /* Fasttracker or Taketracker */
 151         if (((!memcmp(id + 2, "CH", 2)) || (!memcmp(id + 2, "CN", 2)))
 152                 && (mik_isdigit(id[0])) && (mik_isdigit(id[1]))) {
 153                 if (id[3] == 'H') {
 154                         *descr = fasttracker;
 155                         modtype = 2;            /* this can also be Imago Orpheus */
 156                 } else {
 157                         *descr = taketracker;
 158                         modtype = 1;
 159                 }
 160                 *numchn = (id[0] - '0') * 10 + (id[1] - '0');
 161                 return 1;
 162         }
 163
 164         return 0;
 165 }
 166
 167 static BOOL MOD_Test(void)
 168 {
 169         UBYTE id[4], numchn;
 170         CHAR *descr;
 171
 172         _mm_fseek(modreader, MODULEHEADERSIZE, SEEK_SET);
 173         if (!_mm_read_UBYTES(id, 4, modreader))
 174                 return 0;
 175
 176         if (MOD_CheckType(id, &numchn, &descr))
 177                 return 1;
 178
 179         return 0;
 180 }
 181
 182 static BOOL MOD_Init(void)
 183 {
 184         if (!(mh = (MODULEHEADER *)MikMod_malloc(sizeof(MODULEHEADER))))
 185                 return 0;
 186         return 1;
 187 }
 188
 189 static void MOD_Cleanup(void)
 190 {
 191         MikMod_free(mh);
 192         MikMod_free(patbuf);
 193         mh=NULL;
 194         patbuf=NULL;
 195 }
 196
 197 /*
 198 Old (amiga) noteinfo:
 199
 200 _____byte 1_____   byte2_    _____byte 3_____   byte4_
 201 /                \ /      \  /                \ /      \
 202 0000          0000-00000000  0000          0000-00000000
 203
 204 Upper four    12 bits for    Lower four    Effect command.
 205 bits of sam-  note period.   bits of sam-
 206 ple number.                  ple number.
 207
 208 */
 209
 210 static UBYTE ConvertNote(MODNOTE *n, UBYTE lasteffect)
 211 {
 212         UBYTE instrument, effect, effdat, note;
 213         UWORD period;
 214         UBYTE lastnote = 0;
 215
 216         /* extract the various information from the 4 bytes that make up a note */
 217         instrument = (n->a & 0x10) | (n->c >> 4);
 218         period = (((UWORD)n->a & 0xf) << 8) + n->b;
 219         effect = n->c & 0xf;
 220         effdat = n->d;
 221
 222         /* Convert the period to a note number */
 223         note = 0;
 224         if (period) {
 225                 for (note = 0; note < 7 * OCTAVE; note++)
 226                         if (period >= npertab[note])
 227                                 break;
 228                 if (note == 7 * OCTAVE)
 229                         note = 0;
 230                 else
 231                         note++;
 232         }
 233
 234         if (instrument) {
 235                 /* if instrument does not exist, note cut */
 236                 if ((instrument > 31) || (!mh->samples[instrument - 1].length)) {
 237                         UniPTEffect(0xc, 0);
 238                         if (effect == 0xc)
 239                                 effect = effdat = 0;
 240                 } else {
 241                         /* Protracker handling */
 242                         if (!modtype) {
 243                                 /* if we had a note, then change instrument... */
 244                                 if (note)
 245                                         UniInstrument(instrument - 1);
 246                                 /* ...otherwise, only adjust volume... */
 247                                 else {
 248                                         /* ...unless an effect was specified, which forces a new
 249                                            note to be played */
 250                                         if (effect || effdat) {
 251                                                 UniInstrument(instrument - 1);
 252                                                 note = lastnote;
 253                                         } else
 254                                                 UniPTEffect(0xc,
 255                                                                         mh->samples[instrument -
 256                                                                                                 1].volume & 0x7f);
 257                                 }
 258                         } else {
 259                                 /* Fasttracker handling */
 260                                 UniInstrument(instrument - 1);
 261                                 if (!note)
 262                                         note = lastnote;
 263                         }
 264                 }
 265         }
 266         if (note) {
 267                 UniNote(note + 2 * OCTAVE - 1);
 268                 lastnote = note;
 269         }
 270
 271         /* Convert pattern jump from Dec to Hex */
 272         if (effect == 0xd)
 273                 effdat = (((effdat & 0xf0) >> 4) * 10) + (effdat & 0xf);
 274
 275         /* Volume slide, up has priority */
 276         if ((effect == 0xa) && (effdat & 0xf) && (effdat & 0xf0))
 277                 effdat &= 0xf0;
 278
 279         /* Handle ``heavy'' volumes correctly */
 280         if ((effect == 0xc) && (effdat > 0x40))
 281                 effdat = 0x40;
 282
 283         /* An isolated 100, 200 or 300 effect should be ignored (no
 284            "standalone" porta memory in mod files). However, a sequence such
 285            as 1XX, 100, 100, 100 is fine. */
 286         if ((!effdat) && ((effect == 1)||(effect == 2)||(effect ==3)) &&
 287                 (lasteffect < 0x10) && (effect != lasteffect))
 288                 effect = 0;
 289
 290         UniPTEffect(effect, effdat);
 291         if (effect == 8)
 292                 of.flags |= UF_PANNING;
 293
 294         return effect;
 295 }
 296
 297 static UBYTE *ConvertTrack(MODNOTE *n, int numchn)
 298 {
 299         int t;
 300         UBYTE lasteffect = 0x10;        /* non existant effect */
 301
 302         UniReset();
 303         for (t = 0; t < 64; t++) {
 304                 lasteffect = ConvertNote(n,lasteffect);
 305                 UniNewline();
 306                 n += numchn;
 307         }
 308         return UniDup();
 309 }
 310
 311 /* Loads all patterns of a modfile and converts them into the 3 byte format. */
 312 static BOOL ML_LoadPatterns(void)
 313 {
 314         int t, s, tracks = 0;
 315
 316         if (!AllocPatterns())
 317                 return 0;
 318         if (!AllocTracks())
 319                 return 0;
 320
 321         /* Allocate temporary buffer for loading and converting the patterns */
 322         if (!(patbuf = (MODNOTE *)MikMod_calloc(64U * of.numchn, sizeof(MODNOTE))))
 323                 return 0;
 324
 325         if (trekker && of.numchn == 8) {
 326                 /* Startrekker module dual pattern */
 327                 for (t = 0; t < of.numpat; t++) {
 328                         for (s = 0; s < (64U * 4); s++) {
 329                                 patbuf[s].a = _mm_read_UBYTE(modreader);
 330                                 patbuf[s].b = _mm_read_UBYTE(modreader);
 331                                 patbuf[s].c = _mm_read_UBYTE(modreader);
 332                                 patbuf[s].d = _mm_read_UBYTE(modreader);
 333                         }
 334                         for (s = 0; s < 4; s++)
 335                                 if (!(of.tracks[tracks++] = ConvertTrack(patbuf + s, 4)))
 336                                         return 0;
 337                         for (s = 0; s < (64U * 4); s++) {
 338                                 patbuf[s].a = _mm_read_UBYTE(modreader);
 339                                 patbuf[s].b = _mm_read_UBYTE(modreader);
 340                                 patbuf[s].c = _mm_read_UBYTE(modreader);
 341                                 patbuf[s].d = _mm_read_UBYTE(modreader);
 342                         }
 343                         for (s = 0; s < 4; s++)
 344                                 if (!(of.tracks[tracks++] = ConvertTrack(patbuf + s, 4)))
 345                                         return 0;
 346                 }
 347         } else {
 348                 /* Generic module pattern */
 349                 for (t = 0; t < of.numpat; t++) {
 350                         /* Load the pattern into the temp buffer and convert it */
 351                         for (s = 0; s < (int)(64U * of.numchn); s++) {
 352                                 patbuf[s].a = _mm_read_UBYTE(modreader);
 353                                 patbuf[s].b = _mm_read_UBYTE(modreader);
 354                                 patbuf[s].c = _mm_read_UBYTE(modreader);
 355                                 patbuf[s].d = _mm_read_UBYTE(modreader);
 356                         }
 357                         for (s = 0; s < of.numchn; s++)
 358                                 if (!(of.tracks[tracks++] = ConvertTrack(patbuf + s, of.numchn)))
 359                                         return 0;
 360                 }
 361         }
 362         return 1;
 363 }
 364
 365 static BOOL MOD_Load(BOOL curious)
 366 {
 367         int t, scan;
 368         SAMPLE *q;
 369         MSAMPINFO *s;
 370         CHAR *descr;
 371
 372         /* try to read module header */
 373         _mm_read_string((CHAR *)mh->songname, 20, modreader);
 374         mh->songname[20] = 0;           /* just in case */
 375
 376         for (t = 0; t < 31; t++) {
 377                 s = &mh->samples[t];
 378                 _mm_read_string(s->samplename, 22, modreader);
 379                 s->samplename[22] = 0;  /* just in case */
 380                 s->length = _mm_read_M_UWORD(modreader);
 381                 s->finetune = _mm_read_UBYTE(modreader);
 382                 s->volume = _mm_read_UBYTE(modreader);
 383                 s->reppos = _mm_read_M_UWORD(modreader);
 384                 s->replen = _mm_read_M_UWORD(modreader);
 385         }
 386
 387         mh->songlength = _mm_read_UBYTE(modreader);
 388
 389         /* this fixes mods which declare more than 128 positions.
 390          * eg: beatwave.mod */
 391         if (mh->songlength > 128) { mh->songlength = 128; }
 392
 393         mh->magic1 = _mm_read_UBYTE(modreader);
 394         _mm_read_UBYTES(mh->positions, 128, modreader);
 395         _mm_read_UBYTES(mh->magic2, 4, modreader);
 396
 397         if (_mm_eof(modreader)) {
 398                 _mm_errno = MMERR_LOADING_HEADER;
 399                 return 0;
 400         }
 401
 402         /* set module variables */
 403         of.initspeed = 6;
 404         of.inittempo = 125;
 405         if (!(MOD_CheckType(mh->magic2, &of.numchn, &descr))) {
 406                 _mm_errno = MMERR_NOT_A_MODULE;
 407                 return 0;
 408         }
 409         if (trekker && of.numchn == 8)
 410                 for (t = 0; t < 128; t++)
 411                         /* if module pretends to be FLT8, yet the order table
 412                            contains odd numbers, chances are it's a lying FLT4... */
 413                         if (mh->positions[t] & 1) {
 414                                 of.numchn = 4;
 415                                 break;
 416                         }
 417         if (trekker && of.numchn == 8)
 418                 for (t = 0; t < 128; t++)
 419                         mh->positions[t] >>= 1;
 420
 421         of.songname = DupStr(mh->songname, 21, 1);
 422         of.numpos = mh->songlength;
 423         of.reppos = 0;
 424
 425         /* Count the number of patterns */
 426         of.numpat = 0;
 427         for (t = 0; t < of.numpos; t++)
 428                 if (mh->positions[t] > of.numpat)
 429                         of.numpat = mh->positions[t];
 430
 431         /* since some old modules embed extra patterns, we have to check the
 432            whole list to get the samples' file offsets right - however we can find
 433            garbage here, so check carefully */
 434         scan = 1;
 435         for (t = of.numpos; t < 128; t++)
 436                 if (mh->positions[t] >= 0x80)
 437                         scan = 0;
 438         if (scan)
 439                 for (t = of.numpos; t < 128; t++) {
 440                         if (mh->positions[t] > of.numpat)
 441                                 of.numpat = mh->positions[t];
 442                         if ((curious) && (mh->positions[t]))
 443                                 of.numpos = t + 1;
 444                 }
 445         of.numpat++;
 446         of.numtrk = of.numpat * of.numchn;
 447
 448         if (!AllocPositions(of.numpos))
 449                 return 0;
 450         for (t = 0; t < of.numpos; t++)
 451                 of.positions[t] = mh->positions[t];
 452
 453         /* Finally, init the sampleinfo structures  */
 454         of.numins = of.numsmp = 31;
 455         if (!AllocSamples())
 456                 return 0;
 457         s = mh->samples;
 458         q = of.samples;
 459         for (t = 0; t < of.numins; t++) {
 460                 /* convert the samplename */
 461                 q->samplename = DupStr(s->samplename, 23, 1);
 462                 /* init the sampleinfo variables and convert the size pointers */
 463                 q->speed = finetune[s->finetune & 0xf];
 464                 q->volume = s->volume & 0x7f;
 465                 q->loopstart = (ULONG)s->reppos << 1;
 466                 q->loopend = q->loopstart + ((ULONG)s->replen << 1);
 467                 q->length = (ULONG)s->length << 1;
 468                 q->flags = SF_SIGNED;
 469                 /* Imago Orpheus creates MODs with 16 bit samples, check */
 470                 if ((modtype == 2) && (s->volume & 0x80)) {
 471                         q->flags |= SF_16BITS;
 472                         descr = orpheus;
 473                 }
 474                 if (s->replen > 2)
 475                         q->flags |= SF_LOOP;
 476
 477                 s++;
 478                 q++;
 479         }
 480
 481         of.modtype = MikMod_strdup(descr);
 482
 483         if (!ML_LoadPatterns())
 484                 return 0;
 485
 486         return 1;
 487 }
 488
 489 static CHAR *MOD_LoadTitle(void)
 490 {
 491         CHAR s[21];
 492
 493         _mm_fseek(modreader, 0, SEEK_SET);
 494         if (!_mm_read_UBYTES(s, 20, modreader))
 495                 return NULL;
 496         s[20] = 0;                                      /* just in case */
 497
 498         return (DupStr(s, 21, 1));
 499 }
 500
 501 /*========== Loader information */
 502
 503 MIKMODAPI MLOADER load_mod = {
 504         NULL,
 505         "Standard module",
 506         "MOD (31 instruments)",
 507         MOD_Init,
 508         MOD_Test,
 509         MOD_Load,
 510         MOD_Cleanup,
 511         MOD_LoadTitle
 512 };
 513
 514 /* ex:set ts=4: */