libunimod/load_xm.c

   1 /*      MikMod sound library
   2    (c) 1998, 1999 Miodrag Vallat and others - see file AUTHORS for
   3    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   Fasttracker (XM) module loader
  26
  27 ==============================================================================*/
  28
  29 #ifdef HAVE_CONFIG_H
  30 #include "config.h"
  31 #endif
  32
  33 #ifdef HAVE_STRING_H
  34 #include <string.h>
  35 #endif
  36
  37 #include "unimod_priv.h"
  38
  39 /*========== Module structure */
  40
  41 typedef struct XMHEADER
  42   {
  43     CHAR id[17];                /* ID text: 'Extended module: ' */
  44     CHAR songname[21];          /* Module name */
  45     CHAR trackername[20];       /* Tracker name */
  46     UWORD version;              /* Version number */
  47     ULONG headersize;           /* Header size */
  48     UWORD songlength;           /* Song length (in patten order table) */
  49     UWORD restart;              /* Restart position */
  50     UWORD numchn;               /* Number of channels (2,4,6,8,10,...,32) */
  51     UWORD numpat;               /* Number of patterns (max 256) */
  52     UWORD numins;               /* Number of instruments (max 128) */
  53     UWORD flags;
  54     UWORD tempo;                /* Default tempo */
  55     UWORD bpm;                  /* Default BPM */
  56     UBYTE orders[256];          /* Pattern order table  */
  57   }
  58 XMHEADER;
  59
  60 typedef struct XMINSTHEADER
  61   {
  62     ULONG size;                 /* Instrument size */
  63     CHAR name[22];              /* Instrument name */
  64     UBYTE type;                 /* Instrument type (always 0) */
  65     UWORD numsmp;               /* Number of samples in instrument */
  66     ULONG ssize;
  67   }
  68 XMINSTHEADER;
  69
  70 #define XMENVCNT (12 * 2)
  71 #define XMNOTECNT (8*OCTAVE)
  72 typedef struct XMPATCHHEADER
  73   {
  74     UBYTE what[XMNOTECNT];      /*  Sample number for all notes */
  75     UWORD volenv[XMENVCNT];     /*  Points for volume envelope */
  76     UWORD panenv[XMENVCNT];     /*  Points for panning envelope */
  77     UBYTE volpts;               /*  Number of volume points */
  78     UBYTE panpts;               /*  Number of panning points */
  79     UBYTE volsus;               /*  Volume sustain point */
  80     UBYTE volbeg;               /*  Volume loop start point */
  81     UBYTE volend;               /*  Volume loop end point */
  82     UBYTE pansus;               /*  Panning sustain point */
  83     UBYTE panbeg;               /*  Panning loop start point */
  84     UBYTE panend;               /*  Panning loop end point */
  85     UBYTE volflg;               /*  Volume type: bit 0: On; 1: Sustain; 2: Loop */
  86     UBYTE panflg;               /*  Panning type: bit 0: On; 1: Sustain; 2: Loop */
  87     UBYTE vibflg;               /*  Vibrato type */
  88     UBYTE vibsweep;             /*  Vibrato sweep */
  89     UBYTE vibdepth;             /*  Vibrato depth */
  90     UBYTE vibrate;              /*  Vibrato rate */
  91     UWORD volfade;              /*  Volume fadeout */
  92   }
  93 XMPATCHHEADER;
  94
  95 typedef struct XMWAVHEADER
  96   {
  97     ULONG length;               /* Sample length */
  98     ULONG loopstart;            /* Sample loop start */
  99     ULONG looplength;           /* Sample loop length */
 100     UBYTE volume;               /* Volume  */
 101     SBYTE finetune;             /* Finetune (signed byte -128..+127) */
 102     UBYTE type;                 /* Loop type */
 103     UBYTE panning;              /* Panning (0-255) */
 104     SBYTE relnote;              /* Relative note number (signed byte) */
 105     UBYTE reserved;
 106     CHAR samplename[22];        /* Sample name */
 107     UBYTE vibtype;              /* Vibrato type */
 108     UBYTE vibsweep;             /* Vibrato sweep */
 109     UBYTE vibdepth;             /* Vibrato depth */
 110     UBYTE vibrate;              /* Vibrato rate */
 111   }
 112 XMWAVHEADER;
 113
 114 typedef struct XMPATHEADER
 115   {
 116     ULONG size;                 /* Pattern header length  */
 117     UBYTE packing;              /* Packing type (always 0) */
 118     UWORD numrows;              /* Number of rows in pattern (1..256) */
 119     SWORD packsize;             /* Packed patterndata size */
 120   }
 121 XMPATHEADER;
 122
 123 typedef struct XMNOTE
 124   {
 125     UBYTE note, ins, vol, eff, dat;
 126   }
 127 XMNOTE;
 128
 129 /*========== Loader variables */
 130
 131 static XMNOTE *xmpat = NULL;
 132 static XMHEADER *mh = NULL;
 133
 134 /* increment unit for sample array reallocation */
 135 #define XM_SMPINCR 64
 136 static ULONG *nextwav = NULL;
 137 static XMWAVHEADER *wh = NULL, *s = NULL;
 138
 139 /*========== Loader code */
 140
 141 static BOOL
 142 XM_Test(void)
 143 {
 144   UBYTE id[38];
 145
 146   if (!_mm_read_UBYTES(id, 38, modreader))
 147     return 0;
 148   if (memcmp(id, "Extended Module: ", 17))
 149     return 0;
 150   if (id[37] == 0x1a)
 151     return 1;
 152   return 0;
 153 }
 154
 155 static BOOL
 156 XM_Init(void)
 157 {
 158   if (!(mh = (XMHEADER*) _mm_malloc(sizeof(XMHEADER))))
 159     return 0;
 160   return 1;
 161 }
 162
 163 static void
 164 XM_Cleanup(void)
 165 {
 166   _mm_free(mh);
 167 }
 168
 169 static int
 170 XM_ReadNote(XMNOTE * n)
 171 {
 172   UBYTE cmp, result = 1;
 173
 174   memset(n, 0, sizeof(XMNOTE));
 175   cmp = _mm_read_UBYTE(modreader);
 176
 177   if (cmp & 0x80)
 178     {
 179       if (cmp & 1)
 180         {
 181           result++;
 182           n->note = _mm_read_UBYTE(modreader);
 183         }
 184       if (cmp & 2)
 185         {
 186           result++;
 187           n->ins = _mm_read_UBYTE(modreader);
 188         }
 189       if (cmp & 4)
 190         {
 191           result++;
 192           n->vol = _mm_read_UBYTE(modreader);
 193         }
 194       if (cmp & 8)
 195         {
 196           result++;
 197           n->eff = _mm_read_UBYTE(modreader);
 198         }
 199       if (cmp & 16)
 200         {
 201           result++;
 202           n->dat = _mm_read_UBYTE(modreader);
 203         }
 204     }
 205   else
 206     {
 207       n->note = cmp;
 208       n->ins = _mm_read_UBYTE(modreader);
 209       n->vol = _mm_read_UBYTE(modreader);
 210       n->eff = _mm_read_UBYTE(modreader);
 211       n->dat = _mm_read_UBYTE(modreader);
 212       result += 4;
 213     }
 214   return result;
 215 }
 216
 217 static UBYTE *
 218 XM_Convert(XMNOTE * xmtrack, UWORD rows)
 219 {
 220   int t;
 221   UBYTE note, ins, vol, eff, dat;
 222
 223   UniReset();
 224   for (t = 0; t < rows; t++)
 225     {
 226       note = xmtrack->note;
 227       ins = xmtrack->ins;
 228       vol = xmtrack->vol;
 229       eff = xmtrack->eff;
 230       dat = xmtrack->dat;
 231
 232       if (note)
 233         {
 234           if (note > XMNOTECNT)
 235             UniEffect(UNI_KEYFADE, 0);
 236           else
 237             UniNote(note - 1);
 238         }
 239       if (ins)
 240         UniInstrument(ins - 1);
 241
 242       switch (vol >> 4)
 243         {
 244         case 0x6:               /* volslide down */
 245           if (vol & 0xf)
 246             UniEffect(UNI_XMEFFECTA, vol & 0xf);
 247           break;
 248         case 0x7:               /* volslide up */
 249           if (vol & 0xf)
 250             UniEffect(UNI_XMEFFECTA, (vol << 4) & 0xff);
 251           break;
 252
 253           /* volume-row fine volume slide is compatible with protracker
 254              EBx and EAx effects i.e. a zero nibble means DO NOT SLIDE, as
 255              opposed to 'take the last sliding value'. */
 256         case 0x8:               /* finevol down */
 257           UniPTEffect(0xe, 0xb0 | (vol & 0xf));
 258           break;
 259         case 0x9:               /* finevol up */
 260           UniPTEffect(0xe, 0xa0 | (vol & 0xf));
 261           break;
 262         case 0xa:               /* set vibrato speed */
 263           UniPTEffect(0x4, (vol << 4) & 0xff);
 264           break;
 265         case 0xb:               /* vibrato */
 266           UniPTEffect(0x4, vol & 0xf);
 267           break;
 268         case 0xc:               /* set panning */
 269           UniPTEffect(0x8, (vol << 4) & 0xff);
 270           break;
 271         case 0xd:               /* panning slide left (only slide when data not zero) */
 272           if (vol & 0xf)
 273             UniEffect(UNI_XMEFFECTP, vol & 0xf);
 274           break;
 275         case 0xe:               /* panning slide right (only slide when data not zero) */
 276           if (vol & 0xf)
 277             UniEffect(UNI_XMEFFECTP, vol << 4);
 278           break;
 279         case 0xf:               /* tone porta */
 280           UniPTEffect(0x3, (vol << 4) & 0xff);
 281           break;
 282         default:
 283           if ((vol >= 0x10) && (vol <= 0x50))
 284             UniPTEffect(0xc, vol - 0x10);
 285         }
 286
 287       switch (eff)
 288         {
 289         case 0x4:
 290           UniEffect(UNI_XMEFFECT4, dat);
 291           break;
 292         case 0xa:
 293           UniEffect(UNI_XMEFFECTA, dat);
 294           break;
 295         case 0xe:               /* Extended effects */
 296           switch (dat >> 4)
 297             {
 298             case 0x1:           /* XM fine porta up */
 299               UniEffect(UNI_XMEFFECTE1, dat & 0xf);
 300               break;
 301             case 0x2:           /* XM fine porta down */
 302               UniEffect(UNI_XMEFFECTE2, dat & 0xf);
 303               break;
 304             case 0xa:           /* XM fine volume up */
 305               UniEffect(UNI_XMEFFECTEA, dat & 0xf);
 306               break;
 307             case 0xb:           /* XM fine volume down */
 308               UniEffect(UNI_XMEFFECTEB, dat & 0xf);
 309               break;
 310             default:
 311               UniPTEffect(eff, dat);
 312             }
 313           break;
 314         case 'G' - 55:          /* G - set global volume */
 315           UniEffect(UNI_XMEFFECTG, dat > 64 ? 64 : dat);
 316           break;
 317         case 'H' - 55:          /* H - global volume slide */
 318           UniEffect(UNI_XMEFFECTH, dat);
 319           break;
 320         case 'K' - 55:          /* K - keyOff and KeyFade */
 321           UniEffect(UNI_KEYFADE, dat);
 322           break;
 323         case 'L' - 55:          /* L - set envelope position */
 324           UniEffect(UNI_XMEFFECTL, dat);
 325           break;
 326         case 'P' - 55:          /* P - panning slide */
 327           UniEffect(UNI_XMEFFECTP, dat);
 328           break;
 329         case 'R' - 55:          /* R - multi retrig note */
 330           UniEffect(UNI_S3MEFFECTQ, dat);
 331           break;
 332         case 'T' - 55:          /* T - Tremor */
 333           UniEffect(UNI_S3MEFFECTI, dat);
 334           break;
 335         case 'X' - 55:
 336           switch (dat >> 4)
 337             {
 338             case 1:             /* X1 - Extra Fine Porta up */
 339               UniEffect(UNI_XMEFFECTX1, dat & 0xf);
 340               break;
 341             case 2:             /* X2 - Extra Fine Porta down */
 342               UniEffect(UNI_XMEFFECTX2, dat & 0xf);
 343               break;
 344             }
 345           break;
 346         default:
 347           if (eff <= 0xf)
 348             {
 349               /* the pattern jump destination is written in decimal,
 350                  but it seems some poor tracker software writes them
 351                  in hexadecimal... (sigh) */
 352               if (eff == 0xd)
 353                 /* don't change anything if we're sure it's in hexa */
 354                 if ((((dat & 0xf0) >> 4) <= 9) && ((dat & 0xf) <= 9))
 355                   /* otherwise, convert from dec to hex */
 356                   dat = (((dat & 0xf0) >> 4) * 10) + (dat & 0xf);
 357               UniPTEffect(eff, dat);
 358             }
 359           break;
 360         }
 361       UniNewline();
 362       xmtrack++;
 363     }
 364   return UniDup();
 365 }
 366
 367 static BOOL
 368 LoadPatterns(BOOL dummypat)
 369 {
 370   int t, u, v, numtrk;
 371
 372   if (!AllocTracks())
 373     return 0;
 374   if (!AllocPatterns())
 375     return 0;
 376
 377   numtrk = 0;
 378   for (t = 0; t < mh->numpat; t++)
 379     {
 380       XMPATHEADER ph;
 381
 382       ph.size = _mm_read_I_ULONG(modreader);
 383       if (ph.size < (mh->version == 0x0102 ? 8 : 9))
 384         {
 385           _mm_errno = MMERR_LOADING_PATTERN;
 386           return 0;
 387         }
 388       ph.packing = _mm_read_UBYTE(modreader);
 389       if (ph.packing)
 390         {
 391           _mm_errno = MMERR_LOADING_PATTERN;
 392           return 0;
 393         }
 394       if (mh->version == 0x0102)
 395         ph.numrows = _mm_read_UBYTE(modreader) + 1;
 396       else
 397         ph.numrows = _mm_read_I_UWORD(modreader);
 398       ph.packsize = _mm_read_I_UWORD(modreader);
 399
 400       ph.size -= (mh->version == 0x0102 ? 8 : 9);
 401       if (ph.size)
 402         _mm_fseek(modreader, ph.size, SEEK_CUR);
 403
 404       of.pattrows[t] = ph.numrows;
 405
 406       if (ph.numrows)
 407         {
 408           if (!(xmpat = (XMNOTE*) _mm_calloc(ph.numrows * of.numchn, sizeof(XMNOTE))))
 409             return 0;
 410
 411           /* when packsize is 0, don't try to load a pattern.. it's empty. */
 412           if (ph.packsize)
 413             for (u = 0; u < ph.numrows; u++)
 414               for (v = 0; v < of.numchn; v++)
 415                 {
 416                   if (!ph.packsize)
 417                     break;
 418
 419                   ph.packsize -= XM_ReadNote(&xmpat[(v * ph.numrows) + u]);
 420                   if (ph.packsize < 0)
 421                     {
 422                       _mm_free(xmpat);
 423                       xmpat = NULL;
 424                       _mm_errno = MMERR_LOADING_PATTERN;
 425                       return 0;
 426                     }
 427                 }
 428
 429           if (ph.packsize)
 430             {
 431               _mm_fseek(modreader, ph.packsize, SEEK_CUR);
 432             }
 433
 434           if (_mm_eof(modreader))
 435             {
 436               _mm_free(xmpat);
 437               xmpat = NULL;
 438               _mm_errno = MMERR_LOADING_PATTERN;
 439               return 0;
 440             }
 441
 442           for (v = 0; v < of.numchn; v++)
 443             of.tracks[numtrk++] = XM_Convert(&xmpat[v * ph.numrows], ph.numrows);
 444
 445           _mm_free(xmpat);
 446           xmpat = NULL;
 447         }
 448       else
 449         {
 450           for (v = 0; v < of.numchn; v++)
 451             of.tracks[numtrk++] = XM_Convert(NULL, ph.numrows);
 452         }
 453     }
 454
 455   if (dummypat)
 456     {
 457       of.pattrows[t] = 64;
 458       if (!(xmpat = (XMNOTE*) _mm_calloc(64 * of.numchn, sizeof(XMNOTE))))
 459         return 0;
 460       for (v = 0; v < of.numchn; v++)
 461         of.tracks[numtrk++] = XM_Convert(&xmpat[v * 64], 64);
 462       _mm_free(xmpat);
 463       xmpat = NULL;
 464     }
 465
 466   return 1;
 467 }
 468
 469 static BOOL
 470 LoadInstruments(void)
 471 {
 472   int t, u, ck;
 473   INSTRUMENT *d;
 474   SLONG next = 0;
 475   UWORD wavcnt = 0;
 476
 477   if (!AllocInstruments())
 478     return 0;
 479   d = of.instruments;
 480   for (t = 0; t < of.numins; t++, d++)
 481     {
 482       XMINSTHEADER ih;
 483       SLONG headend;
 484
 485       memset(d->samplenumber, 0xff, INSTNOTES * sizeof(UWORD));
 486
 487       /* read instrument header */
 488       headend = _mm_ftell(modreader);
 489       ih.size = _mm_read_I_ULONG(modreader);
 490       headend += ih.size;
 491       ck = _mm_ftell(modreader);
 492       _mm_fseek(modreader, 0, SEEK_END);
 493       if ((headend < 0) || (_mm_ftell(modreader) < headend) || (headend < ck)) {
 494         _mm_fseek(modreader, ck, SEEK_SET);
 495         break;
 496       }
 497       _mm_fseek(modreader, ck, SEEK_SET);
 498       _mm_read_string(ih.name, 22, modreader);
 499       ih.type = _mm_read_UBYTE(modreader);
 500       ih.numsmp = _mm_read_I_UWORD(modreader);
 501
 502       d->insname = DupStr(ih.name, 22, 1);
 503
 504       if ((SWORD) ih.size > 29)
 505         {
 506           ih.ssize = _mm_read_I_ULONG(modreader);
 507           if (((SWORD) ih.numsmp > 0) && (ih.numsmp <= XMNOTECNT))
 508             {
 509               XMPATCHHEADER pth;
 510               int p;
 511               ULONG *newnextwav;
 512               XMWAVHEADER *newwh;
 513
 514               _mm_read_UBYTES(pth.what, XMNOTECNT, modreader);
 515               _mm_read_I_UWORDS(pth.volenv, XMENVCNT, modreader);
 516               _mm_read_I_UWORDS(pth.panenv, XMENVCNT, modreader);
 517               pth.volpts = _mm_read_UBYTE(modreader);
 518               pth.panpts = _mm_read_UBYTE(modreader);
 519               pth.volsus = _mm_read_UBYTE(modreader);
 520               pth.volbeg = _mm_read_UBYTE(modreader);
 521               pth.volend = _mm_read_UBYTE(modreader);
 522               pth.pansus = _mm_read_UBYTE(modreader);
 523               pth.panbeg = _mm_read_UBYTE(modreader);
 524               pth.panend = _mm_read_UBYTE(modreader);
 525               pth.volflg = _mm_read_UBYTE(modreader);
 526               pth.panflg = _mm_read_UBYTE(modreader);
 527               pth.vibflg = _mm_read_UBYTE(modreader);
 528               pth.vibsweep = _mm_read_UBYTE(modreader);
 529               pth.vibdepth = _mm_read_UBYTE(modreader);
 530               pth.vibrate = _mm_read_UBYTE(modreader);
 531               pth.volfade = _mm_read_I_UWORD(modreader);
 532
 533               /* read the remainder of the header
 534                  (2 bytes for 1.03, 22 for 1.04) */
 535               if (headend >= _mm_ftell(modreader))
 536               for (u = headend - _mm_ftell(modreader); u; u--)
 537                 _mm_read_UBYTE(modreader);
 538
 539               /* #@!$&% fix for K_OSPACE.XM and possibly others */
 540               if (pth.volpts > XMENVCNT / 2)
 541                 pth.volpts = XMENVCNT / 2;
 542               if (pth.panpts > XMENVCNT / 2)
 543                 pth.panpts = XMENVCNT / 2;
 544
 545               if ((_mm_eof(modreader)) || (pth.volpts > XMENVCNT / 2) || (pth.panpts > XMENVCNT / 2))
 546                 {
 547                   _mm_free(nextwav);
 548                   nextwav = NULL;
 549                   _mm_free(wh);
 550                   wh = NULL;
 551                   _mm_errno = MMERR_LOADING_SAMPLEINFO;
 552                   return 0;
 553                 }
 554
 555               for (u = 0; u < XMNOTECNT; u++)
 556                 d->samplenumber[u] = pth.what[u] + of.numsmp;
 557               d->volfade = pth.volfade;
 558
 559 #define XM_ProcessEnvelope(name)                                                                                        \
 560                                 for (u = 0; u < (XMENVCNT / 2); u++) {                                          \
 561                                         d->name##env[u].pos = pth.name##env[2*u];               \
 562                                         d->name##env[u].val = pth.name##env[2*u + 1];   \
 563                                 }                                                                                                                       \
 564                                 memcpy(d->name##env, pth.name##env, XMENVCNT);                  \
 565                                 if (pth.name##flg & 1) d->name##flg |= EF_ON;                           \
 566                                 if (pth.name##flg & 2) d->name##flg |= EF_SUSTAIN;                      \
 567                                 if (pth.name##flg & 4) d->name##flg |= EF_LOOP;                         \
 568                                 d->name##susbeg = d->name##susend = pth.name##sus;              \
 569                                 d->name##beg = pth.name##beg;                                                           \
 570                                 d->name##end = pth.name##end;                                                           \
 571                                 d->name##pts = pth.name##pts;                                                           \
 572                                                                                                                                                         \
 573                                 /* scale envelope */                                                                            \
 574                                 for (p = 0; p < XMENVCNT / 2; p++)                                                                      \
 575                                         d->name##env[p].val <<= 2;                                                              \
 576                                                                                                                                                         \
 577                                 if ((d->name##flg & EF_ON) && (d->name##pts < 2))                               \
 578                                         d->name##flg &= ~EF_ON;
 579
 580               XM_ProcessEnvelope(vol);
 581               XM_ProcessEnvelope(pan);
 582 #undef XM_ProcessEnvelope
 583
 584               /* Samples are stored outside the instrument struct now, so we
 585                  have to load them all into a temp area, count the of.numsmp
 586                  along the way and then do an AllocSamples() and move
 587                  everything over */
 588               if (mh->version > 0x0103)
 589                 next = 0;
 590               for (u = 0; u < ih.numsmp; u++, s++)
 591                 {
 592                   /* Allocate more room for sample information if necessary */
 593                   if (of.numsmp + u == wavcnt)
 594                     {
 595                       wavcnt += XM_SMPINCR;
 596                       if (!(newnextwav = realloc(nextwav, wavcnt * sizeof(ULONG))))
 597                         {
 598                           _mm_free(nextwav);
 599                           _mm_free(wh);
 600                           wh = NULL;
 601                           _mm_errno = MMERR_OUT_OF_MEMORY;
 602                           return 0;
 603                         }
 604                       nextwav = newnextwav;
 605                       if (!(newwh = realloc(wh, wavcnt * sizeof(XMWAVHEADER))))
 606                         {
 607                           _mm_free(wh);
 608                           _mm_free(nextwav);
 609                           nextwav = NULL;
 610                           _mm_errno = MMERR_OUT_OF_MEMORY;
 611                           return 0;
 612                         }
 613                       wh = newwh;
 614                       s = wh + (wavcnt - XM_SMPINCR);
 615                     }
 616
 617                   s->length = _mm_read_I_ULONG(modreader);
 618                   s->loopstart = _mm_read_I_ULONG(modreader);
 619                   s->looplength = _mm_read_I_ULONG(modreader);
 620                   s->volume = _mm_read_UBYTE(modreader);
 621                   s->finetune = _mm_read_SBYTE(modreader);
 622                   s->type = _mm_read_UBYTE(modreader);
 623                   s->panning = _mm_read_UBYTE(modreader);
 624                   s->relnote = _mm_read_SBYTE(modreader);
 625                   s->vibtype = pth.vibflg;
 626                   s->vibsweep = pth.vibsweep;
 627                   s->vibdepth = pth.vibdepth * 4;
 628                   s->vibrate = pth.vibrate;
 629                   s->reserved = _mm_read_UBYTE(modreader);
 630                   _mm_read_string(s->samplename, 22, modreader);
 631
 632                   nextwav[of.numsmp + u] = next;
 633                   next += s->length;
 634
 635                   if (_mm_eof(modreader))
 636                     {
 637                       _mm_free(nextwav);
 638                       nextwav = NULL;
 639                       _mm_free(wh);
 640                       wh = NULL;
 641                       _mm_errno = MMERR_LOADING_SAMPLEINFO;
 642                       return 0;
 643                     }
 644                 }
 645
 646               if (mh->version > 0x0103)
 647                 {
 648                   for (u = 0; u < ih.numsmp; u++)
 649                     nextwav[of.numsmp++] += _mm_ftell(modreader);
 650                   _mm_fseek(modreader, next, SEEK_CUR);
 651                 }
 652               else
 653                 of.numsmp += ih.numsmp;
 654             }
 655           else
 656             {
 657               /* read the remainder of the header */
 658               ck = _mm_ftell(modreader);
 659               _mm_fseek(modreader, 0, SEEK_END);
 660               if ((headend < 0) || (_mm_ftell(modreader) < headend) || (headend < ck)) {
 661                 _mm_fseek(modreader, ck, SEEK_SET);
 662                 break;
 663               }
 664               _mm_fseek(modreader, ck, SEEK_SET);
 665
 666               for (u = headend - _mm_ftell(modreader); u; u--)
 667                 _mm_read_UBYTE(modreader);
 668
 669               /* last instrument is at the end of file in version 0x0104 */
 670               if (_mm_eof(modreader) && (mh->version < 0x0104 || t < of.numins - 1))
 671                 {
 672                   _mm_free(nextwav);
 673                   nextwav = NULL;
 674                   _mm_free(wh);
 675                   wh = NULL;
 676                   _mm_errno = MMERR_LOADING_SAMPLEINFO;
 677                   return 0;
 678                 }
 679             }
 680         }
 681     }
 682
 683   /* sanity check */
 684   if (!of.numsmp)
 685     {
 686       _mm_free(nextwav);
 687       nextwav = NULL;
 688       _mm_free(wh);
 689       wh = NULL;
 690       _mm_errno = MMERR_LOADING_SAMPLEINFO;
 691       return 0;
 692     }
 693
 694   return 1;
 695 }
 696
 697 static BOOL
 698 XM_Load(BOOL curious)
 699 {
 700   INSTRUMENT *d;
 701   SAMPLE *q;
 702   int t, u;
 703   BOOL dummypat = 0;
 704   char tracker[21], modtype[60];
 705
 706   /* try to read module header */
 707   _mm_read_string(mh->id, 17, modreader);
 708   _mm_read_string(mh->songname, 21, modreader);
 709   _mm_read_string(mh->trackername, 20, modreader);
 710   mh->version = _mm_read_I_UWORD(modreader);
 711   if ((mh->version < 0x102) || (mh->version > 0x104))
 712     {
 713       _mm_errno = MMERR_NOT_A_MODULE;
 714       return 0;
 715     }
 716   mh->headersize = _mm_read_I_ULONG(modreader);
 717   mh->songlength = _mm_read_I_UWORD(modreader);
 718   mh->restart = _mm_read_I_UWORD(modreader);
 719   mh->numchn = _mm_read_I_UWORD(modreader);
 720   mh->numpat = _mm_read_I_UWORD(modreader);
 721   mh->numins = _mm_read_I_UWORD(modreader);
 722   mh->flags = _mm_read_I_UWORD(modreader);
 723   mh->tempo = _mm_read_I_UWORD(modreader);
 724   mh->bpm = _mm_read_I_UWORD(modreader);
 725   if (!mh->bpm)
 726     {
 727       _mm_errno = MMERR_NOT_A_MODULE;
 728       return 0;
 729     }
 730   t = mh->headersize - 20;
 731   if (t > sizeof(mh->orders)) t = sizeof(mh->orders);
 732   _mm_read_UBYTES(mh->orders, t, modreader);
 733
 734   if (_mm_eof(modreader))
 735     {
 736       _mm_errno = MMERR_LOADING_HEADER;
 737       return 0;
 738     }
 739
 740   /* set module variables */
 741   of.initspeed = mh->tempo;
 742   of.inittempo = mh->bpm;
 743   strncpy(tracker, mh->trackername, 20);
 744   tracker[20] = 0;
 745   for (t = 20; (tracker[t] <= ' ') && (t >= 0); t--)
 746     tracker[t] = 0;
 747
 748   /* some modules have the tracker name empty */
 749   if (!tracker[0])
 750     strcpy(tracker, "Unknown tracker");
 751
 752 #ifdef HAVE_SNPRINTF
 753   snprintf(modtype, 60, "%s (XM format %d.%02d)",
 754             tracker, mh->version >> 8, mh->version & 0xff);
 755 #else
 756   sprintf(modtype, "%s (XM format %d.%02d)",
 757            tracker, mh->version >> 8, mh->version & 0xff);
 758 #endif
 759   of.modtype = strdup(modtype);
 760   of.numchn = mh->numchn;
 761   of.numpat = mh->numpat;
 762   of.numtrk = (UWORD) of.numpat * of.numchn;    /* get number of channels */
 763   of.songname = DupStr(mh->songname, 20, 1);
 764   of.numpos = mh->songlength;   /* copy the songlength */
 765   of.reppos = mh->restart < mh->songlength ? mh->restart : 0;
 766   of.numins = mh->numins;
 767   of.flags |= UF_XMPERIODS | UF_INST | UF_BGSLIDES | UF_NOWRAP | UF_FT2QUIRKS;
 768   if (mh->flags & 1)
 769     of.flags |= UF_LINEAR;
 770
 771   memset(of.chanvol, 64, of.numchn);    /* store channel volumes */
 772
 773   if (!AllocPositions(of.numpos + 1))
 774     return 0;
 775   for (t = 0; t < of.numpos; t++)
 776     of.positions[t] = mh->orders[t];
 777
 778   /* We have to check for any pattern numbers in the order list greater than
 779      the number of patterns total. If one or more is found, we set it equal to
 780      the pattern total and make a dummy pattern to workaround the problem */
 781   for (t = 0; t < of.numpos; t++)
 782     {
 783       if (of.positions[t] >= of.numpat)
 784         {
 785           of.positions[t] = of.numpat;
 786           dummypat = 1;
 787         }
 788     }
 789   if (dummypat)
 790     {
 791       of.numpat++;
 792       of.numtrk += of.numchn;
 793     }
 794
 795   if (mh->version < 0x0104)
 796     {
 797       if (!LoadInstruments())
 798         return 0;
 799       if (!LoadPatterns(dummypat))
 800         return 0;
 801       for (t = 0; t < of.numsmp; t++)
 802         nextwav[t] += _mm_ftell(modreader);
 803     }
 804   else
 805     {
 806       if (!LoadPatterns(dummypat))
 807         return 0;
 808       if (!LoadInstruments())
 809         return 0;
 810     }
 811
 812   if (!AllocSamples())
 813     {
 814       _mm_free(nextwav);
 815       nextwav = NULL;
 816       _mm_free(wh);
 817       wh = NULL;
 818       return 0;
 819     }
 820   q = of.samples;
 821   s = wh;
 822   for (u = 0; u < of.numsmp; u++, q++, s++)
 823     {
 824       q->samplename = DupStr(s->samplename, 22, 1);
 825       q->length = s->length;
 826       q->loopstart = s->loopstart;
 827       q->loopend = s->loopstart + s->looplength;
 828       q->volume = s->volume;
 829       q->speed = s->finetune + 128;
 830       q->panning = s->panning;
 831       q->seekpos = nextwav[u];
 832       q->vibtype = s->vibtype;
 833       q->vibsweep = s->vibsweep;
 834       q->vibdepth = s->vibdepth;
 835       q->vibrate = s->vibrate;
 836
 837       if (s->type & 0x10)
 838         {
 839           q->length >>= 1;
 840           q->loopstart >>= 1;
 841           q->loopend >>= 1;
 842         }
 843
 844       q->flags |= SF_OWNPAN;
 845       if (s->type & 0x3)
 846         q->flags |= SF_LOOP;
 847       if (s->type & 0x2)
 848         q->flags |= SF_BIDI;
 849       if (s->type & 0x10)
 850         q->flags |= SF_16BITS;
 851       q->flags |= SF_DELTA | SF_SIGNED;
 852     }
 853
 854   d = of.instruments;
 855   s = wh;
 856   for (u = 0; u < of.numins; u++, d++)
 857     for (t = 0; t < XMNOTECNT; t++)
 858       {
 859         if (d->samplenumber[t] >= of.numsmp)
 860           d->samplenote[t] = 255;
 861         else
 862           {
 863             int note = t + s[d->samplenumber[t]].relnote;
 864             d->samplenote[t] = (note < 0) ? 0 : note;
 865           }
 866       }
 867
 868   _mm_free(wh);
 869   nextwav = NULL;
 870   _mm_free(nextwav);
 871   wh = NULL;
 872   return 1;
 873 }
 874
 875 static CHAR *
 876 XM_LoadTitle(void)
 877 {
 878   CHAR s[21];
 879
 880   _mm_fseek(modreader, 17, SEEK_SET);
 881   if (!_mm_read_UBYTES(s, 21, modreader))
 882     return NULL;
 883
 884   return (DupStr(s, 21, 1));
 885 }
 886
 887 /*========== Loader information */
 888
 889 MLOADER load_xm =
 890 {
 891   NULL,
 892   "XM",
 893   "XM (FastTracker 2)",
 894   XM_Init,
 895   XM_Test,
 896   XM_Load,
 897   XM_Cleanup,
 898   XM_LoadTitle
 899 };
 900
 901 /* ex:set ts=4: */