/
instrum.c
601 lines (524 loc) · 15 KB
1
/*
2
3
4
5
6
TiMidity -- Experimental MIDI to WAVE converter
Copyright (C) 1995 Tuukka Toivonen <toivonen@clinet.fi>
This program is free software; you can redistribute it and/or modify
7
it under the terms of the Perl Artistic License, available in COPYING.
8
9
10
11
12
13
14
15
16
17
instrum.c
Code to load and unload GUS-compatible instrument patches.
*/
#if HAVE_CONFIG_H
# include <config.h>
#endif
18
19
20
21
22
#include <stdio.h>
#include <string.h>
#include <stdlib.h>
23
24
25
26
#include "SDL.h"
#include "timidity.h"
#include "options.h"
27
28
29
30
#include "common.h"
#include "instrum.h"
#include "resample.h"
#include "tables.h"
31
32
33
34
35
36
37
38
39
static void free_instrument(Instrument *ip)
{
Sample *sp;
int i;
if (!ip) return;
for (i=0; i<ip->samples; i++)
{
sp=&(ip->sample[i]);
40
free(sp->data);
41
42
43
44
45
}
free(ip->sample);
free(ip);
}
46
static void free_bank(MidiSong *song, int dr, int b)
47
48
{
int i;
49
50
51
ToneBank *bank=((dr) ? song->drumset[b] : song->tonebank[b]);
for (i=0; i<MAXBANK; i++)
if (bank->instrument[i])
52
{
53
54
55
56
/* Not that this could ever happen, of course */
if (bank->instrument[i] != MAGIC_LOAD_INSTRUMENT)
free_instrument(bank->instrument[i]);
bank->instrument[i]=0;
57
58
59
}
}
60
static Sint32 convert_envelope_rate(MidiSong *song, Uint8 rate)
61
{
62
63
64
65
66
Sint32 r;
r = 3 - ((rate >> 6) & 0x3);
r *= 3;
r = (Sint32) (rate & 0x3f) << r; /* 6.9 fixed point */
67
68
/* 15.15 fixed point. */
69
r = ((r * 44100) / song->rate) * song->control_ratio;
70
71
72
73
74
75
#ifdef FAST_DECAY
return r << 10;
#else
return r << 9;
#endif
76
77
}
78
static Sint32 convert_envelope_offset(Uint8 offset)
79
80
81
82
83
84
85
86
{
/* This is not too good... Can anyone tell me what these values mean?
Are they GUS-style "exponential" volumes? And what does that mean? */
/* 15.15 fixed point */
return offset << (7+15);
}
87
static Sint32 convert_tremolo_sweep(MidiSong *song, Uint8 sweep)
88
89
90
91
92
{
if (!sweep)
return 0;
return
93
94
((song->control_ratio * SWEEP_TUNING) << SWEEP_SHIFT) /
(song->rate * sweep);
95
96
}
97
98
static Sint32 convert_vibrato_sweep(MidiSong *song, Uint8 sweep,
Sint32 vib_control_ratio)
99
100
101
102
103
{
if (!sweep)
return 0;
return
104
105
(Sint32) (FSCALE((double) (vib_control_ratio) * SWEEP_TUNING, SWEEP_SHIFT)
/ (double)(song->rate * sweep));
106
107
108
109
/* this was overflowing with seashore.pat
((vib_control_ratio * SWEEP_TUNING) << SWEEP_SHIFT) /
110
(song->rate * sweep); */
111
112
}
113
static Sint32 convert_tremolo_rate(MidiSong *song, Uint8 rate)
114
115
{
return
116
117
((SINE_CYCLE_LENGTH * song->control_ratio * rate) << RATE_SHIFT) /
(TREMOLO_RATE_TUNING * song->rate);
118
119
}
120
static Sint32 convert_vibrato_rate(MidiSong *song, Uint8 rate)
121
122
123
{
/* Return a suitable vibrato_control_ratio value */
return
124
(VIBRATO_RATE_TUNING * song->rate) /
125
126
127
(rate * 2 * VIBRATO_SAMPLE_INCREMENTS);
}
128
static void reverse_data(Sint16 *sp, Sint32 ls, Sint32 le)
129
{
130
Sint16 s, *ep=sp+le;
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
sp+=ls;
le-=ls;
le/=2;
while (le--)
{
s=*sp;
*sp++=*ep;
*ep--=s;
}
}
/*
If panning or note_to_use != -1, it will be used for all samples,
instead of the sample-specific values in the instrument file.
For note_to_use, any value <0 or >127 will be forced to 0.
For other parameters, 1 means yes, 0 means no, other values are
undefined.
TODO: do reverse loops right */
152
153
static Instrument *load_instrument(MidiSong *song, char *name, int percussion,
int panning, int amp, int note_to_use,
154
int strip_loop, int strip_envelope,
155
int strip_tail)
156
157
{
Instrument *ip;
158
159
160
Sample *sp;
SDL_RWops *rw;
char tmp[1024];
161
162
163
164
165
166
int i,j,noluck=0;
static char *patch_ext[] = PATCH_EXT_LIST;
if (!name) return 0;
/* Open patch file */
167
if ((rw=open_file(name)) == NULL)
168
169
170
171
172
{
noluck=1;
/* Try with various extensions */
for (i=0; patch_ext[i]; i++)
{
173
if (strlen(name)+strlen(patch_ext[i])<1024)
174
{
175
176
177
strcpy(tmp, name);
strcat(tmp, patch_ext[i]);
if ((rw=open_file(tmp)) != NULL)
178
179
180
181
182
183
184
185
186
187
{
noluck=0;
break;
}
}
}
}
if (noluck)
{
188
SNDDBG(("Instrument `%s' can't be found.\n", name));
189
190
191
return 0;
}
192
SNDDBG(("Loading instrument %s\n", tmp));
193
194
195
196
/* Read some headers and do cursory sanity checks. There are loads
of magic offsets. This could be rewritten... */
197
if ((239 != SDL_RWread(rw, tmp, 1, 239)) ||
198
199
200
201
(memcmp(tmp, "GF1PATCH110\0ID#000002", 22) &&
memcmp(tmp, "GF1PATCH100\0ID#000002", 22))) /* don't know what the
differences are */
{
202
SNDDBG(("%s: not an instrument\n", name));
203
204
return 0;
}
205
206
207
208
if (tmp[82] != 1 && tmp[82] != 0) /* instruments. To some patch makers,
0 means 1 */
{
209
SNDDBG(("Can't handle patches with %d instruments\n", tmp[82]));
210
211
212
213
214
return 0;
}
if (tmp[151] != 1 && tmp[151] != 0) /* layers. What's a layer? */
{
215
SNDDBG(("Can't handle instruments with %d layers\n", tmp[151]));
216
217
218
return 0;
}
219
220
221
222
ip=safe_malloc(sizeof(Instrument));
ip->samples = tmp[198];
ip->sample = safe_malloc(sizeof(Sample) * ip->samples);
for (i=0; i<ip->samples; i++)
223
{
224
225
226
227
228
Uint8 fractions;
Sint32 tmplong;
Uint16 tmpshort;
Uint8 tmpchar;
229
230
#define READ_CHAR(thing) \
231
if (1 != SDL_RWread(rw, &tmpchar, 1, 1)) goto fail; \
232
233
thing = tmpchar;
#define READ_SHORT(thing) \
234
235
if (1 != SDL_RWread(rw, &tmpshort, 2, 1)) goto fail; \
thing = SDL_SwapLE16(tmpshort);
236
#define READ_LONG(thing) \
237
238
if (1 != SDL_RWread(rw, &tmplong, 4, 1)) goto fail; \
thing = SDL_SwapLE32(tmplong);
239
240
241
242
SDL_RWseek(rw, 7, RW_SEEK_CUR); /* Skip the wave name */
if (1 != SDL_RWread(rw, &fractions, 1, 1))
243
244
{
fail:
245
SNDDBG(("Error reading sample %d\n", i));
246
for (j=0; j<i; j++)
247
248
free(ip->sample[j].data);
free(ip->sample);
249
250
251
252
free(ip);
return 0;
}
253
254
sp=&(ip->sample[i]);
255
256
257
258
259
260
261
READ_LONG(sp->data_length);
READ_LONG(sp->loop_start);
READ_LONG(sp->loop_end);
READ_SHORT(sp->sample_rate);
READ_LONG(sp->low_freq);
READ_LONG(sp->high_freq);
READ_LONG(sp->root_freq);
262
263
SDL_RWseek(rw, 2, RW_SEEK_CUR); /* Why have a "root frequency" and then
* "tuning"?? */
264
265
266
267
268
269
READ_CHAR(tmp[0]);
if (panning==-1)
sp->panning = (tmp[0] * 8 + 4) & 0x7f;
else
270
sp->panning=(Uint8)(panning & 0x7F);
271
272
/* envelope, tremolo, and vibrato */
273
if (18 != SDL_RWread(rw, tmp, 1, 18)) goto fail;
274
275
276
277
278
if (!tmp[13] || !tmp[14])
{
sp->tremolo_sweep_increment=
sp->tremolo_phase_increment=sp->tremolo_depth=0;
279
SNDDBG((" * no tremolo\n"));
280
281
282
}
else
{
283
284
sp->tremolo_sweep_increment=convert_tremolo_sweep(song, tmp[12]);
sp->tremolo_phase_increment=convert_tremolo_rate(song, tmp[13]);
285
sp->tremolo_depth=tmp[14];
286
SNDDBG((" * tremolo: sweep %d, phase %d, depth %d\n",
287
sp->tremolo_sweep_increment, sp->tremolo_phase_increment,
288
sp->tremolo_depth));
289
290
291
292
293
294
}
if (!tmp[16] || !tmp[17])
{
sp->vibrato_sweep_increment=
sp->vibrato_control_ratio=sp->vibrato_depth=0;
295
SNDDBG((" * no vibrato\n"));
296
297
298
}
else
{
299
sp->vibrato_control_ratio=convert_vibrato_rate(song, tmp[16]);
300
sp->vibrato_sweep_increment=
301
convert_vibrato_sweep(song, tmp[15], sp->vibrato_control_ratio);
302
sp->vibrato_depth=tmp[17];
303
SNDDBG((" * vibrato: sweep %d, ctl %d, depth %d\n",
304
sp->vibrato_sweep_increment, sp->vibrato_control_ratio,
305
sp->vibrato_depth));
306
307
308
309
}
READ_CHAR(sp->modes);
310
311
312
313
SDL_RWseek(rw, 40, RW_SEEK_CUR); /* skip the useless scale frequency, scale
factor (what's it mean?), and reserved
space */
314
315
316
/* Mark this as a fixed-pitch instrument if such a deed is desired. */
if (note_to_use!=-1)
317
sp->note_to_use=(Uint8)(note_to_use);
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
else
sp->note_to_use=0;
/* seashore.pat in the Midia patch set has no Sustain. I don't
understand why, and fixing it by adding the Sustain flag to
all looped patches probably breaks something else. We do it
anyway. */
if (sp->modes & MODES_LOOPING)
sp->modes |= MODES_SUSTAIN;
/* Strip any loops and envelopes we're permitted to */
if ((strip_loop==1) &&
(sp->modes & (MODES_SUSTAIN | MODES_LOOPING |
MODES_PINGPONG | MODES_REVERSE)))
{
334
SNDDBG((" - Removing loop and/or sustain\n"));
335
336
337
338
339
340
341
sp->modes &=~(MODES_SUSTAIN | MODES_LOOPING |
MODES_PINGPONG | MODES_REVERSE);
}
if (strip_envelope==1)
{
if (sp->modes & MODES_ENVELOPE)
342
SNDDBG((" - Removing envelope\n"));
343
344
345
346
347
348
349
350
351
352
sp->modes &= ~MODES_ENVELOPE;
}
else if (strip_envelope != 0)
{
/* Have to make a guess. */
if (!(sp->modes & (MODES_LOOPING | MODES_PINGPONG | MODES_REVERSE)))
{
/* No loop? Then what's there to sustain? No envelope needed
either... */
sp->modes &= ~(MODES_SUSTAIN|MODES_ENVELOPE);
353
SNDDBG((" - No loop, removing sustain and envelope\n"));
354
355
356
357
358
359
}
else if (!memcmp(tmp, "??????", 6) || tmp[11] >= 100)
{
/* Envelope rates all maxed out? Envelope end at a high "offset"?
That's a weird envelope. Take it out. */
sp->modes &= ~MODES_ENVELOPE;
360
SNDDBG((" - Weirdness, removing envelope\n"));
361
362
363
364
365
366
367
368
}
else if (!(sp->modes & MODES_SUSTAIN))
{
/* No sustain? Then no envelope. I don't know if this is
justified, but patches without sustain usually don't need the
envelope either... at least the Gravis ones. They're mostly
drums. I think. */
sp->modes &= ~MODES_ENVELOPE;
369
SNDDBG((" - No sustain, removing envelope\n"));
370
371
372
}
}
373
for (j=0; j<6; j++)
374
375
{
sp->envelope_rate[j]=
376
convert_envelope_rate(song, tmp[j]);
377
378
379
380
381
sp->envelope_offset[j]=
convert_envelope_offset(tmp[6+j]);
}
/* Then read the sample data */
382
383
sp->data = safe_malloc(sp->data_length);
if (1 != SDL_RWread(rw, sp->data, sp->data_length, 1))
384
385
386
387
goto fail;
if (!(sp->modes & MODES_16BIT)) /* convert to 16-bit data */
{
388
389
390
391
Sint32 i=sp->data_length;
Uint8 *cp=(Uint8 *)(sp->data);
Uint16 *tmp,*new;
tmp=new=safe_malloc(sp->data_length*2);
392
while (i--)
393
394
395
*tmp++ = (Uint16)(*cp++) << 8;
cp=(Uint8 *)(sp->data);
sp->data = (sample_t *)new;
396
397
398
399
400
free(cp);
sp->data_length *= 2;
sp->loop_start *= 2;
sp->loop_end *= 2;
}
401
#if SDL_BYTEORDER == SDL_BIG_ENDIAN
402
403
404
else
/* convert to machine byte order */
{
405
406
Sint32 i=sp->data_length/2;
Sint16 *tmp=(Sint16 *)sp->data,s;
407
408
while (i--)
{
409
s=SDL_SwapLE16(*tmp);
410
411
412
413
414
415
416
*tmp++=s;
}
}
#endif
if (sp->modes & MODES_UNSIGNED) /* convert to signed data */
{
417
418
Sint32 i=sp->data_length/2;
Sint16 *tmp=(Sint16 *)sp->data;
419
420
421
422
423
424
425
while (i--)
*tmp++ ^= 0x8000;
}
/* Reverse reverse loops and pass them off as normal loops */
if (sp->modes & MODES_REVERSE)
{
426
Sint32 t;
427
428
429
/* The GUS apparently plays reverse loops by reversing the
whole sample. We do the same because the GUS does not SUCK. */
430
431
SNDDBG(("Reverse loop in %s\n", name));
reverse_data((Sint16 *)sp->data, 0, sp->data_length/2);
432
433
434
435
436
437
438
439
440
441
442
t=sp->loop_start;
sp->loop_start=sp->data_length - sp->loop_end;
sp->loop_end=sp->data_length - t;
sp->modes &= ~MODES_REVERSE;
sp->modes |= MODES_LOOPING; /* just in case */
}
#ifdef ADJUST_SAMPLE_VOLUMES
if (amp!=-1)
443
sp->volume=(float)((amp) / 100.0);
444
445
446
447
448
else
{
/* Try to determine a volume scaling factor for the sample.
This is a very crude adjustment, but things sound more
balanced with it. Still, this should be a runtime option. */
449
450
451
Sint32 i=sp->data_length/2;
Sint16 maxamp=0,a;
Sint16 *tmp=(Sint16 *)sp->data;
452
453
454
455
456
457
458
while (i--)
{
a=*tmp++;
if (a<0) a=-a;
if (a>maxamp)
maxamp=a;
}
459
460
sp->volume=(float)(32768.0 / maxamp);
SNDDBG((" * volume comp: %f\n", sp->volume));
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
}
#else
if (amp!=-1)
sp->volume=(double)(amp) / 100.0;
else
sp->volume=1.0;
#endif
sp->data_length /= 2; /* These are in bytes. Convert into samples. */
sp->loop_start /= 2;
sp->loop_end /= 2;
/* Then fractional samples */
sp->data_length <<= FRACTION_BITS;
sp->loop_start <<= FRACTION_BITS;
sp->loop_end <<= FRACTION_BITS;
/* Adjust for fractional loop points. This is a guess. Does anyone
know what "fractions" really stands for? */
sp->loop_start |=
(fractions & 0x0F) << (FRACTION_BITS-4);
sp->loop_end |=
((fractions>>4) & 0x0F) << (FRACTION_BITS-4);
/* If this instrument will always be played on the same note,
and it's not looped, we can resample it now. */
if (sp->note_to_use && !(sp->modes & MODES_LOOPING))
488
pre_resample(song, sp);
489
490
491
492
if (strip_tail==1)
{
/* Let's not really, just say we did. */
493
SNDDBG((" - Stripping tail\n"));
494
495
sp->data_length = sp->loop_end;
}
496
}
497
498
499
SDL_RWclose(rw);
return ip;
500
501
}
502
static int fill_bank(MidiSong *song, int dr, int b)
503
504
{
int i, errors=0;
505
ToneBank *bank=((dr) ? song->drumset[b] : song->tonebank[b]);
506
507
if (!bank)
{
508
509
SNDDBG(("Huh. Tried to load instruments in non-existent %s %d\n",
(dr) ? "drumset" : "tone bank", b));
510
511
return 0;
}
512
for (i=0; i<MAXBANK; i++)
513
{
514
if (bank->instrument[i]==MAGIC_LOAD_INSTRUMENT)
515
516
517
{
if (!(bank->tone[i].name))
{
518
SNDDBG(("No instrument mapped to %s %d, program %d%s\n",
519
(dr)? "drum set" : "tone bank", b, i,
520
(b!=0) ? "" : " - this instrument will not be heard"));
521
522
523
524
525
526
if (b!=0)
{
/* Mark the corresponding instrument in the default
bank / drumset for loading (if it isn't already) */
if (!dr)
{
527
528
if (!(song->tonebank[0]->instrument[i]))
song->tonebank[0]->instrument[i] =
529
530
531
532
MAGIC_LOAD_INSTRUMENT;
}
else
{
533
534
if (!(song->drumset[0]->instrument[i]))
song->drumset[0]->instrument[i] =
535
536
537
MAGIC_LOAD_INSTRUMENT;
}
}
538
bank->instrument[i] = 0;
539
540
errors++;
}
541
542
543
else if (!(bank->instrument[i] =
load_instrument(song,
bank->tone[i].name,
544
545
546
547
(dr) ? 1 : 0,
bank->tone[i].pan,
bank->tone[i].amp,
(bank->tone[i].note!=-1) ?
548
549
bank->tone[i].note :
((dr) ? i : -1),
550
551
552
553
554
555
(bank->tone[i].strip_loop!=-1) ?
bank->tone[i].strip_loop :
((dr) ? 1 : -1),
(bank->tone[i].strip_envelope != -1) ?
bank->tone[i].strip_envelope :
((dr) ? 1 : -1),
556
bank->tone[i].strip_tail )))
557
{
558
SNDDBG(("Couldn't load instrument %s (%s %d, program %d)\n",
559
bank->tone[i].name,
560
(dr)? "drum set" : "tone bank", b, i));
561
562
563
564
565
566
567
errors++;
}
}
}
return errors;
}
568
int load_missing_instruments(MidiSong *song)
569
{
570
int i=MAXBANK,errors=0;
571
572
while (i--)
{
573
574
575
576
if (song->tonebank[i])
errors+=fill_bank(song,0,i);
if (song->drumset[i])
errors+=fill_bank(song,1,i);
577
578
579
580
}
return errors;
}
581
void free_instruments(MidiSong *song)
582
{
583
int i=MAXBANK;
584
585
while(i--)
{
586
587
588
589
if (song->tonebank[i])
free_bank(song, 0, i);
if (song->drumset[i])
free_bank(song, 1, i);
590
591
592
}
}
593
int set_default_instrument(MidiSong *song, char *name)
594
{
595
596
Instrument *ip;
if (!(ip=load_instrument(song, name, 0, -1, -1, -1, 0, 0, 0)))
597
return -1;
598
599
song->default_instrument = ip;
song->default_program = SPECIAL_PROGRAM;
600
601
return 0;
}