libunimod/load_it.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   Impulse tracker (IT) module loader
  26
  27 ==============================================================================*/
  28
  29 #ifdef HAVE_CONFIG_H
  30 #include "config.h"
  31 #endif
  32
  33 #include <ctype.h>
  34 #include <string.h>
  35
  36 #include "unimod_priv.h"
  37
  38 /*========== Module structure */
  39
  40 /* header */
  41 typedef struct ITHEADER
  42   {
  43     CHAR songname[26];
  44     UBYTE blank01[2];
  45     UWORD ordnum;
  46     UWORD insnum;
  47     UWORD smpnum;
  48     UWORD patnum;
  49     UWORD cwt;                  /* Created with tracker (y.xx = 0x0yxx) */
  50     UWORD cmwt;                 /* Compatible with tracker ver > than val. */
  51     UWORD flags;
  52     UWORD special;              /* bit 0 set = song message attached */
  53     UBYTE globvol;
  54     UBYTE mixvol;               /* mixing volume [ignored] */
  55     UBYTE initspeed;
  56     UBYTE inittempo;
  57     UBYTE pansep;               /* panning separation between channels */
  58     UBYTE zerobyte;
  59     UWORD msglength;
  60     ULONG msgoffset;
  61     UBYTE blank02[4];
  62     UBYTE pantable[64];
  63     UBYTE voltable[64];
  64   }
  65 ITHEADER;
  66
  67 /* sample information */
  68 typedef struct ITSAMPLE
  69   {
  70     CHAR filename[12];
  71     UBYTE zerobyte;
  72     UBYTE globvol;
  73     UBYTE flag;
  74     UBYTE volume;
  75     UBYTE panning;
  76     CHAR sampname[28];
  77     UWORD convert;              /* sample conversion flag */
  78     ULONG length;
  79     ULONG loopbeg;
  80     ULONG loopend;
  81     ULONG c5spd;
  82     ULONG susbegin;
  83     ULONG susend;
  84     ULONG sampoffset;
  85     UBYTE vibspeed;
  86     UBYTE vibdepth;
  87     UBYTE vibrate;
  88     UBYTE vibwave;              /* 0=sine, 1=rampdown, 2=square, 3=random (speed ignored) */
  89   }
  90 ITSAMPLE;
  91
  92 /* instrument information */
  93
  94 #define ITENVCNT 25
  95 #define ITNOTECNT 120
  96 typedef struct ITINSTHEADER
  97   {
  98     ULONG size;                 /* (dword) Instrument size */
  99     CHAR filename[12];          /* (char) Instrument filename */
 100     UBYTE zerobyte;             /* (byte) Instrument type (always 0) */
 101     UBYTE volflg;
 102     UBYTE volpts;
 103     UBYTE volbeg;               /* (byte) Volume loop start (node) */
 104     UBYTE volend;               /* (byte) Volume loop end (node) */
 105     UBYTE volsusbeg;            /* (byte) Volume sustain begin (node) */
 106     UBYTE volsusend;            /* (byte) Volume Sustain end (node) */
 107     UBYTE panflg;
 108     UBYTE panpts;
 109     UBYTE panbeg;               /* (byte) channel loop start (node) */
 110     UBYTE panend;               /* (byte) channel loop end (node) */
 111     UBYTE pansusbeg;            /* (byte) channel sustain begin (node) */
 112     UBYTE pansusend;            /* (byte) channel Sustain end (node) */
 113     UBYTE pitflg;
 114     UBYTE pitpts;
 115     UBYTE pitbeg;               /* (byte) pitch loop start (node) */
 116     UBYTE pitend;               /* (byte) pitch loop end (node) */
 117     UBYTE pitsusbeg;            /* (byte) pitch sustain begin (node) */
 118     UBYTE pitsusend;            /* (byte) pitch Sustain end (node) */
 119     UWORD blank;
 120     UBYTE globvol;
 121     UBYTE chanpan;
 122     UWORD fadeout;              /* Envelope end / NNA volume fadeout */
 123     UBYTE dnc;                  /* Duplicate note check */
 124     UBYTE dca;                  /* Duplicate check action */
 125     UBYTE dct;                  /* Duplicate check type */
 126     UBYTE nna;                  /* New Note Action [0,1,2,3] */
 127     UWORD trkvers;              /* tracker version used to save [files only] */
 128     UBYTE ppsep;                /* Pitch-pan Separation */
 129     UBYTE ppcenter;             /* Pitch-pan Center */
 130     UBYTE rvolvar;              /* random volume varations */
 131     UBYTE rpanvar;              /* random panning varations */
 132     UWORD numsmp;               /* Number of samples in instrument [files only] */
 133     CHAR name[26];              /* Instrument name */
 134     UBYTE blank01[6];
 135     UWORD samptable[ITNOTECNT]; /* sample for each note [note / samp pairs] */
 136     UBYTE volenv[200];          /* volume envelope (IT 1.x stuff) */
 137     UBYTE oldvoltick[ITENVCNT]; /* volume tick position (IT 1.x stuff) */
 138     UBYTE volnode[ITENVCNT];    /* amplitude of volume nodes */
 139     UWORD voltick[ITENVCNT];    /* tick value of volume nodes */
 140     SBYTE pannode[ITENVCNT];    /* panenv - node points */
 141     UWORD pantick[ITENVCNT];    /* tick value of panning nodes */
 142     SBYTE pitnode[ITENVCNT];    /* pitchenv - node points */
 143     UWORD pittick[ITENVCNT];    /* tick value of pitch nodes */
 144   }
 145 ITINSTHEADER;
 146
 147 /* unpacked note */
 148
 149 typedef struct ITNOTE
 150   {
 151     UBYTE note, ins, volpan, cmd, inf;
 152   }
 153 ITNOTE;
 154
 155 /*========== Loader data */
 156
 157 static ULONG *paraptr = NULL;   /* parapointer array (see IT docs) */
 158 static ITHEADER *mh = NULL;
 159 static ITNOTE *itpat = NULL;    /* allocate to space for one full pattern */
 160 static UBYTE *mask = NULL;      /* arrays allocated to 64 elements and used for */
 161 static ITNOTE *last = NULL;     /* uncompressing IT's pattern information */
 162 static int numtrk = 0;
 163 static int old_effect;          /* if set, use S3M old-effects stuffs */
 164
 165 static CHAR *IT_Version[] =
 166 {
 167   "ImpulseTracker  .  ",
 168   "Compressed ImpulseTracker  .  ",
 169   "ImpulseTracker 2.14p3",
 170   "Compressed ImpulseTracker 2.14p3",
 171   "ImpulseTracker 2.14p4",
 172   "Compressed ImpulseTracker 2.14p4",
 173 };
 174
 175 /* table for porta-to-note command within volume/panning column */
 176 static UBYTE portatable[10] =
 177 {0, 1, 4, 8, 16, 32, 64, 96, 128, 255};
 178
 179 /*========== Loader code */
 180
 181 BOOL
 182 IT_Test (void)
 183 {
 184   UBYTE id[4];
 185
 186   if (!_mm_read_UBYTES (id, 4, modreader))
 187     return 0;
 188   if (!memcmp (id, "IMPM", 4))
 189     return 1;
 190   return 0;
 191 }
 192
 193 BOOL
 194 IT_Init (void)
 195 {
 196   if (!(mh = (ITHEADER *) _mm_malloc (sizeof (ITHEADER))))
 197     return 0;
 198   if (!(poslookup = (UBYTE *) _mm_malloc (256 * sizeof (UBYTE))))
 199     return 0;
 200   if (!(itpat = (ITNOTE *) _mm_malloc (200 * 64 * sizeof (ITNOTE))))
 201     return 0;
 202   if (!(mask = (UBYTE *) _mm_malloc (64 * sizeof (UBYTE))))
 203     return 0;
 204   if (!(last = (ITNOTE *) _mm_malloc (64 * sizeof (ITNOTE))))
 205     return 0;
 206
 207   return 1;
 208 }
 209
 210 void
 211 IT_Cleanup (void)
 212 {
 213   FreeLinear ();
 214
 215   _mm_free (mh);
 216   _mm_free (poslookup);
 217   _mm_free (itpat);
 218   _mm_free (mask);
 219   _mm_free (last);
 220   _mm_free (paraptr);
 221   _mm_free (origpositions);
 222 }
 223
 224 /* Because so many IT files have 64 channels as the set number used, but really
 225    only use far less (usually from 8 to 24 still), I had to make this function,
 226    which determines the number of channels that are actually USED by a pattern.
 227
 228    NOTE: You must first seek to the file location of the pattern before calling
 229    this procedure.
 230
 231    Returns 1 on error
 232  */
 233 static BOOL
 234 IT_GetNumChannels (UWORD patrows)
 235 {
 236   int row = 0, flag, ch;
 237
 238   do
 239     {
 240       if ((flag = _mm_read_UBYTE (modreader)) == EOF)
 241         {
 242           _mm_errno = MMERR_LOADING_PATTERN;
 243           return 1;
 244         }
 245       if (!flag)
 246         row++;
 247       else
 248         {
 249           ch = (flag - 1) & 63;
 250           remap[ch] = 0;
 251           if (flag & 128)
 252             mask[ch] = _mm_read_UBYTE (modreader);
 253           if (mask[ch] & 1)
 254             _mm_read_UBYTE (modreader);
 255           if (mask[ch] & 2)
 256             _mm_read_UBYTE (modreader);
 257           if (mask[ch] & 4)
 258             _mm_read_UBYTE (modreader);
 259           if (mask[ch] & 8)
 260             {
 261               _mm_read_UBYTE (modreader);
 262               _mm_read_UBYTE (modreader);
 263             }
 264         }
 265     }
 266   while (row < patrows);
 267
 268   return 0;
 269 }
 270
 271 static UBYTE *
 272 IT_ConvertTrack (ITNOTE * tr, UWORD numrows)
 273 {
 274   int t;
 275   UBYTE note, ins, volpan;
 276
 277   UniReset ();
 278
 279   for (t = 0; t < numrows; t++)
 280     {
 281       note = tr[t * of.numchn].note;
 282       ins = tr[t * of.numchn].ins;
 283       volpan = tr[t * of.numchn].volpan;
 284
 285       if (note != 255)
 286         {
 287           if (note == 253)
 288             UniWriteByte (UNI_KEYOFF);
 289           else if (note == 254)
 290             {
 291               UniPTEffect (0xc, -1);    /* note cut command */
 292               volpan = 255;
 293             }
 294           else
 295             UniNote (note);
 296         }
 297
 298       if ((ins) && (ins < 100))
 299         UniInstrument (ins - 1);
 300       else if (ins == 253)
 301         UniWriteByte (UNI_KEYOFF);
 302       else if (ins != 255)
 303         {                       /* crap */
 304           _mm_errno = MMERR_LOADING_PATTERN;
 305           return NULL;
 306         }
 307
 308       /* process volume / panning column
 309          volume / panning effects do NOT all share the same memory address
 310          yet. */
 311       if (volpan <= 64)
 312         UniVolEffect (VOL_VOLUME, volpan);
 313       else if (volpan <= 74)    /* fine volume slide up (65-74) */
 314         UniVolEffect (VOL_VOLSLIDE, 0x0f + ((volpan - 65) << 4));
 315       else if (volpan <= 84)    /* fine volume slide down (75-84) */
 316         UniVolEffect (VOL_VOLSLIDE, 0xf0 + (volpan - 75));
 317       else if (volpan <= 94)    /* volume slide up (85-94) */
 318         UniVolEffect (VOL_VOLSLIDE, ((volpan - 85) << 4));
 319       else if (volpan <= 104)   /* volume slide down (95-104) */
 320         UniVolEffect (VOL_VOLSLIDE, (volpan - 95));
 321       else if (volpan <= 114)   /* pitch slide down (105-114) */
 322         UniVolEffect (VOL_PITCHSLIDEDN, (volpan - 105));
 323       else if (volpan <= 124)   /* pitch slide up (115-124) */
 324         UniVolEffect (VOL_PITCHSLIDEUP, (volpan - 115));
 325       else if (volpan <= 127)
 326         {                       /* crap */
 327           _mm_errno = MMERR_LOADING_PATTERN;
 328           return NULL;
 329         }
 330       else if (volpan <= 192)
 331         UniVolEffect (VOL_PANNING, ((volpan - 128) == 64) ? 255 : ((volpan - 128) << 2));
 332       else if (volpan <= 202)   /* portamento to note */
 333         UniVolEffect (VOL_PORTAMENTO, portatable[volpan - 193]);
 334       else if (volpan <= 212)   /* vibrato */
 335         UniVolEffect (VOL_VIBRATO, (volpan - 203));
 336       else if ((volpan != 239) && (volpan != 255))
 337         {                       /* crap */
 338           _mm_errno = MMERR_LOADING_PATTERN;
 339           return NULL;
 340         }
 341
 342       S3MIT_ProcessCmd (tr[t * of.numchn].cmd, tr[t * of.numchn].inf, old_effect | 2);
 343
 344       UniNewline ();
 345     }
 346   return UniDup ();
 347 }
 348
 349 static BOOL
 350 IT_ReadPattern (UWORD patrows)
 351 {
 352   int row = 0, flag, ch, blah;
 353   ITNOTE *itt = itpat, dummy, *n, *l;
 354
 355   memset (itt, 255, 200 * 64 * sizeof (ITNOTE));
 356
 357   do
 358     {
 359       if ((flag = _mm_read_UBYTE (modreader)) == EOF)
 360         {
 361           _mm_errno = MMERR_LOADING_PATTERN;
 362           return 0;
 363         }
 364       if (!flag)
 365         {
 366           itt = &itt[of.numchn];
 367           row++;
 368         }
 369       else
 370         {
 371           ch = remap[(flag - 1) & 63];
 372           if (ch != -1)
 373             {
 374               n = &itt[ch];
 375               l = &last[ch];
 376             }
 377           else
 378             n = l = &dummy;
 379
 380           if (flag & 128)
 381             mask[ch] = _mm_read_UBYTE (modreader);
 382           if (mask[ch] & 1)
 383             /* convert IT note off to internal note off */
 384             if ((l->note = n->note = _mm_read_UBYTE (modreader)) == 255)
 385               l->note = n->note = 253;
 386           if (mask[ch] & 2)
 387             l->ins = n->ins = _mm_read_UBYTE (modreader);
 388           if (mask[ch] & 4)
 389             l->volpan = n->volpan = _mm_read_UBYTE (modreader);
 390           if (mask[ch] & 8)
 391             {
 392               l->cmd = n->cmd = _mm_read_UBYTE (modreader);
 393               l->inf = n->inf = _mm_read_UBYTE (modreader);
 394             }
 395           if (mask[ch] & 16)
 396             n->note = l->note;
 397           if (mask[ch] & 32)
 398             n->ins = l->ins;
 399           if (mask[ch] & 64)
 400             n->volpan = l->volpan;
 401           if (mask[ch] & 128)
 402             {
 403               n->cmd = l->cmd;
 404               n->inf = l->inf;
 405             }
 406         }
 407     }
 408   while (row < patrows);
 409
 410   for (blah = 0; blah < of.numchn; blah++)
 411     {
 412       if (!(of.tracks[numtrk++] = IT_ConvertTrack (&itpat[blah], patrows)))
 413         return 0;
 414     }
 415
 416   return 1;
 417 }
 418
 419 static void
 420 LoadMidiString (URL modreader, CHAR * dest)
 421 {
 422   CHAR *cur, *last;
 423
 424   _mm_read_UBYTES (dest, 32, modreader);
 425   cur = last = dest;
 426   /* remove blanks and uppercase all */
 427   while (*last)
 428     {
 429       if (isalnum ((int) *last))
 430         *(cur++) = toupper ((int) *last);
 431       last++;
 432     }
 433   *cur = 0;
 434 }
 435
 436 /* Load embedded midi information for resonant filters */
 437 static void
 438 IT_LoadMidiConfiguration (URL modreader)
 439 {
 440   int i;
 441
 442   memset (filtermacros, 0, sizeof (filtermacros));
 443   memset (filtersettings, 0, sizeof (filtersettings));
 444
 445   if (modreader)
 446     {                           /* information is embedded in file */
 447       UWORD dat;
 448       CHAR midiline[33];
 449
 450       dat = _mm_read_I_UWORD (modreader);
 451       _mm_fseek (modreader, 8 * dat + 0x120, SEEK_CUR);
 452
 453       /* read midi macros */
 454       for (i = 0; i < 16; i++)
 455         {
 456           LoadMidiString (modreader, midiline);
 457           if ((!strncmp (midiline, "F0F00", 5)) &&
 458               ((midiline[5] == '0') || (midiline[5] == '1')))
 459             filtermacros[i] = (midiline[5] - '0') | 0x80;
 460         }
 461
 462       /* read standalone filters */
 463       for (i = 0x80; i < 0x100; i++)
 464         {
 465           LoadMidiString (modreader, midiline);
 466           if ((!strncmp (midiline, "F0F00", 5)) &&
 467               ((midiline[5] == '0') || (midiline[5] == '1')))
 468             {
 469               filtersettings[i].filter = (midiline[5] - '0') | 0x80;
 470               dat = (midiline[6]) ? (midiline[6] - '0') : 0;
 471               if (midiline[7])
 472                 dat = (dat << 4) | (midiline[7] - '0');
 473               filtersettings[i].inf = dat;
 474             }
 475         }
 476     }
 477   else
 478     {                           /* use default information */
 479       filtermacros[0] = FILT_CUT;
 480       for (i = 0x80; i < 0x90; i++)
 481         {
 482           filtersettings[i].filter = FILT_RESONANT;
 483           filtersettings[i].inf = (i & 0x7f) << 3;
 484         }
 485     }
 486   activemacro = 0;
 487   for (i = 0; i < 0x80; i++)
 488     {
 489       filtersettings[i].filter = filtermacros[0];
 490       filtersettings[i].inf = i;
 491     }
 492 }
 493
 494 BOOL
 495 IT_Load (BOOL curious)
 496 {
 497   int t, u, lp;
 498   INSTRUMENT *d;
 499   SAMPLE *q;
 500   BOOL compressed = 0;
 501
 502   numtrk = 0;
 503   filters = 0;
 504
 505   /* try to read module header */
 506   _mm_read_I_ULONG (modreader); /* kill the 4 byte header */
 507   _mm_read_string (mh->songname, 26, modreader);
 508   _mm_read_UBYTES (mh->blank01, 2, modreader);
 509   mh->ordnum = _mm_read_I_UWORD (modreader);
 510   mh->insnum = _mm_read_I_UWORD (modreader);
 511   mh->smpnum = _mm_read_I_UWORD (modreader);
 512   mh->patnum = _mm_read_I_UWORD (modreader);
 513   mh->cwt = _mm_read_I_UWORD (modreader);
 514   mh->cmwt = _mm_read_I_UWORD (modreader);
 515   mh->flags = _mm_read_I_UWORD (modreader);
 516   mh->special = _mm_read_I_UWORD (modreader);
 517   mh->globvol = _mm_read_UBYTE (modreader);
 518   mh->mixvol = _mm_read_UBYTE (modreader);
 519   mh->initspeed = _mm_read_UBYTE (modreader);
 520   mh->inittempo = _mm_read_UBYTE (modreader);
 521   mh->pansep = _mm_read_UBYTE (modreader);
 522   mh->zerobyte = _mm_read_UBYTE (modreader);
 523   mh->msglength = _mm_read_I_UWORD (modreader);
 524   mh->msgoffset = _mm_read_I_ULONG (modreader);
 525   _mm_read_UBYTES (mh->blank02, 4, modreader);
 526   _mm_read_UBYTES (mh->pantable, 64, modreader);
 527   _mm_read_UBYTES (mh->voltable, 64, modreader);
 528
 529   if (_mm_eof (modreader))
 530     {
 531       _mm_errno = MMERR_LOADING_HEADER;
 532       return 0;
 533     }
 534
 535   /* set module variables */
 536   of.songname = DupStr (mh->songname, 26, 0);   /* make a cstr of songname  */
 537   of.reppos = 0;
 538   of.numpat = mh->patnum;
 539   of.numins = mh->insnum;
 540   of.numsmp = mh->smpnum;
 541   of.initspeed = mh->initspeed;
 542   of.inittempo = mh->inittempo;
 543   of.initvolume = mh->globvol;
 544   of.flags |= UF_BGSLIDES | UF_ARPMEM;
 545
 546   if (mh->songname[25])
 547     {
 548       of.numvoices = 1 + mh->songname[25];
 549 #ifdef MIKMOD_DEBUG
 550       fprintf (stderr, "Embedded IT limitation to %d voices\n", of.numvoices);
 551 #endif
 552     }
 553
 554   /* set the module type */
 555   /* 2.17 : IT 2.14p4 */
 556   /* 2.16 : IT 2.14p3 with resonant filters */
 557   /* 2.15 : IT 2.14p3 (improved compression) */
 558   if ((mh->cwt <= 0x219) && (mh->cwt >= 0x217))
 559     of.modtype = strdup (IT_Version[mh->cmwt < 0x214 ? 4 : 5]);
 560   else if (mh->cwt >= 0x215)
 561     of.modtype = strdup (IT_Version[mh->cmwt < 0x214 ? 2 : 3]);
 562   else
 563     {
 564       of.modtype = strdup (IT_Version[mh->cmwt < 0x214 ? 0 : 1]);
 565       of.modtype[mh->cmwt < 0x214 ? 15 : 26] = (mh->cwt >> 8) + '0';
 566       of.modtype[mh->cmwt < 0x214 ? 17 : 28] = ((mh->cwt >> 4) & 0xf) + '0';
 567       of.modtype[mh->cmwt < 0x214 ? 18 : 29] = ((mh->cwt) & 0xf) + '0';
 568     }
 569
 570   if (mh->flags & 8)
 571     of.flags |= (UF_XMPERIODS | UF_LINEAR);
 572
 573   if ((mh->cwt >= 0x106) && (mh->flags & 16))
 574     old_effect = 1;
 575   else
 576     old_effect = 0;
 577
 578   /* set panning positions */
 579   for (t = 0; t < 64; t++)
 580     {
 581       mh->pantable[t] &= 0x7f;
 582       if (mh->pantable[t] < 64)
 583         of.panning[t] = mh->pantable[t] << 2;
 584       else if (mh->pantable[t] == 64)
 585         of.panning[t] = 255;
 586       else if (mh->pantable[t] == 100)
 587         of.panning[t] = PAN_SURROUND;
 588       else if (mh->pantable[t] == 127)
 589         of.panning[t] = PAN_CENTER;
 590       else
 591         {
 592           _mm_errno = MMERR_LOADING_HEADER;
 593           return 0;
 594         }
 595     }
 596
 597   /* set channel volumes */
 598   memcpy (of.chanvol, mh->voltable, 64);
 599
 600   /* read the order data */
 601   if (!AllocPositions (mh->ordnum))
 602     return 0;
 603   if (!(origpositions = _mm_calloc (mh->ordnum, sizeof (UWORD))))
 604     return 0;
 605
 606   for (t = 0; t < mh->ordnum; t++)
 607     {
 608       origpositions[t] = _mm_read_UBYTE (modreader);
 609       if ((origpositions[t] > mh->patnum) && (origpositions[t] < 254))
 610         origpositions[t] = 255;
 611     }
 612
 613   if (_mm_eof (modreader))
 614     {
 615       _mm_errno = MMERR_LOADING_HEADER;
 616       return 0;
 617     }
 618
 619   poslookupcnt = mh->ordnum;
 620   S3MIT_CreateOrders (curious);
 621
 622   if (!(paraptr = (ULONG *) _mm_malloc ((mh->insnum + mh->smpnum + of.numpat) *
 623                                         sizeof (ULONG))))
 624     return 0;
 625
 626   /* read the instrument, sample, and pattern parapointers */
 627   _mm_read_I_ULONGS (paraptr, mh->insnum + mh->smpnum + of.numpat, modreader);
 628
 629   if (_mm_eof (modreader))
 630     {
 631       _mm_errno = MMERR_LOADING_HEADER;
 632       return 0;
 633     }
 634
 635   /* Check for and load midi information for resonant filters */
 636   if (mh->cmwt >= 0x216)
 637     {
 638       if (mh->special & 8)
 639         {
 640           IT_LoadMidiConfiguration (modreader);
 641           if (_mm_eof (modreader))
 642             {
 643               _mm_errno = MMERR_LOADING_HEADER;
 644               return 0;
 645             }
 646         }
 647       else
 648         IT_LoadMidiConfiguration (NULL);
 649       filters = 1;
 650     }
 651
 652   /* Check for and load song comment */
 653   if ((mh->special & 1) && (mh->cwt >= 0x104) && (mh->msglength))
 654     {
 655       _mm_fseek (modreader, (long) (mh->msgoffset), SEEK_SET);
 656       if (!ReadComment (mh->msglength))
 657         return 0;
 658     }
 659
 660   if (!(mh->flags & 4))
 661     of.numins = of.numsmp;
 662   if (!AllocSamples ())
 663     return 0;
 664
 665   if (!AllocLinear ())
 666     return 0;
 667
 668   /* Load all samples */
 669   q = of.samples;
 670   for (t = 0; t < mh->smpnum; t++)
 671     {
 672       ITSAMPLE s;
 673
 674       /* seek to sample position */
 675       _mm_fseek (modreader, (long) (paraptr[mh->insnum + t] + 4), SEEK_SET);
 676
 677       /* load sample info */
 678       _mm_read_string (s.filename, 12, modreader);
 679       s.zerobyte = _mm_read_UBYTE (modreader);
 680       s.globvol = _mm_read_UBYTE (modreader);
 681       s.flag = _mm_read_UBYTE (modreader);
 682       s.volume = _mm_read_UBYTE (modreader);
 683       _mm_read_string (s.sampname, 26, modreader);
 684       s.convert = _mm_read_UBYTE (modreader);
 685       s.panning = _mm_read_UBYTE (modreader);
 686       s.length = _mm_read_I_ULONG (modreader);
 687       s.loopbeg = _mm_read_I_ULONG (modreader);
 688       s.loopend = _mm_read_I_ULONG (modreader);
 689       s.c5spd = _mm_read_I_ULONG (modreader);
 690       s.susbegin = _mm_read_I_ULONG (modreader);
 691       s.susend = _mm_read_I_ULONG (modreader);
 692       s.sampoffset = _mm_read_I_ULONG (modreader);
 693       s.vibspeed = _mm_read_UBYTE (modreader);
 694       s.vibdepth = _mm_read_UBYTE (modreader);
 695       s.vibrate = _mm_read_UBYTE (modreader);
 696       s.vibwave = _mm_read_UBYTE (modreader);
 697
 698       /* Some IT files have bogues loopbeg/loopend if looping is not used by
 699        * a sample. */
 700       if (!(s.flag & 80))
 701         s.loopbeg = s.loopend = 0;
 702
 703       /* Generate an error if c5spd is > 512k, or samplelength > 256 megs
 704          (nothing would EVER be that high) */
 705
 706       if (_mm_eof (modreader) || (s.c5spd > 0x7ffffL) || (s.length > 0xfffffffUL) ||
 707           (s.loopbeg > 0xfffffffUL) || (s.loopend > 0xfffffffUL))
 708         {
 709           _mm_errno = MMERR_LOADING_SAMPLEINFO;
 710           return 0;
 711         }
 712
 713       q->samplename = DupStr (s.sampname, 26, 0);
 714       q->speed = s.c5spd / 2;
 715       q->panning = ((s.panning & 127) == 64) ? 255 : (s.panning & 127) << 2;
 716       q->length = s.length;
 717       q->loopstart = s.loopbeg;
 718       q->loopend = s.loopend;
 719       q->volume = s.volume;
 720       q->globvol = s.globvol;
 721       q->seekpos = s.sampoffset;
 722
 723       /* Convert speed to XM linear finetune */
 724       if (of.flags & UF_LINEAR)
 725         q->speed = speed_to_finetune (s.c5spd, t);
 726
 727       if (s.panning & 128)
 728         q->flags |= SF_OWNPAN;
 729
 730       if (s.vibrate)
 731         {
 732           q->vibflags |= AV_IT;
 733           q->vibtype = s.vibwave;
 734           q->vibsweep = s.vibrate * 2;
 735           q->vibdepth = s.vibdepth;
 736           q->vibrate = s.vibspeed;
 737         }
 738
 739       if (s.flag & 2)
 740         q->flags |= SF_16BITS;
 741       if ((s.flag & 8) && (mh->cwt >= 0x214))
 742         {
 743           q->flags |= SF_ITPACKED;
 744           compressed = 1;
 745         }
 746       if (s.flag & 16)
 747         q->flags |= SF_LOOP;
 748       if (s.flag & 64)
 749         q->flags |= SF_BIDI;
 750
 751       if (mh->cwt >= 0x200)
 752         {
 753           if (s.convert & 1)
 754             q->flags |= SF_SIGNED;
 755           if (s.convert & 4)
 756             q->flags |= SF_DELTA;
 757         }
 758
 759       q++;
 760     }
 761
 762   /* Load instruments if instrument mode flag enabled */
 763   if (mh->flags & 4)
 764     {
 765       if (!AllocInstruments ())
 766         return 0;
 767       d = of.instruments;
 768       of.flags |= UF_NNA | UF_INST;
 769
 770       for (t = 0; t < mh->insnum; t++)
 771         {
 772           ITINSTHEADER ih;
 773
 774           /* seek to instrument position */
 775           _mm_fseek (modreader, paraptr[t] + 4, SEEK_SET);
 776
 777           /* load instrument info */
 778           _mm_read_string (ih.filename, 12, modreader);
 779           ih.zerobyte = _mm_read_UBYTE (modreader);
 780           if (mh->cwt < 0x200)
 781             {
 782               /* load IT 1.xx inst header */
 783               ih.volflg = _mm_read_UBYTE (modreader);
 784               ih.volbeg = _mm_read_UBYTE (modreader);
 785               ih.volend = _mm_read_UBYTE (modreader);
 786               ih.volsusbeg = _mm_read_UBYTE (modreader);
 787               ih.volsusend = _mm_read_UBYTE (modreader);
 788               _mm_read_I_UWORD (modreader);
 789               ih.fadeout = _mm_read_I_UWORD (modreader);
 790               ih.nna = _mm_read_UBYTE (modreader);
 791               ih.dnc = _mm_read_UBYTE (modreader);
 792             }
 793           else
 794             {
 795               /* Read IT200+ header */
 796               ih.nna = _mm_read_UBYTE (modreader);
 797               ih.dct = _mm_read_UBYTE (modreader);
 798               ih.dca = _mm_read_UBYTE (modreader);
 799               ih.fadeout = _mm_read_I_UWORD (modreader);
 800               ih.ppsep = _mm_read_UBYTE (modreader);
 801               ih.ppcenter = _mm_read_UBYTE (modreader);
 802               ih.globvol = _mm_read_UBYTE (modreader);
 803               ih.chanpan = _mm_read_UBYTE (modreader);
 804               ih.rvolvar = _mm_read_UBYTE (modreader);
 805               ih.rpanvar = _mm_read_UBYTE (modreader);
 806             }
 807
 808           ih.trkvers = _mm_read_I_UWORD (modreader);
 809           ih.numsmp = _mm_read_UBYTE (modreader);
 810           _mm_read_UBYTE (modreader);
 811           _mm_read_string (ih.name, 26, modreader);
 812           _mm_read_UBYTES (ih.blank01, 6, modreader);
 813           _mm_read_I_UWORDS (ih.samptable, ITNOTECNT, modreader);
 814           if (mh->cwt < 0x200)
 815             {
 816               /* load IT 1xx volume envelope */
 817               _mm_read_UBYTES (ih.volenv, 200, modreader);
 818               for (lp = 0; lp < ITENVCNT; lp++)
 819                 {
 820                   ih.oldvoltick[lp] = _mm_read_UBYTE (modreader);
 821                   ih.volnode[lp] = _mm_read_UBYTE (modreader);
 822                 }
 823             }
 824           else
 825             {
 826               /* load IT 2xx volume, pan and pitch envelopes */
 827 #define IT_LoadEnvelope(name,type)                                                                                      \
 828                                 ih.name##flg   =_mm_read_UBYTE(modreader);                              \
 829                                 ih.name##pts   =_mm_read_UBYTE(modreader);                              \
 830                                 ih.name##beg   =_mm_read_UBYTE(modreader);                              \
 831                                 ih.name##end   =_mm_read_UBYTE(modreader);                              \
 832                                 ih.name##susbeg=_mm_read_UBYTE(modreader);                              \
 833                                 ih.name##susend=_mm_read_UBYTE(modreader);                              \
 834                                 for(lp=0;lp<ITENVCNT;lp++) {                                                            \
 835                                         ih.name##node[lp]=_mm_read_##type(modreader);           \
 836                                         ih.name##tick[lp]=_mm_read_I_UWORD(modreader);          \
 837                                 }                                                                                                                       \
 838                                 _mm_read_UBYTE(modreader);
 839
 840               IT_LoadEnvelope (vol, UBYTE);
 841               IT_LoadEnvelope (pan, SBYTE);
 842               IT_LoadEnvelope (pit, SBYTE);
 843 #undef IT_LoadEnvelope
 844             }
 845
 846           if (_mm_eof (modreader))
 847             {
 848               _mm_errno = MMERR_LOADING_SAMPLEINFO;
 849               return 0;
 850             }
 851
 852           d->volflg |= EF_VOLENV;
 853           d->insname = DupStr (ih.name, 26, 0);
 854           d->nnatype = ih.nna;
 855
 856           if (mh->cwt < 0x200)
 857             {
 858               d->volfade = ih.fadeout << 6;
 859               if (ih.dnc)
 860                 {
 861                   d->dct = DCT_NOTE;
 862                   d->dca = DCA_CUT;
 863                 }
 864
 865               if (ih.volflg & 1)
 866                 d->volflg |= EF_ON;
 867               if (ih.volflg & 2)
 868                 d->volflg |= EF_LOOP;
 869               if (ih.volflg & 4)
 870                 d->volflg |= EF_SUSTAIN;
 871
 872               /* XM conversion of IT envelope Array */
 873               d->volbeg = ih.volbeg;
 874               d->volend = ih.volend;
 875               d->volsusbeg = ih.volsusbeg;
 876               d->volsusend = ih.volsusend;
 877
 878               if (ih.volflg & 1)
 879                 {
 880                   for (u = 0; u < ITENVCNT; u++)
 881                     if (ih.oldvoltick[d->volpts] != 0xff)
 882                       {
 883                         d->volenv[d->volpts].val = (ih.volnode[d->volpts] << 2);
 884                         d->volenv[d->volpts].pos = ih.oldvoltick[d->volpts];
 885                         d->volpts++;
 886                       }
 887                     else
 888                       break;
 889                 }
 890             }
 891           else
 892             {
 893               d->panning = ((ih.chanpan & 127) == 64) ? 255 : (ih.chanpan & 127) << 2;
 894               if (!(ih.chanpan & 128))
 895                 d->flags |= IF_OWNPAN;
 896
 897               if (!(ih.ppsep & 128))
 898                 {
 899                   d->pitpansep = ih.ppsep << 2;
 900                   d->pitpancenter = ih.ppcenter;
 901                   d->flags |= IF_PITCHPAN;
 902                 }
 903               d->globvol = ih.globvol >> 1;
 904               d->volfade = ih.fadeout << 5;
 905               d->dct = ih.dct;
 906               d->dca = ih.dca;
 907
 908               if (mh->cwt >= 0x204)
 909                 {
 910                   d->rvolvar = ih.rvolvar;
 911                   d->rpanvar = ih.rpanvar;
 912                 }
 913
 914 #define IT_ProcessEnvelope(name)                                                                                        \
 915                                 if(ih.name##flg&1) d->name##flg|=EF_ON;                                 \
 916                                 if(ih.name##flg&2) d->name##flg|=EF_LOOP;                               \
 917                                 if(ih.name##flg&4) d->name##flg|=EF_SUSTAIN;                    \
 918                                 d->name##pts=ih.name##pts;                                                              \
 919                                 d->name##beg=ih.name##beg;                                                              \
 920                                 d->name##end=ih.name##end;                                                              \
 921                                 d->name##susbeg=ih.name##susbeg;                                                \
 922                                 d->name##susend=ih.name##susend;                                                \
 923                                                                                                                                                         \
 924                                 for(u=0;u<ih.name##pts;u++)                                                             \
 925                                         d->name##env[u].pos=ih.name##tick[u];                           \
 926                                                                                                                                                         \
 927                                 if((d->name##flg&EF_ON)&&(d->name##pts<2))                              \
 928                                         d->name##flg&=~EF_ON;
 929
 930               IT_ProcessEnvelope (vol);
 931               for (u = 0; u < ih.volpts; u++)
 932                 d->volenv[u].val = (ih.volnode[u] << 2);
 933
 934               IT_ProcessEnvelope (pan);
 935               for (u = 0; u < ih.panpts; u++)
 936                 d->panenv[u].val =
 937                   ih.pannode[u] == 32 ? 255 : (ih.pannode[u] + 32) << 2;
 938
 939               IT_ProcessEnvelope (pit);
 940               for (u = 0; u < ih.pitpts; u++)
 941                 d->pitenv[u].val = ih.pitnode[u] + 32;
 942 #undef IT_ProcessEnvelope
 943
 944               if (ih.pitflg & 0x80)
 945                 {
 946                   /* filter envelopes not supported yet */
 947                   d->pitflg &= ~EF_ON;
 948                   ih.pitpts = ih.pitbeg = ih.pitend = 0;
 949 #ifdef MIKMOD_DEBUG
 950                   {
 951                     static int warn = 0;
 952
 953                     if (!warn)
 954                       fputs ("\rFilter envelopes not supported yet\n", stderr);
 955                     warn = 1;
 956                   }
 957 #endif
 958                 }
 959
 960               d->volpts = ih.volpts;
 961               d->volbeg = ih.volbeg;
 962               d->volend = ih.volend;
 963               d->volsusbeg = ih.volsusbeg;
 964               d->volsusend = ih.volsusend;
 965
 966               for (u = 0; u < ih.volpts; u++)
 967                 {
 968                   d->volenv[u].val = (ih.volnode[u] << 2);
 969                   d->volenv[u].pos = ih.voltick[u];
 970                 }
 971
 972               d->panpts = ih.panpts;
 973               d->panbeg = ih.panbeg;
 974               d->panend = ih.panend;
 975               d->pansusbeg = ih.pansusbeg;
 976               d->pansusend = ih.pansusend;
 977
 978               for (u = 0; u < ih.panpts; u++)
 979                 {
 980                   d->panenv[u].val = ih.pannode[u] == 32 ? 255 : (ih.pannode[u] + 32) << 2;
 981                   d->panenv[u].pos = ih.pantick[u];
 982                 }
 983
 984               d->pitpts = ih.pitpts;
 985               d->pitbeg = ih.pitbeg;
 986               d->pitend = ih.pitend;
 987               d->pitsusbeg = ih.pitsusbeg;
 988               d->pitsusend = ih.pitsusend;
 989
 990               for (u = 0; u < ih.pitpts; u++)
 991                 {
 992                   d->pitenv[u].val = ih.pitnode[u] + 32;
 993                   d->pitenv[u].pos = ih.pittick[u];
 994                 }
 995             }
 996
 997           for (u = 0; u < ITNOTECNT; u++)
 998             {
 999               d->samplenote[u] = (ih.samptable[u] & 255);
1000               d->samplenumber[u] =
1001                 (ih.samptable[u] >> 8) ? ((ih.samptable[u] >> 8) - 1) : 0xffff;
1002               if (d->samplenumber[u] >= of.numsmp)
1003                 d->samplenote[u] = 255;
1004               else if (of.flags & UF_LINEAR)
1005                 {
1006                   int note = (int) d->samplenote[u] + noteindex[d->samplenumber[u]];
1007                   d->samplenote[u] = (note < 0) ? 0 : (note > 255 ? 255 : note);
1008                 }
1009             }
1010
1011           d++;
1012         }
1013     }
1014   else if (of.flags & UF_LINEAR)
1015     {
1016       if (!AllocInstruments ())
1017         return 0;
1018       d = of.instruments;
1019       of.flags |= UF_INST;
1020
1021       for (t = 0; t < mh->smpnum; t++, d++)
1022         for (u = 0; u < ITNOTECNT; u++)
1023           {
1024             if (d->samplenumber[u] >= of.numsmp)
1025               d->samplenote[u] = 255;
1026             else
1027               {
1028                 int note = (int) d->samplenote[u] + noteindex[d->samplenumber[u]];
1029                 d->samplenote[u] = (note < 0) ? 0 : (note > 255 ? 255 : note);
1030               }
1031           }
1032     }
1033
1034   /* Figure out how many channels this song actually uses */
1035   of.numchn = 0;
1036   memset (remap, -1, 64 * sizeof (UBYTE));
1037   for (t = 0; t < of.numpat; t++)
1038     {
1039       UWORD packlen;
1040
1041       /* seek to pattern position */
1042       if (paraptr[mh->insnum + mh->smpnum + t])
1043         {                       /* 0 -> empty 64 row pattern */
1044           _mm_fseek (modreader, ((long) paraptr[mh->insnum + mh->smpnum + t]), SEEK_SET);
1045           _mm_read_I_UWORD (modreader);
1046           /* read pattern length (# of rows)
1047              Impulse Tracker never creates patterns with less than 32 rows,
1048              but some other trackers do, so we only check for more than 256
1049              rows */
1050           packlen = _mm_read_I_UWORD (modreader);
1051           if (packlen > 256)
1052             {
1053               _mm_errno = MMERR_LOADING_PATTERN;
1054               return 0;
1055             }
1056           _mm_read_I_ULONG (modreader);
1057           if (IT_GetNumChannels (packlen))
1058             return 0;
1059         }
1060     }
1061
1062   /* give each of them a different number */
1063   for (t = 0; t < 64; t++)
1064     if (!remap[t])
1065       remap[t] = of.numchn++;
1066
1067   of.numtrk = of.numpat * of.numchn;
1068   if (of.numvoices)
1069     if (of.numvoices < of.numchn)
1070       of.numvoices = of.numchn;
1071
1072   if (!AllocPatterns ())
1073     return 0;
1074   if (!AllocTracks ())
1075     return 0;
1076
1077   for (t = 0; t < of.numpat; t++)
1078     {
1079       UWORD packlen;
1080
1081       /* seek to pattern position */
1082       if (!paraptr[mh->insnum + mh->smpnum + t])
1083         {                       /* 0 -> empty 64 row pattern */
1084           of.pattrows[t] = 64;
1085           for (u = 0; u < of.numchn; u++)
1086             {
1087               int k;
1088
1089               UniReset ();
1090               for (k = 0; k < 64; k++)
1091                 UniNewline ();
1092               of.tracks[numtrk++] = UniDup ();
1093             }
1094         }
1095       else
1096         {
1097           _mm_fseek (modreader, ((long) paraptr[mh->insnum + mh->smpnum + t]), SEEK_SET);
1098           packlen = _mm_read_I_UWORD (modreader);
1099           of.pattrows[t] = _mm_read_I_UWORD (modreader);
1100           _mm_read_I_ULONG (modreader);
1101           if (!IT_ReadPattern (of.pattrows[t]))
1102             return 0;
1103         }
1104     }
1105
1106   return 1;
1107 }
1108
1109 CHAR *
1110 IT_LoadTitle (void)
1111 {
1112   CHAR s[26];
1113
1114   _mm_fseek (modreader, 4, SEEK_SET);
1115   if (!_mm_read_UBYTES (s, 26, modreader))
1116     return NULL;
1117
1118   return (DupStr (s, 26, 0));
1119 }
1120
1121 /*========== Loader information */
1122
1123 MLOADER load_it =
1124 {
1125   NULL,
1126   "IT",
1127   "IT (Impulse Tracker)",
1128   IT_Init,
1129   IT_Test,
1130   IT_Load,
1131   IT_Cleanup,
1132   IT_LoadTitle
1133 };
1134
1135 /* ex:set ts=4: */