1 /*
2 TiMidity++ -- MIDI to WAVE converter and player
3 Copyright (C) 1999-2002 Masanao Izumo <mo@goice.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 /* rcp.c - written by Masanao Izumo <mo@goice.co.jp> */
25
26 #include <stdio.h>
27 #ifndef NO_STRING_H
28 #include <string.h>
29 #else
30 #include <strings.h>
31 #endif
32 #include "timidity.h"
33 #include "common.h"
34 #include "instrum.h"
35 #include "playmidi.h"
36 #include "readmidi.h"
37 #include "controls.h"
38
39 #define RCP_MAXCHANNELS 32
40 /* #define RCP_LOOP_CONT_LIMIT 16 */
41 #define RCP_LOOP_TIME_LIMIT 600
42
43 struct NoteList
44 {
45 int32 gate; /* Note length */
46 int ch; /* channel */
47 int note; /* Note number */
48 struct NoteList *next; /* next note */
49 };
50
51 struct RCPNoteTracer
52 {
53 int gfmt; /*! RCP format (1 if G36 or G18) */
54 int32 at; /*! current time */
55 int32 tempo; /*! current tempo (sync with current_tempo) */
56 int32 tempo_to; /*! tempo gradate to */
57 int tempo_grade; /*! tempo gradation slope */
58 int tempo_step; /*! tempo gradation step */
59 struct NoteList *notes; /*! note list */
60 MBlockList pool; /*! memory pool for notes */
61 struct NoteList *freelist; /*! free note list */
62 };
63
64 #define SETMIDIEVENT(e, at, t, ch, pa, pb) \
65 { (e).time = (at); (e).type = (t); \
66 (e).channel = (uint8)(ch); (e).a = (uint8)(pa); (e).b = (uint8)(pb); }
67
68 #define MIDIEVENT(at, t, ch, pa, pb) \
69 { MidiEvent event; SETMIDIEVENT(event, at, t, ch, pa, pb); \
70 readmidi_add_event(&event); }
71
72 static int read_rcp_track(struct timidity_file *tf, int trackno, int gfmt);
73 static int preprocess_sysex(uint8* ex, int ch, int gt, int vel);
74
75 /* Note Tracer */
76 static void ntr_init(struct RCPNoteTracer *ntr, int gfmt, int32 at);
77 static void ntr_end(struct RCPNoteTracer *ntr);
78 static void ntr_incr(struct RCPNoteTracer *ntr, int step);
79 static void ntr_note_on(struct RCPNoteTracer *ntr,
80 int ch, int note, int velo, int gate);
81 static void ntr_wait_all_off(struct RCPNoteTracer *ntr);
82 #define ntr_at(ntr) ((ntr).at)
83
84 #define USER_EXCLUSIVE_LENGTH 24
85 #define MAX_EXCLUSIVE_LENGTH 1024
86 static uint8 user_exclusive_data[8][USER_EXCLUSIVE_LENGTH];
87 static int32 init_tempo;
88 static int32 init_keysig;
89 static int play_bias;
90
91 #define TEMPO_GRADATION_SKIP 2
92 #define TEMPO_GRADATION_GRADE 600
93
read_rcp_file(struct timidity_file * tf,char * magic0,char * fn)94 int read_rcp_file(struct timidity_file *tf, char *magic0, char *fn)
95 {
96 char buff[361], *p;
97 int ntrack, timebase1, timebase2, i, len, gfmt;
98
99 strncpy(buff, magic0, 4);
100 if(tf_read(buff + 4, 1, 32-4, tf) != 32-4)
101 return 1;
102 len = strlen(fn);
103 if(strncmp(buff, "RCM-PC98V2.0(C)COME ON MUSIC", 28) == 0)
104 {
105 /* RCP or R36 */
106 gfmt = 0;
107 if(check_file_extension(fn, ".r36", 1))
108 current_file_info->file_type = IS_R36_FILE;
109 else
110 current_file_info->file_type = IS_RCP_FILE;
111 }
112 else if(strncmp(buff, "COME ON MUSIC RECOMPOSER RCP3.0", 31) == 0)
113 {
114 /* G36 or G18 */
115 gfmt = 1;
116 if(check_file_extension(fn, ".g18", 1))
117 current_file_info->file_type = IS_G18_FILE;
118 else
119 current_file_info->file_type = IS_G36_FILE;
120 }
121 else
122 return 1;
123
124 /* title */
125 if(tf_read(buff, 1, 64, tf) != 64)
126 return 1;
127 if(current_file_info->seq_name == NULL)
128 {
129 buff[64] = '\0';
130 for(len = 63; len >= 0; len--)
131 {
132 if(buff[len] == ' ')
133 buff[len] = '\0';
134 else if(buff[len] != '\0')
135 break;
136 }
137
138 len = SAFE_CONVERT_LENGTH(len + 1);
139 p = (char *)new_segment(&tmpbuffer, len);
140 code_convert(buff, p, len, NULL, NULL);
141 current_file_info->seq_name = (char *)safe_strdup(p);
142 reuse_mblock(&tmpbuffer);
143 }
144 current_file_info->format = 1;
145
146 if(!gfmt) /* RCP or R36 */
147 {
148 if(tf_read(buff, 1, 336, tf) != 336)
149 return 1;
150 #ifndef __BORLANDC__
151 buff[336] = '\0';
152 for(len = 335; len >= 0; len--)
153 {
154 if(buff[len] == ' ')
155 buff[len] = '\0';
156 else if(buff[len] != '\0')
157 break;
158 }
159 len = SAFE_CONVERT_LENGTH(len + 1);
160
161 p = (char *)new_segment(&tmpbuffer, len);
162 code_convert(buff, p, len, NULL, NULL);
163 ctl->cmsg(CMSG_INFO, VERB_VERBOSE, "Memo: %s", p);
164 reuse_mblock(&tmpbuffer);
165 #else
166 buff[336] = '\0';
167 {
168 char tmp[30];
169 int i;
170 for(i=0;i<336;i+=28)
171 {
172 strncpy(tmp,buff+i,28);
173 tmp[28] = '\0';
174 for(len=28; len>=0; len--)
175 {
176 if(tmp[len] == ' ')
177 tmp[len] = '\0';
178 else if(tmp[len] != '\0')
179 break;
180 }
181 if(tmp[0]=='\0')
182 continue;
183 len = SAFE_CONVERT_LENGTH(len + 1);
184
185 p = (char *)new_segment(&tmpbuffer, len);
186 code_convert(tmp, p, len, NULL, NULL);
187 ctl->cmsg(CMSG_INFO, VERB_VERBOSE, "Memo: %s", p);
188 reuse_mblock(&tmpbuffer);
189 }
190 }
191 #endif
192
193 skip(tf, 16); /* 0x40 */
194
195 timebase1 = tf_getc(tf);
196 init_tempo = tf_getc(tf); /* tempo */
197 ctl->cmsg(CMSG_INFO, VERB_DEBUG, "Tempo %d", init_tempo);
198 if(init_tempo < 8 || init_tempo > 250)
199 init_tempo = 120;
200
201 /* Time Signature: numerator, denominator, Key Signature */
202 current_file_info->time_sig_n = tf_getc(tf);
203 ctl->cmsg(CMSG_INFO, VERB_DEBUG, "Time signature(n) %d",
204 current_file_info->time_sig_n);
205 current_file_info->time_sig_d = tf_getc(tf);
206 ctl->cmsg(CMSG_INFO, VERB_DEBUG, "Time signature(d) %d",
207 current_file_info->time_sig_d);
208 init_keysig = tf_getc(tf);
209 ctl->cmsg(CMSG_INFO, VERB_DEBUG, "Key signature %d", init_keysig);
210 if (init_keysig < 0 || init_keysig >= 32)
211 init_keysig = 0;
212
213 play_bias = (int)(signed char)tf_getc(tf);
214 ctl->cmsg(CMSG_INFO, VERB_DEBUG, "Play bias %d", play_bias);
215 if(play_bias < -36 || play_bias > 36)
216 play_bias = 0;
217
218 skip(tf, 12); /* cm6 */
219 skip(tf, 4); /* reserved */
220 skip(tf, 12); /* gsd */
221 skip(tf, 4); /* reserved */
222
223 if((ntrack = tf_getc(tf)) == EOF)
224 return 1;
225 ctl->cmsg(CMSG_INFO, VERB_DEBUG, "Number of tracks %d", ntrack);
226 if(ntrack != 18 && ntrack != 36)
227 ntrack = 18;
228 timebase2 = tf_getc(tf);
229 skip(tf, 14); /* reserved */
230 skip(tf, 16); /* */
231
232 skip(tf, 32 * (14 + 2)); /* rhythm definition */
233 }
234 else /* G36 or G18 */
235 {
236 skip(tf, 64); /* reserved */
237
238 /* memo */
239 if(tf_read(buff, 1, 360, tf) != 360)
240 return 1;
241 buff[360] = '\0';
242 for(len = 359; len >= 0; len--)
243 {
244 if(buff[len] == ' ')
245 buff[len] = '\0';
246 else if(buff[len] != '\0')
247 break;
248 }
249 len = SAFE_CONVERT_LENGTH(len + 1);
250 p = (char *)new_segment(&tmpbuffer, len);
251 code_convert(buff, p, len, NULL, NULL);
252 ctl->cmsg(CMSG_INFO, VERB_VERBOSE, "Memo: %s", p);
253 reuse_mblock(&tmpbuffer);
254
255 /* Number of tracks */
256 ntrack = tf_getc(tf);
257 ctl->cmsg(CMSG_INFO, VERB_DEBUG, "Number of tracks %d", ntrack);
258 if(ntrack != 18 && ntrack != 36)
259 ntrack = 18;
260 skip(tf, 1);
261 timebase1 = tf_getc(tf);
262 timebase2 = tf_getc(tf);
263 init_tempo = tf_getc(tf); /* tempo */
264 ctl->cmsg(CMSG_INFO, VERB_DEBUG, "Tempo %d", init_tempo);
265 if(init_tempo < 8 || init_tempo > 250)
266 init_tempo = 120;
267 skip(tf, 1); /* ?? */
268
269 /* Time Signature: numerator, denominator, Key Signature */
270 current_file_info->time_sig_n = tf_getc(tf);
271 ctl->cmsg(CMSG_INFO, VERB_DEBUG, "Time signature(n) %d",
272 current_file_info->time_sig_n);
273 current_file_info->time_sig_d = tf_getc(tf);
274 ctl->cmsg(CMSG_INFO, VERB_DEBUG, "Time signature(n) %d",
275 current_file_info->time_sig_d);
276 init_keysig = tf_getc(tf);
277 ctl->cmsg(CMSG_INFO, VERB_DEBUG, "Key signature %d", init_keysig);
278 if (init_keysig < 0 || init_keysig >= 32)
279 init_keysig = 0;
280
281 play_bias = (int)(signed char)tf_getc(tf);
282 ctl->cmsg(CMSG_INFO, VERB_DEBUG, "Play bias %d", play_bias);
283 if(play_bias < -36 || play_bias > 36)
284 play_bias = 0;
285 skip(tf, 6 + 16 + 112); /* reserved */
286 skip(tf, 12); /* gsd */
287 skip(tf, 4);
288 skip(tf, 12); /* gsd */
289 skip(tf, 4);
290 skip(tf, 12); /* cm6 */
291 skip(tf, 4);
292 skip(tf, 80); /* reserved */
293 skip(tf, 128 * (14 + 2)); /* rhythm definition */
294 }
295
296 /* SysEx data */
297 for(i = 0; i < 8; i++)
298 {
299 int mid;
300 skip(tf, 24); /* memo */
301 if(tf_read(user_exclusive_data[i], 1, USER_EXCLUSIVE_LENGTH, tf)
302 != USER_EXCLUSIVE_LENGTH)
303 return 1;
304 mid = user_exclusive_data[i][0];
305 if(mid > 0 && mid < 0x7e &&
306 (current_file_info->mid == 0 || current_file_info->mid >= 0x7e))
307 current_file_info->mid = mid;
308 }
309
310 current_file_info->divisions = (timebase1 | (timebase2 << 8));
311 ctl->cmsg(CMSG_INFO, VERB_DEBUG, "divisions %d",
312 current_file_info->divisions);
313 current_file_info->format = 1;
314 current_file_info->tracks = ntrack;
315
316 if(!IS_URL_SEEK_SAFE(tf->url))
317 if((tf->url = url_cache_open(tf->url, 1)) == NULL)
318 return 1;
319
320 for(i = 0; i < ntrack; i++)
321 if(read_rcp_track(tf, i, gfmt))
322 {
323 if(ignore_midi_error)
324 return 0;
325 return 1;
326 }
327 return 0;
328 }
329
rcp_tempo_set(int32 at,int32 tempo)330 static void rcp_tempo_set(int32 at, int32 tempo)
331 {
332 int lo, mid, hi;
333
334 lo = (tempo & 0xff);
335 mid = ((tempo >> 8) & 0xff);
336 hi = ((tempo >> 16) & 0xff);
337 MIDIEVENT(at, ME_TEMPO, lo, hi, mid);
338 }
339
rcp_tempo_change(struct RCPNoteTracer * ntr,int a,int b)340 static int32 rcp_tempo_change(struct RCPNoteTracer *ntr, int a, int b)
341 {
342 int32 tempo;
343
344 tempo = (int32)((uint32)60000000 * 64 / (init_tempo * a)); /* 6*10^7 / (ini*a/64) */
345 ntr->tempo_grade = b;
346 if (b != 0)
347 {
348 ntr->tempo_to = tempo;
349 ntr->tempo_step = 0;
350 ntr->tempo_grade *= TEMPO_GRADATION_GRADE * TEMPO_GRADATION_SKIP;
351 tempo = ntr->tempo; /* unchanged */
352 }
353 else
354 {
355 ntr->tempo = tempo;
356 rcp_tempo_set(ntr_at(*ntr), tempo);
357 }
358 return tempo;
359 }
360
rcp_timesig_change(int32 at)361 static void rcp_timesig_change(int32 at)
362 {
363 int n, d;
364
365 n = current_file_info->time_sig_n;
366 d = current_file_info->time_sig_d;
367 MIDIEVENT(at, ME_TIMESIG, 0, n, d);
368 }
369
rcp_keysig_change(int32 at,int32 key)370 static void rcp_keysig_change(int32 at, int32 key)
371 {
372 int8 sf, mi;
373
374 if (key < 8)
375 sf = key, mi = 0;
376 else if (key < 16)
377 sf = 8 - key, mi = 0;
378 else if (key < 24)
379 sf = key - 16, mi = 1;
380 else
381 sf = 24 - key, mi = 1;
382 MIDIEVENT(at, ME_KEYSIG, 0, sf, mi);
383 }
384
rcp_cmd_name(int cmd)385 static char *rcp_cmd_name(int cmd)
386 {
387 if(cmd < 0x80)
388 {
389 static char name[16];
390 sprintf(name, "NoteOn %d", cmd);
391 return name;
392 }
393
394 switch(cmd)
395 {
396 case 0x90: return "UserExclusive0";
397 case 0x91: return "UserExclusive1";
398 case 0x92: return "UserExclusive2";
399 case 0x93: return "UserExclusive3";
400 case 0x94: return "UserExclusive4";
401 case 0x95: return "UserExclusive5";
402 case 0x96: return "UserExclusive6";
403 case 0x97: return "UserExclusive7";
404 case 0x98: return "ChannelExclusive";
405 case 0xc0: return "DX7 function";
406 case 0xc1: return "DX parameter";
407 case 0xc2: return "DX RERF";
408 case 0xc3: return "TX function";
409 case 0xc5: return "FB-01 P parameter";
410 case 0xc6: return "FB-01 S System";
411 case 0xc7: return "TX81Z V VCED";
412 case 0xc8: return "TX81Z A ACED";
413 case 0xc9: return "TX81Z P PCED";
414 case 0xca: return "TX81Z S System";
415 case 0xcb: return "TX81Z E EFFECT";
416 case 0xcc: return "DX7-2 R REMOTE SW";
417 case 0xcd: return "DX7-2 A ACED";
418 case 0xce: return "DX7-2 P PCED";
419 case 0xcf: return "TX802 P PCED";
420 case 0xd0: return "YamahaBase";
421 case 0xd1: return "YamahaPara";
422 case 0xd2: return "YamahaDevice";
423 case 0xd3: return "XGPara";
424 case 0xdc: return "MKS-7";
425 case 0xdd: return "RolandBase";
426 case 0xde: return "RolandPara";
427 case 0xdf: return "RolandDevice";
428 case 0xe1: return "BnkLPrg";
429 case 0xe2: return "Bank&ProgCng";
430 case 0xe5: return "KeyScan";
431 case 0xe6: return "ChChange";
432 case 0xe7: return "TempoChange";
433 case 0xea: return "ChannelAfterTouch";
434 case 0xeb: return "ControlChange";
435 case 0xec: return "ProgChange";
436 case 0xed: return "AfterTouch";
437 case 0xee: return "PitchBend";
438 case 0xf5: return "KeyChange";
439 case 0xf6: return "Comment";
440 case 0xf7: return "2ndEvent";
441 case 0xf8: return "LoopEnd";
442 case 0xf9: return "LoopStart";
443 case 0xfc: return "SameMeasure";
444 case 0xfd: return "MeasureEnd";
445 case 0xfe: return "EndOfTrack";
446 }
447 return "Unknown";
448 }
449
rcp_parse_sysex_event(int32 at,uint8 * val,int32 len)450 static int rcp_parse_sysex_event(int32 at, uint8 *val, int32 len)
451 {
452 MidiEvent ev, evm[260];
453 int ne, i;
454
455 if(len == 0) {return 0;}
456
457 if(parse_sysex_event(val, len, &ev))
458 {
459 ev.time = at;
460 readmidi_add_event(&ev);
461 }
462 if ((ne = parse_sysex_event_multi(val, len, evm)) > 0)
463 for (i = 0; i < ne; i++) {
464 evm[i].time = at;
465 readmidi_add_event(&evm[i]);
466 }
467
468 return 0;
469 }
470
471 #define MAX_STACK_DEPTH 16
read_rcp_track(struct timidity_file * tf,int trackno,int gfmt)472 static int read_rcp_track(struct timidity_file *tf, int trackno, int gfmt)
473 {
474 int32 current_tempo;
475 int size;
476 int ch;
477 long last_point, cmdlen;
478 int key_offset;
479 struct RCPNoteTracer ntr;
480 struct
481 {
482 long start_at; /* loop start time */
483 long loop_start; /* loop start seek point */
484 int count; /* loop count */
485 } stack[MAX_STACK_DEPTH];
486 int sp;
487 int i, len;
488 uint8 sysex[MAX_EXCLUSIVE_LENGTH];
489
490 int roland_base_init = 0;
491 int roland_dev_init = 0;
492 int roland_base_addr0 = 0;
493 int roland_base_addr1 = 0;
494 int roland_device_id = 0x10;
495 int roland_model_id = 0x16;
496
497 int yamaha_base_init = 0;
498 int yamaha_dev_init = 0;
499 int yamaha_base_addr0 = 0;
500 int yamaha_base_addr1 = 0;
501 int yamaha_device_id = 0x10; /* ??? */
502 int yamaha_model_id = 0x16; /* ??? */
503
504 unsigned char cs; /* check sum */
505
506 long same_measure = -1; /* Meassure to stack pointer */
507 long track_top, data_top;
508 int time_offset;
509 char buff[64], *p;
510 int ret = 0;
511
512 /*
513 * Read Track Header
514 */
515
516 track_top = tf_tell(tf);
517 ctl->cmsg(CMSG_INFO, VERB_DEBUG_SILLY, "Track top: %d", track_top);
518
519 size = tf_getc(tf);
520 size |= (tf_getc(tf) << 8);
521
522 ctl->cmsg(CMSG_INFO, VERB_DEBUG, "Track size %d", size);
523 last_point = size + tf_tell(tf) - 2;
524
525 if(gfmt)
526 {
527 skip(tf, 2);
528 cmdlen = 6;
529 }
530 else
531 cmdlen = 4;
532
533 i = tf_getc(tf); /* Track Number */
534 ctl->cmsg(CMSG_INFO, VERB_DEBUG, "Track number %d", i);
535 skip(tf, 1); /* Rhythm */
536
537 if((ch = tf_getc(tf)) == 0xff) /* No playing */
538 {
539 tf_seek(tf, last_point, SEEK_SET);
540 return 0;
541 }
542
543 ctl->cmsg(CMSG_INFO, VERB_DEBUG, "Track channel %d", ch);
544
545 if(ch >= RCP_MAXCHANNELS)
546 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE,
547 "RCP: Invalid channel: %d", ch);
548
549 /* Key offset */
550 key_offset = tf_getc(tf);
551 ctl->cmsg(CMSG_INFO, VERB_DEBUG, "Key offset %d", key_offset);
552 if(key_offset > 64)
553 key_offset -= 128;
554 key_offset += play_bias;
555
556 /* Time offset */
557 time_offset = (int)(signed char)tf_getc(tf);
558 ctl->cmsg(CMSG_INFO, VERB_DEBUG, "Time offset %d", time_offset);
559 if(time_offset < -99 || 99 < time_offset)
560 {
561 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE,
562 "RCP: Invalid time offset: %d", time_offset);
563 if(time_offset < -99)
564 time_offset = -99;
565 else
566 time_offset = 99;
567 }
568
569 i = tf_getc(tf); /* mode */
570 if(i == 1)
571 {
572 /* Mute */
573 tf_seek(tf, last_point, SEEK_SET);
574 return 0;
575 }
576
577 /* Comment */
578 tf_read(buff, 1, 36, tf);
579 buff[36] = '\0';
580 for(len = 35; len >= 0; len--)
581 {
582 if(buff[len] == ' ')
583 buff[len] = '\0';
584 else if(buff[len] != '\0')
585 break;
586 }
587 len = SAFE_CONVERT_LENGTH(len+1);
588 p = (char *)new_segment(&tmpbuffer, len);
589 code_convert(buff, p, len, NULL, NULL);
590 if(*p)
591 ctl->cmsg(CMSG_INFO, VERB_VERBOSE, "RCP Track name: %s", p);
592 reuse_mblock(&tmpbuffer);
593
594 /*
595 * End of Track Header
596 */
597
598 sp = 0;
599 ntr.tempo = current_tempo = 60000000 / init_tempo;
600 ntr_init(&ntr, gfmt, readmidi_set_track(trackno, 1));
601 if(trackno == 0 && init_tempo != 120)
602 ntr.tempo = current_tempo = rcp_tempo_change(&ntr, 64, 0);
603 if (trackno == 0) {
604 rcp_timesig_change(ntr_at(ntr));
605 rcp_keysig_change(ntr_at(ntr), init_keysig);
606 }
607 ntr_incr(&ntr, time_offset);
608
609 data_top = tf_tell(tf);
610 while(last_point >= tf_tell(tf) + cmdlen)
611 {
612 int cmd, a, b, step, gate;
613 int st1, gt1, st2, gt2;
614
615 if(readmidi_error_flag)
616 {
617 ret = -1;
618 break;
619 }
620
621 if(!gfmt)
622 {
623 cmd = tf_getc(tf);
624 step = tf_getc(tf);
625 gate = a = tf_getc(tf);
626 if((b = tf_getc(tf)) == EOF)
627 {
628 ret = -1;
629 break;
630 }
631 st1 = gt1 = st2 = gt2 = 0;
632
633 if(ctl->verbosity >= VERB_DEBUG_SILLY)
634 {
635 ctl->cmsg(CMSG_INFO, VERB_DEBUG_SILLY,
636 "[%d] %d %s: ch=%d step=%d a=%d b=%d sp=%d",
637 tf_tell(tf) - 4 - track_top,
638 ntr_at(ntr), rcp_cmd_name(cmd), ch, step, a, b, sp);
639 }
640 }
641 else
642 {
643 cmd = tf_getc(tf);
644 b = tf_getc(tf);
645 st1 = tf_getc(tf);
646 st2 = tf_getc(tf);
647 a = gt1 = tf_getc(tf);
648 if((gt2 = tf_getc(tf)) == EOF)
649 {
650 ret = -1;
651 break;
652 }
653
654 step = st1 + (st2 << 8);
655 gate = gt1 + (gt2 << 8);
656
657 if(ctl->verbosity >= VERB_DEBUG_SILLY)
658 {
659 ctl->cmsg(CMSG_INFO, VERB_DEBUG_SILLY,
660 "[%d] %d %s: ch=%d step=%d gate=%d a=%d b=%d sp=%d",
661 tf_tell(tf) - 6 - track_top,
662 ntr_at(ntr), rcp_cmd_name(cmd), ch,
663 step, gate, a, b, sp);
664 }
665 }
666
667 if(cmd < 0x80) /* Note event */
668 {
669 if(gate > 0)
670 {
671 int note = cmd + key_offset;
672 ntr_note_on(&ntr, ch, note & 0x7f, b, gate);
673 }
674 ntr_incr(&ntr, step);
675 continue;
676 }
677
678 /* command */
679 switch(cmd)
680 {
681 case 0x90: /* User Exclusive 1 */
682 case 0x91: /* User Exclusive 2 */
683 case 0x92: /* User Exclusive 3 */
684 case 0x93: /* User Exclusive 4 */
685 case 0x94: /* User Exclusive 5 */
686 case 0x95: /* User Exclusive 6 */
687 case 0x96: /* User Exclusive 7 */
688 case 0x97: /* User Exclusive 8 */
689 memcpy(sysex, user_exclusive_data[cmd - 0x90],
690 USER_EXCLUSIVE_LENGTH);
691 sysex[USER_EXCLUSIVE_LENGTH] = 0xf7;
692 len = preprocess_sysex(sysex, ch, a, b);
693 rcp_parse_sysex_event(ntr_at(ntr), sysex, len);
694 ntr_incr(&ntr, step);
695 break;
696
697 case 0x98: /* Channel Exclusive */
698 len = 0;
699 while(tf_getc(tf) == 0xf7 && len + 6 < sizeof(sysex))
700 {
701 if(gfmt)
702 {
703 if(tf_read(sysex + len, 1, 5, tf) != 5)
704 {
705 ret = -1;
706 goto end_of_track;
707 }
708 len += 5;
709 }
710 else
711 {
712 tf_getc(tf); /* 0x00 */
713 if(tf_read(sysex + len, 1, 2, tf) != 2)
714 {
715 ret = -1;
716 goto end_of_track;
717 }
718 len += 2;
719 }
720 }
721 tf_seek(tf, -1, SEEK_CUR);
722 sysex[len] = 0xf7;
723 len = preprocess_sysex(sysex, ch, a, b);
724 rcp_parse_sysex_event(ntr_at(ntr), sysex, len);
725 ntr_incr(&ntr, step);
726 break;
727
728 case 0xd0: /* Yamaha base */
729 a &= 0x7f;
730 b &= 0x7f;
731 yamaha_base_addr0 = a;
732 yamaha_base_addr1 = b;
733 yamaha_base_init = 1;
734 ntr_incr(&ntr, step);
735 break;
736
737 case 0xd1: /* Yamaha para */
738 a &= 0x7f;
739 b &= 0x7f;
740 if(!yamaha_base_init)
741 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE,
742 "YamPara used before initializing YamBase");
743 if(!yamaha_dev_init)
744 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE,
745 "YamPara used before initializing YamDev#");
746 yamaha_base_init = yamaha_dev_init = 1;
747 sysex[0] = 0x43;
748 sysex[1] = yamaha_device_id;
749 sysex[2] = yamaha_model_id;
750 sysex[3] = 0x12;
751 cs = 0;
752 cs += sysex[4] = yamaha_base_addr0;
753 cs += sysex[5] = yamaha_base_addr1;
754 cs += sysex[6] = a;
755 cs += sysex[7] = b;
756 sysex[8] = 128 - (cs & 0x7f);
757 sysex[9] = 0xf7;
758 rcp_parse_sysex_event(ntr_at(ntr), sysex, 10);
759 ntr_incr(&ntr, step);
760 break;
761
762 case 0xd2: /* Yamaha device */
763 a &= 0x7f;
764 b &= 0x7f;
765 yamaha_device_id = a;
766 yamaha_model_id = b;
767 yamaha_dev_init = 1;
768 ntr_incr(&ntr, step);
769 break;
770
771 case 0xd3: /* XG para */
772 /* ?? */
773 a &= 0x7f;
774 b &= 0x7f;
775 sysex[0] = 0x43;
776 sysex[1] = yamaha_device_id;
777 sysex[2] = yamaha_model_id;
778 sysex[3] = 0x12;
779 cs = 0;
780 cs += sysex[4] = yamaha_base_addr0;
781 cs += sysex[5] = yamaha_base_addr1;
782 cs += sysex[6] = a;
783 cs += sysex[7] = b;
784 sysex[8] = 128 - (cs & 0x7f);
785 sysex[9] = 0xf7;
786 rcp_parse_sysex_event(ntr_at(ntr), sysex, 10);
787 ntr_incr(&ntr, step);
788 break;
789
790 case 0xdd: /* Roland base */
791 a &= 0x7f;
792 b &= 0x7f;
793 roland_base_addr0 = a;
794 roland_base_addr1 = b;
795 roland_base_init = 1;
796 ntr_incr(&ntr, step);
797 break;
798
799 case 0xde: /* Roland para */
800 a &= 0x7f;
801 b &= 0x7f;
802 if(!roland_base_init)
803 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE,
804 "RolPara used before initializing RolBase");
805 if(!roland_dev_init)
806 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE,
807 "RolPara used before initializing RolDev#");
808 roland_base_init = roland_dev_init = 1;
809 sysex[0] = 0x41;
810 sysex[1] = roland_device_id;
811 sysex[2] = roland_model_id;
812 sysex[3] = 0x12;
813 cs = 0;
814 cs += sysex[4] = roland_base_addr0;
815 cs += sysex[5] = roland_base_addr1;
816 cs += sysex[6] = a;
817 cs += sysex[7] = b;
818 sysex[8] = 128 - (cs & 0x7f);
819 sysex[9] = 0xf7;
820 rcp_parse_sysex_event(ntr_at(ntr), sysex, 10);
821 ntr_incr(&ntr, step);
822 break;
823
824 case 0xdf: /* Roland device */
825 a &= 0x7f;
826 b &= 0x7f;
827 roland_device_id = a;
828 roland_model_id = b;
829 roland_dev_init = 1;
830 ntr_incr(&ntr, step);
831 break;
832
833 case 0xe1: /* BnkLPrg */
834 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE,
835 "BnkLPrg is not supported: 0x%02x 0x%02x", a, b);
836 ntr_incr(&ntr, step);
837 break;
838
839 case 0xe2: /* bank & program change */
840 readmidi_add_ctl_event(ntr_at(ntr), ch, 0, b); /*Change MSB Bank*/
841 MIDIEVENT(ntr_at(ntr), ME_PROGRAM, ch, a & 0x7f, 0);
842 ntr_incr(&ntr, step);
843 break;
844
845 case 0xe5: /* key scan */
846 #if 0
847 switch(a)
848 {
849 case 12: /* suspend playing */
850 case 18: /* increase play bias */
851 case 23: /* stop playing */
852 case 32: /* show main screen */
853 case 33: /* show 11th track */
854 case 34: /* show 12th track */
855 case 35: /* show 13th track */
856 case 36: /* show 14th track */
857 case 37: /* show 15th track */
858 case 38: /* show 16th track */
859 case 39: /* show 17th track */
860 case 40: /* show 18th track */
861 case 48: /* show 10th track */
862 case 49: /* show 1st track */
863 case 50: /* show 2nd track */
864 case 51: /* show 3rd track */
865 case 52: /* show 4th track */
866 case 53: /* show 5th track */
867 case 54: /* show 6th track */
868 case 55: /* show 7th track */
869 case 56: /* show 8th track */
870 case 57: /* show 9th track */
871 case 61: /* mute 1st track */
872 break;
873 }
874 #endif
875 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE,
876 "Key scan 0x%02x 0x%02x is not supported", a, b);
877 ntr_incr(&ntr, step);
878 break;
879
880 case 0xe6: /* MIDI channel change */
881 ch = a - 1;
882 if(ch == 0) /* ##?? */
883 ctl->cmsg(CMSG_INFO, VERB_VERBOSE, "MIDI channel off");
884 else if(ch >= RCP_MAXCHANNELS)
885 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE,
886 "RCP: Invalid channel: %d", ch);
887 ntr_incr(&ntr, step);
888 break;
889
890 case 0xe7: /* tempo change */
891 if(a == 0)
892 {
893 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE,
894 "Invalid tempo change\n");
895 a = 64;
896 }
897 current_tempo = rcp_tempo_change(&ntr, a, b);
898 ntr_incr(&ntr, step);
899 break;
900
901 case 0xea: /* channel after touch (channel pressure) */
902 a &= 0x7f;
903 MIDIEVENT(ntr_at(ntr), ME_CHANNEL_PRESSURE, ch, a, 0);
904 ntr_incr(&ntr, step);
905 break;
906
907 case 0xeb: /* control change */
908 readmidi_add_ctl_event(ntr_at(ntr), ch, a, b);
909 ntr_incr(&ntr, step);
910 break;
911
912 case 0xec: /* program change */
913 a &= 0x7f;
914 MIDIEVENT(ntr_at(ntr), ME_PROGRAM, ch, a, 0);
915 ntr_incr(&ntr, step);
916 break;
917
918 case 0xed: /* after touch polyphonic (polyphonic key pressure) */
919 a &= 0x7f;
920 b &= 0x7f;
921 MIDIEVENT(ntr_at(ntr), ME_KEYPRESSURE, ch, a, b);
922 ntr_incr(&ntr, step);
923 break;
924
925 case 0xee: /* pitch bend */
926 a &= 0x7f;
927 b &= 0x7f;
928 MIDIEVENT(ntr_at(ntr), ME_PITCHWHEEL, ch, a, b);
929 ntr_incr(&ntr, step);
930 break;
931
932 case 0xf5: /* key change */
933 if (step < 0 || step >= 32) {
934 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE, "Invalid key change\n");
935 step = 0;
936 }
937 rcp_keysig_change(ntr_at(ntr), step);
938 break;
939
940 case 0xf6: /* comment */
941 len = 0;
942 if(!gfmt)
943 {
944 buff[len++] = a;
945 buff[len++] = b;
946 }
947 else
948 {
949 buff[len++] = b;
950 buff[len++] = st1;
951 buff[len++] = st2;
952 buff[len++] = gt1;
953 buff[len++] = gt2;
954 }
955
956 while(tf_getc(tf) == 0xf7 && len + 6 < sizeof(buff))
957 {
958 if(gfmt)
959 {
960 if(tf_read(buff + len, 1, 5, tf) != 5)
961 {
962 ret = -1;
963 goto end_of_track;
964 }
965 len += 5;
966 }
967 else
968 {
969 tf_getc(tf); /* 0x00 */
970 if(tf_read(buff + len, 1, 2, tf) != 2)
971 {
972 ret = -1;
973 goto end_of_track;
974 }
975 len += 2;
976 }
977 }
978 tf_seek(tf, -1, SEEK_CUR);
979
980 if(ctl->verbosity >= VERB_VERBOSE || opt_trace_text_meta_event)
981 {
982 buff[len] = '\0';
983 for(len--; len >= 0; len--)
984 {
985 if(buff[len] == ' ')
986 buff[len] = '\0';
987 else if(buff[len] != '\0')
988 break;
989 }
990
991 if(opt_trace_text_meta_event)
992 {
993 MidiEvent ev;
994 if(readmidi_make_string_event(ME_TEXT, buff, &ev, 1)
995 != NULL)
996 {
997 ev.time = ntr_at(ntr);
998 readmidi_add_event(&ev);
999 }
1000 }
1001 else if(ctl->verbosity >= VERB_VERBOSE)
1002 {
1003 len = SAFE_CONVERT_LENGTH(len+1);
1004 p = (char *)new_segment(&tmpbuffer, len);
1005 code_convert(buff, p, len, NULL, NULL);
1006 ctl->cmsg(CMSG_INFO, VERB_VERBOSE, "Comment: %s", p);
1007 reuse_mblock(&tmpbuffer);
1008 }
1009 }
1010 break;
1011
1012 case 0xf7: /* 2nd Event */
1013 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE,
1014 "Something's wrong: 2nd Event is appeared");
1015 break;
1016
1017 case 0xf8: /* loop end */
1018 if(ctl->verbosity >= VERB_DEBUG_SILLY)
1019 ctl->cmsg(CMSG_INFO, VERB_DEBUG_SILLY,
1020 "Loop end at %d",
1021 tf_tell(tf) - track_top - cmdlen);
1022 if(sp == 0)
1023 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE,
1024 "Misplaced loop end (ch=%d)", ch);
1025 else if(sp > MAX_STACK_DEPTH)
1026 sp--; /* through deeply loop */
1027 else
1028 {
1029 int top;
1030
1031 top = sp - 1;
1032
1033 if(same_measure == top)
1034 {
1035 sp = same_measure;
1036 tf_seek(tf, stack[sp].loop_start, SEEK_SET);
1037 same_measure = -1;
1038 goto break_loop_end;
1039 }
1040
1041 if((!gfmt && step == 0xff) || (gfmt && step == 0xffff))
1042 {
1043 sp = top;
1044 goto break_loop_end;
1045 }
1046
1047 if(stack[top].count >= step)
1048 sp = top;
1049 #ifdef RCP_LOOP_CONT_LIMIT
1050 else if(stack[top].count >= RCP_LOOP_CONT_LIMIT)
1051 {
1052 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE,
1053 "Loop limit exceeded (ch=%d)", ch);
1054 sp = top;
1055 }
1056 #endif /* RCP_LOOP_CONT_LIMIT */
1057 #ifdef RCP_LOOP_TIME_LIMIT
1058 else if((current_tempo / 1000000.0) *
1059 (ntr_at(ntr) - stack[top].start_at)
1060 / current_file_info->divisions
1061 > RCP_LOOP_TIME_LIMIT)
1062 {
1063 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE,
1064 "Loop time exceeded (ch=%d)", ch);
1065 sp = top;
1066 }
1067 #endif /* RCP_LOOP_TIME_LIMIT */
1068 else
1069 {
1070 stack[top].count++;
1071 ctl->cmsg(CMSG_INFO, VERB_DEBUG_SILLY,
1072 "Jump to %d (cnt=%d)",
1073 stack[top].loop_start - track_top,
1074 stack[top].count);
1075 tf_seek(tf, stack[top].loop_start, SEEK_SET);
1076 }
1077 }
1078 break_loop_end:
1079 break;
1080
1081 case 0xf9: /* loop start */
1082 #if 1
1083 if(!gfmt && step == 0xff) /* ##?? */
1084 continue;
1085 #endif
1086 if(ctl->verbosity >= VERB_DEBUG_SILLY)
1087 ctl->cmsg(CMSG_INFO, VERB_DEBUG_SILLY,
1088 "Loop start at %d",
1089 tf_tell(tf) - track_top - cmdlen);
1090
1091 if(sp >= MAX_STACK_DEPTH)
1092 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE,
1093 "Too deeply nested %d (ch=%d, Ignored this loop)",
1094 ch, sp);
1095 else
1096 {
1097 stack[sp].start_at = ntr_at(ntr);
1098 stack[sp].loop_start = tf_tell(tf);
1099 stack[sp].count = 1;
1100 }
1101 sp++;
1102 break;
1103
1104 case 0xfc: /* same measure */
1105 if(ctl->verbosity >= VERB_DEBUG_SILLY)
1106 ctl->cmsg(CMSG_INFO, VERB_DEBUG_SILLY,
1107 "Same measure at %d",
1108 tf_tell(tf) - track_top - cmdlen);
1109 if(sp >= MAX_STACK_DEPTH)
1110 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE,
1111 "Too deeply nested %d (ch=%d)", sp, ch);
1112 else
1113 {
1114 long jmp, nextflag;
1115
1116 if(same_measure >= 0)
1117 {
1118 sp = same_measure;
1119 tf_seek(tf, stack[sp].loop_start, SEEK_SET);
1120 same_measure = -1;
1121 goto break_same_measure;
1122 }
1123
1124 nextflag = 0;
1125
1126 next_same_measure:
1127 if(!gfmt)
1128 {
1129 jmp = (long)a | ((long)b << 8);
1130
1131 if(jmp & 0x03) /* ##?? */
1132 {
1133 /* What do these two bits mean? */
1134 /* Clear them here. */
1135 ctl->cmsg(CMSG_WARNING, VERB_DEBUG,
1136 "Jump %d is changed to %d",
1137 jmp, jmp & ~3);
1138 jmp &= ~3; /* jmp=(jmp/4)*4 */
1139 }
1140 }
1141 else
1142 {
1143 #if 0
1144 if(b != 0)
1145 {
1146 /* ##?? */
1147 }
1148 #endif
1149 jmp = gate;
1150 if(current_file_info->file_type == IS_G36_FILE)
1151 jmp = jmp * 6 - 242;
1152 else
1153 jmp -= (jmp + 2) % 6; /* (jmp+2)%6==0 */
1154 }
1155
1156 if(jmp < data_top - track_top ||
1157 jmp >= last_point - track_top)
1158 {
1159 ctl->cmsg(CMSG_WARNING, VERB_NOISY,
1160 "RCP Invalid same measure: %d (ch=%d)", jmp, ch);
1161 break;
1162 }
1163
1164 if(nextflag == 0)
1165 {
1166 stack[sp].start_at = ntr_at(ntr);
1167 stack[sp].loop_start = tf_tell(tf);
1168 same_measure = sp;
1169 sp++;
1170 }
1171
1172 ctl->cmsg(CMSG_INFO, VERB_DEBUG_SILLY, "Jump to %d", jmp);
1173 tf_seek(tf, track_top + jmp, SEEK_SET);
1174
1175 if(tf_getc(tf) == 0xfc)
1176 {
1177 nextflag = 1;
1178 if(!gfmt)
1179 {
1180 tf_getc(tf); /* step */
1181 a = tf_getc(tf);
1182 b = tf_getc(tf);
1183 }
1184 else
1185 {
1186 b = tf_getc(tf);
1187 tf_getc(tf); /* st1 */
1188 tf_getc(tf); /* st2 */
1189 a = gt1 = tf_getc(tf);
1190 gate = gt1 + (gt2 << 8);
1191 }
1192 goto next_same_measure;
1193 }
1194 tf_seek(tf, -1, SEEK_CUR);
1195 }
1196 break_same_measure:
1197 break;
1198
1199 case 0xfd: /* measure end */
1200 if(same_measure >= 0)
1201 {
1202 sp = same_measure;
1203 tf_seek(tf, stack[sp].loop_start, SEEK_SET);
1204 same_measure = -1;
1205 }
1206 break;
1207
1208 case 0xfe: /* end of track */
1209 goto end_of_track;
1210
1211 case 0xc0: /* DX7 function */
1212 case 0xc1: /* DX parameter */
1213 case 0xc2: /* DX RERF */
1214 case 0xc3: /* TX function */
1215 case 0xc5: /* FB-01 P parameter */
1216 case 0xc6: /* FB-01 S System */
1217 case 0xc7: /* TX81Z V VCED */
1218 case 0xc8: /* TX81Z A ACED */
1219 case 0xc9: /* TX81Z P PCED */
1220 case 0xca: /* TX81Z S System */
1221 case 0xcb: /* TX81Z E EFFECT */
1222 case 0xcc: /* DX7-2 R REMOTE SW */
1223 case 0xcd: /* DX7-2 A ACED */
1224 case 0xce: /* DX7-2 P PCED */
1225 case 0xcf: /* TX802 P PCED */
1226 case 0xdc: /* MKS-7 */
1227 if(!gfmt)
1228 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE,
1229 "RCP %s is not unsupported: "
1230 "0x%02x 0x%02x 0x%02x 0x%02x (ch=%d)",
1231 rcp_cmd_name(cmd), cmd, step, a, b, ch);
1232 else
1233 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE,
1234 "RCP %s is not unsupported: "
1235 "0x%02x 0x%02x 0x%02x 0x%02x 0x%02x (ch=%d)",
1236 rcp_cmd_name(cmd), cmd, b, st1, st2, gt1, gt2, ch);
1237 ntr_incr(&ntr, step);
1238 break;
1239 default:
1240 if(!gfmt)
1241 {
1242 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE,
1243 "RCP Unknown Command: 0x%02x 0x%02x 0x%02x 0x%02x "
1244 "(ch=%d)",
1245 cmd, step, a, b, ch);
1246 /* ##?? */
1247 if(cmd == 0xe9 && step == 0xf0 && a == 0xe0 && b == 0x80)
1248 {
1249 ctl->cmsg(CMSG_ERROR, VERB_VERBOSE,
1250 "RCP e9 f0 e0 80 is end of track ??");
1251 goto end_of_track;
1252 }
1253 }
1254 else
1255 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE,
1256 "RCP Unknown Command: "
1257 "0x%02x 0x%02x 0x%02x 0x%02x 0x%02x 0x%02x (ch=%d)",
1258 cmd, b, st1, st2, gt1, gt2, ch);
1259 #if 0
1260 ntr_incr(&ntr, step);
1261 #endif
1262 break;
1263 }
1264 }
1265
1266 end_of_track:
1267 /* All note off */
1268 ntr_wait_all_off(&ntr);
1269 ntr_end(&ntr);
1270 tf_seek(tf, last_point, SEEK_SET);
1271 return ret;
1272 }
1273
ntr_init(struct RCPNoteTracer * ntr,int gfmt,int32 at)1274 static void ntr_init(struct RCPNoteTracer *ntr, int gfmt, int32 at)
1275 {
1276 memset(ntr, 0, sizeof(*ntr));
1277 init_mblock(&ntr->pool);
1278 ntr->gfmt = gfmt;
1279 ntr->at = at;
1280 ntr->tempo_grade = 0;
1281 }
1282
ntr_end(struct RCPNoteTracer * ntr)1283 static void ntr_end(struct RCPNoteTracer *ntr)
1284 {
1285 reuse_mblock(&ntr->pool);
1286 }
1287
ntr_add(struct RCPNoteTracer * ntr,int ch,int note,int gate)1288 static void ntr_add(struct RCPNoteTracer *ntr, int ch, int note, int gate)
1289 {
1290 struct NoteList *p;
1291
1292 if(ntr->freelist)
1293 {
1294 p = ntr->freelist;
1295 ntr->freelist = ntr->freelist->next;
1296 }
1297 else
1298 p = (struct NoteList *)new_segment(&ntr->pool,
1299 sizeof(struct NoteList));
1300 p->gate = gate;
1301 p->ch = ch;
1302 p->note = note;
1303 p->next = ntr->notes;
1304 ntr->notes = p;
1305 }
1306
ntr_note_on(struct RCPNoteTracer * ntr,int ch,int note,int velo,int gate)1307 static void ntr_note_on(struct RCPNoteTracer *ntr,
1308 int ch, int note, int velo, int gate)
1309 {
1310 struct NoteList *p;
1311
1312 for(p = ntr->notes; p != NULL; p = p->next)
1313 if(p->ch == ch && p->note == note)
1314 {
1315 p->gate = gate;
1316 return;
1317 }
1318
1319 MIDIEVENT(ntr->at, ME_NOTEON, ch, note, velo);
1320 ntr_add(ntr, ch, note, gate);
1321 }
1322
rcp_tempo_gradate(struct RCPNoteTracer * ntr,int step)1323 static void rcp_tempo_gradate(struct RCPNoteTracer *ntr, int step)
1324 {
1325 int tempo_grade, tempo_step, tempo, diff, sign, at;
1326
1327 if (step <= 0 || (tempo_grade = ntr->tempo_grade) == 0)
1328 return;
1329 tempo_step = ntr->tempo_step - step;
1330 if (tempo_step <= 0)
1331 {
1332 tempo = ntr->tempo;
1333 diff = ntr->tempo_to - tempo;
1334 sign = (diff < 0) ? -1 : 1;
1335 diff *= sign; /* abs(diff) */
1336 at = ntr_at(*ntr);
1337 while (tempo_step <= 0 && diff != 0)
1338 {
1339 if (tempo_grade > diff)
1340 tempo_grade = diff;
1341 tempo += sign * tempo_grade;
1342 diff -= tempo_grade;
1343 rcp_tempo_set(at, tempo);
1344 at += TEMPO_GRADATION_SKIP;
1345 tempo_step += TEMPO_GRADATION_SKIP;
1346 }
1347 ntr->tempo = tempo;
1348 if (diff == 0)
1349 ntr->tempo_grade = 0;
1350 }
1351 ntr->tempo_step = tempo_step;
1352 }
1353
ntr_incr(struct RCPNoteTracer * ntr,int step)1354 static void ntr_incr(struct RCPNoteTracer *ntr, int step)
1355 {
1356 if(step < 0) {
1357 struct NoteList *p;
1358 ntr->at += step;
1359 for(p = ntr->notes; p != NULL; p = p->next)
1360 p->gate -= step;
1361 return;
1362 }
1363
1364 rcp_tempo_gradate(ntr, step);
1365
1366 while(step >= 0)
1367 {
1368 int32 mingate;
1369 struct NoteList *p, *q;
1370
1371 if(ntr->notes == NULL)
1372 {
1373 ntr->at += step;
1374 return;
1375 }
1376
1377 q = NULL;
1378 p = ntr->notes;
1379 mingate = step;
1380 while(p)
1381 {
1382 struct NoteList *next;
1383
1384 next = p->next;
1385 if(p->gate == 0)
1386 {
1387 if(ctl->verbosity >= VERB_DEBUG_SILLY)
1388 ctl->cmsg(CMSG_INFO, VERB_DEBUG_SILLY,
1389 "NoteOff %d at %d", p->note, ntr->at);
1390 MIDIEVENT(ntr->at, ME_NOTEOFF, p->ch, p->note, 0);
1391 p->next = ntr->freelist;
1392 ntr->freelist = p;
1393 }
1394 else
1395 {
1396 if(mingate > p->gate)
1397 mingate = p->gate;
1398 p->next = q;
1399 q = p;
1400 }
1401 p = next;
1402 }
1403 ntr->notes = q;
1404
1405 if(step == 0)
1406 return;
1407
1408 step -= mingate;
1409 ntr->at += mingate;
1410
1411 for(p = ntr->notes; p != NULL; p = p->next)
1412 p->gate -= mingate;
1413 }
1414 }
1415
ntr_wait_all_off(struct RCPNoteTracer * ntr)1416 static void ntr_wait_all_off(struct RCPNoteTracer *ntr)
1417 {
1418 while(ntr->notes)
1419 {
1420 int32 mingate;
1421 struct NoteList *p, *q;
1422
1423 mingate = 256;
1424 q = NULL;
1425 p = ntr->notes;
1426 while(p)
1427 {
1428 struct NoteList *next;
1429
1430 next = p->next;
1431 if(p->gate == 0)
1432 {
1433 if(ctl->verbosity >= VERB_DEBUG_SILLY)
1434 ctl->cmsg(CMSG_INFO, VERB_DEBUG_SILLY,
1435 "NoteOff %d", p->note);
1436 MIDIEVENT(ntr->at, ME_NOTEOFF, p->ch, p->note, 0);
1437 p->next = ntr->freelist;
1438 ntr->freelist = p;
1439 }
1440 else
1441 {
1442 if(mingate > p->gate)
1443 mingate = p->gate;
1444 p->next = q;
1445 q = p;
1446 }
1447 p = next;
1448 }
1449 ntr->notes = q;
1450 for(p = ntr->notes; p != NULL; p = p->next)
1451 p->gate -= mingate;
1452 rcp_tempo_gradate(ntr, mingate);
1453 ntr->at += mingate;
1454 }
1455 }
1456
preprocess_sysex(uint8 * ex,int ch,int gt,int vel)1457 static int preprocess_sysex(uint8 *ex, int ch, int gt, int vel)
1458 {
1459 uint8 cs = 0; /* check sum */
1460 int len = 0;
1461 int i;
1462
1463 for(i = 0; i < MAX_EXCLUSIVE_LENGTH && ex[i] != 0xf7; i++)
1464 {
1465 switch(ex[i])
1466 {
1467 case 0x80: /* gt */
1468 cs += ex[len++] = gt;
1469 break;
1470 case 0x81: /* ve */
1471 cs += ex[len++] = vel;
1472 break;
1473 case 0x82: /* ch */
1474 cs += ex[len++] = ch;
1475 break;
1476 case 0x83: /* (Clear Sum) */
1477 #if 0
1478 if(ex[0] == 0x41 && len == 3 &&
1479 ex[len - 2] == 0x10 && ex[len - 1] == 0x12) /* ##?? */
1480 {
1481 ex[len - 1] = 0x42;
1482 ex[len++] = 0x12;
1483 }
1484 #endif
1485 cs = 0;
1486 break;
1487 case 0x84: /* (Send Sum) */
1488 ex[len++] = 128 - (cs & 0x7f);
1489 break;
1490 default:
1491 cs += ex[len++] = ex[i];
1492 break;
1493 }
1494 }
1495 ex[len++] = 0xf7;
1496 return len;
1497 }
1498