Mercurial > SDL_sound_CoreAudio

comparison decoders/timidity/timidity.c @ 199:2d887640d300

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
Initial add.
author Ryan C. Gordon <icculus@icculus.org>
date Fri, 04 Jan 2002 06:49:49 +0000
parents
children e122de403a2d
comparison
equal deleted inserted replaced
198:f9a752f41ab6 199:2d887640d300
1 /*
2
3 TiMidity -- Experimental MIDI to WAVE converter
4 Copyright (C) 1995 Tuukka Toivonen <toivonen@clinet.fi>
5
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19
20 */
21
22 #if HAVE_CONFIG_H
23 # include <config.h>
24 #endif
25
26 #include <stdio.h>
27 #include <stdlib.h>
28 #include <string.h>
29
30 #include "SDL_sound.h"
31
32 #define __SDL_SOUND_INTERNAL__
33 #include "SDL_sound_internal.h"
34
35 #include "timidity.h"
36
37 #include "options.h"
38 #include "common.h"
39 #include "instrum.h"
40 #include "playmidi.h"
41 #include "readmidi.h"
42 #include "output.h"
43
44 #include "tables.h"
45
46 ToneBank *master_tonebank[128], *master_drumset[128];
47
48 static char def_instr_name[256] = "";
49
50 #define MAXWORDS 10
51
52 /* Quick-and-dirty fgets() replacement. */
53
54 static char *RWgets(SDL_RWops *rw, char *s, int size)
55 {
56 int num_read = 0;
57 int newline = 0;
58
59 while (num_read < size && !newline)
60 {
61 if (SDL_RWread(rw, &s[num_read], 1, 1) != 1)
62 break;
63
64 /* Unlike fgets(), don't store newline. Under Windows/DOS we'll
65 * probably get an extra blank line for every line that's being
66 * read, but that should be ok.
67 */
68 if (s[num_read] == '\n' || s[num_read] == '\r')
69 {
70 s[num_read] = '\0';
71 newline = 1;
72 }
73
74 num_read++;
75 }
76
77 s[num_read] = '\0';
78
79 return (num_read != 0) ? s : NULL;
80 }
81
82 static int read_config_file(char *name)
83 {
84 SDL_RWops *rw;
85 char tmp[1024], *w[MAXWORDS], *cp;
86 ToneBank *bank=0;
87 int i, j, k, line=0, words;
88 static int rcf_count=0;
89
90 if (rcf_count>50)
91 {
92 SNDDBG(("Probable source loop in configuration files\n"));
93 return (-1);
94 }
95
96 if (!(rw=open_file(name)))
97 return -1;
98
99 while (RWgets(rw, tmp, sizeof(tmp)))
100 {
101 line++;
102 w[words=0]=strtok(tmp, " \t\240");
103 if (!w[0] || (*w[0]=='#')) continue;
104 while (w[words] && *w[words] != '#' && (words < MAXWORDS))
105 w[++words]=strtok(0," \t\240");
106 if (!strcmp(w[0], "dir"))
107 {
108 if (words < 2)
109 {
110 SNDDBG(("%s: line %d: No directory given\n", name, line));
111 return -2;
112 }
113 for (i=1; i<words; i++)
114 add_to_pathlist(w[i]);
115 }
116 else if (!strcmp(w[0], "source"))
117 {
118 if (words < 2)
119 {
120 SNDDBG(("%s: line %d: No file name given\n", name, line));
121 return -2;
122 }
123 for (i=1; i<words; i++)
124 {
125 rcf_count++;
126 read_config_file(w[i]);
127 rcf_count--;
128 }
129 }
130 else if (!strcmp(w[0], "default"))
131 {
132 if (words != 2)
133 {
134 SNDDBG(("%s: line %d: Must specify exactly one patch name\n",
135 name, line));
136 return -2;
137 }
138 strncpy(def_instr_name, w[1], 255);
139 def_instr_name[255]='\0';
140 }
141 else if (!strcmp(w[0], "drumset"))
142 {
143 if (words < 2)
144 {
145 SNDDBG(("%s: line %d: No drum set number given\n", name, line));
146 return -2;
147 }
148 i=atoi(w[1]);
149 if (i<0 || i>127)
150 {
151 SNDDBG(("%s: line %d: Drum set must be between 0 and 127\n",
152 name, line));
153 return -2;
154 }
155 if (!master_drumset[i])
156 {
157 master_drumset[i] = safe_malloc(sizeof(ToneBank));
158 memset(master_drumset[i], 0, sizeof(ToneBank));
159 master_drumset[i]->tone = safe_malloc(128 * sizeof(ToneBankElement));
160 memset(master_drumset[i]->tone, 0, 128 * sizeof(ToneBankElement));
161 }
162 bank=master_drumset[i];
163 }
164 else if (!strcmp(w[0], "bank"))
165 {
166 if (words < 2)
167 {
168 SNDDBG(("%s: line %d: No bank number given\n", name, line));
169 return -2;
170 }
171 i=atoi(w[1]);
172 if (i<0 || i>127)
173 {
174 SNDDBG(("%s: line %d: Tone bank must be between 0 and 127\n",
175 name, line));
176 return -2;
177 }
178 if (!master_tonebank[i])
179 {
180 master_tonebank[i] = safe_malloc(sizeof(ToneBank));
181 memset(master_tonebank[i], 0, sizeof(ToneBank));
182 master_tonebank[i]->tone = safe_malloc(128 * sizeof(ToneBankElement));
183 memset(master_tonebank[i]->tone, 0, 128 * sizeof(ToneBankElement));
184 }
185 bank=master_tonebank[i];
186 }
187 else
188 {
189 if ((words < 2) || (*w[0] < '0' || *w[0] > '9'))
190 {
191 SNDDBG(("%s: line %d: syntax error\n", name, line));
192 return -2;
193 }
194 i=atoi(w[0]);
195 if (i<0 || i>127)
196 {
197 SNDDBG(("%s: line %d: Program must be between 0 and 127\n",
198 name, line));
199 return -2;
200 }
201 if (!bank)
202 {
203 SNDDBG(("%s: line %d: Must specify tone bank or drum set before assignment\n",
204 name, line));
205 return -2;
206 }
207 if (bank->tone[i].name)
208 free(bank->tone[i].name);
209 strcpy((bank->tone[i].name=safe_malloc(strlen(w[1])+1)),w[1]);
210 bank->tone[i].note=bank->tone[i].amp=bank->tone[i].pan=
211 bank->tone[i].strip_loop=bank->tone[i].strip_envelope=
212 bank->tone[i].strip_tail=-1;
213
214 for (j=2; j<words; j++)
215 {
216 if (!(cp=strchr(w[j], '=')))
217 {
218 SNDDBG(("%s: line %d: bad patch option %s\n", name, line, w[j]));
219 return -2;
220 }
221 *cp++=0;
222 if (!strcmp(w[j], "amp"))
223 {
224 k=atoi(cp);
225 if ((k<0 || k>MAX_AMPLIFICATION) || (*cp < '0' || *cp > '9'))
226 {
227 SNDDBG(("%s: line %d: amplification must be between 0 and %d\n",
228 name, line, MAX_AMPLIFICATION));
229 return -2;
230 }
231 bank->tone[i].amp=k;
232 }
233 else if (!strcmp(w[j], "note"))
234 {
235 k=atoi(cp);
236 if ((k<0 || k>127) || (*cp < '0' || *cp > '9'))
237 {
238 SNDDBG(("%s: line %d: note must be between 0 and 127\n",
239 name, line));
240 return -2;
241 }
242 bank->tone[i].note=k;
243 }
244 else if (!strcmp(w[j], "pan"))
245 {
246 if (!strcmp(cp, "center"))
247 k=64;
248 else if (!strcmp(cp, "left"))
249 k=0;
250 else if (!strcmp(cp, "right"))
251 k=127;
252 else
253 k=((atoi(cp)+100) * 100) / 157;
254 if ((k<0 || k>127) || (k==0 && *cp!='-' && (*cp < '0' || *cp > '9')))
255 {
256 SNDDBG(("%s: line %d: panning must be left, right, center, or between -100 and 100\n",
257 name, line));
258 return -2;
259 }
260 bank->tone[i].pan=k;
261 }
262 else if (!strcmp(w[j], "keep"))
263 {
264 if (!strcmp(cp, "env"))
265 bank->tone[i].strip_envelope=0;
266 else if (!strcmp(cp, "loop"))
267 bank->tone[i].strip_loop=0;
268 else
269 {
270 SNDDBG(("%s: line %d: keep must be env or loop\n", name, line));
271 return -2;
272 }
273 }
274 else if (!strcmp(w[j], "strip"))
275 {
276 if (!strcmp(cp, "env"))
277 bank->tone[i].strip_envelope=1;
278 else if (!strcmp(cp, "loop"))
279 bank->tone[i].strip_loop=1;
280 else if (!strcmp(cp, "tail"))
281 bank->tone[i].strip_tail=1;
282 else
283 {
284 SNDDBG(("%s: line %d: strip must be env, loop, or tail\n",
285 name, line));
286 return -2;
287 }
288 }
289 else
290 {
291 SNDDBG(("%s: line %d: bad patch option %s\n", name, line, w[j]));
292 return -2;
293 }
294 }
295 }
296 }
297 SDL_RWclose(rw);
298 return 0;
299 }
300
301 int Timidity_Init()
302 {
303 /* !!! FIXME: This may be ugly, but slightly less so than requiring the
304 * default search path to have only one element. I think.
305 *
306 * We only need to include the likely locations for the config
307 * file itself since that file should contain any other directory
308 * that needs to be added to the search path.
309 */
310 #ifdef WIN32
311 add_to_pathlist("\\TIMIDITY");
312 #else
313 add_to_pathlist("/usr/local/lib/timidity");
314 add_to_pathlist("/etc");
315 #endif
316
317 /* Allocate memory for the standard tonebank and drumset */
318 master_tonebank[0] = safe_malloc(sizeof(ToneBank));
319 memset(master_tonebank[0], 0, sizeof(ToneBank));
320 master_tonebank[0]->tone = safe_malloc(128 * sizeof(ToneBankElement));
321 memset(master_tonebank[0]->tone, 0, 128 * sizeof(ToneBankElement));
322
323 master_drumset[0] = safe_malloc(sizeof(ToneBank));
324 memset(master_drumset[0], 0, sizeof(ToneBank));
325 master_drumset[0]->tone = safe_malloc(128 * sizeof(ToneBankElement));
326 memset(master_drumset[0]->tone, 0, 128 * sizeof(ToneBankElement));
327
328 return read_config_file(CONFIG_FILE);
329 }
330
331 MidiSong *Timidity_LoadSong(SDL_RWops *rw, SDL_AudioSpec *audio)
332 {
333 MidiSong *song;
334 Sint32 events;
335 int i;
336
337 if (rw == NULL)
338 return NULL;
339
340 /* Allocate memory for the song */
341 song = (MidiSong *)safe_malloc(sizeof(*song));
342 memset(song, 0, sizeof(*song));
343
344 for (i = 0; i < 128; i++)
345 {
346 if (master_tonebank[i])
347 {
348 song->tonebank[i] = safe_malloc(sizeof(ToneBank));
349 song->tonebank[i]->tone = master_tonebank[i]->tone;
350 }
351 if (master_drumset[i])
352 {
353 song->drumset[i] = safe_malloc(sizeof(ToneBank));
354 song->drumset[i]->tone = master_drumset[i]->tone;
355 }
356 }
357
358 song->amplification = DEFAULT_AMPLIFICATION;
359 song->voices = DEFAULT_VOICES;
360 song->drumchannels = DEFAULT_DRUMCHANNELS;
361
362 song->rw = rw;
363
364 song->rate = audio->freq;
365 song->encoding = 0;
366 if ((audio->format & 0xFF) == 16)
367 song->encoding |= PE_16BIT;
368 if (audio->format & 0x8000)
369 song->encoding |= PE_SIGNED;
370 if (audio->channels == 1)
371 song->encoding |= PE_MONO;
372 switch (audio->format) {
373 case AUDIO_S8:
374 song->write = s32tos8;
375 break;
376 case AUDIO_U8:
377 song->write = s32tou8;
378 break;
379 case AUDIO_S16LSB:
380 song->write = s32tos16l;
381 break;
382 case AUDIO_S16MSB:
383 song->write = s32tos16b;
384 break;
385 case AUDIO_U16LSB:
386 song->write = s32tou16l;
387 break;
388 default:
389 SNDDBG(("Unsupported audio format"));
390 song->write = s32tou16l;
391 break;
392 }
393
394 song->buffer_size = audio->samples;
395 song->resample_buffer = safe_malloc(audio->samples * sizeof(sample_t));
396 song->common_buffer = safe_malloc(audio->samples * 2 * sizeof(Sint32));
397
398 song->control_ratio = audio->freq / CONTROLS_PER_SECOND;
399 if (song->control_ratio < 1)
400 song->control_ratio = 1;
401 else if (song->control_ratio > MAX_CONTROL_RATIO)
402 song->control_ratio = MAX_CONTROL_RATIO;
403
404 song->lost_notes = 0;
405 song->cut_notes = 0;
406
407 song->events = read_midi_file(song, &events, &song->samples);
408
409 /* The RWops can safely be closed at this point, but let's make that the
410 * responsibility of the caller.
411 */
412
413 /* Make sure everything is okay */
414 if (!song->events) {
415 free(song);
416 return(NULL);
417 }
418
419 song->default_instrument = 0;
420 song->default_program = DEFAULT_PROGRAM;
421
422 if (*def_instr_name)
423 set_default_instrument(song, def_instr_name);
424
425 load_missing_instruments(song);
426
427 return(song);
428 }
429
430 void Timidity_FreeSong(MidiSong *song)
431 {
432 int i;
433
434 free_instruments(song);
435
436 for (i = 0; i < 128; i++)
437 {
438 if (song->tonebank[i])
439 free(song->tonebank[i]);
440 if (song->drumset[i])
441 free(song->drumset[i]);
442 }
443
444 free(song->common_buffer);
445 free(song->resample_buffer);
446 free(song->events);
447 free(song);
448 }
449
450 void Timidity_Exit(void)
451 {
452 int i;
453
454 for (i = 0; i < 128; i++)
455 {
456 if (master_tonebank[i])
457 {
458 free(master_tonebank[i]->tone);
459 free(master_tonebank[i]);
460 }
461 if (master_drumset[i])
462 {
463 free(master_drumset[i]->tone);
464 free(master_drumset[i]);
465 }
466 }
467
468 free_pathlist();
469 }