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 static BOOL
IMF_Test(void)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 static BOOL
IMF_Init(void)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 static void
IMF_Cleanup(void)151 IMF_Cleanup (void)
152 {
153 FreeLinear ();
154
155 _mm_free (imfpat);
156 _mm_free (mh);
157 }
158
159 static BOOL
IMF_ReadPattern(SLONG size,UWORD rows)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
IMF_ProcessCmd(UBYTE eff,UBYTE inf)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 *
IMF_ConvertTrack(IMFNOTE * tr,UWORD rows)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 static BOOL
IMF_Load(BOOL curious)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 static CHAR *
IMF_LoadTitle(void)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: */
800