1 /*
2 TiMidity++ -- MIDI to WAVE converter and player
3 Copyright (C) 1999-2009 Masanao Izumo <iz@onicos.co.jp>
4 Copyright (C) 1995 Tuukka Toivonen <tt@cgs.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., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19 */
20
21 #ifdef HAVE_CONFIG_H
22 #include "config.h"
23 #endif /* HAVE_CONFIG_H */
24 #ifdef __POCC__
25 #include <sys/types.h>
26 #endif //for off_t
27 #include <stdio.h>
28 #include <stdlib.h>
29 #ifndef NO_STRING_H
30 #include <string.h>
31 #else
32 #include <strings.h>
33 #endif
34 #ifdef HAVE_UNISTD_H
35 #include <unistd.h>
36 #endif /* HAVE_UNISTD_H */
37 #include "timidity.h"
38 #include "common.h"
39 #include "instrum.h"
40 #include "playmidi.h"
41 #include "readmidi.h"
42 #include "output.h"
43 #include "controls.h"
44 #include "strtab.h"
45 #include "memb.h"
46 #include "zip.h"
47 #include "arc.h"
48 #include "mod.h"
49 #include "wrd.h"
50 #include "tables.h"
51 #include "reverb.h"
52 #include <math.h>
53
54 /* rcp.c */
55 int read_rcp_file(struct timidity_file *tf, char *magic0, char *fn);
56
57 /* mld.c */
58 extern int read_mfi_file(struct timidity_file *tf);
59 extern char *get_mfi_file_title(struct timidity_file *tf);
60
61 #define MAX_MIDI_EVENT ((MAX_SAFE_MALLOC_SIZE / sizeof(MidiEvent)) - 1)
62 #define MARKER_START_CHAR '('
63 #define MARKER_END_CHAR ')'
64
65 static uint8 rhythm_part[2]; /* for GS */
66 static uint8 drum_setup_xg[16] = { 9, 9, 9, 9, 9, 9, 9, 9,
67 9, 9, 9, 9, 9, 9, 9, 9 }; /* for XG */
68
69 enum
70 {
71 CHORUS_ST_NOT_OK = 0,
72 CHORUS_ST_OK
73 };
74
75 #ifdef ALWAYS_TRACE_TEXT_META_EVENT
76 int opt_trace_text_meta_event = 1;
77 #else
78 int opt_trace_text_meta_event = 0;
79 #endif /* ALWAYS_TRACE_TEXT_META_EVENT */
80
81 int opt_default_mid = 0;
82 int opt_system_mid = 0;
83 int ignore_midi_error = 1;
84 ChannelBitMask quietchannels;
85 struct midi_file_info *current_file_info = NULL;
86 int readmidi_error_flag = 0;
87 int readmidi_wrd_mode = 0;
88 int play_system_mode = DEFAULT_SYSTEM_MODE;
89
90 /* Mingw gcc3 and Borland C hack */
91 /* If these are not NULL initialized cause Hang up */
92 /* why ? I dont know. (Keishi Suenaga) */
93 static MidiEventList *evlist=NULL, *current_midi_point=NULL;
94 static int32 event_count;
95 static MBlockList mempool;
96 static StringTable string_event_strtab = { 0 };
97 static int current_read_track;
98 static int karaoke_format, karaoke_title_flag;
99 static struct midi_file_info *midi_file_info = NULL;
100 static char **string_event_table = NULL;
101 static int string_event_table_size = 0;
102 int default_channel_program[256];
103 static MidiEvent timesig[256];
104 TimeSegment *time_segments = NULL;
105
106 void init_delay_status_gs(void);
107 void init_chorus_status_gs(void);
108 void init_reverb_status_gs(void);
109 void init_eq_status_gs(void);
110 void init_insertion_effect_gs(void);
111 void init_multi_eq_xg(void);
112 static void init_all_effect_xg(void);
113
114 /* MIDI ports will be merged in several channels in the future. */
115 int midi_port_number;
116
117 /* These would both fit into 32 bits, but they are often added in
118 large multiples, so it's simpler to have two roomy ints */
119 static int32 sample_increment, sample_correction; /*samples per MIDI delta-t*/
120
121 #define SETMIDIEVENT(e, at, t, ch, pa, pb) \
122 { (e).time = (at); (e).type = (t); \
123 (e).channel = (uint8)(ch); (e).a = (uint8)(pa); (e).b = (uint8)(pb); }
124
125 #define MIDIEVENT(at, t, ch, pa, pb) \
126 { MidiEvent event; SETMIDIEVENT(event, at, t, ch, pa, pb); \
127 readmidi_add_event(&event); }
128
129 #if MAX_CHANNELS <= 16
130 #define MERGE_CHANNEL_PORT(ch) ((int)(ch))
131 #define MERGE_CHANNEL_PORT2(ch, port) ((int)(ch))
132 #else
133 #define MERGE_CHANNEL_PORT(ch) ((int)(ch) | (midi_port_number << 4))
134 #define MERGE_CHANNEL_PORT2(ch, port) ((int)(ch) | ((int)port << 4))
135 #endif
136
137 #define alloc_midi_event() \
138 (MidiEventList *)new_segment(&mempool, sizeof(MidiEventList))
139
140 typedef struct _UserDrumset {
141 int8 bank;
142 int8 prog;
143 int8 play_note;
144 int8 level;
145 int8 assign_group;
146 int8 pan;
147 int8 reverb_send_level;
148 int8 chorus_send_level;
149 int8 rx_note_off;
150 int8 rx_note_on;
151 int8 delay_send_level;
152 int8 source_map;
153 int8 source_prog;
154 int8 source_note;
155 struct _UserDrumset *next;
156 } UserDrumset;
157
158 UserDrumset *userdrum_first = (UserDrumset *)NULL;
159 UserDrumset *userdrum_last = (UserDrumset *)NULL;
160
161 void init_userdrum();
162 UserDrumset *get_userdrum(int bank, int prog);
163 void recompute_userdrum_altassign(int bank,int group);
164
165 typedef struct _UserInstrument {
166 int8 bank;
167 int8 prog;
168 int8 source_map;
169 int8 source_bank;
170 int8 source_prog;
171 int8 vibrato_rate;
172 int8 vibrato_depth;
173 int8 cutoff_freq;
174 int8 resonance;
175 int8 env_attack;
176 int8 env_decay;
177 int8 env_release;
178 int8 vibrato_delay;
179 struct _UserInstrument *next;
180 } UserInstrument;
181
182 UserInstrument *userinst_first = (UserInstrument *)NULL;
183 UserInstrument *userinst_last = (UserInstrument *)NULL;
184
185 void init_userinst();
186 UserInstrument *get_userinst(int bank, int prog);
187 void recompute_userinst(int bank, int prog);
188 void recompute_userinst_altassign(int bank,int group);
189
readmidi_set_track(int trackno,int rewindp)190 int32 readmidi_set_track(int trackno, int rewindp)
191 {
192 current_read_track = trackno;
193 memset(&chorus_status_gs.text, 0, sizeof(struct chorus_text_gs_t));
194 if(karaoke_format == 1 && current_read_track == 2)
195 karaoke_format = 2; /* Start karaoke lyric */
196 else if(karaoke_format == 2 && current_read_track == 3)
197 karaoke_format = 3; /* End karaoke lyric */
198 midi_port_number = 0;
199
200 if(evlist == NULL)
201 return 0;
202 if(rewindp)
203 current_midi_point = evlist;
204 else
205 {
206 /* find the last event in the list */
207 while(current_midi_point->next != NULL)
208 current_midi_point = current_midi_point->next;
209 }
210 return current_midi_point->event.time;
211 }
212
readmidi_add_event(MidiEvent * a_event)213 void readmidi_add_event(MidiEvent *a_event)
214 {
215 MidiEventList *newev;
216 int32 at;
217
218 if(event_count == MAX_MIDI_EVENT)
219 {
220 if(!readmidi_error_flag)
221 {
222 readmidi_error_flag = 1;
223 ctl->cmsg(CMSG_ERROR, VERB_NORMAL,
224 "Maxmum number of events is exceeded");
225 }
226 return;
227 }
228 event_count++;
229
230 at = a_event->time;
231 newev = alloc_midi_event();
232 newev->event = *a_event; /* assign by value!!! */
233 if(at < 0) /* for safety */
234 at = newev->event.time = 0;
235
236 if(at >= current_midi_point->event.time)
237 {
238 /* Forward scan */
239 MidiEventList *next = current_midi_point->next;
240 while (next && (next->event.time <= at))
241 {
242 current_midi_point = next;
243 next = current_midi_point->next;
244 }
245 newev->prev = current_midi_point;
246 newev->next = next;
247 current_midi_point->next = newev;
248 if (next)
249 next->prev = newev;
250 }
251 else
252 {
253 /* Backward scan -- symmetrical to the one above */
254 MidiEventList *prev = current_midi_point->prev;
255 while (prev && (prev->event.time > at)) {
256 current_midi_point = prev;
257 prev = current_midi_point->prev;
258 }
259 newev->prev = prev;
260 newev->next = current_midi_point;
261 current_midi_point->prev = newev;
262 if (prev)
263 prev->next = newev;
264 }
265 current_midi_point = newev;
266 }
267
readmidi_add_ctl_event(int32 at,int ch,int a,int b)268 void readmidi_add_ctl_event(int32 at, int ch, int a, int b)
269 {
270 MidiEvent ev;
271
272 if(convert_midi_control_change(ch, a, b, &ev))
273 {
274 ev.time = at;
275 readmidi_add_event(&ev);
276 }
277 else
278 ctl->cmsg(CMSG_INFO, VERB_DEBUG, "(Control ch=%d %d: %d)", ch, a, b);
279 }
280
readmidi_make_string_event(int type,char * string,MidiEvent * ev,int cnv)281 char *readmidi_make_string_event(int type, char *string, MidiEvent *ev,
282 int cnv)
283 {
284 char *text;
285 int len;
286 StringTableNode *st;
287 int a, b;
288
289 if(string_event_strtab.nstring == 0)
290 put_string_table(&string_event_strtab, "", 0);
291 else if(string_event_strtab.nstring == 0x7FFE)
292 {
293 SETMIDIEVENT(*ev, 0, type, 0, 0, 0);
294 return NULL; /* Over flow */
295 }
296 a = (string_event_strtab.nstring & 0xff);
297 b = ((string_event_strtab.nstring >> 8) & 0xff);
298
299 len = strlen(string);
300 if(cnv)
301 {
302 text = (char *)new_segment(&tmpbuffer, SAFE_CONVERT_LENGTH(len) + 1);
303 code_convert(string, text + 1, SAFE_CONVERT_LENGTH(len), NULL, NULL);
304 }
305 else
306 {
307 text = (char *)new_segment(&tmpbuffer, len + 1);
308 memcpy(text + 1, string, len);
309 text[len + 1] = '\0';
310 }
311
312 st = put_string_table(&string_event_strtab, text, strlen(text + 1) + 1);
313 reuse_mblock(&tmpbuffer);
314
315 text = st->string;
316 *text = type;
317 SETMIDIEVENT(*ev, 0, type, 0, a, b);
318 return text;
319 }
320
readmidi_make_lcd_event(int type,const uint8 * data,MidiEvent * ev)321 static char *readmidi_make_lcd_event(int type, const uint8 *data, MidiEvent *ev)
322 {
323 char *text;
324 int len;
325 StringTableNode *st;
326 int a, b, i;
327
328 if(string_event_strtab.nstring == 0)
329 put_string_table(&string_event_strtab, "", 0);
330 else if(string_event_strtab.nstring == 0x7FFE)
331 {
332 SETMIDIEVENT(*ev, 0, type, 0, 0, 0);
333 return NULL; /* Over flow */
334 }
335 a = (string_event_strtab.nstring & 0xff);
336 b = ((string_event_strtab.nstring >> 8) & 0xff);
337
338 len = 128;
339
340 text = (char *)new_segment(&tmpbuffer, len + 2);
341
342 for( i=0; i<64; i++){
343 const char tbl[]= "0123456789ABCDEF";
344 text[1+i*2 ]=tbl[data[i]>>4];
345 text[1+i*2+1]=tbl[data[i]&0xF];
346 }
347 text[len + 1] = '\0';
348
349
350 st = put_string_table(&string_event_strtab, text, strlen(text + 1) + 1);
351 reuse_mblock(&tmpbuffer);
352
353 text = st->string;
354 *text = type;
355 SETMIDIEVENT(*ev, 0, type, 0, a, b);
356 return text;
357 }
358
359 /* Computes how many (fractional) samples one MIDI delta-time unit contains */
compute_sample_increment(int32 tempo,int32 divisions)360 static void compute_sample_increment(int32 tempo, int32 divisions)
361 {
362 double a;
363 a = (double) (tempo) * (double) (play_mode->rate) * (65536.0/1000000.0) /
364 (double)(divisions);
365
366 sample_correction = (int32)(a) & 0xFFFF;
367 sample_increment = (int32)(a) >> 16;
368
369 ctl->cmsg(CMSG_INFO, VERB_DEBUG, "Samples per delta-t: %d (correction %d)",
370 sample_increment, sample_correction);
371 }
372
373 /* Read variable-length number (7 bits per byte, MSB first) */
getvl(struct timidity_file * tf)374 static int32 getvl(struct timidity_file *tf)
375 {
376 int32 l;
377 int c;
378
379 errno = 0;
380 l = 0;
381
382 /* 1 */
383 if((c = tf_getc(tf)) == EOF)
384 goto eof;
385 if(!(c & 0x80)) return l | c;
386 l = (l | (c & 0x7f)) << 7;
387
388 /* 2 */
389 if((c = tf_getc(tf)) == EOF)
390 goto eof;
391 if(!(c & 0x80)) return l | c;
392 l = (l | (c & 0x7f)) << 7;
393
394 /* 3 */
395 if((c = tf_getc(tf)) == EOF)
396 goto eof;
397 if(!(c & 0x80)) return l | c;
398 l = (l | (c & 0x7f)) << 7;
399
400 /* 4 */
401 if((c = tf_getc(tf)) == EOF)
402 goto eof;
403 if(!(c & 0x80)) return l | c;
404
405 /* Error */
406 ctl->cmsg(CMSG_ERROR, VERB_NORMAL,
407 "%s: Illigal Variable-length quantity format.",
408 current_filename);
409 return -2;
410
411 eof:
412 if(errno)
413 ctl->cmsg(CMSG_ERROR, VERB_NORMAL,
414 "%s: read_midi_event: %s",
415 current_filename, strerror(errno));
416 else
417 ctl->cmsg(CMSG_ERROR, VERB_NORMAL,
418 "Warning: %s: Too shorten midi file.",
419 current_filename);
420 return -1;
421 }
422
add_karaoke_title(char * s1,char * s2)423 static char *add_karaoke_title(char *s1, char *s2)
424 {
425 char *ks;
426 int k1, k2;
427
428 if(s1 == NULL)
429 return safe_strdup(s2);
430
431 k1 = strlen(s1);
432 k2 = strlen(s2);
433 if(k2 == 0)
434 return s1;
435 ks = (char *)safe_malloc(k1 + k2 + 2);
436 memcpy(ks, s1, k1);
437 ks[k1++] = ' ';
438 memcpy(ks + k1, s2, k2 + 1);
439 free(s1);
440 s1 = NULL;
441
442 return ks;
443 }
444
445
446 /* Print a string from the file, followed by a newline. Any non-ASCII
447 or unprintable characters will be converted to periods. */
dumpstring(int type,int32 len,char * label,int allocp,struct timidity_file * tf)448 static char *dumpstring(int type, int32 len, char *label, int allocp,
449 struct timidity_file *tf)
450 {
451 char *si, *so;
452 int s_maxlen = SAFE_CONVERT_LENGTH(len);
453 int llen, solen;
454
455 if(len <= 0)
456 {
457 ctl->cmsg(CMSG_TEXT, VERB_VERBOSE, "%s", label);
458 return NULL;
459 }
460
461 si = (char *)new_segment(&tmpbuffer, len + 1);
462 so = (char *)new_segment(&tmpbuffer, s_maxlen);
463
464 if(len != tf_read(si, 1, len, tf))
465 {
466 reuse_mblock(&tmpbuffer);
467 return NULL;
468 }
469 si[len]='\0';
470
471 if(type == 1 &&
472 current_file_info->format == 1 &&
473 (strncmp(si, "@K", 2) == 0))
474 /* Karaoke string should be "@KMIDI KARAOKE FILE" */
475 karaoke_format = 1;
476
477 code_convert(si, so, s_maxlen, NULL, NULL);
478
479 llen = strlen(label);
480 solen = strlen(so);
481 if(llen + solen >= MIN_MBLOCK_SIZE)
482 so[MIN_MBLOCK_SIZE - llen - 1] = '\0';
483
484 ctl->cmsg(CMSG_TEXT, VERB_VERBOSE, "%s%s", label, so);
485
486 if(allocp)
487 {
488 so = safe_strdup(so);
489 reuse_mblock(&tmpbuffer);
490 return so;
491 }
492 reuse_mblock(&tmpbuffer);
493 return NULL;
494 }
495
gs_convert_master_vol(int vol)496 static uint16 gs_convert_master_vol(int vol)
497 {
498 double v;
499
500 if(vol >= 0x7f)
501 return 0xffff;
502 v = (double)vol * (0xffff/127.0);
503 if(v >= 0xffff)
504 return 0xffff;
505 return (uint16)v;
506 }
507
gm_convert_master_vol(uint16 v1,uint16 v2)508 static uint16 gm_convert_master_vol(uint16 v1, uint16 v2)
509 {
510 return (((v1 & 0x7f) | ((v2 & 0x7f) << 7)) << 2) | 3;
511 }
512
check_chorus_text_start(void)513 static void check_chorus_text_start(void)
514 {
515 struct chorus_text_gs_t *p = &(chorus_status_gs.text);
516 if(p->status != CHORUS_ST_OK && p->voice_reserve[17] &&
517 p->macro[2] && p->pre_lpf[2] && p->level[2] &&
518 p->feed_back[2] && p->delay[2] && p->rate[2] &&
519 p->depth[2] && p->send_level[2])
520 {
521 ctl->cmsg(CMSG_INFO, VERB_DEBUG, "Chorus text start");
522 p->status = CHORUS_ST_OK;
523 }
524 }
525
526 struct ctl_chg_types {
527 unsigned char mtype;
528 int ttype;
529 } ctl_chg_list[] = {
530 { 0, ME_TONE_BANK_MSB },
531 { 1, ME_MODULATION_WHEEL },
532 { 2, ME_BREATH },
533 { 4, ME_FOOT },
534 { 5, ME_PORTAMENTO_TIME_MSB },
535 { 6, ME_DATA_ENTRY_MSB },
536 { 7, ME_MAINVOLUME },
537 { 8, ME_BALANCE },
538 { 10, ME_PAN },
539 { 11, ME_EXPRESSION },
540 { 32, ME_TONE_BANK_LSB },
541 { 37, ME_PORTAMENTO_TIME_LSB },
542 { 38, ME_DATA_ENTRY_LSB },
543 { 64, ME_SUSTAIN },
544 { 65, ME_PORTAMENTO },
545 { 66, ME_SOSTENUTO },
546 { 67, ME_SOFT_PEDAL },
547 { 68, ME_LEGATO_FOOTSWITCH },
548 { 69, ME_HOLD2 },
549 { 71, ME_HARMONIC_CONTENT },
550 { 72, ME_RELEASE_TIME },
551 { 73, ME_ATTACK_TIME },
552 { 74, ME_BRIGHTNESS },
553 { 84, ME_PORTAMENTO_CONTROL },
554 { 91, ME_REVERB_EFFECT },
555 { 92, ME_TREMOLO_EFFECT },
556 { 93, ME_CHORUS_EFFECT },
557 { 94, ME_CELESTE_EFFECT },
558 { 95, ME_PHASER_EFFECT },
559 { 96, ME_RPN_INC },
560 { 97, ME_RPN_DEC },
561 { 98, ME_NRPN_LSB },
562 { 99, ME_NRPN_MSB },
563 { 100, ME_RPN_LSB },
564 { 101, ME_RPN_MSB },
565 { 120, ME_ALL_SOUNDS_OFF },
566 { 121, ME_RESET_CONTROLLERS },
567 { 123, ME_ALL_NOTES_OFF },
568 { 126, ME_MONO },
569 { 127, ME_POLY },
570 };
571
convert_midi_control_change(int chn,int type,int val,MidiEvent * ev_ret)572 int convert_midi_control_change(int chn, int type, int val, MidiEvent *ev_ret)
573 {
574 int i;
575 for (i = 0; i < ARRAY_SIZE(ctl_chg_list); i++) {
576 if (ctl_chg_list[i].mtype == type) {
577 type = ctl_chg_list[i].ttype;
578 break;
579 }
580 }
581 if (i >= ARRAY_SIZE(ctl_chg_list))
582 type = -1;
583
584 if(type != -1)
585 {
586 if(val > 127)
587 val = 127;
588 ev_ret->type = type;
589 ev_ret->channel = chn;
590 ev_ret->a = val;
591 ev_ret->b = 0;
592 return 1;
593 }
594 return 0;
595 }
596
unconvert_midi_control_change(MidiEvent * ev)597 int unconvert_midi_control_change(MidiEvent *ev)
598 {
599 int i;
600 for (i = 0; i < ARRAY_SIZE(ctl_chg_list); i++) {
601 if (ctl_chg_list[i].ttype == ev->type)
602 break;
603 }
604 if (i >= ARRAY_SIZE(ctl_chg_list))
605 return -1;
606
607 return ctl_chg_list[i].mtype;
608 }
609
block_to_part(int block,int port)610 static int block_to_part(int block, int port)
611 {
612 int p;
613 p = block & 0x0F;
614 if(p == 0) {p = 9;}
615 else if(p <= 9) {p--;}
616 return MERGE_CHANNEL_PORT2(p, port);
617 }
618
619 /* Map XG types onto GS types. XG should eventually have its own tables */
set_xg_reverb_type(int msb,int lsb)620 static int set_xg_reverb_type(int msb, int lsb)
621 {
622 int type = 4;
623
624 if ((msb == 0x00) ||
625 (msb >= 0x05 && msb <= 0x0F) ||
626 (msb >= 0x14)) /* NO EFFECT */
627 {
628 ctl->cmsg(CMSG_INFO,VERB_NOISY,"XG Set Reverb Type (NO EFFECT %d %d)", msb, lsb);
629 return -1;
630 }
631
632 switch(msb)
633 {
634 case 0x01:
635 type = 3; /* Hall 1 */
636 break;
637 case 0x02:
638 type = 0; /* Room 1 */
639 break;
640 case 0x03:
641 type = 3; /* Stage 1 -> Hall 1 */
642 break;
643 case 0x04:
644 type = 5; /* Plate */
645 break;
646 default:
647 type = 4; /* unsupported -> Hall 2 */
648 break;
649 }
650 if (lsb == 0x01)
651 {
652 switch(msb)
653 {
654 case 0x01:
655 type = 4; /* Hall 2 */
656 break;
657 case 0x02:
658 type = 1; /* Room 2 */
659 break;
660 case 0x03:
661 type = 4; /* Stage 2 -> Hall 2 */
662 break;
663 default:
664 break;
665 }
666 }
667 if (lsb == 0x02 && msb == 0x02)
668 type = 2; /* Room 3 */
669
670 ctl->cmsg(CMSG_INFO,VERB_NOISY,"XG Set Reverb Type (%d)", type);
671 return type;
672 }
673
674 /* Map XG types onto GS types. XG should eventually have its own tables */
set_xg_chorus_type(int msb,int lsb)675 static int set_xg_chorus_type(int msb, int lsb)
676 {
677 int type = 2;
678
679 if ((msb >= 0x00 && msb <= 0x40) ||
680 (msb >= 0x45 && msb <= 0x47) ||
681 (msb >= 0x49)) /* NO EFFECT */
682 {
683 ctl->cmsg(CMSG_INFO,VERB_NOISY,"XG Set Chorus Type (NO EFFECT %d %d)", msb, lsb);
684 return -1;
685 }
686
687 switch(msb)
688 {
689 case 0x41:
690 type = 0; /* Chorus 1 */
691 break;
692 case 0x42:
693 type = 0; /* Celeste 1 -> Chorus 1 */
694 break;
695 case 0x43:
696 type = 5;
697 break;
698 default:
699 type = 2; /* unsupported -> Chorus 3 */
700 break;
701 }
702 if (lsb == 0x01)
703 {
704 switch(msb)
705 {
706 case 0x41:
707 type = 1; /* Chorus 2 */
708 break;
709 case 0x42:
710 type = 1; /* Celeste 2 -> Chorus 2 */
711 break;
712 default:
713 break;
714 }
715 }
716 else if (lsb == 0x02)
717 {
718 switch(msb)
719 {
720 case 0x41:
721 type = 2; /* Chorus 3 */
722 break;
723 case 0x42:
724 type = 2; /* Celeste 3 -> Chorus 3 */
725 break;
726 default:
727 break;
728 }
729 }
730 else if (lsb == 0x08)
731 {
732 switch(msb)
733 {
734 case 0x41:
735 type = 3; /* Chorus 4 */
736 break;
737 case 0x42:
738 type = 3; /* Celeste 4 -> Chorus 4 */
739 break;
740 default:
741 break;
742 }
743 }
744
745 ctl->cmsg(CMSG_INFO,VERB_NOISY,"XG Set Chorus Type (%d)", type);
746 return type;
747 }
748
749 /* XG SysEx parsing function by Eric A. Welsh
750 * Also handles GS patch+bank changes
751 *
752 * This function provides basic support for XG Bulk Dump and Parameter
753 * Change SysEx events
754 */
parse_sysex_event_multi(uint8 * val,int32 len,MidiEvent * evm)755 int parse_sysex_event_multi(uint8 *val, int32 len, MidiEvent *evm)
756 {
757 int num_events = 0; /* Number of events added */
758 uint32 channel_tt;
759 int i, j;
760 static uint8 xg_reverb_type_msb = 0x01, xg_reverb_type_lsb = 0x00;
761 static uint8 xg_chorus_type_msb = 0x41, xg_chorus_type_lsb = 0x00;
762
763 if(current_file_info->mid == 0 || current_file_info->mid >= 0x7e)
764 current_file_info->mid = val[0];
765
766 /* Effect 1 or Multi EQ */
767 if(len >= 8 &&
768 val[0] == 0x43 && /* Yamaha ID */
769 val[2] == 0x4C && /* XG Model ID */
770 ((val[1] < 0x10 && val[5] == 0x02) || /* Bulk Dump*/
771 (val[1] >= 0x10 && val[3] == 0x02))) /* Parameter Change */
772 {
773 uint8 addhigh, addmid, addlow; /* Addresses */
774 uint8 *body; /* SysEx body */
775 int ent, v; /* Entry # of sub-event */
776 uint8 *body_end; /* End of SysEx body */
777
778 if (val[1] < 0x10) /* Bulk Dump */
779 {
780 addhigh = val[5];
781 addmid = val[6];
782 addlow = val[7];
783 body = val + 8;
784 body_end = val + len - 3;
785 }
786 else /* Parameter Change */
787 {
788 addhigh = val[3];
789 addmid = val[4];
790 addlow = val[5];
791 body = val + 6;
792 body_end = val + len - 2;
793 }
794
795 /* set the SYSEX_XG_MSB info */
796 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_MSB, 0, addhigh, addmid);
797 num_events++;
798
799 for (ent = addlow; body <= body_end; body++, ent++) {
800 if(addmid == 0x01) { /* Effect 1 */
801 switch(ent) {
802 case 0x00: /* Reverb Type MSB */
803 xg_reverb_type_msb = *body;
804 #if 0 /* XG specific reverb is not supported yet, use GS instead */
805 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_LSB, 0, *body, ent);
806 num_events++;
807 #endif
808 break;
809
810 case 0x01: /* Reverb Type LSB */
811 xg_reverb_type_lsb = *body;
812 #if 0 /* XG specific reverb is not supported yet, use GS instead */
813 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_LSB, 0, *body, ent);
814 num_events++;
815 #else
816 v = set_xg_reverb_type(xg_reverb_type_msb, xg_reverb_type_lsb);
817 if (v >= 0) {
818 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_GS_LSB, 0, v, 0x05);
819 num_events++;
820 }
821 #endif
822 break;
823
824 case 0x0C: /* Reverb Return */
825 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_LSB, 0, *body, ent);
826 num_events++;
827 break;
828
829 case 0x20: /* Chorus Type MSB */
830 xg_chorus_type_msb = *body;
831 #if 0 /* XG specific chorus is not supported yet, use GS instead */
832 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_LSB, 0, *body, ent);
833 num_events++;
834 #endif
835 break;
836
837 case 0x21: /* Chorus Type LSB */
838 xg_chorus_type_lsb = *body;
839 #if 0 /* XG specific chorus is not supported yet, use GS instead */
840 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_LSB, 0, *body, ent);
841 num_events++;
842 #else
843 v = set_xg_chorus_type(xg_chorus_type_msb, xg_chorus_type_lsb);
844 if (v >= 0) {
845 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_GS_LSB, 0, v, 0x0D);
846 num_events++;
847 }
848 #endif
849 break;
850
851 case 0x2C: /* Chorus Return */
852 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_LSB, 0, *body, ent);
853 num_events++;
854 break;
855
856 default:
857 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_LSB, 0, *body, ent);
858 num_events++;
859 break;
860 }
861 }
862 else if(addmid == 0x40) { /* Multi EQ */
863 switch(ent) {
864 case 0x00: /* EQ type */
865 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_LSB, 0, *body, ent);
866 num_events++;
867 break;
868
869 case 0x01: /* EQ gain1 */
870 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_LSB, 0, *body, ent);
871 num_events++;
872 break;
873
874 case 0x02: /* EQ frequency1 */
875 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_LSB, 0, *body, ent);
876 num_events++;
877 break;
878
879 case 0x03: /* EQ Q1 */
880 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_LSB, 0, *body, ent);
881 num_events++;
882 break;
883
884 case 0x04: /* EQ shape1 */
885 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_LSB, 0, *body, ent);
886 num_events++;
887 break;
888
889 case 0x05: /* EQ gain2 */
890 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_LSB, 0, *body, ent);
891 num_events++;
892 break;
893
894 case 0x06: /* EQ frequency2 */
895 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_LSB, 0, *body, ent);
896 num_events++;
897 break;
898
899 case 0x07: /* EQ Q2 */
900 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_LSB, 0, *body, ent);
901 num_events++;
902 break;
903
904 case 0x09: /* EQ gain3 */
905 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_LSB, 0, *body, ent);
906 num_events++;
907 break;
908
909 case 0x0A: /* EQ frequency3 */
910 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_LSB, 0, *body, ent);
911 num_events++;
912 break;
913
914 case 0x0B: /* EQ Q3 */
915 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_LSB, 0, *body, ent);
916 num_events++;
917 break;
918
919 case 0x0D: /* EQ gain4 */
920 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_LSB, 0, *body, ent);
921 num_events++;
922 break;
923
924 case 0x0E: /* EQ frequency4 */
925 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_LSB, 0, *body, ent);
926 num_events++;
927 break;
928
929 case 0x0F: /* EQ Q4 */
930 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_LSB, 0, *body, ent);
931 num_events++;
932 break;
933
934 case 0x11: /* EQ gain5 */
935 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_LSB, 0, *body, ent);
936 num_events++;
937 break;
938
939 case 0x12: /* EQ frequency5 */
940 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_LSB, 0, *body, ent);
941 num_events++;
942 break;
943
944 case 0x13: /* EQ Q5 */
945 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_LSB, 0, *body, ent);
946 num_events++;
947 break;
948
949 case 0x14: /* EQ shape5 */
950 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_LSB, 0, *body, ent);
951 num_events++;
952 break;
953
954 default:
955 break;
956 }
957 }
958 }
959 }
960
961 /* Effect 2 (Insertion Effects) */
962 else if(len >= 8 &&
963 val[0] == 0x43 && /* Yamaha ID */
964 val[2] == 0x4C && /* XG Model ID */
965 ((val[1] < 0x10 && val[5] == 0x03) || /* Bulk Dump*/
966 (val[1] >= 0x10 && val[3] == 0x03))) /* Parameter Change */
967 {
968 uint8 addhigh, addmid, addlow; /* Addresses */
969 uint8 *body; /* SysEx body */
970 int ent; /* Entry # of sub-event */
971 uint8 *body_end; /* End of SysEx body */
972
973 if (val[1] < 0x10) /* Bulk Dump */
974 {
975 addhigh = val[5];
976 addmid = val[6];
977 addlow = val[7];
978 body = val + 8;
979 body_end = val + len - 3;
980 }
981 else /* Parameter Change */
982 {
983 addhigh = val[3];
984 addmid = val[4];
985 addlow = val[5];
986 body = val + 6;
987 body_end = val + len - 2;
988 }
989
990 /* set the SYSEX_XG_MSB info */
991 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_MSB, 0, addhigh, addmid);
992 num_events++;
993
994 for (ent = addlow; body <= body_end; body++, ent++) {
995 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_LSB, 0, *body, ent);
996 num_events++;
997 }
998 }
999
1000 /* XG Multi Part Data parameter change */
1001 else if(len >= 10 &&
1002 val[0] == 0x43 && /* Yamaha ID */
1003 val[2] == 0x4C && /* XG Model ID */
1004 ((val[1] < 0x10 && val[5] == 0x08 && /* Bulk Dump */
1005 (val[4] == 0x29 || val[4] == 0x3F)) || /* Blocks 1 or 2 */
1006 (val[1] >= 0x10 && val[3] == 0x08))) /* Parameter Change */
1007 {
1008 uint8 addhigh, addmid, addlow; /* Addresses */
1009 uint8 *body; /* SysEx body */
1010 uint8 p; /* Channel part number [0..15] */
1011 int ent; /* Entry # of sub-event */
1012 uint8 *body_end; /* End of SysEx body */
1013
1014 if (val[1] < 0x10) /* Bulk Dump */
1015 {
1016 addhigh = val[5];
1017 addmid = val[6];
1018 addlow = val[7];
1019 body = val + 8;
1020 p = addmid;
1021 body_end = val + len - 3;
1022 }
1023 else /* Parameter Change */
1024 {
1025 addhigh = val[3];
1026 addmid = val[4];
1027 addlow = val[5];
1028 body = val + 6;
1029 p = addmid;
1030 body_end = val + len - 2;
1031 }
1032
1033 /* set the SYSEX_XG_MSB info */
1034 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_MSB, p, addhigh, addmid);
1035 num_events++;
1036
1037 for (ent = addlow; body <= body_end; body++, ent++) {
1038 switch(ent) {
1039 case 0x00: /* Element Reserve */
1040 /* ctl->cmsg(CMSG_INFO, VERB_NOISY, "Element Reserve is not supported. (CH:%d VAL:%d)", p, *body); */
1041 break;
1042
1043 case 0x01: /* bank select MSB */
1044 SETMIDIEVENT(evm[num_events], 0, ME_TONE_BANK_MSB, p, *body, SYSEX_TAG);
1045 num_events++;
1046 break;
1047
1048 case 0x02: /* bank select LSB */
1049 SETMIDIEVENT(evm[num_events], 0, ME_TONE_BANK_LSB, p, *body, SYSEX_TAG);
1050 num_events++;
1051 break;
1052
1053 case 0x03: /* program number */
1054 SETMIDIEVENT(evm[num_events], 0, ME_PROGRAM, p, *body, SYSEX_TAG);
1055 num_events++;
1056 break;
1057
1058 case 0x04: /* Rcv CHANNEL */
1059 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_LSB, p, *body, 0x99);
1060 num_events++;
1061 break;
1062
1063 case 0x05: /* mono/poly mode */
1064 if(*body == 0) {SETMIDIEVENT(evm[num_events], 0, ME_MONO, p, 0, SYSEX_TAG);}
1065 else {SETMIDIEVENT(evm[num_events], 0, ME_POLY, p, 0, SYSEX_TAG);}
1066 num_events++;
1067 break;
1068
1069 case 0x06: /* Same Note Number Key On Assign */
1070 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_LSB, p, *body, ent);
1071 num_events++;
1072 break;
1073
1074 case 0x07: /* Part Mode */
1075 drum_setup_xg[*body] = p;
1076 SETMIDIEVENT(evm[num_events], 0, ME_DRUMPART, p, *body, SYSEX_TAG);
1077 num_events++;
1078 break;
1079
1080 case 0x08: /* note shift */
1081 SETMIDIEVENT(evm[num_events], 0, ME_KEYSHIFT, p, *body, SYSEX_TAG);
1082 num_events++;
1083 break;
1084
1085 case 0x09: /* Detune 1st bit */
1086 ctl->cmsg(CMSG_INFO, VERB_NOISY, "Detune 1st bit is not supported. (CH:%d VAL:%d)", p, *body);
1087 break;
1088
1089 case 0x0A: /* Detune 2nd bit */
1090 ctl->cmsg(CMSG_INFO, VERB_NOISY, "Detune 2nd bit is not supported. (CH:%d VAL:%d)", p, *body);
1091 break;
1092
1093 case 0x0B: /* volume */
1094 SETMIDIEVENT(evm[num_events], 0, ME_MAINVOLUME, p, *body, SYSEX_TAG);
1095 num_events++;
1096 break;
1097
1098 case 0x0C: /* Velocity Sense Depth */
1099 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_GS_LSB, p, *body, 0x21);
1100 num_events++;
1101 break;
1102
1103 case 0x0D: /* Velocity Sense Offset */
1104 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_GS_LSB, p, *body, 0x22);
1105 num_events++;
1106 break;
1107
1108 case 0x0E: /* pan */
1109 if(*body == 0) {
1110 SETMIDIEVENT(evm[num_events], 0, ME_RANDOM_PAN, p, 0, SYSEX_TAG);
1111 }
1112 else {
1113 SETMIDIEVENT(evm[num_events], 0, ME_PAN, p, *body, SYSEX_TAG);
1114 }
1115 num_events++;
1116 break;
1117
1118 case 0x0F: /* Note Limit Low */
1119 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x42);
1120 num_events++;
1121 break;
1122
1123 case 0x10: /* Note Limit High */
1124 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x43);
1125 num_events++;
1126 break;
1127
1128 case 0x11: /* Dry Level */
1129 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_LSB, p, *body, ent);
1130 num_events++;
1131 break;
1132
1133 case 0x12: /* chorus send */
1134 SETMIDIEVENT(evm[num_events], 0, ME_CHORUS_EFFECT, p, *body, SYSEX_TAG);
1135 num_events++;
1136 break;
1137
1138 case 0x13: /* reverb send */
1139 SETMIDIEVENT(evm[num_events], 0, ME_REVERB_EFFECT, p, *body, SYSEX_TAG);
1140 num_events++;
1141 break;
1142
1143 case 0x14: /* Variation Send */
1144 SETMIDIEVENT(evm[num_events], 0, ME_CELESTE_EFFECT, p, *body, SYSEX_TAG);
1145 num_events++;
1146 break;
1147
1148 case 0x15: /* Vibrato Rate */
1149 SETMIDIEVENT(evm[num_events], 0, ME_NRPN_MSB, p, 0x01, SYSEX_TAG);
1150 SETMIDIEVENT(evm[num_events + 1], 0, ME_NRPN_LSB, p, 0x08, SYSEX_TAG);
1151 SETMIDIEVENT(evm[num_events + 2], 0, ME_DATA_ENTRY_MSB, p, *body, SYSEX_TAG);
1152 num_events += 3;
1153 break;
1154
1155 case 0x16: /* Vibrato Depth */
1156 SETMIDIEVENT(evm[num_events], 0, ME_NRPN_MSB, p, 0x01, SYSEX_TAG);
1157 SETMIDIEVENT(evm[num_events + 1], 0, ME_NRPN_LSB, p, 0x09, SYSEX_TAG);
1158 SETMIDIEVENT(evm[num_events + 2], 0, ME_DATA_ENTRY_MSB, p, *body, SYSEX_TAG);
1159 num_events += 3;
1160 break;
1161
1162 case 0x17: /* Vibrato Delay */
1163 SETMIDIEVENT(evm[num_events], 0, ME_NRPN_MSB, p, 0x01, SYSEX_TAG);
1164 SETMIDIEVENT(evm[num_events + 1], 0, ME_NRPN_LSB, p, 0x0A, SYSEX_TAG);
1165 SETMIDIEVENT(evm[num_events + 2], 0, ME_DATA_ENTRY_MSB, p, *body, SYSEX_TAG);
1166 num_events += 3;
1167 break;
1168
1169 case 0x18: /* Filter Cutoff Frequency */
1170 SETMIDIEVENT(evm[num_events], 0, ME_NRPN_MSB, p, 0x01, SYSEX_TAG);
1171 SETMIDIEVENT(evm[num_events + 1], 0, ME_NRPN_LSB, p, 0x20, SYSEX_TAG);
1172 SETMIDIEVENT(evm[num_events + 2], 0, ME_DATA_ENTRY_MSB, p, *body, SYSEX_TAG);
1173 num_events += 3;
1174 break;
1175
1176 case 0x19: /* Filter Resonance */
1177 SETMIDIEVENT(evm[num_events], 0, ME_NRPN_MSB, p, 0x01, SYSEX_TAG);
1178 SETMIDIEVENT(evm[num_events + 1], 0, ME_NRPN_LSB, p, 0x21, SYSEX_TAG);
1179 SETMIDIEVENT(evm[num_events + 2], 0, ME_DATA_ENTRY_MSB, p, *body, SYSEX_TAG);
1180 num_events += 3;
1181 break;
1182
1183 case 0x1A: /* EG Attack Time */
1184 SETMIDIEVENT(evm[num_events], 0, ME_NRPN_MSB, p, 0x01, SYSEX_TAG);
1185 SETMIDIEVENT(evm[num_events + 1], 0, ME_NRPN_LSB, p, 0x63, SYSEX_TAG);
1186 SETMIDIEVENT(evm[num_events + 2], 0, ME_DATA_ENTRY_MSB, p, *body, SYSEX_TAG);
1187 num_events += 3;
1188 break;
1189
1190 case 0x1B: /* EG Decay Time */
1191 SETMIDIEVENT(evm[num_events], 0, ME_NRPN_MSB, p, 0x01, SYSEX_TAG);
1192 SETMIDIEVENT(evm[num_events + 1], 0, ME_NRPN_LSB, p, 0x64, SYSEX_TAG);
1193 SETMIDIEVENT(evm[num_events + 2], 0, ME_DATA_ENTRY_MSB, p, *body, SYSEX_TAG);
1194 num_events += 3;
1195 break;
1196
1197 case 0x1C: /* EG Release Time */
1198 SETMIDIEVENT(evm[num_events], 0, ME_NRPN_MSB, p, 0x01, SYSEX_TAG);
1199 SETMIDIEVENT(evm[num_events + 1], 0, ME_NRPN_LSB, p, 0x66, SYSEX_TAG);
1200 SETMIDIEVENT(evm[num_events + 2], 0, ME_DATA_ENTRY_MSB, p, *body, SYSEX_TAG);
1201 num_events += 3;
1202 break;
1203
1204 case 0x1D: /* MW Pitch Control */
1205 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x16);
1206 num_events++;
1207 break;
1208
1209 case 0x1E: /* MW Filter Control */
1210 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x17);
1211 num_events++;
1212 break;
1213
1214 case 0x1F: /* MW Amplitude Control */
1215 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x18);
1216 num_events++;
1217 break;
1218
1219 case 0x20: /* MW LFO PMod Depth */
1220 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x1A);
1221 num_events++;
1222 break;
1223
1224 case 0x21: /* MW LFO FMod Depth */
1225 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x1B);
1226 num_events++;
1227 break;
1228
1229 case 0x22: /* MW LFO AMod Depth */
1230 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x1C);
1231 num_events++;
1232 break;
1233
1234 case 0x23: /* bend pitch control */
1235 SETMIDIEVENT(evm[num_events], 0, ME_RPN_MSB, p, 0, SYSEX_TAG);
1236 SETMIDIEVENT(evm[num_events + 1], 0, ME_RPN_LSB, p, 0, SYSEX_TAG);
1237 SETMIDIEVENT(evm[num_events + 2], 0, ME_DATA_ENTRY_MSB, p, (*body - 0x40) & 0x7F, SYSEX_TAG);
1238 num_events += 3;
1239 break;
1240
1241 case 0x24: /* Bend Filter Control */
1242 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x22);
1243 num_events++;
1244 break;
1245
1246 case 0x25: /* Bend Amplitude Control */
1247 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x23);
1248 num_events++;
1249 break;
1250
1251 case 0x26: /* Bend LFO PMod Depth */
1252 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x25);
1253 num_events++;
1254 break;
1255
1256 case 0x27: /* Bend LFO FMod Depth */
1257 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x26);
1258 num_events++;
1259 break;
1260
1261 case 0x28: /* Bend LFO AMod Depth */
1262 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x27);
1263 num_events++;
1264 break;
1265
1266 case 0x30: /* Rcv Pitch Bend */
1267 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x48);
1268 num_events++;
1269 break;
1270
1271 case 0x31: /* Rcv Channel Pressure */
1272 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x49);
1273 num_events++;
1274 break;
1275
1276 case 0x32: /* Rcv Program Change */
1277 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x4A);
1278 num_events++;
1279 break;
1280
1281 case 0x33: /* Rcv Control Change */
1282 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x4B);
1283 num_events++;
1284 break;
1285
1286 case 0x34: /* Rcv Poly Pressure */
1287 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x4C);
1288 num_events++;
1289 break;
1290
1291 case 0x35: /* Rcv Note Message */
1292 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x4D);
1293 num_events++;
1294 break;
1295
1296 case 0x36: /* Rcv RPN */
1297 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x4E);
1298 num_events++;
1299 break;
1300
1301 case 0x37: /* Rcv NRPN */
1302 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x4F);
1303 num_events++;
1304 break;
1305
1306 case 0x38: /* Rcv Modulation */
1307 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x50);
1308 num_events++;
1309 break;
1310
1311 case 0x39: /* Rcv Volume */
1312 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x51);
1313 num_events++;
1314 break;
1315
1316 case 0x3A: /* Rcv Pan */
1317 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x52);
1318 num_events++;
1319 break;
1320
1321 case 0x3B: /* Rcv Expression */
1322 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x53);
1323 num_events++;
1324 break;
1325
1326 case 0x3C: /* Rcv Hold1 */
1327 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x54);
1328 num_events++;
1329 break;
1330
1331 case 0x3D: /* Rcv Portamento */
1332 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x55);
1333 num_events++;
1334 break;
1335
1336 case 0x3E: /* Rcv Sostenuto */
1337 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x56);
1338 num_events++;
1339 break;
1340
1341 case 0x3F: /* Rcv Soft */
1342 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x57);
1343 num_events++;
1344 break;
1345
1346 case 0x40: /* Rcv Bank Select */
1347 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x58);
1348 num_events++;
1349 break;
1350
1351 case 0x41: /* scale tuning */
1352 case 0x42:
1353 case 0x43:
1354 case 0x44:
1355 case 0x45:
1356 case 0x46:
1357 case 0x47:
1358 case 0x48:
1359 case 0x49:
1360 case 0x4a:
1361 case 0x4b:
1362 case 0x4c:
1363 SETMIDIEVENT(evm[num_events], 0, ME_SCALE_TUNING, p, ent - 0x41, *body - 64);
1364 num_events++;
1365 ctl->cmsg(CMSG_INFO, VERB_NOISY, "Scale Tuning %s (CH:%d %d cent)",
1366 note_name[ent - 0x41], p, *body - 64);
1367 break;
1368
1369 case 0x4D: /* CAT Pitch Control */
1370 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x00);
1371 num_events++;
1372 break;
1373
1374 case 0x4E: /* CAT Filter Control */
1375 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x01);
1376 num_events++;
1377 break;
1378
1379 case 0x4F: /* CAT Amplitude Control */
1380 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x02);
1381 num_events++;
1382 break;
1383
1384 case 0x50: /* CAT LFO PMod Depth */
1385 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x04);
1386 num_events++;
1387 break;
1388
1389 case 0x51: /* CAT LFO FMod Depth */
1390 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x05);
1391 num_events++;
1392 break;
1393
1394 case 0x52: /* CAT LFO AMod Depth */
1395 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x06);
1396 num_events++;
1397 break;
1398
1399 case 0x53: /* PAT Pitch Control */
1400 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x0B);
1401 num_events++;
1402 break;
1403
1404 case 0x54: /* PAT Filter Control */
1405 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x0C);
1406 num_events++;
1407 break;
1408
1409 case 0x55: /* PAT Amplitude Control */
1410 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x0D);
1411 num_events++;
1412 break;
1413
1414 case 0x56: /* PAT LFO PMod Depth */
1415 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x0F);
1416 num_events++;
1417 break;
1418
1419 case 0x57: /* PAT LFO FMod Depth */
1420 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x10);
1421 num_events++;
1422 break;
1423
1424 case 0x58: /* PAT LFO AMod Depth */
1425 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x11);
1426 num_events++;
1427 break;
1428
1429 case 0x59: /* AC1 Controller Number */
1430 ctl->cmsg(CMSG_INFO, VERB_NOISY, "AC1 Controller Number is not supported. (CH:%d VAL:%d)", p, *body);
1431 break;
1432
1433 case 0x5A: /* AC1 Pitch Control */
1434 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x2C);
1435 num_events++;
1436 break;
1437
1438 case 0x5B: /* AC1 Filter Control */
1439 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x2D);
1440 num_events++;
1441 break;
1442
1443 case 0x5C: /* AC1 Amplitude Control */
1444 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x2E);
1445 num_events++;
1446 break;
1447
1448 case 0x5D: /* AC1 LFO PMod Depth */
1449 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x30);
1450 num_events++;
1451 break;
1452
1453 case 0x5E: /* AC1 LFO FMod Depth */
1454 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x31);
1455 num_events++;
1456 break;
1457
1458 case 0x5F: /* AC1 LFO AMod Depth */
1459 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x32);
1460 num_events++;
1461 break;
1462
1463 case 0x60: /* AC2 Controller Number */
1464 ctl->cmsg(CMSG_INFO, VERB_NOISY, "AC2 Controller Number is not supported. (CH:%d VAL:%d)", p, *body);
1465 break;
1466
1467 case 0x61: /* AC2 Pitch Control */
1468 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x37);
1469 num_events++;
1470 break;
1471
1472 case 0x62: /* AC2 Filter Control */
1473 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x38);
1474 num_events++;
1475 break;
1476
1477 case 0x63: /* AC2 Amplitude Control */
1478 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x39);
1479 num_events++;
1480 break;
1481
1482 case 0x64: /* AC2 LFO PMod Depth */
1483 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x3B);
1484 num_events++;
1485 break;
1486
1487 case 0x65: /* AC2 LFO FMod Depth */
1488 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x3C);
1489 num_events++;
1490 break;
1491
1492 case 0x66: /* AC2 LFO AMod Depth */
1493 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x3D);
1494 num_events++;
1495 break;
1496
1497 case 0x67: /* Portamento Switch */
1498 SETMIDIEVENT(evm[num_events], 0, ME_PORTAMENTO, p, *body, SYSEX_TAG);
1499 num_events++;
1500
1501 case 0x68: /* Portamento Time */
1502 SETMIDIEVENT(evm[num_events], 0, ME_PORTAMENTO_TIME_MSB, p, *body, SYSEX_TAG);
1503 num_events++;
1504
1505 case 0x69: /* Pitch EG Initial Level */
1506 ctl->cmsg(CMSG_INFO, VERB_NOISY, "Pitch EG Initial Level is not supported. (CH:%d VAL:%d)", p, *body);
1507 break;
1508
1509 case 0x6A: /* Pitch EG Attack Time */
1510 ctl->cmsg(CMSG_INFO, VERB_NOISY, "Pitch EG Attack Time is not supported. (CH:%d VAL:%d)", p, *body);
1511 break;
1512
1513 case 0x6B: /* Pitch EG Release Level */
1514 ctl->cmsg(CMSG_INFO, VERB_NOISY, "Pitch EG Release Level is not supported. (CH:%d VAL:%d)", p, *body);
1515 break;
1516
1517 case 0x6C: /* Pitch EG Release Time */
1518 ctl->cmsg(CMSG_INFO, VERB_NOISY, "Pitch EG Release Time is not supported. (CH:%d VAL:%d)", p, *body);
1519 break;
1520
1521 case 0x6D: /* Velocity Limit Low */
1522 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x44);
1523 num_events++;
1524 break;
1525
1526 case 0x6E: /* Velocity Limit High */
1527 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, p, *body, 0x45);
1528 num_events++;
1529 break;
1530
1531 case 0x70: /* Bend Pitch Low Control */
1532 ctl->cmsg(CMSG_INFO, VERB_NOISY, "Bend Pitch Low Control is not supported. (CH:%d VAL:%d)", p, *body);
1533 break;
1534
1535 case 0x71: /* Filter EG Depth */
1536 ctl->cmsg(CMSG_INFO, VERB_NOISY, "Filter EG Depth is not supported. (CH:%d VAL:%d)", p, *body);
1537 break;
1538
1539 case 0x72: /* EQ BASS */
1540 SETMIDIEVENT(evm[num_events], 0,ME_NRPN_MSB, p, 0x01, SYSEX_TAG);
1541 SETMIDIEVENT(evm[num_events + 1], 0,ME_NRPN_LSB, p, 0x30, SYSEX_TAG);
1542 SETMIDIEVENT(evm[num_events + 2], 0,ME_DATA_ENTRY_MSB, p, *body, SYSEX_TAG);
1543 num_events += 3;
1544 break;
1545
1546 case 0x73: /* EQ TREBLE */
1547 SETMIDIEVENT(evm[num_events], 0,ME_NRPN_MSB, p, 0x01, SYSEX_TAG);
1548 SETMIDIEVENT(evm[num_events + 1], 0,ME_NRPN_LSB, p, 0x31, SYSEX_TAG);
1549 SETMIDIEVENT(evm[num_events + 2], 0,ME_DATA_ENTRY_MSB, p, *body, SYSEX_TAG);
1550 num_events += 3;
1551 break;
1552
1553 case 0x76: /* EQ BASS frequency */
1554 SETMIDIEVENT(evm[num_events], 0,ME_NRPN_MSB, p, 0x01, SYSEX_TAG);
1555 SETMIDIEVENT(evm[num_events + 1], 0,ME_NRPN_LSB, p, 0x34, SYSEX_TAG);
1556 SETMIDIEVENT(evm[num_events + 2], 0,ME_DATA_ENTRY_MSB, p, *body, SYSEX_TAG);
1557 num_events += 3;
1558 break;
1559
1560 case 0x77: /* EQ TREBLE frequency */
1561 SETMIDIEVENT(evm[num_events], 0,ME_NRPN_MSB, p, 0x01, SYSEX_TAG);
1562 SETMIDIEVENT(evm[num_events + 1], 0,ME_NRPN_LSB, p, 0x35, SYSEX_TAG);
1563 SETMIDIEVENT(evm[num_events + 2], 0,ME_DATA_ENTRY_MSB, p, *body, SYSEX_TAG);
1564 num_events += 3;
1565 break;
1566
1567 default:
1568 ctl->cmsg(CMSG_INFO,VERB_NOISY,"Unsupported XG Bulk Dump SysEx. (ADDR:%02X %02X %02X VAL:%02X)",addhigh,addlow,ent,*body);
1569 continue;
1570 break;
1571 }
1572 }
1573 }
1574
1575 /* XG Drum Setup */
1576 else if(len >= 10 &&
1577 val[0] == 0x43 && /* Yamaha ID */
1578 val[2] == 0x4C && /* XG Model ID */
1579 ((val[1] < 0x10 && (val[5] & 0xF0) == 0x30) || /* Bulk Dump*/
1580 (val[1] >= 0x10 && (val[3] & 0xF0) == 0x30))) /* Parameter Change */
1581 {
1582 uint8 addhigh, addmid, addlow; /* Addresses */
1583 uint8 *body; /* SysEx body */
1584 uint8 dp, note; /* Channel part number [0..15] */
1585 int ent; /* Entry # of sub-event */
1586 uint8 *body_end; /* End of SysEx body */
1587
1588 if (val[1] < 0x10) /* Bulk Dump */
1589 {
1590 addhigh = val[5];
1591 addmid = val[6];
1592 addlow = val[7];
1593 body = val + 8;
1594 body_end = val + len - 3;
1595 }
1596 else /* Parameter Change */
1597 {
1598 addhigh = val[3];
1599 addmid = val[4];
1600 addlow = val[5];
1601 body = val + 6;
1602 body_end = val + len - 2;
1603 }
1604
1605 dp = drum_setup_xg[(addhigh & 0x0F) + 1];
1606 note = addmid;
1607
1608 /* set the SYSEX_XG_MSB info */
1609 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_MSB, dp, addhigh, addmid);
1610 num_events++;
1611
1612 for (ent = addlow; body <= body_end; body++, ent++) {
1613 switch(ent) {
1614 case 0x00: /* Pitch Coarse */
1615 SETMIDIEVENT(evm[num_events], 0, ME_NRPN_MSB, dp, 0x18, SYSEX_TAG);
1616 SETMIDIEVENT(evm[num_events + 1], 0, ME_NRPN_LSB, dp, note, SYSEX_TAG);
1617 SETMIDIEVENT(evm[num_events + 2], 0, ME_DATA_ENTRY_MSB, dp, *body, SYSEX_TAG);
1618 num_events += 3;
1619 break;
1620 case 0x01: /* Pitch Fine */
1621 SETMIDIEVENT(evm[num_events], 0, ME_NRPN_MSB, dp, 0x19, SYSEX_TAG);
1622 SETMIDIEVENT(evm[num_events + 1], 0, ME_NRPN_LSB, dp, note, SYSEX_TAG);
1623 SETMIDIEVENT(evm[num_events + 2], 0, ME_DATA_ENTRY_MSB, dp, *body, SYSEX_TAG);
1624 num_events += 3;
1625 break;
1626 case 0x02: /* Level */
1627 SETMIDIEVENT(evm[num_events], 0, ME_NRPN_MSB, dp, 0x1A, SYSEX_TAG);
1628 SETMIDIEVENT(evm[num_events + 1], 0, ME_NRPN_LSB, dp, note, SYSEX_TAG);
1629 SETMIDIEVENT(evm[num_events + 2], 0, ME_DATA_ENTRY_MSB, dp, *body, SYSEX_TAG);
1630 num_events += 3;
1631 break;
1632 case 0x03: /* Alternate Group */
1633 ctl->cmsg(CMSG_INFO, VERB_NOISY, "Alternate Group is not supported. (CH:%d NOTE:%d VAL:%d)", dp, note, *body);
1634 break;
1635 case 0x04: /* Pan */
1636 SETMIDIEVENT(evm[num_events], 0, ME_NRPN_MSB, dp, 0x1C, SYSEX_TAG);
1637 SETMIDIEVENT(evm[num_events + 1], 0, ME_NRPN_LSB, dp, note, SYSEX_TAG);
1638 SETMIDIEVENT(evm[num_events + 2], 0, ME_DATA_ENTRY_MSB, dp, *body, SYSEX_TAG);
1639 num_events += 3;
1640 break;
1641 case 0x05: /* Reverb Send */
1642 SETMIDIEVENT(evm[num_events], 0, ME_NRPN_MSB, dp, 0x1D, SYSEX_TAG);
1643 SETMIDIEVENT(evm[num_events + 1], 0, ME_NRPN_LSB, dp, note, SYSEX_TAG);
1644 SETMIDIEVENT(evm[num_events + 2], 0, ME_DATA_ENTRY_MSB, dp, *body, SYSEX_TAG);
1645 num_events += 3;
1646 break;
1647 case 0x06: /* Chorus Send */
1648 SETMIDIEVENT(evm[num_events], 0, ME_NRPN_MSB, dp, 0x1E, SYSEX_TAG);
1649 SETMIDIEVENT(evm[num_events + 1], 0, ME_NRPN_LSB, dp, note, SYSEX_TAG);
1650 SETMIDIEVENT(evm[num_events + 2], 0, ME_DATA_ENTRY_MSB, dp, *body, SYSEX_TAG);
1651 num_events += 3;
1652 break;
1653 case 0x07: /* Variation Send */
1654 SETMIDIEVENT(evm[num_events], 0, ME_NRPN_MSB, dp, 0x1F, SYSEX_TAG);
1655 SETMIDIEVENT(evm[num_events + 1], 0, ME_NRPN_LSB, dp, note, SYSEX_TAG);
1656 SETMIDIEVENT(evm[num_events + 2], 0, ME_DATA_ENTRY_MSB, dp, *body, SYSEX_TAG);
1657 num_events += 3;
1658 break;
1659 case 0x08: /* Key Assign */
1660 ctl->cmsg(CMSG_INFO, VERB_NOISY, "Key Assign is not supported. (CH:%d NOTE:%d VAL:%d)", dp, note, *body);
1661 break;
1662 case 0x09: /* Rcv Note Off */
1663 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_MSB, dp, note, 0);
1664 SETMIDIEVENT(evm[num_events + 1], 0, ME_SYSEX_LSB, dp, *body, 0x46);
1665 num_events += 2;
1666 break;
1667 case 0x0A: /* Rcv Note On */
1668 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_MSB, dp, note, 0);
1669 SETMIDIEVENT(evm[num_events + 1], 0, ME_SYSEX_LSB, dp, *body, 0x47);
1670 num_events += 2;
1671 break;
1672 case 0x0B: /* Filter Cutoff Frequency */
1673 SETMIDIEVENT(evm[num_events], 0, ME_NRPN_MSB, dp, 0x14, SYSEX_TAG);
1674 SETMIDIEVENT(evm[num_events + 1], 0, ME_NRPN_LSB, dp, note, SYSEX_TAG);
1675 SETMIDIEVENT(evm[num_events + 2], 0, ME_DATA_ENTRY_MSB, dp, *body, SYSEX_TAG);
1676 num_events += 3;
1677 break;
1678 case 0x0C: /* Filter Resonance */
1679 SETMIDIEVENT(evm[num_events], 0, ME_NRPN_MSB, dp, 0x15, SYSEX_TAG);
1680 SETMIDIEVENT(evm[num_events + 1], 0, ME_NRPN_LSB, dp, note, SYSEX_TAG);
1681 SETMIDIEVENT(evm[num_events + 2], 0, ME_DATA_ENTRY_MSB, dp, *body, SYSEX_TAG);
1682 num_events += 3;
1683 break;
1684 case 0x0D: /* EG Attack */
1685 SETMIDIEVENT(evm[num_events], 0, ME_NRPN_MSB, dp, 0x16, SYSEX_TAG);
1686 SETMIDIEVENT(evm[num_events + 1], 0, ME_NRPN_LSB, dp, note, SYSEX_TAG);
1687 SETMIDIEVENT(evm[num_events + 2], 0, ME_DATA_ENTRY_MSB, dp, *body, SYSEX_TAG);
1688 num_events += 3;
1689 break;
1690 case 0x0E: /* EG Decay1 */
1691 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_LSB, dp, *body, ent);
1692 num_events++;
1693 break;
1694 case 0x0F: /* EG Decay2 */
1695 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_XG_LSB, dp, *body, ent);
1696 num_events++;
1697 break;
1698 case 0x20: /* EQ BASS */
1699 SETMIDIEVENT(evm[num_events], 0, ME_NRPN_MSB, dp, 0x30, SYSEX_TAG);
1700 SETMIDIEVENT(evm[num_events + 1], 0, ME_NRPN_LSB, dp, note, SYSEX_TAG);
1701 SETMIDIEVENT(evm[num_events + 2], 0, ME_DATA_ENTRY_MSB, dp, *body, SYSEX_TAG);
1702 num_events += 3;
1703 break;
1704 case 0x21: /* EQ TREBLE */
1705 SETMIDIEVENT(evm[num_events], 0, ME_NRPN_MSB, dp, 0x31, SYSEX_TAG);
1706 SETMIDIEVENT(evm[num_events + 1], 0, ME_NRPN_LSB, dp, note, SYSEX_TAG);
1707 SETMIDIEVENT(evm[num_events + 2], 0, ME_DATA_ENTRY_MSB, dp, *body, SYSEX_TAG);
1708 num_events += 3;
1709 break;
1710 case 0x24: /* EQ BASS frequency */
1711 SETMIDIEVENT(evm[num_events], 0, ME_NRPN_MSB, dp, 0x34, SYSEX_TAG);
1712 SETMIDIEVENT(evm[num_events + 1], 0, ME_NRPN_LSB, dp, note, SYSEX_TAG);
1713 SETMIDIEVENT(evm[num_events + 2], 0, ME_DATA_ENTRY_MSB, dp, *body, SYSEX_TAG);
1714 num_events += 3;
1715 break;
1716 case 0x25: /* EQ TREBLE frequency */
1717 SETMIDIEVENT(evm[num_events], 0, ME_NRPN_MSB, dp, 0x35, SYSEX_TAG);
1718 SETMIDIEVENT(evm[num_events + 1], 0, ME_NRPN_LSB, dp, note, SYSEX_TAG);
1719 SETMIDIEVENT(evm[num_events + 2], 0, ME_DATA_ENTRY_MSB, dp, *body, SYSEX_TAG);
1720 num_events += 3;
1721 break;
1722 case 0x50: /* High Pass Filter Cutoff Frequency */
1723 ctl->cmsg(CMSG_INFO, VERB_NOISY, "High Pass Filter Cutoff Frequency is not supported. (CH:%d NOTE:%d VAL:%d)", dp, note, *body);
1724 break;
1725 case 0x60: /* Velocity Pitch Sense */
1726 ctl->cmsg(CMSG_INFO, VERB_NOISY, "Velocity Pitch Sense is not supported. (CH:%d NOTE:%d VAL:%d)", dp, note, *body);
1727 break;
1728 case 0x61: /* Velocity LPF Cutoff Sense */
1729 ctl->cmsg(CMSG_INFO, VERB_NOISY, "Velocity LPF Cutoff Sense is not supported. (CH:%d NOTE:%d VAL:%d)", dp, note, *body);
1730 break;
1731 default:
1732 ctl->cmsg(CMSG_INFO,VERB_NOISY,"Unsupported XG Bulk Dump SysEx. (ADDR:%02X %02X %02X VAL:%02X)",addhigh,addmid,ent,*body);
1733 break;
1734 }
1735 }
1736 }
1737
1738 /* parsing GS System Exclusive Message...
1739 *
1740 * val[4] == Parameter Address(High)
1741 * val[5] == Parameter Address(Middle)
1742 * val[6] == Parameter Address(Low)
1743 * val[7]... == Data...
1744 * val[last] == Checksum(== 128 - (sum of addresses&data bytes % 128))
1745 */
1746 else if(len >= 9 &&
1747 val[0] == 0x41 && /* Roland ID */
1748 val[1] == 0x10 && /* Device ID */
1749 val[2] == 0x42 && /* GS Model ID */
1750 val[3] == 0x12) /* Data Set Command */
1751 {
1752 uint8 p, dp, udn, gslen, port = 0;
1753 int i, addr, addr_h, addr_m, addr_l, checksum;
1754 p = block_to_part(val[5], midi_port_number);
1755
1756 /* calculate checksum */
1757 checksum = 0;
1758 for(gslen = 9; gslen < len; gslen++)
1759 if(val[gslen] == 0xF7)
1760 break;
1761 for(i=4;i<gslen-1;i++) {
1762 checksum += val[i];
1763 }
1764 if(((128 - (checksum & 0x7F)) & 0x7F) != val[gslen-1]) {
1765 ctl->cmsg(CMSG_INFO,VERB_NOISY,"GS SysEx: Checksum Error.");
1766 return num_events;
1767 }
1768
1769 /* drum channel */
1770 dp = rhythm_part[(val[5] & 0xF0) >> 4];
1771
1772 /* calculate user drumset number */
1773 udn = (val[5] & 0xF0) >> 4;
1774
1775 addr_h = val[4];
1776 addr_m = val[5];
1777 addr_l = val[6];
1778 if(addr_h == 0x50) { /* for double module mode */
1779 port = 1;
1780 p = block_to_part(val[5], port);
1781 addr_h = 0x40;
1782 } else if(addr_h == 0x51) {
1783 port = 1;
1784 p = block_to_part(val[5], port);
1785 addr_h = 0x41;
1786 }
1787 addr = (((int32)addr_h)<<16 | ((int32)addr_m)<<8 | (int32)addr_l);
1788
1789 switch(addr_h) {
1790 case 0x40:
1791 if((addr & 0xFFF000) == 0x401000) {
1792 switch(addr & 0xFF) {
1793 case 0x00: /* Tone Number */
1794 SETMIDIEVENT(evm[0], 0, ME_TONE_BANK_MSB, p,val[7], SYSEX_TAG);
1795 SETMIDIEVENT(evm[1], 0, ME_PROGRAM, p, val[8], SYSEX_TAG);
1796 num_events += 2;
1797 break;
1798 case 0x02: /* Rx. Channel */
1799 if (val[7] == 0x10) {
1800 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB,
1801 block_to_part(val[5],
1802 midi_port_number ^ port), 0x80, 0x45);
1803 } else {
1804 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB,
1805 block_to_part(val[5],
1806 midi_port_number ^ port),
1807 MERGE_CHANNEL_PORT2(val[7],
1808 midi_port_number ^ port), 0x45);
1809 }
1810 num_events++;
1811 break;
1812 case 0x03: /* Rx. Pitch Bend */
1813 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x48);
1814 num_events++;
1815 break;
1816 case 0x04: /* Rx. Channel Pressure */
1817 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x49);
1818 num_events++;
1819 break;
1820 case 0x05: /* Rx. Program Change */
1821 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x4A);
1822 num_events++;
1823 break;
1824 case 0x06: /* Rx. Control Change */
1825 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x4B);
1826 num_events++;
1827 break;
1828 case 0x07: /* Rx. Poly Pressure */
1829 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x4C);
1830 num_events++;
1831 break;
1832 case 0x08: /* Rx. Note Message */
1833 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x4D);
1834 num_events++;
1835 break;
1836 case 0x09: /* Rx. RPN */
1837 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x4E);
1838 num_events++;
1839 break;
1840 case 0x0A: /* Rx. NRPN */
1841 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x4F);
1842 num_events++;
1843 break;
1844 case 0x0B: /* Rx. Modulation */
1845 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x50);
1846 num_events++;
1847 break;
1848 case 0x0C: /* Rx. Volume */
1849 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x51);
1850 num_events++;
1851 break;
1852 case 0x0D: /* Rx. Panpot */
1853 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x52);
1854 num_events++;
1855 break;
1856 case 0x0E: /* Rx. Expression */
1857 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x53);
1858 num_events++;
1859 break;
1860 case 0x0F: /* Rx. Hold1 */
1861 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x54);
1862 num_events++;
1863 break;
1864 case 0x10: /* Rx. Portamento */
1865 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x55);
1866 num_events++;
1867 break;
1868 case 0x11: /* Rx. Sostenuto */
1869 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x56);
1870 num_events++;
1871 break;
1872 case 0x12: /* Rx. Soft */
1873 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x57);
1874 num_events++;
1875 break;
1876 case 0x13: /* MONO/POLY Mode */
1877 if(val[7] == 0) {SETMIDIEVENT(evm[0], 0, ME_MONO, p, val[7], SYSEX_TAG);}
1878 else {SETMIDIEVENT(evm[0], 0, ME_POLY, p, val[7], SYSEX_TAG);}
1879 num_events++;
1880 break;
1881 case 0x14: /* Assign Mode */
1882 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x24);
1883 num_events++;
1884 break;
1885 case 0x15: /* Use for Rhythm Part */
1886 if(val[7]) {
1887 rhythm_part[val[7] - 1] = p;
1888 }
1889 break;
1890 case 0x16: /* Pitch Key Shift (dummy. see parse_sysex_event()) */
1891 break;
1892 case 0x17: /* Pitch Offset Fine */
1893 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x26);
1894 num_events++;
1895 break;
1896 case 0x19: /* Part Level */
1897 SETMIDIEVENT(evm[0], 0, ME_MAINVOLUME, p, val[7], SYSEX_TAG);
1898 num_events++;
1899 break;
1900 case 0x1A: /* Velocity Sense Depth */
1901 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x21);
1902 num_events++;
1903 break;
1904 case 0x1B: /* Velocity Sense Offset */
1905 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x22);
1906 num_events++;
1907 break;
1908 case 0x1C: /* Part Panpot */
1909 if (val[7] == 0) {
1910 SETMIDIEVENT(evm[0], 0, ME_RANDOM_PAN, p, 0, SYSEX_TAG);
1911 } else {
1912 SETMIDIEVENT(evm[0], 0, ME_PAN, p, val[7], SYSEX_TAG);
1913 }
1914 num_events++;
1915 break;
1916 case 0x1D: /* Keyboard Range Low */
1917 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x42);
1918 num_events++;
1919 break;
1920 case 0x1E: /* Keyboard Range High */
1921 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x43);
1922 num_events++;
1923 break;
1924 case 0x1F: /* CC1 Controller Number */
1925 ctl->cmsg(CMSG_INFO, VERB_NOISY, "CC1 Controller Number is not supported. (CH:%d VAL:%d)", p, val[7]);
1926 break;
1927 case 0x20: /* CC2 Controller Number */
1928 ctl->cmsg(CMSG_INFO, VERB_NOISY, "CC2 Controller Number is not supported. (CH:%d VAL:%d)", p, val[7]);
1929 break;
1930 case 0x21: /* Chorus Send Level */
1931 SETMIDIEVENT(evm[0], 0, ME_CHORUS_EFFECT, p, val[7], SYSEX_TAG);
1932 num_events++;
1933 break;
1934 case 0x22: /* Reverb Send Level */
1935 SETMIDIEVENT(evm[0], 0, ME_REVERB_EFFECT, p, val[7], SYSEX_TAG);
1936 num_events++;
1937 break;
1938 case 0x23: /* Rx. Bank Select */
1939 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x58);
1940 num_events++;
1941 break;
1942 case 0x24: /* Rx. Bank Select LSB */
1943 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x59);
1944 num_events++;
1945 break;
1946 case 0x2C: /* Delay Send Level */
1947 SETMIDIEVENT(evm[0], 0, ME_CELESTE_EFFECT, p, val[7], SYSEX_TAG);
1948 num_events++;
1949 break;
1950 case 0x2A: /* Pitch Fine Tune */
1951 SETMIDIEVENT(evm[0], 0, ME_NRPN_MSB, p, 0x00, SYSEX_TAG);
1952 SETMIDIEVENT(evm[1], 0, ME_NRPN_LSB, p, 0x01, SYSEX_TAG);
1953 SETMIDIEVENT(evm[2], 0, ME_DATA_ENTRY_MSB, p, val[7], SYSEX_TAG);
1954 SETMIDIEVENT(evm[3], 0, ME_DATA_ENTRY_LSB, p, val[8], SYSEX_TAG);
1955 num_events += 4;
1956 break;
1957 case 0x30: /* TONE MODIFY1: Vibrato Rate */
1958 SETMIDIEVENT(evm[0], 0, ME_NRPN_MSB, p, 0x01, SYSEX_TAG);
1959 SETMIDIEVENT(evm[1], 0, ME_NRPN_LSB, p, 0x08, SYSEX_TAG);
1960 SETMIDIEVENT(evm[2], 0, ME_DATA_ENTRY_MSB, p, val[7], SYSEX_TAG);
1961 num_events += 3;
1962 break;
1963 case 0x31: /* TONE MODIFY2: Vibrato Depth */
1964 SETMIDIEVENT(evm[0], 0, ME_NRPN_MSB, p, 0x01, SYSEX_TAG);
1965 SETMIDIEVENT(evm[1], 0, ME_NRPN_LSB, p, 0x09, SYSEX_TAG);
1966 SETMIDIEVENT(evm[2], 0, ME_DATA_ENTRY_MSB, p, val[7], SYSEX_TAG);
1967 num_events += 3;
1968 break;
1969 case 0x32: /* TONE MODIFY3: TVF Cutoff Freq */
1970 SETMIDIEVENT(evm[0], 0, ME_NRPN_MSB, p, 0x01, SYSEX_TAG);
1971 SETMIDIEVENT(evm[1], 0, ME_NRPN_LSB, p, 0x20, SYSEX_TAG);
1972 SETMIDIEVENT(evm[2], 0, ME_DATA_ENTRY_MSB, p, val[7], SYSEX_TAG);
1973 num_events += 3;
1974 break;
1975 case 0x33: /* TONE MODIFY4: TVF Resonance */
1976 SETMIDIEVENT(evm[0], 0, ME_NRPN_MSB, p, 0x01, SYSEX_TAG);
1977 SETMIDIEVENT(evm[1], 0, ME_NRPN_LSB, p, 0x21, SYSEX_TAG);
1978 SETMIDIEVENT(evm[2], 0, ME_DATA_ENTRY_MSB, p, val[7], SYSEX_TAG);
1979 num_events += 3;
1980 break;
1981 case 0x34: /* TONE MODIFY5: TVF&TVA Env.attack */
1982 SETMIDIEVENT(evm[0], 0, ME_NRPN_MSB, p, 0x01, SYSEX_TAG);
1983 SETMIDIEVENT(evm[1], 0, ME_NRPN_LSB, p, 0x63, SYSEX_TAG);
1984 SETMIDIEVENT(evm[2], 0, ME_DATA_ENTRY_MSB, p, val[7], SYSEX_TAG);
1985 num_events += 3;
1986 break;
1987 case 0x35: /* TONE MODIFY6: TVF&TVA Env.decay */
1988 SETMIDIEVENT(evm[0], 0, ME_NRPN_MSB, p, 0x01, SYSEX_TAG);
1989 SETMIDIEVENT(evm[1], 0, ME_NRPN_LSB, p, 0x64, SYSEX_TAG);
1990 SETMIDIEVENT(evm[2], 0, ME_DATA_ENTRY_MSB, p, val[7], SYSEX_TAG);
1991 num_events += 3;
1992 break;
1993 case 0x36: /* TONE MODIFY7: TVF&TVA Env.release */
1994 SETMIDIEVENT(evm[0], 0, ME_NRPN_MSB, p, 0x01, SYSEX_TAG);
1995 SETMIDIEVENT(evm[1], 0, ME_NRPN_LSB, p, 0x66, SYSEX_TAG);
1996 SETMIDIEVENT(evm[2], 0, ME_DATA_ENTRY_MSB, p, val[7], SYSEX_TAG);
1997 num_events += 3;
1998 break;
1999 case 0x37: /* TONE MODIFY8: Vibrato Delay */
2000 SETMIDIEVENT(evm[0], 0, ME_NRPN_MSB, p, 0x01, SYSEX_TAG);
2001 SETMIDIEVENT(evm[1], 0, ME_NRPN_LSB, p, 0x0A, SYSEX_TAG);
2002 SETMIDIEVENT(evm[2], 0, ME_DATA_ENTRY_MSB, p, val[7], SYSEX_TAG);
2003 num_events += 3;
2004 break;
2005 case 0x40: /* Scale Tuning */
2006 for (i = 0; i < 12; i++) {
2007 SETMIDIEVENT(evm[i],
2008 0, ME_SCALE_TUNING, p, i, val[i + 7] - 64);
2009 ctl->cmsg(CMSG_INFO, VERB_NOISY,
2010 "Scale Tuning %s (CH:%d %d cent)",
2011 note_name[i], p, val[i + 7] - 64);
2012 }
2013 num_events += 12;
2014 break;
2015 default:
2016 ctl->cmsg(CMSG_INFO,VERB_NOISY,"Unsupported GS SysEx. (ADDR:%02X %02X %02X VAL:%02X %02X)",addr_h,addr_m,addr_l,val[7],val[8]);
2017 break;
2018 }
2019 } else if((addr & 0xFFF000) == 0x402000) {
2020 switch(addr & 0xFF) {
2021 case 0x00: /* MOD Pitch Control */
2022 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x16);
2023 num_events++;
2024 break;
2025 case 0x01: /* MOD TVF Cutoff Control */
2026 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x17);
2027 num_events++;
2028 break;
2029 case 0x02: /* MOD Amplitude Control */
2030 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x18);
2031 num_events++;
2032 break;
2033 case 0x03: /* MOD LFO1 Rate Control */
2034 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x19);
2035 num_events++;
2036 break;
2037 case 0x04: /* MOD LFO1 Pitch Depth */
2038 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x1A);
2039 num_events++;
2040 break;
2041 case 0x05: /* MOD LFO1 TVF Depth */
2042 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x1B);
2043 num_events++;
2044 break;
2045 case 0x06: /* MOD LFO1 TVA Depth */
2046 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x1C);
2047 num_events++;
2048 break;
2049 case 0x07: /* MOD LFO2 Rate Control */
2050 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x1D);
2051 num_events++;
2052 break;
2053 case 0x08: /* MOD LFO2 Pitch Depth */
2054 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x1E);
2055 num_events++;
2056 break;
2057 case 0x09: /* MOD LFO2 TVF Depth */
2058 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x1F);
2059 num_events++;
2060 break;
2061 case 0x0A: /* MOD LFO2 TVA Depth */
2062 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x20);
2063 num_events++;
2064 break;
2065 case 0x10: /* !!!FIXME!!! Bend Pitch Control */
2066 SETMIDIEVENT(evm[0], 0, ME_RPN_MSB, p, 0, SYSEX_TAG);
2067 SETMIDIEVENT(evm[1], 0, ME_RPN_LSB, p, 0, SYSEX_TAG);
2068 SETMIDIEVENT(evm[2], 0, ME_DATA_ENTRY_MSB, p, (val[7] - 0x40) & 0x7F, SYSEX_TAG);
2069 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x21);
2070 num_events += 4;
2071 break;
2072 case 0x11: /* Bend TVF Cutoff Control */
2073 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x22);
2074 num_events++;
2075 break;
2076 case 0x12: /* Bend Amplitude Control */
2077 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x23);
2078 num_events++;
2079 break;
2080 case 0x13: /* Bend LFO1 Rate Control */
2081 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x24);
2082 num_events++;
2083 break;
2084 case 0x14: /* Bend LFO1 Pitch Depth */
2085 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x25);
2086 num_events++;
2087 break;
2088 case 0x15: /* Bend LFO1 TVF Depth */
2089 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x26);
2090 num_events++;
2091 break;
2092 case 0x16: /* Bend LFO1 TVA Depth */
2093 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x27);
2094 num_events++;
2095 break;
2096 case 0x17: /* Bend LFO2 Rate Control */
2097 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x28);
2098 num_events++;
2099 break;
2100 case 0x18: /* Bend LFO2 Pitch Depth */
2101 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x29);
2102 num_events++;
2103 break;
2104 case 0x19: /* Bend LFO2 TVF Depth */
2105 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x2A);
2106 num_events++;
2107 break;
2108 case 0x1A: /* Bend LFO2 TVA Depth */
2109 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x2B);
2110 num_events++;
2111 break;
2112 case 0x20: /* CAf Pitch Control */
2113 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x00);
2114 num_events++;
2115 break;
2116 case 0x21: /* CAf TVF Cutoff Control */
2117 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x01);
2118 num_events++;
2119 break;
2120 case 0x22: /* CAf Amplitude Control */
2121 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x02);
2122 num_events++;
2123 break;
2124 case 0x23: /* CAf LFO1 Rate Control */
2125 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x03);
2126 num_events++;
2127 break;
2128 case 0x24: /* CAf LFO1 Pitch Depth */
2129 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x04);
2130 num_events++;
2131 break;
2132 case 0x25: /* CAf LFO1 TVF Depth */
2133 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x05);
2134 num_events++;
2135 break;
2136 case 0x26: /* CAf LFO1 TVA Depth */
2137 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x06);
2138 num_events++;
2139 break;
2140 case 0x27: /* CAf LFO2 Rate Control */
2141 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x07);
2142 num_events++;
2143 break;
2144 case 0x28: /* CAf LFO2 Pitch Depth */
2145 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x08);
2146 num_events++;
2147 break;
2148 case 0x29: /* CAf LFO2 TVF Depth */
2149 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x09);
2150 num_events++;
2151 break;
2152 case 0x2A: /* CAf LFO2 TVA Depth */
2153 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x0A);
2154 num_events++;
2155 break;
2156 case 0x30: /* PAf Pitch Control */
2157 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x0B);
2158 num_events++;
2159 break;
2160 case 0x31: /* PAf TVF Cutoff Control */
2161 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x0C);
2162 num_events++;
2163 break;
2164 case 0x32: /* PAf Amplitude Control */
2165 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x0D);
2166 num_events++;
2167 break;
2168 case 0x33: /* PAf LFO1 Rate Control */
2169 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x0E);
2170 num_events++;
2171 break;
2172 case 0x34: /* PAf LFO1 Pitch Depth */
2173 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x0F);
2174 num_events++;
2175 break;
2176 case 0x35: /* PAf LFO1 TVF Depth */
2177 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x10);
2178 num_events++;
2179 break;
2180 case 0x36: /* PAf LFO1 TVA Depth */
2181 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x11);
2182 num_events++;
2183 break;
2184 case 0x37: /* PAf LFO2 Rate Control */
2185 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x12);
2186 num_events++;
2187 break;
2188 case 0x38: /* PAf LFO2 Pitch Depth */
2189 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x13);
2190 num_events++;
2191 break;
2192 case 0x39: /* PAf LFO2 TVF Depth */
2193 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x14);
2194 num_events++;
2195 break;
2196 case 0x3A: /* PAf LFO2 TVA Depth */
2197 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x15);
2198 num_events++;
2199 break;
2200 case 0x40: /* CC1 Pitch Control */
2201 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x2C);
2202 num_events++;
2203 break;
2204 case 0x41: /* CC1 TVF Cutoff Control */
2205 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x2D);
2206 num_events++;
2207 break;
2208 case 0x42: /* CC1 Amplitude Control */
2209 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x2E);
2210 num_events++;
2211 break;
2212 case 0x43: /* CC1 LFO1 Rate Control */
2213 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x2F);
2214 num_events++;
2215 break;
2216 case 0x44: /* CC1 LFO1 Pitch Depth */
2217 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x30);
2218 num_events++;
2219 break;
2220 case 0x45: /* CC1 LFO1 TVF Depth */
2221 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x31);
2222 num_events++;
2223 break;
2224 case 0x46: /* CC1 LFO1 TVA Depth */
2225 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x32);
2226 num_events++;
2227 break;
2228 case 0x47: /* CC1 LFO2 Rate Control */
2229 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x33);
2230 num_events++;
2231 break;
2232 case 0x48: /* CC1 LFO2 Pitch Depth */
2233 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x34);
2234 num_events++;
2235 break;
2236 case 0x49: /* CC1 LFO2 TVF Depth */
2237 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x35);
2238 num_events++;
2239 break;
2240 case 0x4A: /* CC1 LFO2 TVA Depth */
2241 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x36);
2242 num_events++;
2243 break;
2244 case 0x50: /* CC2 Pitch Control */
2245 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x37);
2246 num_events++;
2247 break;
2248 case 0x51: /* CC2 TVF Cutoff Control */
2249 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x38);
2250 num_events++;
2251 break;
2252 case 0x52: /* CC2 Amplitude Control */
2253 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x39);
2254 num_events++;
2255 break;
2256 case 0x53: /* CC2 LFO1 Rate Control */
2257 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x3A);
2258 num_events++;
2259 break;
2260 case 0x54: /* CC2 LFO1 Pitch Depth */
2261 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x3B);
2262 num_events++;
2263 break;
2264 case 0x55: /* CC2 LFO1 TVF Depth */
2265 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x3C);
2266 num_events++;
2267 break;
2268 case 0x56: /* CC2 LFO1 TVA Depth */
2269 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x3D);
2270 num_events++;
2271 break;
2272 case 0x57: /* CC2 LFO2 Rate Control */
2273 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x3E);
2274 num_events++;
2275 break;
2276 case 0x58: /* CC2 LFO2 Pitch Depth */
2277 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x3F);
2278 num_events++;
2279 break;
2280 case 0x59: /* CC2 LFO2 TVF Depth */
2281 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x40);
2282 num_events++;
2283 break;
2284 case 0x5A: /* CC2 LFO2 TVA Depth */
2285 SETMIDIEVENT(evm[0], 0, ME_SYSEX_LSB, p, val[7], 0x41);
2286 num_events++;
2287 break;
2288 default:
2289 ctl->cmsg(CMSG_INFO,VERB_NOISY,"Unsupported GS SysEx. (ADDR:%02X %02X %02X VAL:%02X %02X)",addr_h,addr_m,addr_l,val[7],val[8]);
2290 break;
2291 }
2292 } else if((addr & 0xFFFF00) == 0x400100) {
2293 switch(addr & 0xFF) {
2294 case 0x30: /* Reverb Macro */
2295 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x05);
2296 num_events++;
2297 break;
2298 case 0x31: /* Reverb Character */
2299 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x06);
2300 num_events++;
2301 break;
2302 case 0x32: /* Reverb Pre-LPF */
2303 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x07);
2304 num_events++;
2305 break;
2306 case 0x33: /* Reverb Level */
2307 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x08);
2308 num_events++;
2309 break;
2310 case 0x34: /* Reverb Time */
2311 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x09);
2312 num_events++;
2313 break;
2314 case 0x35: /* Reverb Delay Feedback */
2315 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x0A);
2316 num_events++;
2317 break;
2318 case 0x36: /* Unknown Reverb Parameter */
2319 break;
2320 case 0x37: /* Reverb Predelay Time */
2321 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x0C);
2322 num_events++;
2323 break;
2324 case 0x38: /* Chorus Macro */
2325 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x0D);
2326 num_events++;
2327 break;
2328 case 0x39: /* Chorus Pre-LPF */
2329 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x0E);
2330 num_events++;
2331 break;
2332 case 0x3A: /* Chorus Level */
2333 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x0F);
2334 num_events++;
2335 break;
2336 case 0x3B: /* Chorus Feedback */
2337 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x10);
2338 num_events++;
2339 break;
2340 case 0x3C: /* Chorus Delay */
2341 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x11);
2342 num_events++;
2343 break;
2344 case 0x3D: /* Chorus Rate */
2345 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x12);
2346 num_events++;
2347 break;
2348 case 0x3E: /* Chorus Depth */
2349 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x13);
2350 num_events++;
2351 break;
2352 case 0x3F: /* Chorus Send Level to Reverb */
2353 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x14);
2354 num_events++;
2355 break;
2356 case 0x40: /* Chorus Send Level to Delay */
2357 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x15);
2358 num_events++;
2359 break;
2360 case 0x50: /* Delay Macro */
2361 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x16);
2362 num_events++;
2363 break;
2364 case 0x51: /* Delay Pre-LPF */
2365 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x17);
2366 num_events++;
2367 break;
2368 case 0x52: /* Delay Time Center */
2369 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x18);
2370 num_events++;
2371 break;
2372 case 0x53: /* Delay Time Ratio Left */
2373 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x19);
2374 num_events++;
2375 break;
2376 case 0x54: /* Delay Time Ratio Right */
2377 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x1A);
2378 num_events++;
2379 break;
2380 case 0x55: /* Delay Level Center */
2381 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x1B);
2382 num_events++;
2383 break;
2384 case 0x56: /* Delay Level Left */
2385 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x1C);
2386 num_events++;
2387 break;
2388 case 0x57: /* Delay Level Right */
2389 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x1D);
2390 num_events++;
2391 break;
2392 case 0x58: /* Delay Level */
2393 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x1E);
2394 num_events++;
2395 break;
2396 case 0x59: /* Delay Feedback */
2397 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x1F);
2398 num_events++;
2399 break;
2400 case 0x5A: /* Delay Send Level to Reverb */
2401 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x20);
2402 num_events++;
2403 break;
2404 default:
2405 ctl->cmsg(CMSG_INFO,VERB_NOISY,"Unsupported GS SysEx. (ADDR:%02X %02X %02X VAL:%02X %02X)",addr_h,addr_m,addr_l,val[7],val[8]);
2406 break;
2407 }
2408 } else if((addr & 0xFFFF00) == 0x400200) {
2409 switch(addr & 0xFF) { /* EQ Parameter */
2410 case 0x00: /* EQ LOW FREQ */
2411 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x01);
2412 num_events++;
2413 break;
2414 case 0x01: /* EQ LOW GAIN */
2415 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x02);
2416 num_events++;
2417 break;
2418 case 0x02: /* EQ HIGH FREQ */
2419 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x03);
2420 num_events++;
2421 break;
2422 case 0x03: /* EQ HIGH GAIN */
2423 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x04);
2424 num_events++;
2425 break;
2426 default:
2427 ctl->cmsg(CMSG_INFO,VERB_NOISY,"Unsupported GS SysEx. (ADDR:%02X %02X %02X VAL:%02X %02X)",addr_h,addr_m,addr_l,val[7],val[8]);
2428 break;
2429 }
2430 } else if((addr & 0xFFFF00) == 0x400300) {
2431 switch(addr & 0xFF) { /* Insertion Effect Parameter */
2432 case 0x00:
2433 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x27);
2434 SETMIDIEVENT(evm[1], 0, ME_SYSEX_GS_LSB, p, val[8], 0x28);
2435 num_events += 2;
2436 break;
2437 case 0x03:
2438 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x29);
2439 num_events++;
2440 break;
2441 case 0x04:
2442 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x2A);
2443 num_events++;
2444 break;
2445 case 0x05:
2446 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x2B);
2447 num_events++;
2448 break;
2449 case 0x06:
2450 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x2C);
2451 num_events++;
2452 break;
2453 case 0x07:
2454 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x2D);
2455 num_events++;
2456 break;
2457 case 0x08:
2458 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x2E);
2459 num_events++;
2460 break;
2461 case 0x09:
2462 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x2F);
2463 num_events++;
2464 break;
2465 case 0x0A:
2466 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x30);
2467 num_events++;
2468 break;
2469 case 0x0B:
2470 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x31);
2471 num_events++;
2472 break;
2473 case 0x0C:
2474 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x32);
2475 num_events++;
2476 break;
2477 case 0x0D:
2478 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x33);
2479 num_events++;
2480 break;
2481 case 0x0E:
2482 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x34);
2483 num_events++;
2484 break;
2485 case 0x0F:
2486 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x35);
2487 num_events++;
2488 break;
2489 case 0x10:
2490 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x36);
2491 num_events++;
2492 break;
2493 case 0x11:
2494 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x37);
2495 num_events++;
2496 break;
2497 case 0x12:
2498 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x38);
2499 num_events++;
2500 break;
2501 case 0x13:
2502 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x39);
2503 num_events++;
2504 break;
2505 case 0x14:
2506 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x3A);
2507 num_events++;
2508 break;
2509 case 0x15:
2510 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x3B);
2511 num_events++;
2512 break;
2513 case 0x16:
2514 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x3C);
2515 num_events++;
2516 break;
2517 case 0x17:
2518 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x3D);
2519 num_events++;
2520 break;
2521 case 0x18:
2522 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x3E);
2523 num_events++;
2524 break;
2525 case 0x19:
2526 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x3F);
2527 num_events++;
2528 break;
2529 case 0x1B:
2530 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x40);
2531 num_events++;
2532 break;
2533 case 0x1C:
2534 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x41);
2535 num_events++;
2536 break;
2537 case 0x1D:
2538 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x42);
2539 num_events++;
2540 break;
2541 case 0x1E:
2542 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x43);
2543 num_events++;
2544 break;
2545 case 0x1F:
2546 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x44);
2547 num_events++;
2548 break;
2549 default:
2550 ctl->cmsg(CMSG_INFO,VERB_NOISY,"Unsupported GS SysEx. (ADDR:%02X %02X %02X VAL:%02X %02X)",addr_h,addr_m,addr_l,val[7],val[8]);
2551 break;
2552 }
2553 } else if((addr & 0xFFF000) == 0x404000) {
2554 switch(addr & 0xFF) {
2555 case 0x00: /* TONE MAP NUMBER */
2556 SETMIDIEVENT(evm[0], 0, ME_TONE_BANK_LSB, p, val[7], SYSEX_TAG);
2557 num_events++;
2558 break;
2559 case 0x01: /* TONE MAP-0 NUMBER */
2560 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x25);
2561 num_events++;
2562 break;
2563 case 0x20: /* EQ ON/OFF */
2564 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x00);
2565 num_events++;
2566 break;
2567 case 0x22: /* EFX ON/OFF */
2568 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB, p, val[7], 0x23);
2569 num_events++;
2570 break;
2571 default:
2572 ctl->cmsg(CMSG_INFO,VERB_NOISY,"Unsupported GS SysEx. (ADDR:%02X %02X %02X VAL:%02X %02X)",addr_h,addr_m,addr_l,val[7],val[8]);
2573 break;
2574 }
2575 }
2576 break;
2577 case 0x41:
2578 switch(addr & 0xF00) {
2579 case 0x100: /* Play Note Number */
2580 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_MSB, dp, val[6], 0);
2581 SETMIDIEVENT(evm[1], 0, ME_SYSEX_GS_LSB, dp, val[7], 0x47);
2582 num_events += 2;
2583 break;
2584 case 0x200:
2585 SETMIDIEVENT(evm[0], 0, ME_NRPN_MSB, dp, 0x1A, SYSEX_TAG);
2586 SETMIDIEVENT(evm[1], 0, ME_NRPN_LSB, dp, val[6], SYSEX_TAG);
2587 SETMIDIEVENT(evm[2], 0, ME_DATA_ENTRY_MSB, dp, val[7], SYSEX_TAG);
2588 num_events += 3;
2589 break;
2590 case 0x400:
2591 SETMIDIEVENT(evm[0], 0,ME_NRPN_MSB, dp, 0x1C, SYSEX_TAG);
2592 SETMIDIEVENT(evm[1], 0,ME_NRPN_LSB, dp, val[6], SYSEX_TAG);
2593 SETMIDIEVENT(evm[2], 0,ME_DATA_ENTRY_MSB, dp, val[7], SYSEX_TAG);
2594 num_events += 3;
2595 break;
2596 case 0x500:
2597 SETMIDIEVENT(evm[0], 0, ME_NRPN_MSB, dp, 0x1D, SYSEX_TAG);
2598 SETMIDIEVENT(evm[1], 0, ME_NRPN_LSB, dp, val[6], SYSEX_TAG);
2599 SETMIDIEVENT(evm[2], 0, ME_DATA_ENTRY_MSB, dp, val[7], SYSEX_TAG);
2600 num_events += 3;
2601 break;
2602 case 0x600:
2603 SETMIDIEVENT(evm[0], 0, ME_NRPN_MSB, dp, 0x1E, SYSEX_TAG);
2604 SETMIDIEVENT(evm[1], 0, ME_NRPN_LSB, dp, val[6], SYSEX_TAG);
2605 SETMIDIEVENT(evm[2], 0, ME_DATA_ENTRY_MSB, dp, val[7], SYSEX_TAG);
2606 num_events += 3;
2607 break;
2608 case 0x700: /* Rx. Note Off */
2609 SETMIDIEVENT(evm[0], 0, ME_SYSEX_MSB, dp, val[6], 0);
2610 SETMIDIEVENT(evm[1], 0, ME_SYSEX_LSB, dp, val[7], 0x46);
2611 num_events += 2;
2612 break;
2613 case 0x800: /* Rx. Note On */
2614 SETMIDIEVENT(evm[0], 0, ME_SYSEX_MSB, dp, val[6], 0);
2615 SETMIDIEVENT(evm[1], 0, ME_SYSEX_LSB, dp, val[7], 0x47);
2616 num_events += 2;
2617 break;
2618 case 0x900:
2619 SETMIDIEVENT(evm[0], 0, ME_NRPN_MSB, dp, 0x1F, SYSEX_TAG);
2620 SETMIDIEVENT(evm[1], 0, ME_NRPN_LSB, dp, val[6], SYSEX_TAG);
2621 SETMIDIEVENT(evm[2], 0, ME_DATA_ENTRY_MSB, dp, val[7], SYSEX_TAG);
2622 num_events += 3;
2623 break;
2624 default:
2625 ctl->cmsg(CMSG_INFO,VERB_NOISY,"Unsupported GS SysEx. (ADDR:%02X %02X %02X VAL:%02X %02X)",addr_h,addr_m,addr_l,val[7],val[8]);
2626 break;
2627 }
2628 break;
2629 #if 0
2630 case 0x20: /* User Instrument */
2631 switch(addr & 0xF00) {
2632 case 0x000: /* Source Map */
2633 get_userinst(64 + udn, val[6])->source_map = val[7];
2634 break;
2635 case 0x100: /* Source Bank */
2636 get_userinst(64 + udn, val[6])->source_bank = val[7];
2637 break;
2638 #if !defined(TIMIDITY_TOOLS)
2639 case 0x200: /* Source Prog */
2640 get_userinst(64 + udn, val[6])->source_prog = val[7];
2641 break;
2642 #endif
2643 default:
2644 ctl->cmsg(CMSG_INFO,VERB_NOISY,"Unsupported GS SysEx. (ADDR:%02X %02X %02X VAL:%02X %02X)",addr_h,addr_m,addr_l,val[7],val[8]);
2645 break;
2646 }
2647 break;
2648 #endif
2649 case 0x21: /* User Drumset */
2650 switch(addr & 0xF00) {
2651 case 0x100: /* Play Note */
2652 get_userdrum(64 + udn, val[6])->play_note = val[7];
2653 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_MSB, dp, val[6], 0);
2654 SETMIDIEVENT(evm[1], 0, ME_SYSEX_GS_LSB, dp, val[7], 0x47);
2655 num_events += 2;
2656 break;
2657 case 0x200: /* Level */
2658 get_userdrum(64 + udn, val[6])->level = val[7];
2659 SETMIDIEVENT(evm[0], 0, ME_NRPN_MSB, dp, 0x1A, SYSEX_TAG);
2660 SETMIDIEVENT(evm[1], 0, ME_NRPN_LSB, dp, val[6], SYSEX_TAG);
2661 SETMIDIEVENT(evm[2], 0, ME_DATA_ENTRY_MSB, dp, val[7], SYSEX_TAG);
2662 num_events += 3;
2663 break;
2664 case 0x300: /* Assign Group */
2665 get_userdrum(64 + udn, val[6])->assign_group = val[7];
2666 if(val[7] != 0) {recompute_userdrum_altassign(udn + 64, val[7]);}
2667 break;
2668 case 0x400: /* Panpot */
2669 get_userdrum(64 + udn, val[6])->pan = val[7];
2670 SETMIDIEVENT(evm[0], 0, ME_NRPN_MSB, dp, 0x1C, SYSEX_TAG);
2671 SETMIDIEVENT(evm[1], 0, ME_NRPN_LSB, dp, val[6], SYSEX_TAG);
2672 SETMIDIEVENT(evm[2], 0, ME_DATA_ENTRY_MSB, dp, val[7], SYSEX_TAG);
2673 num_events += 3;
2674 break;
2675 case 0x500: /* Reverb Send Level */
2676 get_userdrum(64 + udn, val[6])->reverb_send_level = val[7];
2677 SETMIDIEVENT(evm[0], 0, ME_NRPN_MSB, dp, 0x1D, SYSEX_TAG);
2678 SETMIDIEVENT(evm[1], 0, ME_NRPN_LSB, dp, val[6], SYSEX_TAG);
2679 SETMIDIEVENT(evm[2], 0, ME_DATA_ENTRY_MSB, dp, val[7], SYSEX_TAG);
2680 num_events += 3;
2681 break;
2682 case 0x600: /* Chorus Send Level */
2683 get_userdrum(64 + udn, val[6])->chorus_send_level = val[7];
2684 SETMIDIEVENT(evm[0], 0, ME_NRPN_MSB, dp, 0x1E, SYSEX_TAG);
2685 SETMIDIEVENT(evm[1], 0, ME_NRPN_LSB, dp, val[6], SYSEX_TAG);
2686 SETMIDIEVENT(evm[2], 0, ME_DATA_ENTRY_MSB, dp, val[7], SYSEX_TAG);
2687 num_events += 3;
2688 break;
2689 case 0x700: /* Rx. Note Off */
2690 get_userdrum(64 + udn, val[6])->rx_note_off = val[7];
2691 SETMIDIEVENT(evm[0], 0, ME_SYSEX_MSB, dp, val[6], 0);
2692 SETMIDIEVENT(evm[1], 0, ME_SYSEX_LSB, dp, val[7], 0x46);
2693 num_events += 2;
2694 break;
2695 case 0x800: /* Rx. Note On */
2696 get_userdrum(64 + udn, val[6])->rx_note_on = val[7];
2697 SETMIDIEVENT(evm[0], 0, ME_SYSEX_MSB, dp, val[6], 0);
2698 SETMIDIEVENT(evm[1], 0, ME_SYSEX_LSB, dp, val[7], 0x47);
2699 num_events += 2;
2700 break;
2701 case 0x900: /* Delay Send Level */
2702 get_userdrum(64 + udn, val[6])->delay_send_level = val[7];
2703 SETMIDIEVENT(evm[0], 0, ME_NRPN_MSB, dp, 0x1F, SYSEX_TAG);
2704 SETMIDIEVENT(evm[1], 0, ME_NRPN_LSB, dp, val[6], SYSEX_TAG);
2705 SETMIDIEVENT(evm[2], 0, ME_DATA_ENTRY_MSB, dp, val[7], SYSEX_TAG);
2706 num_events += 3;
2707 break;
2708 case 0xA00: /* Source Map */
2709 get_userdrum(64 + udn, val[6])->source_map = val[7];
2710 break;
2711 case 0xB00: /* Source Prog */
2712 get_userdrum(64 + udn, val[6])->source_prog = val[7];
2713 break;
2714 #if !defined(TIMIDITY_TOOLS)
2715 case 0xC00: /* Source Note */
2716 get_userdrum(64 + udn, val[6])->source_note = val[7];
2717 break;
2718 #endif
2719 default:
2720 ctl->cmsg(CMSG_INFO,VERB_NOISY,"Unsupported GS SysEx. (ADDR:%02X %02X %02X VAL:%02X %02X)",addr_h,addr_m,addr_l,val[7],val[8]);
2721 break;
2722 }
2723 break;
2724 case 0x00: /* System */
2725 switch (addr & 0xfff0) {
2726 case 0x0100: /* Channel Msg Rx Port (A) */
2727 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB,
2728 block_to_part(addr & 0xf, 0), val[7], 0x46);
2729 num_events++;
2730 break;
2731 case 0x0110: /* Channel Msg Rx Port (B) */
2732 SETMIDIEVENT(evm[0], 0, ME_SYSEX_GS_LSB,
2733 block_to_part(addr & 0xf, 1), val[7], 0x46);
2734 num_events++;
2735 break;
2736 default:
2737 /* ctl->cmsg(CMSG_INFO,VERB_NOISY, "Unsupported GS SysEx. "
2738 "(ADDR:%02X %02X %02X VAL:%02X %02X)",
2739 addr_h, addr_m, addr_l, val[7], val[8]);*/
2740 break;
2741 }
2742 break;
2743 }
2744 }
2745
2746 /* Non-RealTime / RealTime Universal SysEx messages
2747 * 0 0x7e(Non-RealTime) / 0x7f(RealTime)
2748 * 1 SysEx device ID. Could be from 0x00 to 0x7f.
2749 * 0x7f means disregard device.
2750 * 2 Sub ID
2751 * ...
2752 * E 0xf7
2753 */
2754 else if (len > 4 && val[0] >= 0x7e)
2755 switch (val[2]) {
2756 case 0x01: /* Sample Dump header */
2757 case 0x02: /* Sample Dump packet */
2758 case 0x03: /* Dump Request */
2759 case 0x04: /* Device Control */
2760 if (val[3] == 0x05) { /* Global Parameter Control */
2761 if (val[7] == 0x01 && val[8] == 0x01) { /* Reverb */
2762 for (i = 9; i < len && val[i] != 0xf7; i+= 2) {
2763 switch(val[i]) {
2764 case 0x00: /* Reverb Type */
2765 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, 0, val[i + 1], 0x60);
2766 num_events++;
2767 break;
2768 case 0x01: /* Reverb Time */
2769 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_GS_LSB, 0, val[i + 1], 0x09);
2770 num_events++;
2771 break;
2772 }
2773 }
2774 } else if (val[7] == 0x01 && val[8] == 0x02) { /* Chorus */
2775 for (i = 9; i < len && val[i] != 0xf7; i+= 2) {
2776 switch(val[i]) {
2777 case 0x00: /* Chorus Type */
2778 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, 0, val[i + 1], 0x61);
2779 num_events++;
2780 break;
2781 case 0x01: /* Modulation Rate */
2782 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_GS_LSB, 0, val[i + 1], 0x12);
2783 num_events++;
2784 break;
2785 case 0x02: /* Modulation Depth */
2786 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_GS_LSB, 0, val[i + 1], 0x13);
2787 num_events++;
2788 break;
2789 case 0x03: /* Feedback */
2790 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_GS_LSB, 0, val[i + 1], 0x10);
2791 num_events++;
2792 break;
2793 case 0x04: /* Send To Reverb */
2794 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_GS_LSB, 0, val[i + 1], 0x14);
2795 num_events++;
2796 break;
2797 }
2798 }
2799 }
2800 }
2801 break;
2802 case 0x05: /* Sample Dump extensions */
2803 case 0x06: /* Inquiry Message */
2804 case 0x07: /* File Dump */
2805 break;
2806 case 0x08: /* MIDI Tuning Standard */
2807 switch (val[3]) {
2808 case 0x01:
2809 SETMIDIEVENT(evm[0], 0, ME_BULK_TUNING_DUMP, 0, val[4], 0);
2810 for (i = 0; i < 128; i++) {
2811 SETMIDIEVENT(evm[i * 2 + 1], 0, ME_BULK_TUNING_DUMP,
2812 1, i, val[i * 3 + 21]);
2813 SETMIDIEVENT(evm[i * 2 + 2], 0, ME_BULK_TUNING_DUMP,
2814 2, val[i * 3 + 22], val[i * 3 + 23]);
2815 }
2816 num_events += 257;
2817 break;
2818 case 0x02:
2819 SETMIDIEVENT(evm[0], 0, ME_SINGLE_NOTE_TUNING,
2820 0, val[4], 0);
2821 for (i = 0; i < val[5]; i++) {
2822 SETMIDIEVENT(evm[i * 2 + 1], 0, ME_SINGLE_NOTE_TUNING,
2823 1, val[i * 4 + 6], val[i * 4 + 7]);
2824 SETMIDIEVENT(evm[i * 2 + 2], 0, ME_SINGLE_NOTE_TUNING,
2825 2, val[i * 4 + 8], val[i * 4 + 9]);
2826 }
2827 num_events += val[5] * 2 + 1;
2828 break;
2829 case 0x0b:
2830 channel_tt = ((val[4] & 0x03) << 14 | val[5] << 7 | val[6])
2831 << ((val[4] >> 2) * 16);
2832 if (val[1] == 0x7f) {
2833 SETMIDIEVENT(evm[0], 0, ME_MASTER_TEMPER_TYPE,
2834 0, val[7], (val[0] == 0x7f));
2835 num_events++;
2836 } else {
2837 for (i = j = 0; i < 32; i++)
2838 if (channel_tt & 1 << i) {
2839 SETMIDIEVENT(evm[j], 0, ME_TEMPER_TYPE,
2840 MERGE_CHANNEL_PORT(i),
2841 val[7], (val[0] == 0x7f));
2842 j++;
2843 }
2844 num_events += j;
2845 }
2846 break;
2847 case 0x0c:
2848 SETMIDIEVENT(evm[0], 0, ME_USER_TEMPER_ENTRY,
2849 0, val[4], val[21]);
2850 for (i = 0; i < val[21]; i++) {
2851 SETMIDIEVENT(evm[i * 5 + 1], 0, ME_USER_TEMPER_ENTRY,
2852 1, val[i * 10 + 22], val[i * 10 + 23]);
2853 SETMIDIEVENT(evm[i * 5 + 2], 0, ME_USER_TEMPER_ENTRY,
2854 2, val[i * 10 + 24], val[i * 10 + 25]);
2855 SETMIDIEVENT(evm[i * 5 + 3], 0, ME_USER_TEMPER_ENTRY,
2856 3, val[i * 10 + 26], val[i * 10 + 27]);
2857 SETMIDIEVENT(evm[i * 5 + 4], 0, ME_USER_TEMPER_ENTRY,
2858 4, val[i * 10 + 28], val[i * 10 + 29]);
2859 SETMIDIEVENT(evm[i * 5 + 5], 0, ME_USER_TEMPER_ENTRY,
2860 5, val[i * 10 + 30], val[i * 10 + 31]);
2861 }
2862 num_events += val[21] * 5 + 1;
2863 break;
2864 }
2865 break;
2866 case 0x09: /* General MIDI Message */
2867 switch(val[3]) {
2868 case 0x01: /* Channel Pressure */
2869 for (i = 5; i < len && val[i] != 0xf7; i+= 2) {
2870 switch(val[i]) {
2871 case 0x00: /* Pitch Control */
2872 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, val[4], val[i + 1], 0x00);
2873 num_events++;
2874 break;
2875 case 0x01: /* Filter Cutoff Control */
2876 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, val[4], val[i + 1], 0x01);
2877 num_events++;
2878 break;
2879 case 0x02: /* Amplitude Control */
2880 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, val[4], val[i + 1], 0x02);
2881 num_events++;
2882 break;
2883 case 0x03: /* LFO Pitch Depth */
2884 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, val[4], val[i + 1], 0x04);
2885 num_events++;
2886 break;
2887 case 0x04: /* LFO Filter Depth */
2888 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, val[4], val[i + 1], 0x05);
2889 num_events++;
2890 break;
2891 case 0x05: /* LFO Amplitude Depth */
2892 SETMIDIEVENT(evm[num_events], 0, ME_SYSEX_LSB, val[4], val[i + 1], 0x06);
2893 num_events++;
2894 break;
2895 }
2896 }
2897 break;
2898 }
2899 break;
2900 case 0x7b: /* End of File */
2901 case 0x7c: /* Handshaking Message: Wait */
2902 case 0x7d: /* Handshaking Message: Cancel */
2903 case 0x7e: /* Handshaking Message: NAK */
2904 case 0x7f: /* Handshaking Message: ACK */
2905 break;
2906 }
2907
2908 return(num_events);
2909 }
2910
parse_sysex_event(uint8 * val,int32 len,MidiEvent * ev)2911 int parse_sysex_event(uint8 *val, int32 len, MidiEvent *ev)
2912 {
2913 uint16 vol;
2914
2915 if(current_file_info->mid == 0 || current_file_info->mid >= 0x7e)
2916 current_file_info->mid = val[0];
2917
2918 if(len >= 10 &&
2919 val[0] == 0x41 && /* Roland ID */
2920 val[1] == 0x10 && /* Device ID */
2921 val[2] == 0x42 && /* GS Model ID */
2922 val[3] == 0x12) /* Data Set Command */
2923 {
2924 /* Roland GS-Based Synthesizers.
2925 * val[4..6] is address, val[7..len-2] is body.
2926 *
2927 * GS Channel part number
2928 * 0 10
2929 * 1-9 1-9
2930 * 10-15 11-16
2931 */
2932
2933 int32 addr,checksum,i; /* SysEx address */
2934 uint8 *body; /* SysEx body */
2935 uint8 p,gslen; /* Channel part number [0..15] */
2936
2937 /* check Checksum */
2938 checksum = 0;
2939 for(gslen = 9; gslen < len; gslen++)
2940 if(val[gslen] == 0xF7)
2941 break;
2942 for(i=4;i<gslen-1;i++) {
2943 checksum += val[i];
2944 }
2945 if(((128 - (checksum & 0x7F)) & 0x7F) != val[gslen-1]) {
2946 return 0;
2947 }
2948
2949 addr = (((int32)val[4])<<16 |
2950 ((int32)val[5])<<8 |
2951 (int32)val[6]);
2952 body = val + 7;
2953 p = (uint8)((addr >> 8) & 0xF);
2954 if(p == 0)
2955 p = 9;
2956 else if(p <= 9)
2957 p--;
2958 p = MERGE_CHANNEL_PORT(p);
2959
2960 if(val[4] == 0x50) { /* for double module mode */
2961 p += 16;
2962 addr = (((int32)0x40)<<16 |
2963 ((int32)val[5])<<8 |
2964 (int32)val[6]);
2965 } else { /* single module mode */
2966 addr = (((int32)val[4])<<16 |
2967 ((int32)val[5])<<8 |
2968 (int32)val[6]);
2969 }
2970
2971 if((addr & 0xFFF0FF) == 0x401015) /* Rhythm Parts */
2972 {
2973 #ifdef GS_DRUMPART
2974 /* GS drum part check from Masaaki Koyanagi's patch (GS_Drum_Part_Check()) */
2975 /* Modified by Masanao Izumo */
2976 SETMIDIEVENT(*ev, 0, ME_DRUMPART, p, *body, SYSEX_TAG);
2977 return 1;
2978 #else
2979 return 0;
2980 #endif /* GS_DRUMPART */
2981 }
2982
2983 if((addr & 0xFFF0FF) == 0x401016) /* Key Shift */
2984 {
2985 SETMIDIEVENT(*ev, 0, ME_KEYSHIFT, p, *body, SYSEX_TAG);
2986 return 1;
2987 }
2988
2989 if(addr == 0x400000) /* Master Tune, not for SMF */
2990 {
2991 uint16 tune = ((body[1] & 0xF) << 8) | ((body[2] & 0xF) << 4) | (body[3] & 0xF);
2992
2993 if (tune < 0x18)
2994 tune = 0x18;
2995 else if (tune > 0x7E8)
2996 tune = 0x7E8;
2997 SETMIDIEVENT(*ev, 0, ME_MASTER_TUNING, 0, tune & 0xFF, (tune >> 8) & 0x7F);
2998 return 1;
2999 }
3000
3001 if(addr == 0x400004) /* Master Volume */
3002 {
3003 vol = gs_convert_master_vol(*body);
3004 SETMIDIEVENT(*ev, 0, ME_MASTER_VOLUME,
3005 0, vol & 0xFF, (vol >> 8) & 0xFF);
3006 return 1;
3007 }
3008
3009 if((addr & 0xFFF0FF) == 0x401019) /* Volume on/off */
3010 {
3011 #if 0
3012 SETMIDIEVENT(*ev, 0, ME_VOLUME_ONOFF, p, *body >= 64, SYSEX_TAG);
3013 #endif
3014 return 0;
3015 }
3016
3017 if((addr & 0xFFF0FF) == 0x401002) /* Receive channel on/off */
3018 {
3019 #if 0
3020 SETMIDIEVENT(*ev, 0, ME_RECEIVE_CHANNEL, (uint8)p, *body >= 64, SYSEX_TAG);
3021 #endif
3022 return 0;
3023 }
3024
3025 if(0x402000 <= addr && addr <= 0x402F5A) /* Controller Routing */
3026 return 0;
3027
3028 if((addr & 0xFFF0FF) == 0x401040) /* Alternate Scale Tunings */
3029 return 0;
3030
3031 if((addr & 0xFFFFF0) == 0x400130) /* Changing Effects */
3032 {
3033 struct chorus_text_gs_t *chorus_text = &(chorus_status_gs.text);
3034 switch(addr & 0xF)
3035 {
3036 case 0x8: /* macro */
3037 memcpy(chorus_text->macro, body, 3);
3038 break;
3039 case 0x9: /* PRE-LPF */
3040 memcpy(chorus_text->pre_lpf, body, 3);
3041 break;
3042 case 0xa: /* level */
3043 memcpy(chorus_text->level, body, 3);
3044 break;
3045 case 0xb: /* feed back */
3046 memcpy(chorus_text->feed_back, body, 3);
3047 break;
3048 case 0xc: /* delay */
3049 memcpy(chorus_text->delay, body, 3);
3050 break;
3051 case 0xd: /* rate */
3052 memcpy(chorus_text->rate, body, 3);
3053 break;
3054 case 0xe: /* depth */
3055 memcpy(chorus_text->depth, body, 3);
3056 break;
3057 case 0xf: /* send level */
3058 memcpy(chorus_text->send_level, body, 3);
3059 break;
3060 default: break;
3061 }
3062
3063 check_chorus_text_start();
3064 return 0;
3065 }
3066
3067 if((addr & 0xFFF0FF) == 0x401003) /* Rx Pitch-Bend */
3068 return 0;
3069
3070 if(addr == 0x400110) /* Voice Reserve */
3071 {
3072 if(len >= 25)
3073 memcpy(chorus_status_gs.text.voice_reserve, body, 18);
3074 check_chorus_text_start();
3075 return 0;
3076 }
3077
3078 if(addr == 0x40007F || /* GS Reset */
3079 addr == 0x00007F) /* SC-88 Single Module */
3080 {
3081 SETMIDIEVENT(*ev, 0, ME_RESET, 0, GS_SYSTEM_MODE, SYSEX_TAG);
3082 return 1;
3083 }
3084 return 0;
3085 }
3086
3087 if(len > 9 &&
3088 val[0] == 0x41 && /* Roland ID */
3089 val[1] == 0x10 && /* Device ID */
3090 val[2] == 0x45 &&
3091 val[3] == 0x12 &&
3092 val[4] == 0x10 &&
3093 val[5] == 0x00 &&
3094 val[6] == 0x00)
3095 {
3096 /* Text Insert for SC */
3097 uint8 save;
3098
3099 len -= 2;
3100 save = val[len];
3101 val[len] = '\0';
3102 if(readmidi_make_string_event(ME_INSERT_TEXT, (char *)val + 7, ev, 1))
3103 {
3104 val[len] = save;
3105 return 1;
3106 }
3107 val[len] = save;
3108 return 0;
3109 }
3110
3111 if(len > 9 && /* GS lcd event. by T.Nogami*/
3112 val[0] == 0x41 && /* Roland ID */
3113 val[1] == 0x10 && /* Device ID */
3114 val[2] == 0x45 &&
3115 val[3] == 0x12 &&
3116 val[4] == 0x10 &&
3117 val[5] == 0x01 &&
3118 val[6] == 0x00)
3119 {
3120 /* Text Insert for SC */
3121 uint8 save;
3122
3123 len -= 2;
3124 save = val[len];
3125 val[len] = '\0';
3126 if(readmidi_make_lcd_event(ME_GSLCD, (uint8 *)val + 7, ev))
3127 {
3128 val[len] = save;
3129 return 1;
3130 }
3131 val[len] = save;
3132 return 0;
3133 }
3134
3135 /* val[1] can have values other than 0x10 for the XG ON event, which
3136 * work on real XG hardware. I have several midi that use 0x1f instead
3137 * of 0x10. playmidi.h lists 0x10 - 0x13 as MU50/80/90/100. I don't
3138 * know what real world Device Number 0x1f would correspond to, but the
3139 * XG spec says the entire 0x1n range is valid, and 0x1f works on real
3140 * hardware, so I have modified the check below to accept the entire
3141 * 0x1n range.
3142 *
3143 * I think there are/were some hacks somewhere in playmidi.c (?) to work
3144 * around non- 0x10 values, but this fixes the root of the problem, which
3145 * allows the server mode to handle XG initialization properly as well.
3146 */
3147 if(len >= 8 &&
3148 val[0] == 0x43 &&
3149 (val[1] >= 0x10 && val[1] <= 0x1f) &&
3150 val[2] == 0x4C)
3151 {
3152 int addr = (val[3] << 16) | (val[4] << 8) | val[5];
3153
3154 if (addr == 0x00007E) /* XG SYSTEM ON */
3155 {
3156 SETMIDIEVENT(*ev, 0, ME_RESET, 0, XG_SYSTEM_MODE, SYSEX_TAG);
3157 return 1;
3158 }
3159 else if (addr == 0x000000 && len >= 12) /* XG Master Tune */
3160 {
3161 uint16 tune = ((val[7] & 0xF) << 8) | ((val[8] & 0xF) << 4) | (val[9] & 0xF);
3162
3163 if (tune > 0x7FF)
3164 tune = 0x7FF;
3165 SETMIDIEVENT(*ev, 0, ME_MASTER_TUNING, 0, tune & 0xFF, (tune >> 8) & 0x7F);
3166 return 1;
3167 }
3168 }
3169
3170 if (len >= 7 && val[0] == 0x7F && val[1] == 0x7F)
3171 {
3172 if (val[2] == 0x04 && val[3] == 0x03) /* GM2 Master Fine Tune */
3173 {
3174 uint16 tune = (val[4] & 0x7F) | (val[5] << 7) | 0x4000;
3175
3176 SETMIDIEVENT(*ev, 0, ME_MASTER_TUNING, 0, tune & 0xFF, (tune >> 8) & 0x7F);
3177 return 1;
3178 }
3179 if (val[2] == 0x04 && val[3] == 0x04) /* GM2 Master Coarse Tune */
3180 {
3181 uint8 tune = val[5];
3182
3183 if (tune < 0x28)
3184 tune = 0x28;
3185 else if (tune > 0x58)
3186 tune = 0x58;
3187 SETMIDIEVENT(*ev, 0, ME_MASTER_TUNING, 0, tune, 0x80);
3188 return 1;
3189 }
3190 }
3191
3192 /* Non-RealTime / RealTime Universal SysEx messages
3193 * 0 0x7e(Non-RealTime) / 0x7f(RealTime)
3194 * 1 SysEx device ID. Could be from 0x00 to 0x7f.
3195 * 0x7f means disregard device.
3196 * 2 Sub ID
3197 * ...
3198 * E 0xf7
3199 */
3200 if (len > 4 && val[0] >= 0x7e)
3201 switch (val[2]) {
3202 case 0x01: /* Sample Dump header */
3203 case 0x02: /* Sample Dump packet */
3204 case 0x03: /* Dump Request */
3205 break;
3206 case 0x04: /* MIDI Time Code Setup/Device Control */
3207 switch (val[3]) {
3208 case 0x01: /* Master Volume */
3209 vol = gm_convert_master_vol(val[4], val[5]);
3210 if (val[1] == 0x7f) {
3211 SETMIDIEVENT(*ev, 0, ME_MASTER_VOLUME, 0,
3212 vol & 0xff, vol >> 8 & 0xff);
3213 } else {
3214 SETMIDIEVENT(*ev, 0, ME_MAINVOLUME,
3215 MERGE_CHANNEL_PORT(val[1]),
3216 vol >> 8 & 0xff, 0);
3217 }
3218 return 1;
3219 }
3220 break;
3221 case 0x05: /* Sample Dump extensions */
3222 case 0x06: /* Inquiry Message */
3223 case 0x07: /* File Dump */
3224 break;
3225 case 0x08: /* MIDI Tuning Standard */
3226 switch (val[3]) {
3227 case 0x0a:
3228 SETMIDIEVENT(*ev, 0, ME_TEMPER_KEYSIG, 0,
3229 val[4] - 0x40 + val[5] * 16, (val[0] == 0x7f));
3230 return 1;
3231 }
3232 break;
3233 case 0x09: /* General MIDI Message */
3234 /* GM System Enable/Disable */
3235 if(val[3] == 1) {
3236 ctl->cmsg(CMSG_INFO, VERB_DEBUG, "SysEx: GM System On");
3237 SETMIDIEVENT(*ev, 0, ME_RESET, 0, GM_SYSTEM_MODE, 0);
3238 } else if(val[3] == 3) {
3239 ctl->cmsg(CMSG_INFO, VERB_DEBUG, "SysEx: GM2 System On");
3240 SETMIDIEVENT(*ev, 0, ME_RESET, 0, GM2_SYSTEM_MODE, 0);
3241 } else {
3242 ctl->cmsg(CMSG_INFO, VERB_DEBUG, "SysEx: GM System Off");
3243 SETMIDIEVENT(*ev, 0, ME_RESET, 0, DEFAULT_SYSTEM_MODE, 0);
3244 }
3245 return 1;
3246 case 0x7b: /* End of File */
3247 case 0x7c: /* Handshaking Message: Wait */
3248 case 0x7d: /* Handshaking Message: Cancel */
3249 case 0x7e: /* Handshaking Message: NAK */
3250 case 0x7f: /* Handshaking Message: ACK */
3251 break;
3252 }
3253
3254 return 0;
3255 }
3256
read_sysex_event(int32 at,int me,int32 len,struct timidity_file * tf)3257 static int read_sysex_event(int32 at, int me, int32 len,
3258 struct timidity_file *tf)
3259 {
3260 uint8 *val;
3261 MidiEvent ev, evm[260]; /* maximum number of XG bulk dump events */
3262 int ne, i;
3263
3264 if(len == 0)
3265 return 0;
3266 if(me != 0xF0)
3267 {
3268 skip(tf, len);
3269 return 0;
3270 }
3271
3272 val = (uint8 *)new_segment(&tmpbuffer, len);
3273 if(tf_read(val, 1, len, tf) != len)
3274 {
3275 reuse_mblock(&tmpbuffer);
3276 return -1;
3277 }
3278 if(parse_sysex_event(val, len, &ev))
3279 {
3280 ev.time = at;
3281 readmidi_add_event(&ev);
3282 }
3283 if ((ne = parse_sysex_event_multi(val, len, evm)))
3284 {
3285 for (i = 0; i < ne; i++) {
3286 evm[i].time = at;
3287 readmidi_add_event(&evm[i]);
3288 }
3289 }
3290
3291 reuse_mblock(&tmpbuffer);
3292
3293 return 0;
3294 }
3295
fix_string(char * s)3296 static char *fix_string(char *s)
3297 {
3298 int i, j, w;
3299 char c;
3300
3301 if(s == NULL)
3302 return NULL;
3303 while(*s == ' ' || *s == '\t' || *s == '\r' || *s == '\n')
3304 s++;
3305
3306 /* s =~ tr/ \t\r\n/ /s; */
3307 w = 0;
3308 for(i = j = 0; (c = s[i]) != '\0'; i++)
3309 {
3310 if(c == '\t' || c == '\r' || c == '\n')
3311 c = ' ';
3312 if(w)
3313 w = (c == ' ');
3314 if(!w)
3315 {
3316 s[j++] = c;
3317 w = (c == ' ');
3318 }
3319 }
3320
3321 /* s =~ s/ $//; */
3322 if(j > 0 && s[j - 1] == ' ')
3323 j--;
3324
3325 s[j] = '\0';
3326 return s;
3327 }
3328
smf_time_signature(int32 at,struct timidity_file * tf,int len)3329 static void smf_time_signature(int32 at, struct timidity_file *tf, int len)
3330 {
3331 int n, d, c, b;
3332
3333 /* Time Signature (nn dd cc bb)
3334 * [0]: numerator
3335 * [1]: denominator
3336 * [2]: number of MIDI clocks in a metronome click
3337 * [3]: number of notated 32nd-notes in a MIDI
3338 * quarter-note (24 MIDI Clocks).
3339 */
3340
3341 if(len != 4)
3342 {
3343 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE, "Invalid time signature");
3344 skip(tf, len);
3345 return;
3346 }
3347
3348 n = tf_getc(tf);
3349 d = (1<<tf_getc(tf));
3350 c = tf_getc(tf);
3351 b = tf_getc(tf);
3352
3353 if(n == 0 || (uint8) d == 0)
3354 {
3355 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE, "Invalid time signature");
3356 return;
3357 }
3358
3359 MIDIEVENT(at, ME_TIMESIG, 0, n, d);
3360 MIDIEVENT(at, ME_TIMESIG, 1, c, b);
3361 ctl->cmsg(CMSG_INFO, VERB_NOISY,
3362 "Time signature: %d/%d %d clock %d q.n.", n, d, c, b);
3363 if(current_file_info->time_sig_n == -1)
3364 {
3365 current_file_info->time_sig_n = n;
3366 current_file_info->time_sig_d = d;
3367 current_file_info->time_sig_c = c;
3368 current_file_info->time_sig_b = b;
3369 }
3370 }
3371
smf_key_signature(int32 at,struct timidity_file * tf,int len)3372 static void smf_key_signature(int32 at, struct timidity_file *tf, int len)
3373 {
3374 int8 sf, mi;
3375 /* Key Signature (sf mi)
3376 * sf = -7: 7 flats
3377 * sf = -1: 1 flat
3378 * sf = 0: key of C
3379 * sf = 1: 1 sharp
3380 * sf = 7: 7 sharps
3381 * mi = 0: major key
3382 * mi = 1: minor key
3383 */
3384
3385 if (len != 2) {
3386 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE, "Invalid key signature");
3387 skip(tf, len);
3388 return;
3389 }
3390 sf = tf_getc(tf);
3391 mi = tf_getc(tf);
3392 if (sf < -7 || sf > 7) {
3393 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE, "Invalid key signature");
3394 return;
3395 }
3396 if (mi != 0 && mi != 1) {
3397 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE, "Invalid key signature");
3398 return;
3399 }
3400 MIDIEVENT(at, ME_KEYSIG, 0, sf, mi);
3401 ctl->cmsg(CMSG_INFO, VERB_NOISY,
3402 "Key signature: %d %s %s", abs(sf),
3403 (sf < 0) ? "flat(s)" : "sharp(s)", (mi) ? "minor" : "major");
3404 }
3405
3406 /* Used for WRD reader */
dump_current_timesig(MidiEvent * codes,int maxlen)3407 int dump_current_timesig(MidiEvent *codes, int maxlen)
3408 {
3409 int i, n;
3410 MidiEventList *e;
3411
3412 if(maxlen <= 0 || evlist == NULL)
3413 return 0;
3414 n = 0;
3415 for(i = 0, e = evlist; i < event_count; i++, e = e->next)
3416 if(e->event.type == ME_TIMESIG && e->event.channel == 0)
3417 {
3418 if(n == 0 && e->event.time > 0)
3419 {
3420 /* 4/4 is default */
3421 SETMIDIEVENT(codes[0], 0, ME_TIMESIG, 0, 4, 4);
3422 n++;
3423 if(maxlen == 1)
3424 return 1;
3425 }
3426
3427 if(n > 0)
3428 {
3429 if(e->event.a == codes[n - 1].a &&
3430 e->event.b == codes[n - 1].b)
3431 continue; /* Unchanged */
3432 if(e->event.time == codes[n - 1].time)
3433 n--; /* overwrite previous code */
3434 }
3435 codes[n++] = e->event;
3436 if(n == maxlen)
3437 return n;
3438 }
3439 return n;
3440 }
3441
3442 /* Read a SMF track */
read_smf_track(struct timidity_file * tf,int trackno,int rewindp)3443 static int read_smf_track(struct timidity_file *tf, int trackno, int rewindp)
3444 {
3445 int32 len, next_pos, pos;
3446 char tmp[4];
3447 int lastchan, laststatus;
3448 int me, type, a, b, c;
3449 int i;
3450 int32 smf_at_time;
3451 int note_seen = (! opt_preserve_silence);
3452
3453 smf_at_time = readmidi_set_track(trackno, rewindp);
3454
3455 /* Check the formalities */
3456 if((tf_read(tmp, 1, 4, tf) != 4) || (tf_read(&len, 4, 1, tf) != 1))
3457 {
3458 ctl->cmsg(CMSG_ERROR, VERB_NORMAL,
3459 "%s: Can't read track header.", current_filename);
3460 return -1;
3461 }
3462 len = BE_LONG(len);
3463 next_pos = tf_tell(tf) + len;
3464 if(strncmp(tmp, "MTrk", 4))
3465 {
3466 ctl->cmsg(CMSG_ERROR, VERB_NORMAL,
3467 "%s: Corrupt MIDI file.", current_filename);
3468 return -2;
3469 }
3470
3471 lastchan = laststatus = 0;
3472
3473 for(;;)
3474 {
3475 if(readmidi_error_flag)
3476 return -1;
3477 if((len = getvl(tf)) < 0)
3478 return -1;
3479 smf_at_time += len;
3480 errno = 0;
3481 if((i = tf_getc(tf)) == EOF)
3482 {
3483 if(errno)
3484 ctl->cmsg(CMSG_ERROR, VERB_NORMAL,
3485 "%s: read_midi_event: %s",
3486 current_filename, strerror(errno));
3487 else
3488 ctl->cmsg(CMSG_ERROR, VERB_NORMAL,
3489 "Warning: %s: Too shorten midi file.",
3490 current_filename);
3491 return -1;
3492 }
3493
3494 me = (uint8)i;
3495 if(me == 0xF0 || me == 0xF7) /* SysEx event */
3496 {
3497 if((len = getvl(tf)) < 0)
3498 return -1;
3499 if((i = read_sysex_event(smf_at_time, me, len, tf)) != 0)
3500 return i;
3501 }
3502 else if(me == 0xFF) /* Meta event */
3503 {
3504 type = tf_getc(tf);
3505 if((len = getvl(tf)) < 0)
3506 return -1;
3507 if(type > 0 && type < 16)
3508 {
3509 static char *label[] =
3510 {
3511 "Text event: ", "Text: ", "Copyright: ", "Track name: ",
3512 "Instrument: ", "Lyric: ", "Marker: ", "Cue point: "
3513 };
3514
3515 if(type == 5 || /* Lyric */
3516 (type == 1 && (opt_trace_text_meta_event ||
3517 karaoke_format == 2 ||
3518 chorus_status_gs.text.status == CHORUS_ST_OK)) ||
3519 (type == 6 && (current_file_info->format == 0 ||
3520 (current_file_info->format == 1 &&
3521 current_read_track == 0))))
3522 {
3523 char *str, *text;
3524 MidiEvent ev;
3525
3526 str = (char *)new_segment(&tmpbuffer, len + 3);
3527 if(type != 6)
3528 {
3529 i = tf_read(str, 1, len, tf);
3530 str[len] = '\0';
3531 }
3532 else
3533 {
3534 i = tf_read(str + 1, 1, len, tf);
3535 str[0] = MARKER_START_CHAR;
3536 str[len + 1] = MARKER_END_CHAR;
3537 str[len + 2] = '\0';
3538 }
3539
3540 if(i != len)
3541 {
3542 ctl->cmsg(CMSG_ERROR, VERB_NORMAL,
3543 "Warning: %s: Too shorten midi file.",
3544 current_filename);
3545 reuse_mblock(&tmpbuffer);
3546 return -1;
3547 }
3548
3549 if((text = readmidi_make_string_event(1, str, &ev, 1))
3550 == NULL)
3551 {
3552 reuse_mblock(&tmpbuffer);
3553 continue;
3554 }
3555 ev.time = smf_at_time;
3556
3557 if(type == 6)
3558 {
3559 if(strlen(fix_string(text + 1)) == 2)
3560 {
3561 reuse_mblock(&tmpbuffer);
3562 continue; /* Empty Marker */
3563 }
3564 }
3565
3566 switch(type)
3567 {
3568 case 1:
3569 if(karaoke_format == 2)
3570 {
3571 *text = ME_KARAOKE_LYRIC;
3572 if(karaoke_title_flag == 0 &&
3573 strncmp(str, "@T", 2) == 0)
3574 current_file_info->karaoke_title =
3575 add_karaoke_title(current_file_info->
3576 karaoke_title, str + 2);
3577 ev.type = ME_KARAOKE_LYRIC;
3578 readmidi_add_event(&ev);
3579 continue;
3580 }
3581 if(chorus_status_gs.text.status == CHORUS_ST_OK)
3582 {
3583 *text = ME_CHORUS_TEXT;
3584 ev.type = ME_CHORUS_TEXT;
3585 readmidi_add_event(&ev);
3586 continue;
3587 }
3588 *text = ME_TEXT;
3589 ev.type = ME_TEXT;
3590 readmidi_add_event(&ev);
3591 continue;
3592 case 5:
3593 *text = ME_LYRIC;
3594 ev.type = ME_LYRIC;
3595 readmidi_add_event(&ev);
3596 continue;
3597 case 6:
3598 *text = ME_MARKER;
3599 ev.type = ME_MARKER;
3600 readmidi_add_event(&ev);
3601 continue;
3602 }
3603 }
3604
3605 if(type == 3 && /* Sequence or Track Name */
3606 (current_file_info->format == 0 ||
3607 (current_file_info->format == 1 &&
3608 current_read_track == 0)))
3609 {
3610 if(current_file_info->seq_name == NULL) {
3611 char *name = dumpstring(3, len, "Sequence: ", 1, tf);
3612 current_file_info->seq_name = safe_strdup(fix_string(name));
3613 free(name);
3614 }
3615 else
3616 dumpstring(3, len, "Sequence: ", 0, tf);
3617 }
3618 else if(type == 1 &&
3619 current_file_info->first_text == NULL &&
3620 (current_file_info->format == 0 ||
3621 (current_file_info->format == 1 &&
3622 current_read_track == 0))) {
3623 char *name = dumpstring(1, len, "Text: ", 1, tf);
3624 current_file_info->first_text = safe_strdup(fix_string(name));
3625 free(name);
3626 }
3627 else
3628 dumpstring(type, len, label[(type>7) ? 0 : type], 0, tf);
3629 }
3630 else
3631 {
3632 switch(type)
3633 {
3634 case 0x00:
3635 if(len == 2)
3636 {
3637 a = tf_getc(tf);
3638 b = tf_getc(tf);
3639 ctl->cmsg(CMSG_INFO, VERB_DEBUG,
3640 "(Sequence Number %02x %02x)", a, b);
3641 }
3642 else
3643 ctl->cmsg(CMSG_INFO, VERB_DEBUG,
3644 "(Sequence Number len=%d)", len);
3645 break;
3646
3647 case 0x2F: /* End of Track */
3648 pos = tf_tell(tf);
3649 if(pos < next_pos)
3650 tf_seek(tf, next_pos - pos, SEEK_CUR);
3651 return 0;
3652
3653 case 0x51: /* Tempo */
3654 a = tf_getc(tf);
3655 b = tf_getc(tf);
3656 c = tf_getc(tf);
3657 MIDIEVENT(smf_at_time, ME_TEMPO, c, a, b);
3658 break;
3659
3660 case 0x54:
3661 /* SMPTE Offset (hr mn se fr ff)
3662 * hr: hours&type
3663 * 0 1 2 3 4 5 6 7 bits
3664 * 0 |<--type -->|<---- hours [0..23]---->|
3665 * type: 00: 24 frames/second
3666 * 01: 25 frames/second
3667 * 10: 30 frames/second (drop frame)
3668 * 11: 30 frames/second (non-drop frame)
3669 * mn: minis [0..59]
3670 * se: seconds [0..59]
3671 * fr: frames [0..29]
3672 * ff: fractional frames [0..99]
3673 */
3674 ctl->cmsg(CMSG_INFO, VERB_DEBUG,
3675 "(SMPTE Offset meta event)");
3676 skip(tf, len);
3677 break;
3678
3679 case 0x58: /* Time Signature */
3680 smf_time_signature(smf_at_time, tf, len);
3681 break;
3682
3683 case 0x59: /* Key Signature */
3684 smf_key_signature(smf_at_time, tf, len);
3685 break;
3686
3687 case 0x7f: /* Sequencer-Specific Meta-Event */
3688 ctl->cmsg(CMSG_INFO, VERB_DEBUG,
3689 "(Sequencer-Specific meta event, length %ld)",
3690 len);
3691 skip(tf, len);
3692 break;
3693
3694 case 0x20: /* MIDI channel prefix (SMF v1.0) */
3695 if(len == 1)
3696 {
3697 int midi_channel_prefix = tf_getc(tf);
3698 ctl->cmsg(CMSG_INFO, VERB_DEBUG,
3699 "(MIDI channel prefix %d)",
3700 midi_channel_prefix);
3701 }
3702 else
3703 skip(tf, len);
3704 break;
3705
3706 case 0x21: /* MIDI port number */
3707 if(len == 1)
3708 {
3709 if((midi_port_number = tf_getc(tf))
3710 == EOF)
3711 {
3712 ctl->cmsg(CMSG_ERROR, VERB_NORMAL,
3713 "Warning: %s: Too shorten midi file.",
3714 current_filename);
3715 return -1;
3716 }
3717 midi_port_number &= 0xF;
3718 ctl->cmsg(CMSG_INFO, VERB_DEBUG,
3719 "(MIDI port number %d)", midi_port_number);
3720 }
3721 else
3722 skip(tf, len);
3723 break;
3724
3725 default:
3726 ctl->cmsg(CMSG_INFO, VERB_DEBUG,
3727 "(Meta event type 0x%02x, length %ld)",
3728 type, len);
3729 skip(tf, len);
3730 break;
3731 }
3732 }
3733 }
3734 else /* MIDI event */
3735 {
3736 a = me;
3737 if(a & 0x80) /* status byte */
3738 {
3739 lastchan = MERGE_CHANNEL_PORT(a & 0x0F);
3740 laststatus = (a >> 4) & 0x07;
3741 if(laststatus != 7)
3742 a = tf_getc(tf) & 0x7F;
3743 }
3744 switch(laststatus)
3745 {
3746 case 0: /* Note off */
3747 b = tf_getc(tf) & 0x7F;
3748 MIDIEVENT(smf_at_time, ME_NOTEOFF, lastchan, a,b);
3749 break;
3750
3751 case 1: /* Note on */
3752 b = tf_getc(tf) & 0x7F;
3753 if(b)
3754 {
3755 if (! note_seen && smf_at_time > 0)
3756 {
3757 MIDIEVENT(0, ME_NOTEON, lastchan, a, 0);
3758 MIDIEVENT(0, ME_NOTEOFF, lastchan, a, 0);
3759 }
3760 note_seen = 1;
3761 MIDIEVENT(smf_at_time, ME_NOTEON, lastchan, a,b);
3762 }
3763 else /* b == 0 means Note Off */
3764 {
3765 MIDIEVENT(smf_at_time, ME_NOTEOFF, lastchan, a, 0);
3766 }
3767 break;
3768
3769 case 2: /* Key Pressure */
3770 b = tf_getc(tf) & 0x7F;
3771 MIDIEVENT(smf_at_time, ME_KEYPRESSURE, lastchan, a, b);
3772 break;
3773
3774 case 3: /* Control change */
3775 b = tf_getc(tf);
3776 readmidi_add_ctl_event(smf_at_time, lastchan, a, b);
3777 break;
3778
3779 case 4: /* Program change */
3780 MIDIEVENT(smf_at_time, ME_PROGRAM, lastchan, a, 0);
3781 break;
3782
3783 case 5: /* Channel pressure */
3784 MIDIEVENT(smf_at_time, ME_CHANNEL_PRESSURE, lastchan, a, 0);
3785 break;
3786
3787 case 6: /* Pitch wheel */
3788 b = tf_getc(tf) & 0x7F;
3789 MIDIEVENT(smf_at_time, ME_PITCHWHEEL, lastchan, a, b);
3790 break;
3791
3792 default: /* case 7: */
3793 /* Ignore this event */
3794 switch(lastchan & 0xF)
3795 {
3796 case 2: /* Sys Com Song Position Pntr */
3797 ctl->cmsg(CMSG_INFO, VERB_DEBUG,
3798 "(Sys Com Song Position Pntr)");
3799 tf_getc(tf);
3800 tf_getc(tf);
3801 break;
3802
3803 case 3: /* Sys Com Song Select(Song #) */
3804 ctl->cmsg(CMSG_INFO, VERB_DEBUG,
3805 "(Sys Com Song Select(Song #))");
3806 tf_getc(tf);
3807 break;
3808
3809 case 6: /* Sys Com tune request */
3810 ctl->cmsg(CMSG_INFO, VERB_DEBUG,
3811 "(Sys Com tune request)");
3812 break;
3813 case 8: /* Sys real time timing clock */
3814 ctl->cmsg(CMSG_INFO, VERB_DEBUG,
3815 "(Sys real time timing clock)");
3816 break;
3817 case 10: /* Sys real time start */
3818 ctl->cmsg(CMSG_INFO, VERB_DEBUG,
3819 "(Sys real time start)");
3820 break;
3821 case 11: /* Sys real time continue */
3822 ctl->cmsg(CMSG_INFO, VERB_DEBUG,
3823 "(Sys real time continue)");
3824 break;
3825 case 12: /* Sys real time stop */
3826 ctl->cmsg(CMSG_INFO, VERB_DEBUG,
3827 "(Sys real time stop)");
3828 break;
3829 case 14: /* Sys real time active sensing */
3830 ctl->cmsg(CMSG_INFO, VERB_DEBUG,
3831 "(Sys real time active sensing)");
3832 break;
3833 #if 0
3834 case 15: /* Meta */
3835 case 0: /* SysEx */
3836 case 7: /* SysEx */
3837 #endif
3838 default: /* 1, 4, 5, 9, 13 */
3839 ctl->cmsg(CMSG_ERROR, VERB_NORMAL,
3840 "*** Can't happen: status 0x%02X channel 0x%02X",
3841 laststatus, lastchan & 0xF);
3842 break;
3843 }
3844 }
3845 }
3846 }
3847 /*NOTREACHED*/
3848 }
3849
3850 /* Free the linked event list from memory. */
free_midi_list(void)3851 static void free_midi_list(void)
3852 {
3853 if(evlist != NULL)
3854 {
3855 reuse_mblock(&mempool);
3856 evlist = NULL;
3857 }
3858 }
3859
move_channels(int * chidx)3860 static void move_channels(int *chidx)
3861 {
3862 int i, ch, maxch, newch;
3863 MidiEventList *e;
3864
3865 for (i = 0; i < 256; i++)
3866 chidx[i] = -1;
3867 /* check channels */
3868 for (i = maxch = 0, e = evlist; i < event_count; i++, e = e->next)
3869 if (! GLOBAL_CHANNEL_EVENT_TYPE(e->event.type)) {
3870 if ((ch = e->event.channel) < REDUCE_CHANNELS)
3871 chidx[ch] = ch;
3872 if (maxch < ch)
3873 maxch = ch;
3874 }
3875 if (maxch >= REDUCE_CHANNELS)
3876 /* Move channel if enable */
3877 for (i = maxch = 0, e = evlist; i < event_count; i++, e = e->next)
3878 if (! GLOBAL_CHANNEL_EVENT_TYPE(e->event.type)) {
3879 if (chidx[ch = e->event.channel] != -1)
3880 ch = e->event.channel = chidx[ch];
3881 else { /* -1 */
3882 if (ch >= MAX_CHANNELS) {
3883 newch = ch % REDUCE_CHANNELS;
3884 while (newch < ch && newch < MAX_CHANNELS) {
3885 if (chidx[newch] == -1) {
3886 ctl->cmsg(CMSG_INFO, VERB_VERBOSE,
3887 "channel %d => %d", ch, newch);
3888 ch = e->event.channel = chidx[ch] = newch;
3889 break;
3890 }
3891 newch += REDUCE_CHANNELS;
3892 }
3893 }
3894 if (chidx[ch] == -1) {
3895 if (ch < MAX_CHANNELS)
3896 chidx[ch] = ch;
3897 else {
3898 newch = ch % MAX_CHANNELS;
3899 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE,
3900 "channel %d => %d (mixed)", ch, newch);
3901 ch = e->event.channel = chidx[ch] = newch;
3902 }
3903 }
3904 }
3905 if (maxch < ch)
3906 maxch = ch;
3907 }
3908 for (i = 0, e = evlist; i < event_count; i++, e = e->next)
3909 if (e->event.type == ME_SYSEX_GS_LSB) {
3910 if (e->event.b == 0x45 || e->event.b == 0x46)
3911 if (maxch < e->event.channel)
3912 maxch = e->event.channel;
3913 } else if (e->event.type == ME_SYSEX_XG_LSB) {
3914 if (e->event.b == 0x99)
3915 if (maxch < e->event.channel)
3916 maxch = e->event.channel;
3917 }
3918 current_file_info->max_channel = maxch;
3919 }
3920
change_system_mode(int mode)3921 void change_system_mode(int mode)
3922 {
3923 int mid;
3924
3925 if(opt_system_mid)
3926 {
3927 mid = opt_system_mid;
3928 mode = -1; /* Always use opt_system_mid */
3929 }
3930 else
3931 mid = current_file_info->mid;
3932 pan_table = sc_pan_table;
3933 switch(mode)
3934 {
3935 case GM_SYSTEM_MODE:
3936 if(play_system_mode == DEFAULT_SYSTEM_MODE)
3937 {
3938 play_system_mode = GM_SYSTEM_MODE;
3939 vol_table = def_vol_table;
3940 }
3941 break;
3942 case GM2_SYSTEM_MODE:
3943 play_system_mode = GM2_SYSTEM_MODE;
3944 vol_table = def_vol_table;
3945 pan_table = gm2_pan_table;
3946 break;
3947 case GS_SYSTEM_MODE:
3948 play_system_mode = GS_SYSTEM_MODE;
3949 vol_table = gs_vol_table;
3950 break;
3951 case XG_SYSTEM_MODE:
3952 if (play_system_mode != XG_SYSTEM_MODE) {init_all_effect_xg();}
3953 play_system_mode = XG_SYSTEM_MODE;
3954 vol_table = xg_vol_table;
3955 break;
3956 default:
3957 /* --module option */
3958 if (is_gs_module()) {
3959 play_system_mode = GS_SYSTEM_MODE;
3960 break;
3961 } else if (is_xg_module()) {
3962 if (play_system_mode != XG_SYSTEM_MODE) {init_all_effect_xg();}
3963 play_system_mode = XG_SYSTEM_MODE;
3964 break;
3965 }
3966 switch(mid)
3967 {
3968 case 0x41:
3969 play_system_mode = GS_SYSTEM_MODE;
3970 vol_table = gs_vol_table;
3971 break;
3972 case 0x43:
3973 if (play_system_mode != XG_SYSTEM_MODE) {init_all_effect_xg();}
3974 play_system_mode = XG_SYSTEM_MODE;
3975 vol_table = xg_vol_table;
3976 break;
3977 case 0x7e:
3978 play_system_mode = GM_SYSTEM_MODE;
3979 vol_table = def_vol_table;
3980 break;
3981 default:
3982 play_system_mode = DEFAULT_SYSTEM_MODE;
3983 vol_table = def_vol_table;
3984 break;
3985 }
3986 break;
3987 }
3988 }
3989
get_default_mapID(int ch)3990 int get_default_mapID(int ch)
3991 {
3992 if(play_system_mode == XG_SYSTEM_MODE)
3993 return ISDRUMCHANNEL(ch) ? XG_DRUM_MAP : XG_NORMAL_MAP;
3994 return INST_NO_MAP;
3995 }
3996
3997 /* Allocate an array of MidiEvents and fill it from the linked list of
3998 events, marking used instruments for loading. Convert event times to
3999 samples: handle tempo changes. Strip unnecessary events from the list.
4000 Free the linked list. */
groom_list(int32 divisions,int32 * eventsp,int32 * samplesp)4001 static MidiEvent *groom_list(int32 divisions, int32 *eventsp, int32 *samplesp)
4002 {
4003 MidiEvent *groomed_list, *lp;
4004 MidiEventList *meep;
4005 int32 i, j, our_event_count, tempo, skip_this_event;
4006 int32 sample_cum, samples_to_do, at, st, dt, counting_time;
4007 int ch, gch;
4008 uint8 current_set[MAX_CHANNELS],
4009 warn_tonebank[128 + MAP_BANK_COUNT], warn_drumset[128 + MAP_BANK_COUNT];
4010 int8 bank_lsb[MAX_CHANNELS], bank_msb[MAX_CHANNELS], mapID[MAX_CHANNELS];
4011 int current_program[MAX_CHANNELS];
4012 int wrd_args[WRD_MAXPARAM];
4013 int wrd_argc;
4014 int chidx[256];
4015 int newbank, newprog;
4016
4017 move_channels(chidx);
4018
4019 COPY_CHANNELMASK(drumchannels, current_file_info->drumchannels);
4020 COPY_CHANNELMASK(drumchannel_mask, current_file_info->drumchannel_mask);
4021
4022 /* Move drumchannels */
4023 for(ch = REDUCE_CHANNELS; ch < MAX_CHANNELS; ch++)
4024 {
4025 i = chidx[ch];
4026 if(i != -1 && i != ch && !IS_SET_CHANNELMASK(drumchannel_mask, i))
4027 {
4028 if(IS_SET_CHANNELMASK(drumchannels, ch))
4029 SET_CHANNELMASK(drumchannels, i);
4030 else
4031 UNSET_CHANNELMASK(drumchannels, i);
4032 }
4033 }
4034
4035 memset(warn_tonebank, 0, sizeof(warn_tonebank));
4036 if (special_tonebank >= 0)
4037 newbank = special_tonebank;
4038 else
4039 newbank = default_tonebank;
4040 for(j = 0; j < MAX_CHANNELS; j++)
4041 {
4042 if(ISDRUMCHANNEL(j))
4043 current_set[j] = 0;
4044 else
4045 {
4046 if (tonebank[newbank] == NULL)
4047 {
4048 if (warn_tonebank[newbank] == 0)
4049 {
4050 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE,
4051 "Tone bank %d is undefined", newbank);
4052 warn_tonebank[newbank] = 1;
4053 }
4054 newbank = 0;
4055 }
4056 current_set[j] = newbank;
4057 }
4058 bank_lsb[j] = bank_msb[j] = 0;
4059 if(play_system_mode == XG_SYSTEM_MODE && j % 16 == 9)
4060 bank_msb[j] = 127; /* Use MSB=127 for XG */
4061 current_program[j] = default_program[j];
4062 }
4063
4064 memset(warn_drumset, 0, sizeof(warn_drumset));
4065 tempo = 500000;
4066 compute_sample_increment(tempo, divisions);
4067
4068 /* This may allocate a bit more than we need */
4069 groomed_list = lp =
4070 (MidiEvent *)safe_malloc(sizeof(MidiEvent) * (event_count + 1));
4071 meep = evlist;
4072
4073 our_event_count = 0;
4074 st = at = sample_cum = 0;
4075 counting_time = 2; /* We strip any silence before the first NOTE ON. */
4076 wrd_argc = 0;
4077 change_system_mode(DEFAULT_SYSTEM_MODE);
4078
4079 for(j = 0; j < MAX_CHANNELS; j++)
4080 mapID[j] = get_default_mapID(j);
4081
4082 for(i = 0; i < event_count; i++)
4083 {
4084 skip_this_event = 0;
4085 ch = meep->event.channel;
4086 gch = GLOBAL_CHANNEL_EVENT_TYPE(meep->event.type);
4087 if(!gch && ch >= MAX_CHANNELS) /* For safety */
4088 meep->event.channel = ch = ch % MAX_CHANNELS;
4089
4090 if(!gch && IS_SET_CHANNELMASK(quietchannels, ch))
4091 skip_this_event = 1;
4092 else switch(meep->event.type)
4093 {
4094 case ME_NONE:
4095 skip_this_event = 1;
4096 break;
4097 case ME_RESET:
4098 change_system_mode(meep->event.a);
4099 ctl->cmsg(CMSG_INFO, VERB_NOISY, "MIDI reset at %d sec",
4100 (int)((double)st / play_mode->rate + 0.5));
4101 for(j = 0; j < MAX_CHANNELS; j++)
4102 {
4103 if(play_system_mode == XG_SYSTEM_MODE && j % 16 == 9)
4104 mapID[j] = XG_DRUM_MAP;
4105 else
4106 mapID[j] = get_default_mapID(j);
4107 if(ISDRUMCHANNEL(j))
4108 current_set[j] = 0;
4109 else
4110 {
4111 if(special_tonebank >= 0)
4112 current_set[j] = special_tonebank;
4113 else
4114 current_set[j] = default_tonebank;
4115 if(tonebank[current_set[j]] == NULL)
4116 current_set[j] = 0;
4117 }
4118 bank_lsb[j] = bank_msb[j] = 0;
4119 if(play_system_mode == XG_SYSTEM_MODE && j % 16 == 9)
4120 bank_msb[j] = 127; /* Use MSB=127 for XG */
4121 current_program[j] = default_program[j];
4122 }
4123 break;
4124
4125 case ME_PROGRAM:
4126 if (ISDRUMCHANNEL(ch))
4127 newbank = current_program[ch];
4128 else
4129 newbank = current_set[ch];
4130 newprog = meep->event.a;
4131 switch (play_system_mode) {
4132 case GS_SYSTEM_MODE: /* GS */
4133 switch (bank_lsb[ch]) {
4134 case 0: /* No change */
4135 break;
4136 case 1:
4137 ctl->cmsg(CMSG_INFO, VERB_DEBUG,
4138 "(GS ch=%d SC-55 MAP)", ch);
4139 mapID[ch] = (ISDRUMCHANNEL(ch)) ? SC_55_DRUM_MAP
4140 : SC_55_TONE_MAP;
4141 break;
4142 case 2:
4143 ctl->cmsg(CMSG_INFO, VERB_DEBUG,
4144 "(GS ch=%d SC-88 MAP)", ch);
4145 mapID[ch] = (ISDRUMCHANNEL(ch)) ? SC_88_DRUM_MAP
4146 : SC_88_TONE_MAP;
4147 break;
4148 case 3:
4149 ctl->cmsg(CMSG_INFO, VERB_DEBUG,
4150 "(GS ch=%d SC-88Pro MAP)", ch);
4151 mapID[ch] = (ISDRUMCHANNEL(ch)) ? SC_88PRO_DRUM_MAP
4152 : SC_88PRO_TONE_MAP;
4153 break;
4154 case 4:
4155 ctl->cmsg(CMSG_INFO, VERB_DEBUG,
4156 "(GS ch=%d SC-8820/SC-8850 MAP)", ch);
4157 mapID[ch] = (ISDRUMCHANNEL(ch)) ? SC_8850_DRUM_MAP
4158 : SC_8850_TONE_MAP;
4159 break;
4160 default:
4161 ctl->cmsg(CMSG_INFO, VERB_DEBUG,
4162 "(GS: ch=%d Strange bank LSB %d)",
4163 ch, bank_lsb[ch]);
4164 break;
4165 }
4166 newbank = bank_msb[ch];
4167 break;
4168 case XG_SYSTEM_MODE: /* XG */
4169 switch (bank_msb[ch]) {
4170 case 0: /* Normal */
4171 if (ch == 9 && bank_lsb[ch] == 127
4172 && mapID[ch] == XG_DRUM_MAP)
4173 /* FIXME: Why this part is drum? Is this correct? */
4174 ctl->cmsg(CMSG_WARNING, VERB_NORMAL,
4175 "Warning: XG bank 0/127 is found. "
4176 "It may be not correctly played.");
4177 else {
4178 ctl->cmsg(CMSG_INFO, VERB_DEBUG,
4179 "(XG ch=%d Normal voice)", ch);
4180 midi_drumpart_change(ch, 0);
4181 mapID[ch] = XG_NORMAL_MAP;
4182 }
4183 break;
4184 case 64: /* SFX voice */
4185 ctl->cmsg(CMSG_INFO, VERB_DEBUG,
4186 "(XG ch=%d SFX voice)", ch);
4187 midi_drumpart_change(ch, 0);
4188 mapID[ch] = XG_SFX64_MAP;
4189 break;
4190 case 126: /* SFX kit */
4191 ctl->cmsg(CMSG_INFO, VERB_DEBUG,
4192 "(XG ch=%d SFX kit)", ch);
4193 midi_drumpart_change(ch, 1);
4194 mapID[ch] = XG_SFX126_MAP;
4195 break;
4196 case 127: /* Drum kit */
4197 ctl->cmsg(CMSG_INFO, VERB_DEBUG,
4198 "(XG ch=%d Drum kit)", ch);
4199 midi_drumpart_change(ch, 1);
4200 mapID[ch] = XG_DRUM_MAP;
4201 break;
4202 default:
4203 ctl->cmsg(CMSG_INFO, VERB_DEBUG,
4204 "(XG: ch=%d Strange bank MSB %d)",
4205 ch, bank_msb[ch]);
4206 break;
4207 }
4208 newbank = bank_lsb[ch];
4209 break;
4210 case GM2_SYSTEM_MODE: /* GM2 */
4211 ctl->cmsg(CMSG_INFO, VERB_DEBUG, "(GM2 ch=%d)", ch);
4212 if ((bank_msb[ch] & 0xfe) == 0x78) /* 0x78/0x79 */
4213 midi_drumpart_change(ch, bank_msb[ch] == 0x78);
4214 mapID[ch] = (ISDRUMCHANNEL(ch)) ? GM2_DRUM_MAP
4215 : GM2_TONE_MAP;
4216 newbank = bank_lsb[ch];
4217 break;
4218 default:
4219 newbank = bank_msb[ch];
4220 break;
4221 }
4222 if (ISDRUMCHANNEL(ch))
4223 current_set[ch] = newprog;
4224 else {
4225 if (special_tonebank >= 0)
4226 newbank = special_tonebank;
4227 if (current_program[ch] == SPECIAL_PROGRAM)
4228 skip_this_event = 1;
4229 current_set[ch] = newbank;
4230 }
4231 current_program[ch] = newprog;
4232 break;
4233
4234 case ME_NOTEON:
4235 if(counting_time)
4236 counting_time = 1;
4237 if(ISDRUMCHANNEL(ch))
4238 {
4239 newbank = current_set[ch];
4240 newprog = meep->event.a;
4241 instrument_map(mapID[ch], &newbank, &newprog);
4242
4243 if(!drumset[newbank]) /* Is this a defined drumset? */
4244 {
4245 if(warn_drumset[newbank] == 0)
4246 {
4247 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE,
4248 "Drum set %d is undefined", newbank);
4249 warn_drumset[newbank] = 1;
4250 }
4251 newbank = 0;
4252 }
4253
4254 /* Mark this instrument to be loaded */
4255 if(!(drumset[newbank]->tone[newprog].instrument))
4256 drumset[newbank]->tone[newprog].instrument =
4257 MAGIC_LOAD_INSTRUMENT;
4258 }
4259 else
4260 {
4261 if(current_program[ch] == SPECIAL_PROGRAM)
4262 break;
4263 newbank = current_set[ch];
4264 newprog = current_program[ch];
4265 instrument_map(mapID[ch], &newbank, &newprog);
4266 if(tonebank[newbank] == NULL)
4267 {
4268 if(warn_tonebank[newbank] == 0)
4269 {
4270 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE,
4271 "Tone bank %d is undefined", newbank);
4272 warn_tonebank[newbank] = 1;
4273 }
4274 newbank = 0;
4275 }
4276
4277 /* Mark this instrument to be loaded */
4278 if(!(tonebank[newbank]->tone[newprog].instrument))
4279 tonebank[newbank]->tone[newprog].instrument =
4280 MAGIC_LOAD_INSTRUMENT;
4281 }
4282 break;
4283
4284 case ME_TONE_BANK_MSB:
4285 bank_msb[ch] = meep->event.a;
4286 break;
4287
4288 case ME_TONE_BANK_LSB:
4289 bank_lsb[ch] = meep->event.a;
4290 break;
4291
4292 case ME_CHORUS_TEXT:
4293 case ME_LYRIC:
4294 case ME_MARKER:
4295 case ME_INSERT_TEXT:
4296 case ME_TEXT:
4297 case ME_KARAOKE_LYRIC:
4298 if((meep->event.a | meep->event.b) == 0)
4299 skip_this_event = 1;
4300 else if(counting_time && ctl->trace_playing)
4301 counting_time = 1;
4302 break;
4303
4304 case ME_GSLCD:
4305 if (counting_time && ctl->trace_playing)
4306 counting_time = 1;
4307 skip_this_event = !ctl->trace_playing;
4308 break;
4309
4310 case ME_DRUMPART:
4311 midi_drumpart_change(ch, meep->event.a);
4312 break;
4313
4314 case ME_WRD:
4315 if(readmidi_wrd_mode == WRD_TRACE_MIMPI)
4316 {
4317 wrd_args[wrd_argc++] = meep->event.a | 256 * meep->event.b;
4318 if(ch != WRD_ARG)
4319 {
4320 if(ch == WRD_MAG) {
4321 wrdt->apply(WRD_MAGPRELOAD, wrd_argc, wrd_args);
4322 }
4323 else if(ch == WRD_PLOAD)
4324 wrdt->apply(WRD_PHOPRELOAD, wrd_argc, wrd_args);
4325 else if(ch == WRD_PATH)
4326 wrdt->apply(WRD_PATH, wrd_argc, wrd_args);
4327 wrd_argc = 0;
4328 }
4329 }
4330 if(counting_time == 2 && readmidi_wrd_mode != WRD_TRACE_NOTHING)
4331 counting_time = 1;
4332 break;
4333
4334 case ME_SHERRY:
4335 if(counting_time == 2)
4336 counting_time = 1;
4337 break;
4338
4339 case ME_NOTE_STEP:
4340 if(counting_time == 2)
4341 skip_this_event = 1;
4342 break;
4343
4344 case ME_CUEPOINT:
4345 if (counting_time == 2)
4346 skip_this_event = 1;
4347 break;
4348 }
4349
4350 /* Recompute time in samples*/
4351 if((dt = meep->event.time - at) && !counting_time)
4352 {
4353 samples_to_do = sample_increment * dt;
4354 sample_cum += sample_correction * dt;
4355 if(sample_cum & 0xFFFF0000)
4356 {
4357 samples_to_do += ((sample_cum >> 16) & 0xFFFF);
4358 sample_cum &= 0x0000FFFF;
4359 }
4360 st += samples_to_do;
4361 if(st < 0)
4362 {
4363 ctl->cmsg(CMSG_ERROR, VERB_NORMAL,
4364 "Overflow the sample counter");
4365 free(groomed_list);
4366 return NULL;
4367 }
4368 }
4369 else if(counting_time == 1)
4370 counting_time = 0;
4371
4372 if(meep->event.type == ME_TEMPO)
4373 {
4374 tempo = ch + meep->event.b * 256 + meep->event.a * 65536;
4375 compute_sample_increment(tempo, divisions);
4376 }
4377
4378 if(!skip_this_event)
4379 {
4380 /* Add the event to the list */
4381 *lp = meep->event;
4382 lp->time = st;
4383 lp++;
4384 our_event_count++;
4385 }
4386 at = meep->event.time;
4387 meep = meep->next;
4388 }
4389 /* Add an End-of-Track event */
4390 lp->time = st;
4391 lp->type = ME_EOT;
4392 our_event_count++;
4393 free_midi_list();
4394
4395 *eventsp = our_event_count;
4396 *samplesp = st;
4397 return groomed_list;
4398 }
4399
read_smf_file(struct timidity_file * tf)4400 static int read_smf_file(struct timidity_file *tf)
4401 {
4402 int32 len, divisions;
4403 int16 format, tracks, divisions_tmp;
4404 int i;
4405
4406 if(current_file_info->file_type == IS_OTHER_FILE)
4407 current_file_info->file_type = IS_SMF_FILE;
4408
4409 if(current_file_info->karaoke_title == NULL)
4410 karaoke_title_flag = 0;
4411 else
4412 karaoke_title_flag = 1;
4413
4414 errno = 0;
4415 if(tf_read(&len, 4, 1, tf) != 1)
4416 {
4417 if(errno)
4418 ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: %s", current_filename,
4419 strerror(errno));
4420 else
4421 ctl->cmsg(CMSG_WARNING, VERB_NORMAL,
4422 "%s: Not a MIDI file!", current_filename);
4423 return 1;
4424 }
4425 len = BE_LONG(len);
4426
4427 tf_read(&format, 2, 1, tf);
4428 tf_read(&tracks, 2, 1, tf);
4429 tf_read(&divisions_tmp, 2, 1, tf);
4430 format = BE_SHORT(format);
4431 tracks = BE_SHORT(tracks);
4432 divisions_tmp = BE_SHORT(divisions_tmp);
4433
4434 if(divisions_tmp < 0)
4435 {
4436 /* SMPTE time -- totally untested. Got a MIDI file that uses this? */
4437 divisions=
4438 (int32)(-(divisions_tmp / 256)) * (int32)(divisions_tmp & 0xFF);
4439 }
4440 else
4441 divisions = (int32)divisions_tmp;
4442
4443 if(play_mode->flag & PF_MIDI_EVENT)
4444 play_mode->acntl(PM_REQ_DIVISIONS, &divisions);
4445
4446 if(len > 6)
4447 {
4448 ctl->cmsg(CMSG_WARNING, VERB_NORMAL,
4449 "%s: MIDI file header size %ld bytes",
4450 current_filename, len);
4451 skip(tf, len - 6); /* skip the excess */
4452 }
4453 if(format < 0 || format > 2)
4454 {
4455 ctl->cmsg(CMSG_ERROR, VERB_NORMAL,
4456 "%s: Unknown MIDI file format %d", current_filename, format);
4457 return 1;
4458 }
4459 ctl->cmsg(CMSG_INFO, VERB_VERBOSE, "Format: %d Tracks: %d Divisions: %d",
4460 format, tracks, divisions);
4461
4462 current_file_info->format = format;
4463 current_file_info->tracks = tracks;
4464 current_file_info->divisions = divisions;
4465 if(tf->url->url_tell != NULL)
4466 current_file_info->hdrsiz = (int16)tf_tell(tf);
4467 else
4468 current_file_info->hdrsiz = -1;
4469
4470 switch(format)
4471 {
4472 case 0:
4473 if(read_smf_track(tf, 0, 1))
4474 {
4475 if(ignore_midi_error)
4476 break;
4477 return 1;
4478 }
4479 break;
4480
4481 case 1:
4482 for(i = 0; i < tracks; i++)
4483 {
4484 if(read_smf_track(tf, i, 1))
4485 {
4486 if(ignore_midi_error)
4487 break;
4488 return 1;
4489 }
4490 }
4491 break;
4492
4493 case 2: /* We simply play the tracks sequentially */
4494 for(i = 0; i < tracks; i++)
4495 {
4496 if(read_smf_track(tf, i, 0))
4497 {
4498 if(ignore_midi_error)
4499 break;
4500 return 1;
4501 }
4502 }
4503 break;
4504 }
4505 return 0;
4506 }
4507
readmidi_read_init(void)4508 void readmidi_read_init(void)
4509 {
4510 int i;
4511 static int first = 1;
4512
4513 /* initialize effect status */
4514 for (i = 0; i < MAX_CHANNELS; i++)
4515 init_channel_layer(i);
4516 free_effect_buffers();
4517 init_reverb_status_gs();
4518 init_delay_status_gs();
4519 init_chorus_status_gs();
4520 init_eq_status_gs();
4521 init_insertion_effect_gs();
4522 init_multi_eq_xg();
4523 if (play_system_mode == XG_SYSTEM_MODE) {init_all_effect_xg();}
4524 init_userdrum();
4525 init_userinst();
4526 rhythm_part[0] = rhythm_part[1] = 9;
4527 for(i = 0; i < 6; i++) {drum_setup_xg[i] = 9;}
4528
4529 /* Put a do-nothing event first in the list for easier processing */
4530 evlist = current_midi_point = alloc_midi_event();
4531 evlist->event.time = 0;
4532 evlist->event.type = ME_NONE;
4533 evlist->event.channel = 0;
4534 evlist->event.a = 0;
4535 evlist->event.b = 0;
4536 evlist->prev = NULL;
4537 evlist->next = NULL;
4538 readmidi_error_flag = 0;
4539 event_count = 1;
4540
4541 if(string_event_table != NULL)
4542 {
4543 free(string_event_table[0]);
4544 free(string_event_table);
4545 string_event_table = NULL;
4546 string_event_table_size = 0;
4547 }
4548 if (first != 1)
4549 if (string_event_strtab.nstring > 0)
4550 delete_string_table(&string_event_strtab);
4551 init_string_table(&string_event_strtab);
4552 karaoke_format = 0;
4553
4554 for(i = 0; i < 256; i++)
4555 default_channel_program[i] = -1;
4556 readmidi_wrd_mode = WRD_TRACE_NOTHING;
4557 first = 0;
4558 }
4559
insert_note_steps(void)4560 static void insert_note_steps(void)
4561 {
4562 MidiEventList *e;
4563 int32 i, n, at, lasttime, meas, beat;
4564 uint8 num = 0, denom = 1, a, b;
4565
4566 e = evlist;
4567 for (i = n = 0; i < event_count - 1 && n < 256 - 1; i++, e = e->next)
4568 if (e->event.type == ME_TIMESIG && e->event.channel == 0) {
4569 if (n == 0 && e->event.time > 0) { /* 4/4 is default */
4570 SETMIDIEVENT(timesig[n], 0, ME_TIMESIG, 0, 4, 4);
4571 n++;
4572 }
4573 if (n > 0 && e->event.a == timesig[n - 1].a
4574 && e->event.b == timesig[n - 1].b)
4575 continue; /* unchanged */
4576 if (n > 0 && e->event.time == timesig[n - 1].time)
4577 n--; /* overwrite previous timesig */
4578 timesig[n++] = e->event;
4579 }
4580 if (n == 0) {
4581 SETMIDIEVENT(timesig[n], 0, ME_TIMESIG, 0, 4, 4);
4582 n++;
4583 }
4584 timesig[n] = timesig[n - 1];
4585 timesig[n].time = 0x7fffffff; /* stopper */
4586 lasttime = e->event.time;
4587 readmidi_set_track(0, 1);
4588 at = n = meas = beat = 0;
4589 while (at < lasttime && ! readmidi_error_flag) {
4590 if (at >= timesig[n].time) {
4591 if (beat != 0)
4592 meas++, beat = 0;
4593 num = timesig[n].a, denom = timesig[n].b, n++;
4594 }
4595 a = (meas + 1) & 0xff;
4596 b = (((meas + 1) >> 8) & 0x0f) + ((beat + 1) << 4);
4597 MIDIEVENT(at, ME_NOTE_STEP, 0, a, b);
4598 if (++beat == num)
4599 meas++, beat = 0;
4600 at += current_file_info->divisions * 4 / denom;
4601 }
4602 }
4603
4604 static int32 compute_smf_at_time(const int32, int32 *);
4605 static int32 compute_smf_at_time2(const Measure, int32 *);
4606
insert_cuepoints(void)4607 static void insert_cuepoints(void)
4608 {
4609 TimeSegment *sp;
4610 int32 at, st, t;
4611 uint8 a0, b0, a1, b1;
4612
4613 for (sp = time_segments; sp != NULL; sp = sp->next) {
4614 if (sp->type == 0) {
4615 if (sp->prev == NULL && sp->begin.s != 0) {
4616 t = sp->begin.s * play_mode->rate;
4617 a0 = t >> 24, b0 = t >> 16, a1 = t >> 8, b1 = t;
4618 MIDIEVENT(0, ME_NOTEON, 0, 0, 0);
4619 MIDIEVENT(0, ME_CUEPOINT, 0, a0, b0);
4620 MIDIEVENT(0, ME_CUEPOINT, 1, a1, b1);
4621 }
4622 if (sp->next != NULL) {
4623 at = compute_smf_at_time(sp->end.s * play_mode->rate, &st);
4624 if (sp->next->type == 0)
4625 t = sp->next->begin.s * play_mode->rate - st;
4626 else
4627 compute_smf_at_time2(sp->next->begin.m, &t), t -= st;
4628 a0 = t >> 24, b0 = t >> 16, a1 = t >> 8, b1 = t;
4629 MIDIEVENT(at, ME_CUEPOINT, 0, a0, b0);
4630 MIDIEVENT(at, ME_CUEPOINT, 1, a1, b1);
4631 } else if (sp->end.s != -1) {
4632 at = compute_smf_at_time(sp->end.s * play_mode->rate, &st);
4633 t = 0x7fffffff; /* stopper */
4634 a0 = t >> 24, b0 = t >> 16, a1 = t >> 8, b1 = t;
4635 MIDIEVENT(at, ME_CUEPOINT, 0, a0, b0);
4636 MIDIEVENT(at, ME_CUEPOINT, 1, a1, b1);
4637 }
4638 } else {
4639 if (sp->prev == NULL
4640 && (sp->begin.m.meas != 1 || sp->begin.m.beat != 1)) {
4641 compute_smf_at_time2(sp->begin.m, &t);
4642 a0 = t >> 24, b0 = t >> 16, a1 = t >> 8, b1 = t;
4643 MIDIEVENT(0, ME_NOTEON, 0, 0, 0);
4644 MIDIEVENT(0, ME_CUEPOINT, 0, a0, b0);
4645 MIDIEVENT(0, ME_CUEPOINT, 1, a1, b1);
4646 }
4647 if (sp->next != NULL) {
4648 at = compute_smf_at_time2(sp->end.m, &st);
4649 if (sp->next->type == 0)
4650 t = sp->next->begin.s * play_mode->rate - st;
4651 else
4652 compute_smf_at_time2(sp->next->begin.m, &t), t -= st;
4653 a0 = t >> 24, b0 = t >> 16, a1 = t >> 8, b1 = t;
4654 MIDIEVENT(at, ME_CUEPOINT, 0, a0, b0);
4655 MIDIEVENT(at, ME_CUEPOINT, 1, a1, b1);
4656 } else if (sp->end.m.meas != -1 || sp->end.m.beat != -1) {
4657 at = compute_smf_at_time2(sp->end.m, &st);
4658 t = 0x7fffffff; /* stopper */
4659 a0 = t >> 24, b0 = t >> 16, a1 = t >> 8, b1 = t;
4660 MIDIEVENT(at, ME_CUEPOINT, 0, a0, b0);
4661 MIDIEVENT(at, ME_CUEPOINT, 1, a1, b1);
4662 }
4663 }
4664 }
4665 }
4666
compute_smf_at_time(const int32 sample,int32 * sample_adj)4667 static int32 compute_smf_at_time(const int32 sample, int32 *sample_adj)
4668 {
4669 MidiEventList *e;
4670 int32 st = 0, tempo = 500000, prev_time = 0;
4671 int i;
4672
4673 for (i = 0, e = evlist; i < event_count; i++, e = e->next) {
4674 st += (double) tempo * play_mode->rate / 1000000
4675 / current_file_info->divisions
4676 * (e->event.time - prev_time) + 0.5;
4677 if (st >= sample && e->event.type == ME_NOTE_STEP) {
4678 *sample_adj = st;
4679 return e->event.time;
4680 }
4681 if (e->event.type == ME_TEMPO)
4682 tempo = e->event.a * 65536 + e->event.b * 256 + e->event.channel;
4683 prev_time = e->event.time;
4684 }
4685 return -1;
4686 }
4687
compute_smf_at_time2(const Measure m,int32 * sample)4688 static int32 compute_smf_at_time2(const Measure m, int32 *sample)
4689 {
4690 MidiEventList *e;
4691 int32 st = 0, tempo = 500000, prev_time = 0;
4692 int i;
4693
4694 for (i = 0, e = evlist; i < event_count; i++, e = e->next) {
4695 st += (double) tempo * play_mode->rate / 1000000
4696 / current_file_info->divisions
4697 * (e->event.time - prev_time) + 0.5;
4698 if (e->event.type == ME_NOTE_STEP
4699 && ((e->event.a + ((e->event.b & 0x0f) << 8)) * 16
4700 + (e->event.b >> 4)) >= m.meas * 16 + m.beat) {
4701 *sample = st;
4702 return e->event.time;
4703 }
4704 if (e->event.type == ME_TEMPO)
4705 tempo = e->event.a * 65536 + e->event.b * 256 + e->event.channel;
4706 prev_time = e->event.time;
4707 }
4708 return -1;
4709 }
4710
free_time_segments(void)4711 void free_time_segments(void)
4712 {
4713 TimeSegment *sp, *next;
4714
4715 for (sp = time_segments; sp != NULL; sp = next)
4716 next = sp->next, free(sp);
4717 time_segments = NULL;
4718 }
4719
read_midi_file(struct timidity_file * tf,int32 * count,int32 * sp,char * fn)4720 MidiEvent *read_midi_file(struct timidity_file *tf, int32 *count, int32 *sp,
4721 char *fn)
4722 {
4723 char magic[4];
4724 MidiEvent *ev;
4725 int err, macbin_check, mtype, i;
4726
4727 macbin_check = 1;
4728 current_file_info = get_midi_file_info(current_filename, 1);
4729 COPY_CHANNELMASK(drumchannels, current_file_info->drumchannels);
4730 COPY_CHANNELMASK(drumchannel_mask, current_file_info->drumchannel_mask);
4731
4732 errno = 0;
4733
4734 if((mtype = get_module_type(fn)) > 0)
4735 {
4736 readmidi_read_init();
4737 if(!IS_URL_SEEK_SAFE(tf->url))
4738 tf->url = url_cache_open(tf->url, 1);
4739 err = load_module_file(tf, mtype);
4740 if(!err)
4741 {
4742 current_file_info->format = 0;
4743 memset(&drumchannels, 0, sizeof(drumchannels));
4744 goto grooming;
4745 }
4746 free_midi_list();
4747
4748 if(err == 2)
4749 return NULL;
4750 url_rewind(tf->url);
4751 url_cache_disable(tf->url);
4752 }
4753
4754 #if MAX_CHANNELS > 16
4755 for(i = 16; i < MAX_CHANNELS; i++)
4756 {
4757 if(!IS_SET_CHANNELMASK(drumchannel_mask, i))
4758 {
4759 if(IS_SET_CHANNELMASK(drumchannels, i & 0xF))
4760 SET_CHANNELMASK(drumchannels, i);
4761 else
4762 UNSET_CHANNELMASK(drumchannels, i);
4763 }
4764 }
4765 #endif
4766
4767 if(opt_default_mid &&
4768 (current_file_info->mid == 0 || current_file_info->mid >= 0x7e))
4769 current_file_info->mid = opt_default_mid;
4770
4771 retry_read:
4772 if(tf_read(magic, 1, 4, tf) != 4)
4773 {
4774 if(errno)
4775 ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: %s", current_filename,
4776 strerror(errno));
4777 else
4778 ctl->cmsg(CMSG_WARNING, VERB_NORMAL,
4779 "%s: Not a MIDI file!", current_filename);
4780 return NULL;
4781 }
4782
4783 if(memcmp(magic, "MThd", 4) == 0)
4784 {
4785 readmidi_read_init();
4786 err = read_smf_file(tf);
4787 }
4788 else if(memcmp(magic, "RCM-", 4) == 0 || memcmp(magic, "COME", 4) == 0)
4789 {
4790 readmidi_read_init();
4791 err = read_rcp_file(tf, magic, fn);
4792 }
4793 else if (strncmp(magic, "RIFF", 4) == 0) {
4794 if (tf_read(magic, 1, 4, tf) == 4 &&
4795 tf_read(magic, 1, 4, tf) == 4 &&
4796 strncmp(magic, "RMID", 4) == 0 &&
4797 tf_read(magic, 1, 4, tf) == 4 &&
4798 strncmp(magic, "data", 4) == 0 &&
4799 tf_read(magic, 1, 4, tf) == 4) {
4800 goto retry_read;
4801 } else {
4802 err = 1;
4803 ctl->cmsg(CMSG_WARNING, VERB_NORMAL,
4804 "%s: Not a MIDI file!", current_filename);
4805 }
4806 }
4807 else if(memcmp(magic, "melo", 4) == 0)
4808 {
4809 readmidi_read_init();
4810 err = read_mfi_file(tf);
4811 }
4812 else
4813 {
4814 if(macbin_check && magic[0] == 0)
4815 {
4816 /* Mac Binary */
4817 macbin_check = 0;
4818 skip(tf, 128 - 4);
4819 goto retry_read;
4820 }
4821 else if(memcmp(magic, "RIFF", 4) == 0)
4822 {
4823 /* RIFF MIDI file */
4824 skip(tf, 20 - 4);
4825 goto retry_read;
4826 }
4827 err = 1;
4828 ctl->cmsg(CMSG_WARNING, VERB_NORMAL,
4829 "%s: Not a MIDI file!", current_filename);
4830 }
4831
4832 if(err)
4833 {
4834 free_midi_list();
4835 if(string_event_strtab.nstring > 0)
4836 delete_string_table(&string_event_strtab);
4837 return NULL;
4838 }
4839
4840 /* Read WRD file */
4841 if(!(play_mode->flag&PF_CAN_TRACE))
4842 {
4843 if(wrdt->start != NULL)
4844 wrdt->start(WRD_TRACE_NOTHING);
4845 readmidi_wrd_mode = WRD_TRACE_NOTHING;
4846 }
4847 else if(wrdt->id != '-' && wrdt->opened)
4848 {
4849 readmidi_wrd_mode = import_wrd_file(fn);
4850 if(wrdt->start != NULL)
4851 if(wrdt->start(readmidi_wrd_mode) == -1)
4852 {
4853 /* strip all WRD events */
4854 MidiEventList *e;
4855 int32 i;
4856 for(i = 0, e = evlist; i < event_count; i++, e = e->next)
4857 if (e->event.type == ME_WRD || e->event.type == ME_SHERRY)
4858 e->event.type = ME_NONE;
4859 }
4860 }
4861 else
4862 readmidi_wrd_mode = WRD_TRACE_NOTHING;
4863
4864 /* make lyric table */
4865 if(string_event_strtab.nstring > 0)
4866 {
4867 string_event_table_size = string_event_strtab.nstring;
4868 string_event_table = make_string_array(&string_event_strtab);
4869 if(string_event_table == NULL)
4870 {
4871 delete_string_table(&string_event_strtab);
4872 string_event_table_size = 0;
4873 }
4874 }
4875
4876 grooming:
4877 insert_note_steps();
4878 insert_cuepoints();
4879 ev = groom_list(current_file_info->divisions, count, sp);
4880 if(ev == NULL)
4881 {
4882 free_midi_list();
4883 if(string_event_strtab.nstring > 0)
4884 delete_string_table(&string_event_strtab);
4885 return NULL;
4886 }
4887 current_file_info->samples = *sp;
4888 if(current_file_info->first_text == NULL)
4889 current_file_info->first_text = safe_strdup("");
4890 current_file_info->readflag = 1;
4891 return ev;
4892 }
4893
4894
new_midi_file_info(const char * filename)4895 struct midi_file_info *new_midi_file_info(const char *filename)
4896 {
4897 struct midi_file_info *p;
4898 p = (struct midi_file_info *)safe_malloc(sizeof(struct midi_file_info));
4899
4900 /* Initialize default members */
4901 memset(p, 0, sizeof(struct midi_file_info));
4902 p->hdrsiz = -1;
4903 p->format = -1;
4904 p->tracks = -1;
4905 p->divisions = -1;
4906 p->time_sig_n = p->time_sig_d = -1;
4907 p->samples = -1;
4908 p->max_channel = -1;
4909 p->file_type = IS_OTHER_FILE;
4910 if(filename != NULL)
4911 p->filename = safe_strdup(filename);
4912 COPY_CHANNELMASK(p->drumchannels, default_drumchannels);
4913 COPY_CHANNELMASK(p->drumchannel_mask, default_drumchannel_mask);
4914
4915 /* Append to midi_file_info */
4916 p->next = midi_file_info;
4917 midi_file_info = p;
4918
4919 return p;
4920 }
4921
free_all_midi_file_info(void)4922 void free_all_midi_file_info(void)
4923 {
4924 struct midi_file_info *info, *next;
4925
4926 info = midi_file_info;
4927 while (info) {
4928 next = info->next;
4929 free(info->filename);
4930 if (info->seq_name)
4931 free(info->seq_name);
4932 if (info->karaoke_title != NULL && info->karaoke_title == info->first_text)
4933 free(info->karaoke_title);
4934 else {
4935 if (info->karaoke_title)
4936 free(info->karaoke_title);
4937 if (info->first_text)
4938 free(info->first_text);
4939 if (info->midi_data)
4940 free(info->midi_data);
4941 if (info->pcm_filename)
4942 free(info->pcm_filename); /* Note: this memory is freed in playmidi.c*/
4943 }
4944 free(info);
4945 info = next;
4946 }
4947 midi_file_info = NULL;
4948 current_file_info = NULL;
4949 }
4950
get_midi_file_info(char * filename,int newp)4951 struct midi_file_info *get_midi_file_info(char *filename, int newp)
4952 {
4953 struct midi_file_info *p;
4954
4955 filename = url_expand_home_dir(filename);
4956 /* Linear search */
4957 for(p = midi_file_info; p; p = p->next)
4958 if(!strcmp(filename, p->filename))
4959 return p;
4960 if(newp)
4961 return new_midi_file_info(filename);
4962 return NULL;
4963 }
4964
open_midi_file(char * fn,int decompress,int noise_mode)4965 struct timidity_file *open_midi_file(char *fn,
4966 int decompress, int noise_mode)
4967 {
4968 struct midi_file_info *infop;
4969 struct timidity_file *tf;
4970 #if defined(SMFCONV) && defined(__W32__)
4971 extern int opt_rcpcv_dll;
4972 #endif
4973
4974 infop = get_midi_file_info(fn, 0);
4975 if(infop == NULL || infop->midi_data == NULL)
4976 tf = open_file(fn, decompress, noise_mode);
4977 else
4978 {
4979 tf = open_with_mem(infop->midi_data, infop->midi_data_size,
4980 noise_mode);
4981 if(infop->compressed)
4982 {
4983 if((tf->url = url_inflate_open(tf->url, infop->midi_data_size, 1))
4984 == NULL)
4985 {
4986 close_file(tf);
4987 return NULL;
4988 }
4989 }
4990 }
4991
4992 #if defined(SMFCONV) && defined(__W32__)
4993 /* smf convert */
4994 if(tf != NULL && opt_rcpcv_dll)
4995 {
4996 if(smfconv_w32(tf, fn))
4997 {
4998 close_file(tf);
4999 return NULL;
5000 }
5001 }
5002 #endif
5003
5004 return tf;
5005 }
5006
5007 #ifndef NO_MIDI_CACHE
deflate_url_reader(char * buf,long size,void * user_val)5008 static long deflate_url_reader(char *buf, long size, void *user_val)
5009 {
5010 return url_nread((URL)user_val, buf, size);
5011 }
5012
5013 /*
5014 * URL data into deflated buffer.
5015 */
url_make_file_data(URL url,struct midi_file_info * infop)5016 static void url_make_file_data(URL url, struct midi_file_info *infop)
5017 {
5018 char buff[BUFSIZ];
5019 MemBuffer b;
5020 long n;
5021 DeflateHandler compressor;
5022
5023 init_memb(&b);
5024
5025 /* url => b */
5026 if((compressor = open_deflate_handler(deflate_url_reader, url,
5027 ARC_DEFLATE_LEVEL)) == NULL)
5028 return;
5029 while((n = zip_deflate(compressor, buff, sizeof(buff))) > 0)
5030 push_memb(&b, buff, n);
5031 close_deflate_handler(compressor);
5032 infop->compressed = 1;
5033
5034 /* b => mem */
5035 infop->midi_data_size = b.total_size;
5036 rewind_memb(&b);
5037 infop->midi_data = (void *)safe_malloc(infop->midi_data_size);
5038 read_memb(&b, infop->midi_data, infop->midi_data_size);
5039 delete_memb(&b);
5040 }
5041
check_need_cache(URL url,char * filename)5042 static int check_need_cache(URL url, char *filename)
5043 {
5044 int t1, t2;
5045 t1 = url_check_type(filename);
5046 t2 = url->type;
5047 return (t1 == URL_http_t || t1 == URL_ftp_t || t1 == URL_news_t)
5048 && t2 != URL_arc_t;
5049 }
5050 #else
5051 /*ARGSUSED*/
url_make_file_data(URL url,struct midi_file_info * infop)5052 static void url_make_file_data(URL url, struct midi_file_info *infop)
5053 {
5054 }
5055 /*ARGSUSED*/
check_need_cache(URL url,char * filename)5056 static int check_need_cache(URL url, char *filename)
5057 {
5058 return 0;
5059 }
5060 #endif /* NO_MIDI_CACHE */
5061
check_midi_file(char * filename)5062 int check_midi_file(char *filename)
5063 {
5064 struct midi_file_info *p;
5065 struct timidity_file *tf;
5066 char tmp[4];
5067 int32 len;
5068 int16 format;
5069 int check_cache;
5070
5071 if(filename == NULL)
5072 {
5073 if(current_file_info == NULL)
5074 return -1;
5075 filename = current_file_info->filename;
5076 }
5077
5078 p = get_midi_file_info(filename, 0);
5079 if(p != NULL)
5080 return p->format;
5081 p = get_midi_file_info(filename, 1);
5082
5083 if(get_module_type(filename) > 0)
5084 {
5085 p->format = 0;
5086 return 0;
5087 }
5088
5089 tf = open_file(filename, 1, OF_SILENT);
5090 if(tf == NULL)
5091 return -1;
5092
5093 check_cache = check_need_cache(tf->url, filename);
5094 if(check_cache)
5095 {
5096 if(!IS_URL_SEEK_SAFE(tf->url))
5097 {
5098 if((tf->url = url_cache_open(tf->url, 1)) == NULL)
5099 {
5100 close_file(tf);
5101 return -1;
5102 }
5103 }
5104 }
5105
5106 /* Parse MIDI header */
5107 if(tf_read(tmp, 1, 4, tf) != 4)
5108 {
5109 close_file(tf);
5110 return -1;
5111 }
5112
5113 if(tmp[0] == 0)
5114 {
5115 skip(tf, 128 - 4);
5116 if(tf_read(tmp, 1, 4, tf) != 4)
5117 {
5118 close_file(tf);
5119 return -1;
5120 }
5121 }
5122
5123 if(strncmp(tmp, "RCM-", 4) == 0 ||
5124 strncmp(tmp, "COME", 4) == 0 ||
5125 strncmp(tmp, "RIFF", 4) == 0 ||
5126 strncmp(tmp, "melo", 4) == 0 ||
5127 strncmp(tmp, "M1", 2) == 0)
5128 {
5129 p->format = format = 1;
5130 goto end_of_header;
5131 }
5132
5133 if(strncmp(tmp, "MThd", 4) != 0)
5134 {
5135 close_file(tf);
5136 return -1;
5137 }
5138
5139 if(tf_read(&len, 4, 1, tf) != 1)
5140 {
5141 close_file(tf);
5142 return -1;
5143 }
5144 len = BE_LONG(len);
5145
5146 tf_read(&format, 2, 1, tf);
5147 format = BE_SHORT(format);
5148 if(format < 0 || format > 2)
5149 {
5150 close_file(tf);
5151 return -1;
5152 }
5153 skip(tf, len - 2);
5154
5155 p->format = format;
5156 p->hdrsiz = (int16)tf_tell(tf);
5157
5158 end_of_header:
5159 if(check_cache)
5160 {
5161 url_rewind(tf->url);
5162 url_cache_disable(tf->url);
5163 url_make_file_data(tf->url, p);
5164 }
5165 close_file(tf);
5166 return format;
5167 }
5168
get_midi_title1(struct midi_file_info * p)5169 static char *get_midi_title1(struct midi_file_info *p)
5170 {
5171 char *s;
5172
5173 if(p->format != 0 && p->format != 1)
5174 return NULL;
5175
5176 if((s = p->seq_name) == NULL)
5177 if((s = p->karaoke_title) == NULL)
5178 s = p->first_text;
5179 if(s != NULL)
5180 {
5181 int all_space, i;
5182
5183 all_space = 1;
5184 for(i = 0; s[i]; i++)
5185 if(s[i] != ' ')
5186 {
5187 all_space = 0;
5188 break;
5189 }
5190 if(all_space)
5191 s = NULL;
5192 }
5193 return s;
5194 }
5195
get_midi_title(char * filename)5196 char *get_midi_title(char *filename)
5197 {
5198 struct midi_file_info *p;
5199 struct timidity_file *tf;
5200 char tmp[4];
5201 int32 len;
5202 int16 format, tracks, trk;
5203 int laststatus, check_cache;
5204 int mtype;
5205
5206 if(filename == NULL)
5207 {
5208 if(current_file_info == NULL)
5209 return NULL;
5210 filename = current_file_info->filename;
5211 }
5212
5213 p = get_midi_file_info(filename, 0);
5214 if(p == NULL)
5215 p = get_midi_file_info(filename, 1);
5216 else
5217 {
5218 if(p->seq_name != NULL || p->first_text != NULL || p->format < 0)
5219 return get_midi_title1(p);
5220 }
5221
5222 tf = open_file(filename, 1, OF_SILENT);
5223 if(tf == NULL)
5224 return NULL;
5225
5226 mtype = get_module_type(filename);
5227 check_cache = check_need_cache(tf->url, filename);
5228 if(check_cache || mtype > 0)
5229 {
5230 if(!IS_URL_SEEK_SAFE(tf->url))
5231 {
5232 if((tf->url = url_cache_open(tf->url, 1)) == NULL)
5233 {
5234 close_file(tf);
5235 return NULL;
5236 }
5237 }
5238 }
5239
5240 if(mtype > 0)
5241 {
5242 char *title, *str;
5243
5244 title = get_module_title(tf, mtype);
5245 if(title == NULL)
5246 {
5247 /* No title */
5248 p->seq_name = NULL;
5249 p->format = 0;
5250 goto end_of_parse;
5251 }
5252
5253 len = (int32)strlen(title);
5254 len = SAFE_CONVERT_LENGTH(len);
5255 str = (char *)new_segment(&tmpbuffer, len);
5256 code_convert(title, str, len, NULL, NULL);
5257 p->seq_name = (char *)safe_strdup(str);
5258 reuse_mblock(&tmpbuffer);
5259 p->format = 0;
5260 free (title);
5261 goto end_of_parse;
5262 }
5263
5264 /* Parse MIDI header */
5265 if(tf_read(tmp, 1, 4, tf) != 4)
5266 {
5267 close_file(tf);
5268 return NULL;
5269 }
5270
5271 if(tmp[0] == 0)
5272 {
5273 skip(tf, 128 - 4);
5274 if(tf_read(tmp, 1, 4, tf) != 4)
5275 {
5276 close_file(tf);
5277 return NULL;
5278 }
5279 }
5280
5281 if(memcmp(tmp, "RCM-", 4) == 0 || memcmp(tmp, "COME", 4) == 0)
5282 {
5283 int i;
5284 char local[0x40 + 1];
5285 char *str;
5286
5287 p->format = 1;
5288 skip(tf, 0x20 - 4);
5289 tf_read(local, 1, 0x40, tf);
5290 local[0x40]='\0';
5291
5292 for(i = 0x40 - 1; i >= 0; i--)
5293 {
5294 if(local[i] == 0x20)
5295 local[i] = '\0';
5296 else if(local[i] != '\0')
5297 break;
5298 }
5299
5300 i = SAFE_CONVERT_LENGTH(i + 1);
5301 str = (char *)new_segment(&tmpbuffer, i);
5302 code_convert(local, str, i, NULL, NULL);
5303 p->seq_name = (char *)safe_strdup(str);
5304 reuse_mblock(&tmpbuffer);
5305 p->format = 1;
5306 goto end_of_parse;
5307 }
5308 if(memcmp(tmp, "melo", 4) == 0)
5309 {
5310 int i;
5311 char *master, *converted;
5312
5313 master = get_mfi_file_title(tf);
5314 if (master != NULL)
5315 {
5316 i = SAFE_CONVERT_LENGTH(strlen(master) + 1);
5317 converted = (char *)new_segment(&tmpbuffer, i);
5318 code_convert(master, converted, i, NULL, NULL);
5319 p->seq_name = (char *)safe_strdup(converted);
5320 reuse_mblock(&tmpbuffer);
5321 }
5322 else
5323 {
5324 p->seq_name = (char *)safe_malloc(1);
5325 p->seq_name[0] = '\0';
5326 }
5327 p->format = 0;
5328 goto end_of_parse;
5329 }
5330
5331 if(strncmp(tmp, "M1", 2) == 0)
5332 {
5333 /* I don't know MPC file format */
5334 p->format = 1;
5335 goto end_of_parse;
5336 }
5337
5338 if(strncmp(tmp, "RIFF", 4) == 0)
5339 {
5340 /* RIFF MIDI file */
5341 skip(tf, 20 - 4);
5342 if(tf_read(tmp, 1, 4, tf) != 4)
5343 {
5344 close_file(tf);
5345 return NULL;
5346 }
5347 }
5348
5349 if(strncmp(tmp, "MThd", 4) != 0)
5350 {
5351 close_file(tf);
5352 return NULL;
5353 }
5354
5355 if(tf_read(&len, 4, 1, tf) != 1)
5356 {
5357 close_file(tf);
5358 return NULL;
5359 }
5360
5361 len = BE_LONG(len);
5362
5363 tf_read(&format, 2, 1, tf);
5364 tf_read(&tracks, 2, 1, tf);
5365 format = BE_SHORT(format);
5366 tracks = BE_SHORT(tracks);
5367 p->format = format;
5368 p->tracks = tracks;
5369 if(format < 0 || format > 2)
5370 {
5371 p->format = -1;
5372 close_file(tf);
5373 return NULL;
5374 }
5375
5376 skip(tf, len - 4);
5377 p->hdrsiz = (int16)tf_tell(tf);
5378
5379 if(format == 2)
5380 goto end_of_parse;
5381
5382 if(tracks >= 3)
5383 {
5384 tracks = 3;
5385 karaoke_format = 0;
5386 }
5387 else
5388 {
5389 tracks = 1;
5390 karaoke_format = -1;
5391 }
5392
5393 for(trk = 0; trk < tracks; trk++)
5394 {
5395 int32 next_pos, pos;
5396
5397 if(trk >= 1 && karaoke_format == -1)
5398 break;
5399
5400 if((tf_read(tmp,1,4,tf) != 4) || (tf_read(&len,4,1,tf) != 1))
5401 break;
5402
5403 if(memcmp(tmp, "MTrk", 4))
5404 break;
5405
5406 next_pos = tf_tell(tf) + len;
5407 laststatus = -1;
5408 for(;;)
5409 {
5410 int i, me, type;
5411
5412 /* skip Variable-length quantity */
5413 do
5414 {
5415 if((i = tf_getc(tf)) == EOF)
5416 goto end_of_parse;
5417 } while (i & 0x80);
5418
5419 if((me = tf_getc(tf)) == EOF)
5420 goto end_of_parse;
5421
5422 if(me == 0xF0 || me == 0xF7) /* SysEx */
5423 {
5424 if((len = getvl(tf)) < 0)
5425 goto end_of_parse;
5426 if((p->mid == 0 || p->mid >= 0x7e) && len > 0 && me == 0xF0)
5427 {
5428 p->mid = tf_getc(tf);
5429 len--;
5430 }
5431 skip(tf, len);
5432 }
5433 else if(me == 0xFF) /* Meta */
5434 {
5435 type = tf_getc(tf);
5436 if((len = getvl(tf)) < 0)
5437 goto end_of_parse;
5438 if((type == 1 || type == 3) && len > 0 &&
5439 (trk == 0 || karaoke_format != -1))
5440 {
5441 char *si, *so;
5442 int s_maxlen = SAFE_CONVERT_LENGTH(len);
5443
5444 si = (char *)new_segment(&tmpbuffer, len + 1);
5445 so = (char *)new_segment(&tmpbuffer, s_maxlen);
5446
5447 if(len != tf_read(si, 1, len, tf))
5448 {
5449 reuse_mblock(&tmpbuffer);
5450 goto end_of_parse;
5451 }
5452
5453 si[len]='\0';
5454 code_convert(si, so, s_maxlen, NULL, NULL);
5455 if(trk == 0 && type == 3)
5456 {
5457 if(p->seq_name == NULL) {
5458 char *name = safe_strdup(so);
5459 p->seq_name = safe_strdup(fix_string(name));
5460 free(name);
5461 }
5462 reuse_mblock(&tmpbuffer);
5463 if(karaoke_format == -1)
5464 goto end_of_parse;
5465 }
5466 if(p->first_text == NULL) {
5467 char *name;
5468 name = safe_strdup(so);
5469 p->first_text = safe_strdup(fix_string(name));
5470 free(name);
5471 }
5472 if(karaoke_format != -1)
5473 {
5474 if(trk == 1 && strncmp(si, "@K", 2) == 0)
5475 karaoke_format = 1;
5476 else if(karaoke_format == 1 && trk == 2)
5477 karaoke_format = 2;
5478 }
5479 if(type == 1 && karaoke_format == 2)
5480 {
5481 if(strncmp(si, "@T", 2) == 0)
5482 p->karaoke_title =
5483 add_karaoke_title(p->karaoke_title, si + 2);
5484 else if(si[0] == '\\')
5485 goto end_of_parse;
5486 }
5487 reuse_mblock(&tmpbuffer);
5488 }
5489 else if(type == 0x2F)
5490 {
5491 pos = tf_tell(tf);
5492 if(pos < next_pos)
5493 tf_seek(tf, next_pos - pos, SEEK_CUR);
5494 break; /* End of track */
5495 }
5496 else
5497 skip(tf, len);
5498 }
5499 else /* MIDI event */
5500 {
5501 /* skip MIDI event */
5502 karaoke_format = -1;
5503 if(trk != 0)
5504 goto end_of_parse;
5505
5506 if(me & 0x80) /* status byte */
5507 {
5508 laststatus = (me >> 4) & 0x07;
5509 if(laststatus != 7)
5510 tf_getc(tf);
5511 }
5512
5513 switch(laststatus)
5514 {
5515 case 0: case 1: case 2: case 3: case 6:
5516 tf_getc(tf);
5517 break;
5518 case 7:
5519 if(!(me & 0x80))
5520 break;
5521 switch(me & 0x0F)
5522 {
5523 case 2:
5524 tf_getc(tf);
5525 tf_getc(tf);
5526 break;
5527 case 3:
5528 tf_getc(tf);
5529 break;
5530 }
5531 break;
5532 }
5533 }
5534 }
5535 }
5536
5537 end_of_parse:
5538 if(check_cache)
5539 {
5540 url_rewind(tf->url);
5541 url_cache_disable(tf->url);
5542 url_make_file_data(tf->url, p);
5543 }
5544 close_file(tf);
5545 if(p->first_text == NULL)
5546 p->first_text = safe_strdup("");
5547 return get_midi_title1(p);
5548 }
5549
midi_file_save_as(char * in_name,char * out_name)5550 int midi_file_save_as(char *in_name, char *out_name)
5551 {
5552 struct timidity_file *tf;
5553 FILE* ofp;
5554 char buff[BUFSIZ];
5555 long n;
5556
5557 if(in_name == NULL)
5558 {
5559 if(current_file_info == NULL)
5560 return 0;
5561 in_name = current_file_info->filename;
5562 }
5563 out_name = (char *)url_expand_home_dir(out_name);
5564
5565 ctl->cmsg(CMSG_INFO, VERB_NORMAL, "Save as %s...", out_name);
5566
5567 errno = 0;
5568 if((tf = open_midi_file(in_name, 1, 0)) == NULL)
5569 {
5570 ctl->cmsg(CMSG_ERROR, VERB_NORMAL,
5571 "%s: %s", out_name,
5572 errno ? strerror(errno) : "Can't save file");
5573 return -1;
5574 }
5575
5576 errno = 0;
5577 if((ofp = fopen(out_name, "wb")) == NULL)
5578 {
5579 ctl->cmsg(CMSG_ERROR, VERB_NORMAL,
5580 "%s: %s", out_name,
5581 errno ? strerror(errno) : "Can't save file");
5582 close_file(tf);
5583 return -1;
5584 }
5585
5586 while((n = tf_read(buff, 1, sizeof(buff), tf)) > 0) {
5587 size_t dummy = fwrite(buff, 1, n, ofp); ++dummy;
5588 }
5589 ctl->cmsg(CMSG_INFO, VERB_NORMAL, "Save as %s...Done", out_name);
5590
5591 fclose(ofp);
5592 close_file(tf);
5593 return 0;
5594 }
5595
event2string(int id)5596 char *event2string(int id)
5597 {
5598 if(id == 0)
5599 return "";
5600 #ifdef ABORT_AT_FATAL
5601 if(id >= string_event_table_size)
5602 abort();
5603 #endif /* ABORT_AT_FATAL */
5604 if(string_event_table == NULL || id < 0 || id >= string_event_table_size)
5605 return NULL;
5606 return string_event_table[id];
5607 }
5608
5609 /*! initialize Delay Effect (GS) */
init_delay_status_gs(void)5610 void init_delay_status_gs(void)
5611 {
5612 struct delay_status_gs_t *p = &delay_status_gs;
5613 p->type = 0;
5614 p->level = 0x40;
5615 p->level_center = 0x7F;
5616 p->level_left = 0;
5617 p->level_right = 0;
5618 p->time_c = 0x61;
5619 p->time_l = 0x01;
5620 p->time_r = 0x01;
5621 p->feedback = 0x50;
5622 p->pre_lpf = 0;
5623 recompute_delay_status_gs();
5624 }
5625
5626 /*! recompute Delay Effect (GS) */
recompute_delay_status_gs(void)5627 void recompute_delay_status_gs(void)
5628 {
5629 struct delay_status_gs_t *p = &delay_status_gs;
5630 p->time_center = delay_time_center_table[p->time_c > 0x73 ? 0x73 : p->time_c];
5631 p->time_ratio_left = (double)p->time_l / 24;
5632 p->time_ratio_right = (double)p->time_r / 24;
5633 p->sample[0] = p->time_center * play_mode->rate / 1000.0f;
5634 p->sample[1] = p->sample[0] * p->time_ratio_left;
5635 p->sample[2] = p->sample[0] * p->time_ratio_right;
5636 p->level_ratio[0] = p->level * p->level_center / (127.0f * 127.0f);
5637 p->level_ratio[1] = p->level * p->level_left / (127.0f * 127.0f);
5638 p->level_ratio[2] = p->level * p->level_right / (127.0f * 127.0f);
5639 p->feedback_ratio = (double)(p->feedback - 64) * (0.763f * 2.0f / 100.0f);
5640 p->send_reverb_ratio = (double)p->send_reverb * (0.787f / 100.0f);
5641
5642 if(p->level_left != 0 || (p->level_right != 0 && p->type == 0)) {
5643 p->type = 1; /* it needs 3-tap delay effect. */
5644 }
5645
5646 if(p->pre_lpf) {
5647 p->lpf.a = 2.0 * ((double)(7 - p->pre_lpf) / 7.0f * 16000.0f + 200.0f) / play_mode->rate;
5648 init_filter_lowpass1(&(p->lpf));
5649 }
5650 }
5651
5652 /*! Delay Macro (GS) */
set_delay_macro_gs(int macro)5653 void set_delay_macro_gs(int macro)
5654 {
5655 struct delay_status_gs_t *p = &delay_status_gs;
5656 if(macro >= 4) {p->type = 2;} /* cross delay */
5657 macro *= 10;
5658 p->time_center = delay_time_center_table[delay_macro_presets[macro + 1]];
5659 p->time_ratio_left = (double)delay_macro_presets[macro + 2] / 24;
5660 p->time_ratio_right = (double)delay_macro_presets[macro + 3] / 24;
5661 p->level_center = delay_macro_presets[macro + 4];
5662 p->level_left = delay_macro_presets[macro + 5];
5663 p->level_right = delay_macro_presets[macro + 6];
5664 p->level = delay_macro_presets[macro + 7];
5665 p->feedback = delay_macro_presets[macro + 8];
5666 }
5667
5668 /*! initialize Reverb Effect (GS) */
init_reverb_status_gs(void)5669 void init_reverb_status_gs(void)
5670 {
5671 struct reverb_status_gs_t *p = &reverb_status_gs;
5672 p->character = 0x04;
5673 p->pre_lpf = 0;
5674 p->level = 0x40;
5675 p->time = 0x40;
5676 p->delay_feedback = 0;
5677 p->pre_delay_time = 0;
5678 recompute_reverb_status_gs();
5679 init_reverb();
5680 }
5681
5682 /*! recompute Reverb Effect (GS) */
recompute_reverb_status_gs(void)5683 void recompute_reverb_status_gs(void)
5684 {
5685 struct reverb_status_gs_t *p = &reverb_status_gs;
5686
5687 if(p->pre_lpf) {
5688 p->lpf.a = 2.0 * ((double)(7 - p->pre_lpf) / 7.0f * 16000.0f + 200.0f) / play_mode->rate;
5689 init_filter_lowpass1(&(p->lpf));
5690 }
5691 }
5692
5693 /*! Reverb Type (GM2) */
set_reverb_macro_gm2(int macro)5694 void set_reverb_macro_gm2(int macro)
5695 {
5696 struct reverb_status_gs_t *p = &reverb_status_gs;
5697 int type = macro;
5698 if (macro == 8) {macro = 5;}
5699 macro *= 6;
5700 p->character = reverb_macro_presets[macro];
5701 p->pre_lpf = reverb_macro_presets[macro + 1];
5702 p->level = reverb_macro_presets[macro + 2];
5703 p->time = reverb_macro_presets[macro + 3];
5704 p->delay_feedback = reverb_macro_presets[macro + 4];
5705 p->pre_delay_time = reverb_macro_presets[macro + 5];
5706
5707 switch(type) { /* override GS macro's parameter */
5708 case 0: /* Small Room */
5709 p->time = 44;
5710 break;
5711 case 1: /* Medium Room */
5712 case 8: /* Plate */
5713 p->time = 50;
5714 break;
5715 case 2: /* Large Room */
5716 p->time = 56;
5717 break;
5718 case 3: /* Medium Hall */
5719 case 4: /* Large Hall */
5720 p->time = 64;
5721 break;
5722 }
5723 }
5724
5725 /*! Reverb Macro (GS) */
set_reverb_macro_gs(int macro)5726 void set_reverb_macro_gs(int macro)
5727 {
5728 struct reverb_status_gs_t *p = &reverb_status_gs;
5729 macro *= 6;
5730 p->character = reverb_macro_presets[macro];
5731 p->pre_lpf = reverb_macro_presets[macro + 1];
5732 p->level = reverb_macro_presets[macro + 2];
5733 p->time = reverb_macro_presets[macro + 3];
5734 p->delay_feedback = reverb_macro_presets[macro + 4];
5735 p->pre_delay_time = reverb_macro_presets[macro + 5];
5736 }
5737
5738 /*! initialize Chorus Effect (GS) */
init_chorus_status_gs(void)5739 void init_chorus_status_gs(void)
5740 {
5741 struct chorus_status_gs_t *p = &chorus_status_gs;
5742 p->macro = 0;
5743 p->pre_lpf = 0;
5744 p->level = 0x40;
5745 p->feedback = 0x08;
5746 p->delay = 0x50;
5747 p->rate = 0x03;
5748 p->depth = 0x13;
5749 p->send_reverb = 0;
5750 p->send_delay = 0;
5751 recompute_chorus_status_gs();
5752 }
5753
5754 /*! recompute Chorus Effect (GS) */
recompute_chorus_status_gs()5755 void recompute_chorus_status_gs()
5756 {
5757 struct chorus_status_gs_t *p = &chorus_status_gs;
5758
5759 if(p->pre_lpf) {
5760 p->lpf.a = 2.0 * ((double)(7 - p->pre_lpf) / 7.0f * 16000.0f + 200.0f) / play_mode->rate;
5761 init_filter_lowpass1(&(p->lpf));
5762 }
5763 }
5764
5765 /*! Chorus Macro (GS), Chorus Type (GM2) */
set_chorus_macro_gs(int macro)5766 void set_chorus_macro_gs(int macro)
5767 {
5768 struct chorus_status_gs_t *p = &chorus_status_gs;
5769 macro *= 8;
5770 p->pre_lpf = chorus_macro_presets[macro];
5771 p->level = chorus_macro_presets[macro + 1];
5772 p->feedback = chorus_macro_presets[macro + 2];
5773 p->delay = chorus_macro_presets[macro + 3];
5774 p->rate = chorus_macro_presets[macro + 4];
5775 p->depth = chorus_macro_presets[macro + 5];
5776 p->send_reverb = chorus_macro_presets[macro + 6];
5777 p->send_delay = chorus_macro_presets[macro + 7];
5778 }
5779
5780 /*! initialize EQ (GS) */
init_eq_status_gs(void)5781 void init_eq_status_gs(void)
5782 {
5783 struct eq_status_gs_t *p = &eq_status_gs;
5784 p->low_freq = 0;
5785 p->low_gain = 0x40;
5786 p->high_freq = 0;
5787 p->high_gain = 0x40;
5788 recompute_eq_status_gs();
5789 }
5790
5791 /*! recompute EQ (GS) */
recompute_eq_status_gs(void)5792 void recompute_eq_status_gs(void)
5793 {
5794 double freq, dbGain;
5795 struct eq_status_gs_t *p = &eq_status_gs;
5796
5797 /* Lowpass Shelving Filter */
5798 if(p->low_freq == 0) {freq = 200;}
5799 else {freq = 400;}
5800 dbGain = p->low_gain - 0x40;
5801 if(freq < play_mode->rate / 2) {
5802 p->lsf.q = 0;
5803 p->lsf.freq = freq;
5804 p->lsf.gain = dbGain;
5805 calc_filter_shelving_low(&(p->lsf));
5806 }
5807
5808 /* Highpass Shelving Filter */
5809 if(p->high_freq == 0) {freq = 3000;}
5810 else {freq = 6000;}
5811 dbGain = p->high_gain - 0x40;
5812 if(freq < play_mode->rate / 2) {
5813 p->hsf.q = 0;
5814 p->hsf.freq = freq;
5815 p->hsf.gain = dbGain;
5816 calc_filter_shelving_high(&(p->hsf));
5817 }
5818 }
5819
5820 /*! initialize Multi EQ (XG) */
init_multi_eq_xg(void)5821 void init_multi_eq_xg(void)
5822 {
5823 multi_eq_xg.valid = 0;
5824 set_multi_eq_type_xg(0);
5825 recompute_multi_eq_xg();
5826 }
5827
5828 /*! set Multi EQ type (XG) */
set_multi_eq_type_xg(int type)5829 void set_multi_eq_type_xg(int type)
5830 {
5831 struct multi_eq_xg_t *p = &multi_eq_xg;
5832 type *= 20;
5833 p->gain1 = multi_eq_block_table_xg[type];
5834 p->freq1 = multi_eq_block_table_xg[type + 1];
5835 p->q1 = multi_eq_block_table_xg[type + 2];
5836 p->shape1 = multi_eq_block_table_xg[type + 3];
5837 p->gain2 = multi_eq_block_table_xg[type + 4];
5838 p->freq2 = multi_eq_block_table_xg[type + 5];
5839 p->q2 = multi_eq_block_table_xg[type + 6];
5840 p->gain3 = multi_eq_block_table_xg[type + 8];
5841 p->freq3 = multi_eq_block_table_xg[type + 9];
5842 p->q3 = multi_eq_block_table_xg[type + 10];
5843 p->gain4 = multi_eq_block_table_xg[type + 12];
5844 p->freq4 = multi_eq_block_table_xg[type + 13];
5845 p->q4 = multi_eq_block_table_xg[type + 14];
5846 p->gain5 = multi_eq_block_table_xg[type + 16];
5847 p->freq5 = multi_eq_block_table_xg[type + 17];
5848 p->q5 = multi_eq_block_table_xg[type + 18];
5849 p->shape5 = multi_eq_block_table_xg[type + 19];
5850 }
5851
5852 /*! recompute Multi EQ (XG) */
recompute_multi_eq_xg(void)5853 void recompute_multi_eq_xg(void)
5854 {
5855 struct multi_eq_xg_t *p = &multi_eq_xg;
5856
5857 if(p->freq1 != 0 && p->freq1 < 60 && p->gain1 != 0x40) {
5858 p->valid1 = 1;
5859 if(p->shape1) { /* peaking */
5860 p->eq1p.q = (double)p->q1 / 10.0;
5861 p->eq1p.freq = eq_freq_table_xg[p->freq1];
5862 p->eq1p.gain = p->gain1 - 0x40;
5863 calc_filter_peaking(&(p->eq1p));
5864 } else { /* shelving */
5865 p->eq1s.q = (double)p->q1 / 10.0;
5866 p->eq1s.freq = eq_freq_table_xg[p->freq1];
5867 p->eq1s.gain = p->gain1 - 0x40;
5868 calc_filter_shelving_low(&(p->eq1s));
5869 }
5870 } else {p->valid1 = 0;}
5871 if(p->freq2 != 0 && p->freq2 < 60 && p->gain2 != 0x40) {
5872 p->valid2 = 1;
5873 p->eq2p.q = (double)p->q2 / 10.0;
5874 p->eq2p.freq = eq_freq_table_xg[p->freq2];
5875 p->eq2p.gain = p->gain2 - 0x40;
5876 calc_filter_peaking(&(p->eq2p));
5877 } else {p->valid2 = 0;}
5878 if(p->freq3 != 0 && p->freq3 < 60 && p->gain3 != 0x40) {
5879 p->valid3 = 1;
5880 p->eq3p.q = (double)p->q3 / 10.0;
5881 p->eq4p.freq = eq_freq_table_xg[p->freq3];
5882 p->eq4p.gain = p->gain3 - 0x40;
5883 calc_filter_peaking(&(p->eq3p));
5884 } else {p->valid3 = 0;}
5885 if(p->freq4 != 0 && p->freq4 < 60 && p->gain4 != 0x40) {
5886 p->valid4 = 1;
5887 p->eq4p.q = (double)p->q4 / 10.0;
5888 p->eq4p.freq = eq_freq_table_xg[p->freq4];
5889 p->eq4p.gain = p->gain4 - 0x40;
5890 calc_filter_peaking(&(p->eq4p));
5891 } else {p->valid4 = 0;}
5892 if(p->freq5 != 0 && p->freq5 < 60 && p->gain5 != 0x40) {
5893 p->valid5 = 1;
5894 if(p->shape5) { /* peaking */
5895 p->eq5p.q = (double)p->q5 / 10.0;
5896 p->eq5p.freq = eq_freq_table_xg[p->freq5];
5897 p->eq5p.gain = p->gain5 - 0x40;
5898 calc_filter_peaking(&(p->eq5p));
5899 } else { /* shelving */
5900 p->eq5s.q = (double)p->q5 / 10.0;
5901 p->eq5s.freq = eq_freq_table_xg[p->freq5];
5902 p->eq5s.gain = p->gain5 - 0x40;
5903 calc_filter_shelving_high(&(p->eq5s));
5904 }
5905 } else {p->valid5 = 0;}
5906 p->valid = p->valid1 || p->valid2 || p->valid3 || p->valid4 || p->valid5;
5907 }
5908
5909 /*! convert GS user drumset assign groups to internal "alternate assign". */
recompute_userdrum_altassign(int bank,int group)5910 void recompute_userdrum_altassign(int bank, int group)
5911 {
5912 int number = 0, i;
5913 char *params[131], param[10];
5914 ToneBank *bk;
5915 UserDrumset *p;
5916
5917 for(p = userdrum_first; p != NULL; p = p->next) {
5918 if(p->assign_group == group) {
5919 sprintf(param, "%d", p->prog);
5920 params[number] = safe_strdup(param);
5921 number++;
5922 }
5923 }
5924 params[number] = NULL;
5925
5926 alloc_instrument_bank(1, bank);
5927 bk = drumset[bank];
5928 bk->alt = add_altassign_string(bk->alt, params, number);
5929 for (i = number - 1; i >= 0; i--)
5930 free(params[i]);
5931 }
5932
5933 /*! initialize GS user drumset. */
init_userdrum()5934 void init_userdrum()
5935 {
5936 int i;
5937 AlternateAssign *alt;
5938
5939 free_userdrum();
5940
5941 for(i=0;i<2;i++) { /* allocate alternative assign */
5942 alt = (AlternateAssign *)safe_malloc(sizeof(AlternateAssign));
5943 memset(alt, 0, sizeof(AlternateAssign));
5944 alloc_instrument_bank(1, 64 + i);
5945 drumset[64 + i]->alt = alt;
5946 }
5947 }
5948
5949 /*! recompute GS user drumset. */
recompute_userdrum(int bank,int prog)5950 Instrument *recompute_userdrum(int bank, int prog)
5951 {
5952 UserDrumset *p;
5953 Instrument *ip = NULL;
5954
5955 p = get_userdrum(bank, prog);
5956
5957 free_tone_bank_element(&drumset[bank]->tone[prog]);
5958 if(drumset[p->source_prog]) {
5959 ToneBankElement *source_tone = &drumset[p->source_prog]->tone[p->source_note];
5960
5961 if(source_tone->name == NULL /* NULL if "soundfont" directive is used */
5962 && source_tone->instrument == NULL) {
5963 if((ip = load_instrument(1, p->source_prog, p->source_note)) == NULL) {
5964 ip = MAGIC_ERROR_INSTRUMENT;
5965 }
5966 source_tone->instrument = ip;
5967 }
5968 if(source_tone->name) {
5969 copy_tone_bank_element(&drumset[bank]->tone[prog], source_tone);
5970 ctl->cmsg(CMSG_INFO,VERB_NOISY,"User Drumset (%d %d -> %d %d)", p->source_prog, p->source_note, bank, prog);
5971 } else if(drumset[0]->tone[p->source_note].name) {
5972 copy_tone_bank_element(&drumset[bank]->tone[prog], &drumset[0]->tone[p->source_note]);
5973 ctl->cmsg(CMSG_INFO,VERB_NOISY,"User Drumset (%d %d -> %d %d)", 0, p->source_note, bank, prog);
5974 } else {
5975 ctl->cmsg(CMSG_WARNING, VERB_NORMAL, "Referring user drum set %d, note %d not found - this instrument will not be heard as expected", bank, prog);
5976 }
5977 }
5978 return ip;
5979 }
5980
5981 /*! get pointer to requested GS user drumset.
5982 if it's not found, allocate a new item first. */
get_userdrum(int bank,int prog)5983 UserDrumset *get_userdrum(int bank, int prog)
5984 {
5985 UserDrumset *p;
5986
5987 for(p = userdrum_first; p != NULL; p = p->next) {
5988 if(p->bank == bank && p->prog == prog) {return p;}
5989 }
5990
5991 p = (UserDrumset *)safe_malloc(sizeof(UserDrumset));
5992 memset(p, 0, sizeof(UserDrumset));
5993 p->next = NULL;
5994 if(userdrum_first == NULL) {
5995 userdrum_first = p;
5996 userdrum_last = p;
5997 } else {
5998 userdrum_last->next = p;
5999 userdrum_last = p;
6000 }
6001 p->bank = bank;
6002 p->prog = prog;
6003
6004 return p;
6005 }
6006
6007 /*! free GS user drumset. */
free_userdrum()6008 void free_userdrum()
6009 {
6010 UserDrumset *p, *next;
6011
6012 for(p = userdrum_first; p != NULL; p = next){
6013 next = p->next;
6014 free(p);
6015 }
6016 userdrum_first = userdrum_last = NULL;
6017 }
6018
6019 /*! initialize GS user instrument. */
init_userinst()6020 void init_userinst()
6021 {
6022 free_userinst();
6023 }
6024
6025 /*! recompute GS user instrument. */
recompute_userinst(int bank,int prog)6026 void recompute_userinst(int bank, int prog)
6027 {
6028 UserInstrument *p;
6029
6030 p = get_userinst(bank, prog);
6031
6032 free_tone_bank_element(&tonebank[bank]->tone[prog]);
6033 if(tonebank[p->source_bank]) {
6034 if(tonebank[p->source_bank]->tone[p->source_prog].name) {
6035 copy_tone_bank_element(&tonebank[bank]->tone[prog], &tonebank[p->source_bank]->tone[p->source_prog]);
6036 ctl->cmsg(CMSG_INFO,VERB_NOISY,"User Instrument (%d %d -> %d %d)", p->source_bank, p->source_prog, bank, prog);
6037 } else if(tonebank[0]->tone[p->source_prog].name) {
6038 copy_tone_bank_element(&tonebank[bank]->tone[prog], &tonebank[0]->tone[p->source_prog]);
6039 ctl->cmsg(CMSG_INFO,VERB_NOISY,"User Instrument (%d %d -> %d %d)", 0, p->source_prog, bank, prog);
6040 }
6041 }
6042 }
6043
6044 /*! get pointer to requested GS user instrument.
6045 if it's not found, allocate a new item first. */
get_userinst(int bank,int prog)6046 UserInstrument *get_userinst(int bank, int prog)
6047 {
6048 UserInstrument *p;
6049
6050 for(p = userinst_first; p != NULL; p = p->next) {
6051 if(p->bank == bank && p->prog == prog) {return p;}
6052 }
6053
6054 p = (UserInstrument *)safe_malloc(sizeof(UserInstrument));
6055 memset(p, 0, sizeof(UserInstrument));
6056 p->next = NULL;
6057 if(userinst_first == NULL) {
6058 userinst_first = p;
6059 userinst_last = p;
6060 } else {
6061 userinst_last->next = p;
6062 userinst_last = p;
6063 }
6064 p->bank = bank;
6065 p->prog = prog;
6066
6067 return p;
6068 }
6069
6070 /*! free GS user instrument. */
free_userinst()6071 void free_userinst()
6072 {
6073 UserInstrument *p, *next;
6074
6075 for(p = userinst_first; p != NULL; p = next){
6076 next = p->next;
6077 free(p);
6078 }
6079 userinst_first = userinst_last = NULL;
6080 }
6081
set_effect_param_xg(struct effect_xg_t * st,int type_msb,int type_lsb)6082 static void set_effect_param_xg(struct effect_xg_t *st, int type_msb, int type_lsb)
6083 {
6084 int i, j;
6085 for (i = 0; effect_parameter_xg[i].type_msb != -1
6086 && effect_parameter_xg[i].type_lsb != -1; i++) {
6087 if (type_msb == effect_parameter_xg[i].type_msb
6088 && type_lsb == effect_parameter_xg[i].type_lsb) {
6089 for (j = 0; j < 16; j++) {
6090 st->param_lsb[j] = effect_parameter_xg[i].param_lsb[j];
6091 }
6092 for (j = 0; j < 10; j++) {
6093 st->param_msb[j] = effect_parameter_xg[i].param_msb[j];
6094 }
6095 ctl->cmsg(CMSG_INFO, VERB_NOISY, "XG EFX: %s", effect_parameter_xg[i].name);
6096 return;
6097 }
6098 }
6099 if (type_msb != 0) {
6100 for (i = 0; effect_parameter_xg[i].type_msb != -1
6101 && effect_parameter_xg[i].type_lsb != -1; i++) {
6102 if (type_lsb == effect_parameter_xg[i].type_lsb) {
6103 for (j = 0; j < 16; j++) {
6104 st->param_lsb[j] = effect_parameter_xg[i].param_lsb[j];
6105 }
6106 for (j = 0; j < 10; j++) {
6107 st->param_msb[j] = effect_parameter_xg[i].param_msb[j];
6108 }
6109 ctl->cmsg(CMSG_INFO, VERB_NOISY, "XG EFX: %s", effect_parameter_xg[i].name);
6110 return;
6111 }
6112 }
6113 }
6114 }
6115
6116 /*! recompute XG effect parameters. */
recompute_effect_xg(struct effect_xg_t * st)6117 void recompute_effect_xg(struct effect_xg_t *st)
6118 {
6119 EffectList *efc = st->ef;
6120
6121 if (efc == NULL) {return;}
6122 while (efc != NULL && efc->info != NULL)
6123 {
6124 (*efc->engine->conv_xg)(st, efc);
6125 (*efc->engine->do_effect)(NULL, MAGIC_INIT_EFFECT_INFO, efc);
6126 efc = efc->next_ef;
6127 }
6128 }
6129
realloc_effect_xg(struct effect_xg_t * st)6130 void realloc_effect_xg(struct effect_xg_t *st)
6131 {
6132 int type_msb = st->type_msb, type_lsb = st->type_lsb;
6133
6134 free_effect_list(st->ef);
6135 st->ef = NULL;
6136 st->use_msb = 0;
6137
6138 switch(type_msb) {
6139 case 0x05:
6140 st->use_msb = 1;
6141 st->ef = push_effect(st->ef, EFFECT_DELAY_LCR);
6142 st->ef = push_effect(st->ef, EFFECT_DELAY_EQ2);
6143 break;
6144 case 0x06:
6145 st->use_msb = 1;
6146 st->ef = push_effect(st->ef, EFFECT_DELAY_LR);
6147 st->ef = push_effect(st->ef, EFFECT_DELAY_EQ2);
6148 break;
6149 case 0x07:
6150 st->use_msb = 1;
6151 st->ef = push_effect(st->ef, EFFECT_ECHO);
6152 st->ef = push_effect(st->ef, EFFECT_DELAY_EQ2);
6153 break;
6154 case 0x08:
6155 st->use_msb = 1;
6156 st->ef = push_effect(st->ef, EFFECT_CROSS_DELAY);
6157 st->ef = push_effect(st->ef, EFFECT_DELAY_EQ2);
6158 break;
6159 case 0x41:
6160 case 0x42:
6161 st->ef = push_effect(st->ef, EFFECT_CHORUS);
6162 st->ef = push_effect(st->ef, EFFECT_CHORUS_EQ3);
6163 break;
6164 case 0x43:
6165 st->ef = push_effect(st->ef, EFFECT_FLANGER);
6166 st->ef = push_effect(st->ef, EFFECT_CHORUS_EQ3);
6167 break;
6168 case 0x44:
6169 st->ef = push_effect(st->ef, EFFECT_SYMPHONIC);
6170 st->ef = push_effect(st->ef, EFFECT_CHORUS_EQ3);
6171 break;
6172 case 0x49:
6173 st->ef = push_effect(st->ef, EFFECT_STEREO_DISTORTION);
6174 st->ef = push_effect(st->ef, EFFECT_OD_EQ3);
6175 break;
6176 case 0x4A:
6177 st->ef = push_effect(st->ef, EFFECT_STEREO_OVERDRIVE);
6178 st->ef = push_effect(st->ef, EFFECT_OD_EQ3);
6179 break;
6180 case 0x4B:
6181 st->ef = push_effect(st->ef, EFFECT_STEREO_AMP_SIMULATOR);
6182 break;
6183 case 0x4C:
6184 st->ef = push_effect(st->ef, EFFECT_EQ3);
6185 break;
6186 case 0x4D:
6187 st->ef = push_effect(st->ef, EFFECT_EQ2);
6188 break;
6189 case 0x4E:
6190 if (type_lsb == 0x01 || type_lsb == 0x02) {
6191 st->ef = push_effect(st->ef, EFFECT_XG_AUTO_WAH);
6192 st->ef = push_effect(st->ef, EFFECT_XG_AUTO_WAH_EQ2);
6193 st->ef = push_effect(st->ef, EFFECT_XG_AUTO_WAH_OD);
6194 st->ef = push_effect(st->ef, EFFECT_XG_AUTO_WAH_OD_EQ3);
6195 } else {
6196 st->ef = push_effect(st->ef, EFFECT_XG_AUTO_WAH);
6197 st->ef = push_effect(st->ef, EFFECT_XG_AUTO_WAH_EQ2);
6198 }
6199 break;
6200 case 0x5E:
6201 st->ef = push_effect(st->ef, EFFECT_LOFI);
6202 break;
6203 default: /* Not Supported */
6204 type_msb = type_lsb = 0;
6205 break;
6206 }
6207 set_effect_param_xg(st, type_msb, type_lsb);
6208 recompute_effect_xg(st);
6209 }
6210
init_effect_xg(struct effect_xg_t * st)6211 static void init_effect_xg(struct effect_xg_t *st)
6212 {
6213 int i;
6214
6215 free_effect_list(st->ef);
6216 st->ef = NULL;
6217
6218 st->use_msb = 0;
6219 st->type_msb = st->type_lsb = st->connection =
6220 st->send_reverb = st->send_chorus = 0;
6221 st->part = 0x7f;
6222 st->ret = st->pan = st->mw_depth = st->bend_depth = st->cat_depth =
6223 st->ac1_depth = st->ac2_depth = st->cbc1_depth = st->cbc2_depth = 0x40;
6224 for (i = 0; i < 16; i++) {st->param_lsb[i] = 0;}
6225 for (i = 0; i < 10; i++) {st->param_msb[i] = 0;}
6226 }
6227
6228 /*! initialize XG effect parameters */
init_all_effect_xg(void)6229 static void init_all_effect_xg(void)
6230 {
6231 int i;
6232 init_effect_xg(&reverb_status_xg);
6233 reverb_status_xg.type_msb = 0x01;
6234 reverb_status_xg.connection = XG_CONN_SYSTEM_REVERB;
6235 realloc_effect_xg(&reverb_status_xg);
6236 init_effect_xg(&chorus_status_xg);
6237 chorus_status_xg.type_msb = 0x41;
6238 chorus_status_xg.connection = XG_CONN_SYSTEM_CHORUS;
6239 realloc_effect_xg(&chorus_status_xg);
6240 for (i = 0; i < XG_VARIATION_EFFECT_NUM; i++) {
6241 init_effect_xg(&variation_effect_xg[i]);
6242 variation_effect_xg[i].type_msb = 0x05;
6243 realloc_effect_xg(&variation_effect_xg[i]);
6244 }
6245 for (i = 0; i < XG_INSERTION_EFFECT_NUM; i++) {
6246 init_effect_xg(&insertion_effect_xg[i]);
6247 insertion_effect_xg[i].type_msb = 0x49;
6248 realloc_effect_xg(&insertion_effect_xg[i]);
6249 }
6250 init_ch_effect_xg();
6251 }
6252
6253 /*! initialize GS insertion effect parameters */
init_insertion_effect_gs(void)6254 void init_insertion_effect_gs(void)
6255 {
6256 int i;
6257 struct insertion_effect_gs_t *st = &insertion_effect_gs;
6258
6259 free_effect_list(st->ef);
6260 st->ef = NULL;
6261
6262 for(i = 0; i < 20; i++) {st->parameter[i] = 0;}
6263
6264 st->type = 0;
6265 st->type_lsb = 0;
6266 st->type_msb = 0;
6267 st->send_reverb = 0x28;
6268 st->send_chorus = 0;
6269 st->send_delay = 0;
6270 st->control_source1 = 0;
6271 st->control_depth1 = 0x40;
6272 st->control_source2 = 0;
6273 st->control_depth2 = 0x40;
6274 st->send_eq_switch = 0x01;
6275 }
6276
set_effect_param_gs(struct insertion_effect_gs_t * st,int msb,int lsb)6277 static void set_effect_param_gs(struct insertion_effect_gs_t *st, int msb, int lsb)
6278 {
6279 int i, j;
6280 for (i = 0; effect_parameter_gs[i].type_msb != -1
6281 && effect_parameter_gs[i].type_lsb != -1; i++) {
6282 if (msb == effect_parameter_gs[i].type_msb
6283 && lsb == effect_parameter_gs[i].type_lsb) {
6284 for (j = 0; j < 20; j++) {
6285 st->parameter[j] = effect_parameter_gs[i].param[j];
6286 }
6287 ctl->cmsg(CMSG_INFO, VERB_NOISY, "GS EFX: %s", effect_parameter_gs[i].name);
6288 break;
6289 }
6290 }
6291 }
6292
6293 /*! recompute GS insertion effect parameters. */
recompute_insertion_effect_gs(void)6294 void recompute_insertion_effect_gs(void)
6295 {
6296 struct insertion_effect_gs_t *st = &insertion_effect_gs;
6297 EffectList *efc = st->ef;
6298
6299 if (st->ef == NULL) {return;}
6300 while(efc != NULL && efc->info != NULL)
6301 {
6302 (*efc->engine->conv_gs)(st, efc);
6303 (*efc->engine->do_effect)(NULL, MAGIC_INIT_EFFECT_INFO, efc);
6304 efc = efc->next_ef;
6305 }
6306 }
6307
6308 /*! re-allocate GS insertion effect parameters. */
realloc_insertion_effect_gs(void)6309 void realloc_insertion_effect_gs(void)
6310 {
6311 struct insertion_effect_gs_t *st = &insertion_effect_gs;
6312 int type_msb = st->type_msb, type_lsb = st->type_lsb;
6313
6314 free_effect_list(st->ef);
6315 st->ef = NULL;
6316
6317 switch(type_msb) {
6318 case 0x01:
6319 switch(type_lsb) {
6320 case 0x00: /* Stereo-EQ */
6321 st->ef = push_effect(st->ef, EFFECT_STEREO_EQ);
6322 break;
6323 case 0x10: /* Overdrive */
6324 st->ef = push_effect(st->ef, EFFECT_EQ2);
6325 st->ef = push_effect(st->ef, EFFECT_OVERDRIVE1);
6326 break;
6327 case 0x11: /* Distortion */
6328 st->ef = push_effect(st->ef, EFFECT_EQ2);
6329 st->ef = push_effect(st->ef, EFFECT_DISTORTION1);
6330 break;
6331 case 0x40: /* Hexa Chorus */
6332 st->ef = push_effect(st->ef, EFFECT_EQ2);
6333 st->ef = push_effect(st->ef, EFFECT_HEXA_CHORUS);
6334 break;
6335 case 0x72: /* Lo-Fi 1 */
6336 st->ef = push_effect(st->ef, EFFECT_EQ2);
6337 st->ef = push_effect(st->ef, EFFECT_LOFI1);
6338 break;
6339 case 0x73: /* Lo-Fi 2 */
6340 st->ef = push_effect(st->ef, EFFECT_EQ2);
6341 st->ef = push_effect(st->ef, EFFECT_LOFI2);
6342 break;
6343 default: break;
6344 }
6345 break;
6346 case 0x11:
6347 switch(type_lsb) {
6348 case 0x03: /* OD1 / OD2 */
6349 st->ef = push_effect(st->ef, EFFECT_OD1OD2);
6350 break;
6351 default: break;
6352 }
6353 break;
6354 default: break;
6355 }
6356
6357 set_effect_param_gs(st, type_msb, type_lsb);
6358
6359 recompute_insertion_effect_gs();
6360 }
6361
6362 /*! initialize channel layers. */
init_channel_layer(int ch)6363 void init_channel_layer(int ch)
6364 {
6365 if (ch >= MAX_CHANNELS)
6366 return;
6367 CLEAR_CHANNELMASK(channel[ch].channel_layer);
6368 SET_CHANNELMASK(channel[ch].channel_layer, ch);
6369 channel[ch].port_select = ch >> 4;
6370 }
6371
6372 /*! add a new layer. */
add_channel_layer(int to_ch,int from_ch)6373 void add_channel_layer(int to_ch, int from_ch)
6374 {
6375 if (to_ch >= MAX_CHANNELS || from_ch >= MAX_CHANNELS)
6376 return;
6377 /* add a channel layer */
6378 UNSET_CHANNELMASK(channel[to_ch].channel_layer, to_ch);
6379 SET_CHANNELMASK(channel[to_ch].channel_layer, from_ch);
6380 ctl->cmsg(CMSG_INFO, VERB_NOISY,
6381 "Channel Layer (CH:%d -> CH:%d)", from_ch, to_ch);
6382 }
6383
6384 /*! remove all layers for this channel. */
remove_channel_layer(int ch)6385 void remove_channel_layer(int ch)
6386 {
6387 int i, offset;
6388
6389 if (ch >= MAX_CHANNELS)
6390 return;
6391 /* remove channel layers */
6392 offset = ch & ~0xf;
6393 for (i = offset; i < offset + REDUCE_CHANNELS; i++)
6394 UNSET_CHANNELMASK(channel[i].channel_layer, ch);
6395 SET_CHANNELMASK(channel[ch].channel_layer, ch);
6396 }
6397
free_readmidi(void)6398 void free_readmidi(void)
6399 {
6400 reuse_mblock(&mempool);
6401 free_time_segments();
6402 free_all_midi_file_info();
6403 free_userdrum();
6404 free_userinst();
6405 if (string_event_strtab.nstring > 0)
6406 delete_string_table(&string_event_strtab);
6407 if (string_event_table != NULL) {
6408 free(string_event_table[0]);
6409 free(string_event_table);
6410 string_event_table = NULL;
6411 string_event_table_size = 0;
6412 }
6413 }
6414
6415