libunimod/load_imf.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   Imago Orpheus (IMF) module loader
  26
  27 ==============================================================================*/
  28
  29 #ifdef HAVE_CONFIG_H
  30 #include "config.h"
  31 #endif
  32
  33 #include <string.h>
  34
  35 #include "unimod_priv.h"
  36
  37 /*========== Module structure */
  38
  39 /* module header */
  40 typedef struct IMFHEADER
  41   {
  42     CHAR songname[32];
  43     UWORD ordnum;
  44     UWORD patnum;
  45     UWORD insnum;
  46     UWORD flags;
  47     UBYTE initspeed;
  48     UBYTE inittempo;
  49     UBYTE mastervol;
  50     UBYTE mastermult;
  51     UBYTE orders[256];
  52   }
  53 IMFHEADER;
  54
  55 /* channel settings */
  56 typedef struct IMFCHANNEL
  57   {
  58     CHAR name[12];
  59     UBYTE chorus;
  60     UBYTE reverb;
  61     UBYTE pan;
  62     UBYTE status;
  63   }
  64 IMFCHANNEL;
  65
  66 /* instrument header */
  67 #define IMFNOTECNT (10*OCTAVE)
  68 #define IMFENVCNT (16*2)
  69 typedef struct IMFINSTHEADER
  70   {
  71     CHAR name[32];
  72     UBYTE what[IMFNOTECNT];
  73     UWORD volenv[IMFENVCNT];
  74     UWORD panenv[IMFENVCNT];
  75     UWORD pitenv[IMFENVCNT];
  76     UBYTE volpts;
  77     UBYTE volsus;
  78     UBYTE volbeg;
  79     UBYTE volend;
  80     UBYTE volflg;
  81     UBYTE panpts;
  82     UBYTE pansus;
  83     UBYTE panbeg;
  84     UBYTE panend;
  85     UBYTE panflg;
  86     UBYTE pitpts;
  87     UBYTE pitsus;
  88     UBYTE pitbeg;
  89     UBYTE pitend;
  90     UBYTE pitflg;
  91     UWORD volfade;
  92     UWORD numsmp;
  93     ULONG signature;
  94   }
  95 IMFINSTHEADER;
  96
  97 /* sample header */
  98 typedef struct IMFWAVHEADER
  99   {
 100     CHAR samplename[13];
 101     ULONG length;
 102     ULONG loopstart;
 103     ULONG loopend;
 104     ULONG samplerate;
 105     UBYTE volume;
 106     UBYTE pan;
 107     UBYTE flags;
 108   }
 109 IMFWAVHEADER;
 110
 111 typedef struct IMFNOTE
 112   {
 113     UBYTE note, ins, eff1, dat1, eff2, dat2;
 114   }
 115 IMFNOTE;
 116
 117 /*========== Loader variables */
 118
 119 static CHAR IMF_Version[] = "Imago Orpheus";
 120
 121 static IMFNOTE *imfpat = NULL;
 122 static IMFHEADER *mh = NULL;
 123
 124 /*========== Loader code */
 125
 126 BOOL
 127 IMF_Test (void)
 128 {
 129   UBYTE id[4];
 130
 131   _mm_fseek (modreader, 0x3c, SEEK_SET);
 132   if (!_mm_read_UBYTES (id, 4, modreader))
 133     return 0;
 134   if (!memcmp (id, "IM10", 4))
 135     return 1;
 136   return 0;
 137 }
 138
 139 BOOL
 140 IMF_Init (void)
 141 {
 142   if (!(imfpat = (IMFNOTE *) _mm_malloc (32 * 256 * sizeof (IMFNOTE))))
 143     return 0;
 144   if (!(mh = (IMFHEADER *) _mm_malloc (sizeof (IMFHEADER))))
 145     return 0;
 146
 147   return 1;
 148 }
 149
 150 void
 151 IMF_Cleanup (void)
 152 {
 153   FreeLinear ();
 154
 155   _mm_free (imfpat);
 156   _mm_free (mh);
 157 }
 158
 159 static BOOL
 160 IMF_ReadPattern (SLONG size, UWORD rows)
 161 {
 162   int row = 0, flag, ch;
 163   IMFNOTE *n, dummy;
 164
 165   /* clear pattern data */
 166   memset (imfpat, 255, 32 * 256 * sizeof (IMFNOTE));
 167
 168   while ((size > 0) && (row < rows))
 169     {
 170       flag = _mm_read_UBYTE (modreader);
 171       size--;
 172
 173       if (_mm_eof (modreader))
 174         {
 175           _mm_errno = MMERR_LOADING_PATTERN;
 176           return 0;
 177         }
 178
 179       if (flag)
 180         {
 181           ch = remap[flag & 31];
 182
 183           if (ch != -1)
 184             n = &imfpat[256 * ch + row];
 185           else
 186             n = &dummy;
 187
 188           if (flag & 32)
 189             {
 190               n->note = _mm_read_UBYTE (modreader);
 191               if (n->note >= 0xa0)
 192                 n->note = 0xa0; /* note off */
 193               n->ins = _mm_read_UBYTE (modreader);
 194               size -= 2;
 195             }
 196           if (flag & 64)
 197             {
 198               size -= 2;
 199               n->eff2 = _mm_read_UBYTE (modreader);
 200               n->dat2 = _mm_read_UBYTE (modreader);
 201             }
 202           if (flag & 128)
 203             {
 204               n->eff1 = _mm_read_UBYTE (modreader);
 205               n->dat1 = _mm_read_UBYTE (modreader);
 206               size -= 2;
 207             }
 208         }
 209       else
 210         row++;
 211     }
 212   if ((size) || (row != rows))
 213     {
 214       _mm_errno = MMERR_LOADING_PATTERN;
 215       return 0;
 216     }
 217   return 1;
 218 }
 219
 220 static void
 221 IMF_ProcessCmd (UBYTE eff, UBYTE inf)
 222 {
 223   if ((eff) && (eff != 255))
 224     switch (eff)
 225       {
 226       case 0x01:                /* set tempo */
 227         UniEffect (UNI_S3MEFFECTA, inf);
 228         break;
 229       case 0x02:                /* set BPM */
 230         if (inf >= 0x20)
 231           UniEffect (UNI_S3MEFFECTT, inf);
 232         break;
 233       case 0x03:                /* tone portamento */
 234         UniEffect (UNI_ITEFFECTG, inf);
 235         break;
 236       case 0x04:                /* porta + volslide */
 237         UniEffect (UNI_ITEFFECTG, inf);
 238         UniEffect (UNI_S3MEFFECTD, 0);
 239         break;
 240       case 0x05:                /* vibrato */
 241         UniPTEffect (0x4, inf);
 242         break;
 243       case 0x06:                /* vibrato + volslide */
 244         UniPTEffect (0x4, inf);
 245         UniEffect (UNI_S3MEFFECTD, 0);
 246         break;
 247       case 0x07:                /* fine vibrato */
 248         UniEffect (UNI_ITEFFECTU, inf);
 249         break;
 250       case 0x08:                /* tremolo */
 251         UniEffect (UNI_S3MEFFECTR, inf);
 252         break;
 253       case 0x09:                /* arpeggio */
 254         UniPTEffect (0x0, inf);
 255         break;
 256       case 0x0a:                /* panning */
 257         UniPTEffect (0x8, (inf >= 128) ? 255 : (inf << 1));
 258         break;
 259       case 0x0b:                /* pan slide */
 260         UniEffect (UNI_XMEFFECTP, inf);
 261         break;
 262       case 0x0c:                /* set channel volume */
 263         if (inf <= 64)
 264           UniPTEffect (0xc, inf);
 265         break;
 266       case 0x0d:                /* volume slide */
 267         UniEffect (UNI_S3MEFFECTD, inf);
 268         break;
 269       case 0x0e:                /* fine volume slide */
 270         if (inf)
 271           {
 272             if (inf >> 4)
 273               UniEffect (UNI_S3MEFFECTD, 0x0f | inf);
 274             else
 275               UniEffect (UNI_S3MEFFECTD, 0xf0 | inf);
 276           }
 277         else
 278           UniEffect (UNI_S3MEFFECTD, 0);
 279         break;
 280       case 0x0f:                /* set finetune */
 281         UniPTEffect (0xe, 0x50 | (inf >> 4));
 282         break;
 283 #ifdef MIKMOD_DEBUG
 284       case 0x10:                /* note slide up */
 285       case 0x11:                /* not slide down */
 286         fprintf (stderr, "\rIMF effect 0x10/0x11 (note slide)"
 287                  " not implemented (eff=%2X inf=%2X)\n", eff, inf);
 288         break;
 289 #endif
 290       case 0x12:                /* slide up */
 291         UniEffect (UNI_S3MEFFECTF, inf);
 292         break;
 293       case 0x13:                /* slide down */
 294         UniEffect (UNI_S3MEFFECTE, inf);
 295         break;
 296       case 0x14:                /* fine slide up */
 297         if (inf)
 298           {
 299             if (inf < 0x40)
 300               UniEffect (UNI_S3MEFFECTF, 0xe0 | (inf / 4));
 301             else
 302               UniEffect (UNI_S3MEFFECTF, 0xf0 | (inf >> 4));
 303           }
 304         else
 305           UniEffect (UNI_S3MEFFECTF, 0);
 306         break;
 307       case 0x15:                /* fine slide down */
 308         if (inf)
 309           {
 310             if (inf < 0x40)
 311               UniEffect (UNI_S3MEFFECTE, 0xe0 | (inf / 4));
 312             else
 313               UniEffect (UNI_S3MEFFECTE, 0xf0 | (inf >> 4));
 314           }
 315         else
 316           UniEffect (UNI_S3MEFFECTE, 0);
 317         break;
 318         /* 0x16 set filter cutoff (awe32) */
 319         /* 0x17 filter side + resonance (awe32) */
 320       case 0x18:                /* sample offset */
 321         UniPTEffect (0x9, inf);
 322         break;
 323 #ifdef MIKMOD_DEBUG
 324       case 0x19:                /* set fine sample offset */
 325         fprintf (stderr, "\rIMF effect 0x19 (fine sample offset)"
 326                  " not implemented (inf=%2X)\n", inf);
 327         break;
 328 #endif
 329       case 0x1a:                /* keyoff */
 330         UniWriteByte (UNI_KEYOFF);
 331         break;
 332       case 0x1b:                /* retrig */
 333         UniEffect (UNI_S3MEFFECTQ, inf);
 334         break;
 335       case 0x1c:                /* tremor */
 336         UniEffect (UNI_S3MEFFECTI, inf);
 337         break;
 338       case 0x1d:                /* position jump */
 339         UniPTEffect (0xb, inf);
 340         break;
 341       case 0x1e:                /* pattern break */
 342         UniPTEffect (0xd, (inf >> 4) * 10 + (inf & 0xf));
 343         break;
 344       case 0x1f:                /* set master volume */
 345         if (inf <= 64)
 346           UniEffect (UNI_XMEFFECTG, inf);
 347         break;
 348       case 0x20:                /* master volume slide */
 349         UniEffect (UNI_XMEFFECTH, inf);
 350         break;
 351       case 0x21:                /* extended effects */
 352         switch (inf >> 4)
 353           {
 354           case 0x1:             /* set filter */
 355           case 0x5:             /* vibrato waveform */
 356           case 0x8:             /* tremolo waveform */
 357             UniPTEffect (0xe, inf - 0x10);
 358             break;
 359           case 0xa:             /* pattern loop */
 360             UniPTEffect (0xe, 0x60 | (inf & 0xf));
 361             break;
 362           case 0xb:             /* pattern delay */
 363             UniPTEffect (0xe, 0xe0 | (inf & 0xf));
 364             break;
 365           case 0x3:             /* glissando */
 366           case 0xc:             /* note cut */
 367           case 0xd:             /* note delay */
 368           case 0xf:             /* invert loop */
 369             UniPTEffect (0xe, inf);
 370             break;
 371           case 0xe:             /* ignore envelope */
 372             UniEffect (UNI_ITEFFECTS0, 0x77);   /* vol */
 373             UniEffect (UNI_ITEFFECTS0, 0x79);   /* pan */
 374             UniEffect (UNI_ITEFFECTS0, 0x7b);   /* pit */
 375             break;
 376           }
 377         break;
 378         /* 0x22 chorus (awe32) */
 379         /* 0x23 reverb (awe32) */
 380       }
 381 }
 382
 383 static UBYTE *
 384 IMF_ConvertTrack (IMFNOTE * tr, UWORD rows)
 385 {
 386   int t;
 387   UBYTE note, ins;
 388
 389   UniReset ();
 390   for (t = 0; t < rows; t++)
 391     {
 392       note = tr[t].note;
 393       ins = tr[t].ins;
 394
 395       if ((ins) && (ins != 255))
 396         UniInstrument (ins - 1);
 397       if (note != 255)
 398         {
 399           if (note == 0xa0)
 400             {
 401               UniPTEffect (0xc, 0);     /* Note cut */
 402               if (tr[t].eff1 == 0x0c)
 403                 tr[t].eff1 = 0;
 404               if (tr[t].eff2 == 0x0c)
 405                 tr[t].eff2 = 0;
 406             }
 407           else
 408             UniNote (((note >> 4) * OCTAVE) + (note & 0xf));
 409         }
 410
 411       IMF_ProcessCmd (tr[t].eff1, tr[t].dat1);
 412       IMF_ProcessCmd (tr[t].eff2, tr[t].dat2);
 413       UniNewline ();
 414     }
 415   return UniDup ();
 416 }
 417
 418 BOOL
 419 IMF_Load (BOOL curious)
 420 {
 421 #define IMF_SMPINCR 64
 422   int t, u, track = 0;
 423   IMFCHANNEL channels[32];
 424   INSTRUMENT *d;
 425   SAMPLE *q;
 426   IMFWAVHEADER *wh = NULL, *s = NULL;
 427   ULONG *nextwav = NULL;
 428   UWORD wavcnt = 0;
 429   UBYTE id[4];
 430
 431   /* try to read the module header */
 432   _mm_read_string (mh->songname, 32, modreader);
 433   mh->ordnum = _mm_read_I_UWORD (modreader);
 434   mh->patnum = _mm_read_I_UWORD (modreader);
 435   mh->insnum = _mm_read_I_UWORD (modreader);
 436   mh->flags = _mm_read_I_UWORD (modreader);
 437   _mm_fseek (modreader, 8, SEEK_CUR);
 438   mh->initspeed = _mm_read_UBYTE (modreader);
 439   mh->inittempo = _mm_read_UBYTE (modreader);
 440   mh->mastervol = _mm_read_UBYTE (modreader);
 441   mh->mastermult = _mm_read_UBYTE (modreader);
 442   _mm_fseek (modreader, 64, SEEK_SET);
 443
 444   if (_mm_eof (modreader))
 445     {
 446       _mm_errno = MMERR_LOADING_HEADER;
 447       return 0;
 448     }
 449
 450   /* set module variables */
 451   of.songname = DupStr (mh->songname, 31, 1);
 452   of.modtype = strdup (IMF_Version);
 453   of.numpat = mh->patnum;
 454   of.numins = mh->insnum;
 455   of.reppos = 0;
 456   of.initspeed = mh->initspeed;
 457   of.inittempo = mh->inittempo;
 458   of.initvolume = mh->mastervol << 1;
 459   of.flags |= UF_INST;
 460   if (mh->flags & 1)
 461     of.flags |= UF_LINEAR;
 462
 463   /* read channel information */
 464   of.numchn = 0;
 465   memset (remap, -1, 32 * sizeof (UBYTE));
 466   for (t = 0; t < 32; t++)
 467     {
 468       _mm_read_string (channels[t].name, 12, modreader);
 469       channels[t].chorus = _mm_read_UBYTE (modreader);
 470       channels[t].reverb = _mm_read_UBYTE (modreader);
 471       channels[t].pan = _mm_read_UBYTE (modreader);
 472       channels[t].status = _mm_read_UBYTE (modreader);
 473     }
 474   /* bug in Imago Orpheus ? If only channel 1 is enabled, in fact we have to
 475      enable 16 channels */
 476   if (!channels[0].status)
 477     {
 478       for (t = 1; t < 16; t++)
 479         if (channels[t].status != 1)
 480           break;
 481       if (t == 16)
 482         for (t = 1; t < 16; t++)
 483           channels[t].status = 0;
 484     }
 485   for (t = 0; t < 32; t++)
 486     {
 487       if (channels[t].status != 2)
 488         remap[t] = of.numchn++;
 489       else
 490         remap[t] = -1;
 491     }
 492   for (t = 0; t < 32; t++)
 493     if (remap[t] != -1)
 494       {
 495         of.panning[remap[t]] = channels[t].pan;
 496         of.chanvol[remap[t]] = channels[t].status ? 0 : 64;
 497       }
 498
 499   if (_mm_eof (modreader))
 500     {
 501       _mm_errno = MMERR_LOADING_HEADER;
 502       return 0;
 503     }
 504
 505   /* read order list */
 506   _mm_read_UBYTES (mh->orders, 256, modreader);
 507   if (_mm_eof (modreader))
 508     {
 509       _mm_errno = MMERR_LOADING_HEADER;
 510       return 0;
 511     }
 512
 513   of.numpos = 0;
 514   for (t = 0; t < mh->ordnum; t++)
 515     if (mh->orders[t] != 0xff)
 516       of.numpos++;
 517   if (!AllocPositions (of.numpos))
 518     return 0;
 519   for (t = u = 0; t < mh->ordnum; t++)
 520     if (mh->orders[t] != 0xff)
 521       of.positions[u++] = mh->orders[t];
 522
 523   /* load pattern info */
 524   of.numtrk = of.numpat * of.numchn;
 525   if (!AllocTracks ())
 526     return 0;
 527   if (!AllocPatterns ())
 528     return 0;
 529
 530   for (t = 0; t < of.numpat; t++)
 531     {
 532       SLONG size;
 533       UWORD rows;
 534
 535       size = (SLONG) _mm_read_I_UWORD (modreader);
 536       rows = _mm_read_I_UWORD (modreader);
 537       if ((rows > 256) || (size < 4))
 538         {
 539           _mm_errno = MMERR_LOADING_PATTERN;
 540           return 0;
 541         }
 542
 543       of.pattrows[t] = rows;
 544       if (!IMF_ReadPattern (size - 4, rows))
 545         return 0;
 546       for (u = 0; u < of.numchn; u++)
 547         if (!(of.tracks[track++] = IMF_ConvertTrack (&imfpat[u * 256], rows)))
 548           return 0;
 549     }
 550
 551   /* load instruments */
 552   if (!AllocInstruments ())
 553     return 0;
 554   d = of.instruments;
 555
 556   for (t = 0; t < of.numins; t++)
 557     {
 558       IMFINSTHEADER ih;
 559
 560       memset (d->samplenumber, 0xff, INSTNOTES * sizeof (UWORD));
 561
 562       /* read instrument header */
 563       _mm_read_string (ih.name, 32, modreader);
 564       d->insname = DupStr (ih.name, 31, 1);
 565       _mm_read_UBYTES (ih.what, IMFNOTECNT, modreader);
 566       _mm_fseek (modreader, 8, SEEK_CUR);
 567       _mm_read_I_UWORDS (ih.volenv, IMFENVCNT, modreader);
 568       _mm_read_I_UWORDS (ih.panenv, IMFENVCNT, modreader);
 569       _mm_read_I_UWORDS (ih.pitenv, IMFENVCNT, modreader);
 570
 571 #define IMF_FinishLoadingEnvelope(name)                                 \
 572                 ih.name##pts=_mm_read_UBYTE(modreader);         \
 573                 ih.name##sus=_mm_read_UBYTE(modreader);         \
 574                 ih.name##beg=_mm_read_UBYTE(modreader);         \
 575                 ih.name##end=_mm_read_UBYTE(modreader);         \
 576                 ih.name##flg=_mm_read_UBYTE(modreader);         \
 577                 _mm_read_UBYTE(modreader);                                              \
 578                 _mm_read_UBYTE(modreader);                                              \
 579                 _mm_read_UBYTE(modreader);
 580
 581       IMF_FinishLoadingEnvelope (vol);
 582       IMF_FinishLoadingEnvelope (pan);
 583       IMF_FinishLoadingEnvelope (pit);
 584
 585       ih.volfade = _mm_read_I_UWORD (modreader);
 586       ih.numsmp = _mm_read_I_UWORD (modreader);
 587
 588       _mm_read_UBYTES (id, 4, modreader);
 589       if (memcmp (id, "II10", 4))
 590         {
 591           if (nextwav)
 592             free (nextwav);
 593           if (wh)
 594             free (wh);
 595           _mm_errno = MMERR_LOADING_SAMPLEINFO;
 596           return 0;
 597         }
 598       if ((ih.numsmp > 16) || (ih.volpts > IMFENVCNT / 2) || (ih.panpts > IMFENVCNT / 2) ||
 599           (ih.pitpts > IMFENVCNT / 2) || (_mm_eof (modreader)))
 600         {
 601           if (nextwav)
 602             free (nextwav);
 603           if (wh)
 604             free (wh);
 605           _mm_errno = MMERR_LOADING_SAMPLEINFO;
 606           return 0;
 607         }
 608
 609       for (u = 0; u < IMFNOTECNT; u++)
 610         d->samplenumber[u] = ih.what[u] > ih.numsmp ? 0xffff : ih.what[u] + of.numsmp;
 611       d->volfade = ih.volfade;
 612
 613 #define IMF_ProcessEnvelope(name)                                                                               \
 614                 for (u = 0; u < (IMFENVCNT >> 1); u++) {                                                \
 615                         d->name##env[u].pos = ih.name##env[u << 1];                             \
 616                         d->name##env[u].val = ih.name##env[(u << 1)+ 1];                \
 617                 }                                                                                                                               \
 618                 if (ih.name##flg&1) d->name##flg|=EF_ON;                                        \
 619                 if (ih.name##flg&2) d->name##flg|=EF_SUSTAIN;                           \
 620                 if (ih.name##flg&4) d->name##flg|=EF_LOOP;                                      \
 621                 d->name##susbeg=d->name##susend=ih.name##sus;                           \
 622                 d->name##beg=ih.name##beg;                                                                      \
 623                 d->name##end=ih.name##end;                                                                      \
 624                 d->name##pts=ih.name##pts;                                                                      \
 625                                                                                                                                                 \
 626                 if ((d->name##flg&EF_ON)&&(d->name##pts<2))                                     \
 627                         d->name##flg&=~EF_ON;
 628
 629       IMF_ProcessEnvelope (vol);
 630       IMF_ProcessEnvelope (pan);
 631       IMF_ProcessEnvelope (pit);
 632 #undef IMF_ProcessEnvelope
 633
 634       if (ih.pitflg & 1)
 635         {
 636           d->pitflg &= ~EF_ON;
 637 #ifdef MIKMOD_DEBUG
 638           fputs ("\rFilter envelopes not supported yet\n", stderr);
 639 #endif
 640         }
 641
 642       /* gather sample information */
 643       for (u = 0; u < ih.numsmp; u++, s++)
 644         {
 645           /* allocate more room for sample information if necessary */
 646           if (of.numsmp + u == wavcnt)
 647             {
 648               wavcnt += IMF_SMPINCR;
 649               if (!(nextwav = realloc (nextwav, wavcnt * sizeof (ULONG))))
 650                 {
 651                   if (wh)
 652                     free (wh);
 653                   _mm_errno = MMERR_OUT_OF_MEMORY;
 654                   return 0;
 655                 }
 656               if (!(wh = realloc (wh, wavcnt * sizeof (IMFWAVHEADER))))
 657                 {
 658                   free (nextwav);
 659                   _mm_errno = MMERR_OUT_OF_MEMORY;
 660                   return 0;
 661                 }
 662               s = wh + (wavcnt - IMF_SMPINCR);
 663             }
 664
 665           _mm_read_string (s->samplename, 13, modreader);
 666           _mm_read_UBYTE (modreader);
 667           _mm_read_UBYTE (modreader);
 668           _mm_read_UBYTE (modreader);
 669           s->length = _mm_read_I_ULONG (modreader);
 670           s->loopstart = _mm_read_I_ULONG (modreader);
 671           s->loopend = _mm_read_I_ULONG (modreader);
 672           s->samplerate = _mm_read_I_ULONG (modreader);
 673           s->volume = _mm_read_UBYTE (modreader) & 0x7f;
 674           s->pan = _mm_read_UBYTE (modreader);
 675           _mm_fseek (modreader, 14, SEEK_CUR);
 676           s->flags = _mm_read_UBYTE (modreader);
 677           _mm_fseek (modreader, 11, SEEK_CUR);
 678           _mm_read_UBYTES (id, 4, modreader);
 679           if (((memcmp (id, "IS10", 4)) && (memcmp (id, "IW10", 4))) ||
 680               (_mm_eof (modreader)))
 681             {
 682               free (nextwav);
 683               free (wh);
 684               _mm_errno = MMERR_LOADING_SAMPLEINFO;
 685               return 0;
 686             }
 687           nextwav[of.numsmp + u] = _mm_ftell (modreader);
 688           _mm_fseek (modreader, s->length, SEEK_CUR);
 689         }
 690
 691       of.numsmp += ih.numsmp;
 692       d++;
 693     }
 694
 695   /* sanity check */
 696   if (!of.numsmp)
 697     {
 698       if (nextwav)
 699         free (nextwav);
 700       if (wh)
 701         free (wh);
 702       _mm_errno = MMERR_LOADING_SAMPLEINFO;
 703       return 0;
 704     }
 705
 706   /* load samples */
 707   if (!AllocSamples ())
 708     {
 709       free (nextwav);
 710       free (wh);
 711       return 0;
 712     }
 713   if (!AllocLinear ())
 714     {
 715       free (nextwav);
 716       free (wh);
 717       return 0;
 718     }
 719   q = of.samples;
 720   s = wh;
 721   for (u = 0; u < of.numsmp; u++, s++, q++)
 722     {
 723       q->samplename = DupStr (s->samplename, 12, 1);
 724       q->length = s->length;
 725       q->loopstart = s->loopstart;
 726       q->loopend = s->loopend;
 727       q->volume = s->volume;
 728       q->speed = s->samplerate;
 729       if (of.flags & UF_LINEAR)
 730         q->speed = speed_to_finetune (s->samplerate << 1, u);
 731       q->panning = s->pan;
 732       q->seekpos = nextwav[u];
 733
 734       q->flags |= SF_SIGNED;
 735       if (s->flags & 0x1)
 736         q->flags |= SF_LOOP;
 737       if (s->flags & 0x2)
 738         q->flags |= SF_BIDI;
 739       if (s->flags & 0x8)
 740         q->flags |= SF_OWNPAN;
 741       if (s->flags & 0x4)
 742         {
 743           q->flags |= SF_16BITS;
 744           q->length >>= 1;
 745           q->loopstart >>= 1;
 746           q->loopend >>= 1;
 747         }
 748     }
 749
 750   d = of.instruments;
 751   s = wh;
 752   for (u = 0; u < of.numins; u++, d++)
 753     {
 754       for (t = 0; t < IMFNOTECNT; t++)
 755         {
 756           if (d->samplenumber[t] >= of.numsmp)
 757             d->samplenote[t] = 255;
 758           else if (of.flags & UF_LINEAR)
 759             {
 760               int note = (int) d->samplenote[u] + noteindex[d->samplenumber[u]];
 761               d->samplenote[u] = (note < 0) ? 0 : (note > 255 ? 255 : note);
 762             }
 763           else
 764             d->samplenote[t] = t;
 765         }
 766     }
 767
 768   free (wh);
 769   free (nextwav);
 770   return 1;
 771 }
 772
 773 CHAR *
 774 IMF_LoadTitle (void)
 775 {
 776   CHAR s[31];
 777
 778   _mm_fseek (modreader, 0, SEEK_SET);
 779   if (!_mm_read_UBYTES (s, 31, modreader))
 780     return NULL;
 781
 782   return (DupStr (s, 31, 1));
 783 }
 784
 785 /*========== Loader information */
 786
 787 MLOADER load_imf =
 788 {
 789   NULL,
 790   "IMF",
 791   "IMF (Imago Orpheus)",
 792   IMF_Init,
 793   IMF_Test,
 794   IMF_Load,
 795   IMF_Cleanup,
 796   IMF_LoadTitle
 797 };
 798
 799 /* ex:set ts=4: */