1 /* 2 TiMidity -- Experimental MIDI to WAVE converter 3 Copyright (C) 1995 Tuukka Toivonen <toivonen@clinet.fi> 4 5 This program is free software; you can redistribute it and/or modify 6 it under the terms of the Perl Artistic License, available in COPYING. 7 */ 8 9 #include <stdio.h> 10 #include <stdlib.h> 11 #include <errno.h> 12 #include <string.h> 13 14 #include <SDL_rwops.h> 15 16 #include "config.h" 17 #include "common.h" 18 #include "instrum.h" 19 #include "playmidi.h" 20 #include "readmidi.h" 21 #include "output.h" 22 #include "ctrlmode.h" 23 24 int32 quietchannels=0; 25 26 static int midi_port_number; 27 char midi_name[FILENAME_MAX+1]; 28 29 static int track_info, curr_track, curr_title_track; 30 static char title[128]; 31 32 #if MAXCHAN <= 16 33 #define MERGE_CHANNEL_PORT(ch) ((int)(ch)) 34 #else 35 #define MERGE_CHANNEL_PORT(ch) ((int)(ch) | (midi_port_number << 4)) 36 #endif 37 38 /* to avoid some unnecessary parameter passing */ 39 static MidiEventList *evlist; 40 static int32 event_count; 41 static SDL_RWops *rw; 42 static int32 at; 43 44 /* These would both fit into 32 bits, but they are often added in 45 large multiples, so it's simpler to have two roomy ints */ 46 static int32 sample_increment, sample_correction; /*samples per MIDI delta-t*/ 47 48 /* Computes how many (fractional) samples one MIDI delta-time unit contains */ 49 static void compute_sample_increment(int32 tempo, int32 divisions) 50 { 51 double a; 52 a = (double) (tempo) * (double) (play_mode->rate) * (65536.0/1000000.0) / 53 (double)(divisions); 54 55 sample_correction = (int32)(a) & 0xFFFF; 56 sample_increment = (int32)(a) >> 16; 57 58 ctl->cmsg(CMSG_INFO, VERB_DEBUG, "Samples per delta-t: %d (correction %d)", 59 sample_increment, sample_correction); 60 } 61 62 /* Read variable-length number (7 bits per byte, MSB first) */ 63 static int32 getvl(void) 64 { 65 int32 l=0; 66 uint8 c; 67 for (;;) 68 { 69 SDL_RWread(rw,&c,1,1); 70 l += (c & 0x7f); 71 if (!(c & 0x80)) return l; 72 l<<=7; 73 } 74 } 75 76 77 static int sysex(uint32 len, uint8 *syschan, uint8 *sysa, uint8 *sysb, SDL_RWops *rw) 78 { 79 unsigned char *s=(unsigned char *)safe_malloc(len); 80 int id, model, ch, port, adhi, adlo, cd, dta, dtb, dtc; 81 if (len != (uint32)SDL_RWread(rw, s, 1, len)) 82 { 83 free(s); 84 return 0; 85 } 86 if (len<5) { free(s); return 0; } 87 if (curr_track == curr_title_track && track_info > 1) title[0] = '\0'; 88 id=s[0]; port=s[1]; model=s[2]; adhi=s[3]; adlo=s[4]; 89 if (id==0x7e && port==0x7f && model==0x09 && adhi==0x01) 90 { 91 ctl->cmsg(CMSG_TEXT, VERB_VERBOSE, "GM System On", len); 92 GM_System_On=1; 93 free(s); 94 return 0; 95 } 96 ch = adlo & 0x0f; 97 *syschan=(uint8)ch; 98 if (id==0x7f && len==7 && port==0x7f && model==0x04 && adhi==0x01) 99 { 100 ctl->cmsg(CMSG_TEXT, VERB_DEBUG, "Master Volume %d", s[4]+(s[5]<<7)); 101 *sysa = s[4]; 102 *sysb = s[5]; 103 free(s); 104 return ME_MASTERVOLUME; 105 /** return s[4]+(s[5]<<7); **/ 106 } 107 if (len<8) { free(s); return 0; } 108 port &=0x0f; 109 ch = (adlo & 0x0f) | ((port & 0x03) << 4); 110 *syschan=(uint8)ch; 111 cd=s[5]; dta=s[6]; 112 if (len >= 8) dtb=s[7]; 113 else dtb=-1; 114 if (len >= 9) dtc=s[8]; 115 else dtc=-1; 116 free(s); 117 if (id==0x43 && model==0x4c) 118 { 119 if (!adhi && !adlo && cd==0x7e && !dta) 120 { 121 ctl->cmsg(CMSG_TEXT, VERB_VERBOSE, "XG System On", len); 122 XG_System_On=1; 123 #ifdef tplus 124 vol_table = xg_vol_table; 125 #endif 126 } 127 else if (adhi == 2 && adlo == 1) 128 { 129 if (dtb==8) dtb=3; 130 switch (cd) 131 { 132 case 0x00: 133 XG_System_reverb_type=(dta<<3)+dtb; 134 break; 135 case 0x20: 136 XG_System_chorus_type=((dta-64)<<3)+dtb; 137 break; 138 case 0x40: 139 XG_System_variation_type=dta; 140 break; 141 case 0x5a: 142 /* dta==0 Insertion; dta==1 System */ 143 break; 144 default: break; 145 } 146 } 147 else if (adhi == 8 && cd <= 40) 148 { 149 *sysa = dta & 0x7f; 150 switch (cd) 151 { 152 case 0x01: /* bank select MSB */ 153 return ME_TONE_KIT; 154 break; 155 case 0x02: /* bank select LSB */ 156 return ME_TONE_BANK; 157 break; 158 case 0x03: /* program number */ 159 /** MIDIEVENT(d->at, ME_PROGRAM, lastchan, a, 0); **/ 160 return ME_PROGRAM; 161 break; 162 case 0x08: /* */ 163 /* d->channel[adlo&0x0f].transpose = (char)(dta-64); */ 164 channel[ch].transpose = (char)(dta-64); 165 ctl->cmsg(CMSG_TEXT, VERB_DEBUG, "transpose channel %d by %d", 166 (adlo&0x0f)+1, dta-64); 167 break; 168 case 0x0b: /* volume */ 169 return ME_MAINVOLUME; 170 break; 171 case 0x0e: /* pan */ 172 return ME_PAN; 173 break; 174 case 0x12: /* chorus send */ 175 return ME_CHORUSDEPTH; 176 break; 177 case 0x13: /* reverb send */ 178 return ME_REVERBERATION; 179 break; 180 case 0x14: /* variation send */ 181 break; 182 case 0x18: /* filter cutoff */ 183 return ME_BRIGHTNESS; 184 break; 185 case 0x19: /* filter resonance */ 186 return ME_HARMONICCONTENT; 187 break; 188 default: break; 189 } 190 } 191 return 0; 192 } 193 else if (id==0x41 && model==0x42 && adhi==0x12 && adlo==0x40) 194 { 195 if (dtc<0) return 0; 196 if (!cd && dta==0x7f && !dtb && dtc==0x41) 197 { 198 ctl->cmsg(CMSG_TEXT, VERB_VERBOSE, "GS System On", len); 199 GS_System_On=1; 200 #ifdef tplus 201 vol_table = gs_vol_table; 202 #endif 203 } 204 else if (dta==0x15 && (cd&0xf0)==0x10) 205 { 206 int chan=cd&0x0f; 207 if (!chan) chan=9; 208 else if (chan<10) chan--; 209 chan = MERGE_CHANNEL_PORT(chan); 210 channel[chan].kit=dtb; 211 } 212 else if (cd==0x01) switch(dta) 213 { 214 case 0x30: 215 switch(dtb) 216 { 217 case 0: XG_System_reverb_type=16+0; break; 218 case 1: XG_System_reverb_type=16+1; break; 219 case 2: XG_System_reverb_type=16+2; break; 220 case 3: XG_System_reverb_type= 8+0; break; 221 case 4: XG_System_reverb_type= 8+1; break; 222 case 5: XG_System_reverb_type=32+0; break; 223 case 6: XG_System_reverb_type=8*17; break; 224 case 7: XG_System_reverb_type=8*18; break; 225 } 226 break; 227 case 0x38: 228 switch(dtb) 229 { 230 case 0: XG_System_chorus_type= 8+0; break; 231 case 1: XG_System_chorus_type= 8+1; break; 232 case 2: XG_System_chorus_type= 8+2; break; 233 case 3: XG_System_chorus_type= 8+4; break; 234 case 4: XG_System_chorus_type= -1; break; 235 case 5: XG_System_chorus_type= 8*3; break; 236 case 6: XG_System_chorus_type= -1; break; 237 case 7: XG_System_chorus_type= -1; break; 238 } 239 break; 240 } 241 return 0; 242 } 243 return 0; 244 } 245 246 /* Print a string from the file, followed by a newline. Any non-ASCII 247 or unprintable characters will be converted to periods. */ 248 static int dumpstring(int32 len, const char *label) 249 { 250 signed char *s=safe_malloc(len+1); 251 if (len != (int32)SDL_RWread(rw, s, 1, len)) 252 { 253 free(s); 254 return -1; 255 } 256 s[len]='\0'; 257 while (len--) 258 { 259 if (s[len]<32) 260 s[len]='.'; 261 } 262 ctl->cmsg(CMSG_TEXT, VERB_VERBOSE, "%s%s", label, s); 263 free(s); 264 return 0; 265 } 266 267 #define MIDIEVENT(at,t,ch,pa,pb) \ 268 new=safe_malloc(sizeof(MidiEventList)); \ 269 new->event.time=at; new->event.type=t; new->event.channel=ch; \ 270 new->event.a=pa; new->event.b=pb; new->next=0;\ 271 return new; 272 273 #define MAGIC_EOT ((MidiEventList *)(-1)) 274 275 /* Read a MIDI event, returning a freshly allocated element that can 276 be linked to the event list */ 277 static MidiEventList *read_midi_event(void) 278 { 279 static uint8 laststatus, lastchan; 280 static uint8 nrpn=0, rpn_msb[16], rpn_lsb[16]; /* one per channel */ 281 uint8 me, type, a,b,c; 282 int32 len; 283 MidiEventList *new; 284 285 for (;;) 286 { 287 at+=getvl(); 288 if (SDL_RWread(rw,&me,1,1)!=1) 289 { 290 ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: read_midi_event: %s", 291 current_filename, strerror(errno)); 292 return 0; 293 } 294 295 if(me==0xF0 || me == 0xF7) /* SysEx event */ 296 { 297 int32 sret; 298 uint8 sysa=0, sysb=0, syschan=0; 299 300 len=getvl(); 301 sret=sysex(len, &syschan, &sysa, &sysb, rw); 302 if (sret) 303 { 304 MIDIEVENT(at, sret, syschan, sysa, sysb); 305 } 306 } 307 else if(me==0xFF) /* Meta event */ 308 { 309 SDL_RWread(rw,&type,1,1); 310 len=getvl(); 311 if (type>0 && type<16) 312 { 313 static char *label[]={ 314 "Text event: ", "Text: ", "Copyright: ", "Track name: ", 315 "Instrument: ", "Lyric: ", "Marker: ", "Cue point: "}; 316 dumpstring(len, label[(type>7) ? 0 : type]); 317 } 318 else 319 switch(type) 320 { 321 322 case 0x21: /* MIDI port number */ 323 if(len == 1) 324 { 325 SDL_RWread(rw,&midi_port_number,1,1); 326 if(midi_port_number == EOF) 327 { 328 ctl->cmsg(CMSG_ERROR, VERB_NORMAL, 329 "Warning: \"%s\": Short midi file.", 330 midi_name); 331 return 0; 332 } 333 midi_port_number &= 0x0f; 334 if (midi_port_number) 335 ctl->cmsg(CMSG_INFO, VERB_VERBOSE, 336 "(MIDI port number %d)", midi_port_number); 337 midi_port_number &= 0x03; 338 } 339 else SDL_RWseek(rw, len, RW_SEEK_CUR); 340 break; 341 342 case 0x2F: /* End of Track */ 343 return MAGIC_EOT; 344 345 case 0x51: /* Tempo */ 346 SDL_RWread(rw,&a,1,1); SDL_RWread(rw,&b,1,1); SDL_RWread(rw,&c,1,1); 347 MIDIEVENT(at, ME_TEMPO, c, a, b); 348 349 default: 350 ctl->cmsg(CMSG_INFO, VERB_DEBUG, 351 "(Meta event type 0x%02x, length %ld)", type, len); 352 SDL_RWseek(rw, len, RW_SEEK_CUR); 353 break; 354 } 355 } 356 else 357 { 358 a=me; 359 if (a & 0x80) /* status byte */ 360 { 361 lastchan=a & 0x0F; 362 laststatus=(a>>4) & 0x07; 363 SDL_RWread(rw,&a, 1,1); 364 a &= 0x7F; 365 } 366 switch(laststatus) 367 { 368 case 0: /* Note off */ 369 SDL_RWread(rw,&b, 1,1); 370 b &= 0x7F; 371 MIDIEVENT(at, ME_NOTEOFF, lastchan, a,b); 372 373 case 1: /* Note on */ 374 SDL_RWread(rw,&b, 1,1); 375 b &= 0x7F; 376 if (curr_track == curr_title_track && track_info > 1) title[0] = '\0'; 377 MIDIEVENT(at, ME_NOTEON, lastchan, a,b); 378 379 380 case 2: /* Key Pressure */ 381 SDL_RWread(rw,&b, 1,1); 382 b &= 0x7F; 383 MIDIEVENT(at, ME_KEYPRESSURE, lastchan, a, b); 384 385 case 3: /* Control change */ 386 SDL_RWread(rw,&b, 1,1); 387 b &= 0x7F; 388 { 389 int control=255; 390 switch(a) 391 { 392 case 7: control=ME_MAINVOLUME; break; 393 case 10: control=ME_PAN; break; 394 case 11: control=ME_EXPRESSION; break; 395 case 64: control=ME_SUSTAIN; break; 396 397 case 71: control=ME_HARMONICCONTENT; break; 398 case 72: control=ME_RELEASETIME; break; 399 case 73: control=ME_ATTACKTIME; break; 400 case 74: control=ME_BRIGHTNESS; break; 401 case 91: control=ME_REVERBERATION; break; 402 case 93: control=ME_CHORUSDEPTH; break; 403 404 case 120: control=ME_ALL_SOUNDS_OFF; break; 405 case 121: control=ME_RESET_CONTROLLERS; break; 406 case 123: control=ME_ALL_NOTES_OFF; break; 407 408 /* These should be the SCC-1 tone bank switch 409 commands. I don't know why there are two, or 410 why the latter only allows switching to bank 0. 411 Also, some MIDI files use 0 as some sort of 412 continuous controller. This will cause lots of 413 warnings about undefined tone banks. */ 414 case 0: if (XG_System_On) control = ME_TONE_KIT; else control=ME_TONE_BANK; break; 415 416 case 32: if (XG_System_On) control = ME_TONE_BANK; break; 417 418 case 100: nrpn=0; rpn_msb[lastchan]=b; break; 419 case 101: nrpn=0; rpn_lsb[lastchan]=b; break; 420 case 99: nrpn=1; rpn_msb[lastchan]=b; break; 421 case 98: nrpn=1; rpn_lsb[lastchan]=b; break; 422 423 case 6: 424 if (nrpn) 425 { 426 if (rpn_msb[lastchan]==1) switch (rpn_lsb[lastchan]) 427 { 428 #ifdef tplus 429 case 0x08: control=ME_VIBRATO_RATE; break; 430 case 0x09: control=ME_VIBRATO_DEPTH; break; 431 case 0x0a: control=ME_VIBRATO_DELAY; break; 432 #endif 433 case 0x20: control=ME_BRIGHTNESS; break; 434 case 0x21: control=ME_HARMONICCONTENT; break; 435 /* 436 case 0x63: envelope attack rate 437 case 0x64: envelope decay rate 438 case 0x66: envelope release rate 439 */ 440 } 441 else switch (rpn_msb[lastchan]) 442 { 443 /* 444 case 0x14: filter cutoff frequency 445 case 0x15: filter resonance 446 case 0x16: envelope attack rate 447 case 0x17: envelope decay rate 448 case 0x18: pitch coarse 449 case 0x19: pitch fine 450 */ 451 case 0x1a: drumvolume[lastchan][0x7f & rpn_lsb[lastchan]] = b; break; 452 case 0x1c: 453 if (!b) b=(int) (127.0*rand()/(RAND_MAX)); 454 drumpanpot[lastchan][0x7f & rpn_lsb[lastchan]] = b; 455 break; 456 case 0x1d: drumreverberation[lastchan][0x7f & rpn_lsb[lastchan]] = b; break; 457 case 0x1e: drumchorusdepth[lastchan][0x7f & rpn_lsb[lastchan]] = b; break; 458 /* 459 case 0x1f: variation send level 460 */ 461 } 462 463 ctl->cmsg(CMSG_INFO, VERB_DEBUG, 464 "(Data entry (MSB) for NRPN %02x,%02x: %ld)", 465 rpn_msb[lastchan], rpn_lsb[lastchan], 466 b); 467 break; 468 } 469 470 switch((rpn_msb[lastchan]<<8) | rpn_lsb[lastchan]) 471 { 472 case 0x0000: /* Pitch bend sensitivity */ 473 control=ME_PITCH_SENS; 474 break; 475 476 case 0x7F7F: /* RPN reset */ 477 /* reset pitch bend sensitivity to 2 */ 478 MIDIEVENT(at, ME_PITCH_SENS, lastchan, 2, 0); 479 480 default: 481 ctl->cmsg(CMSG_INFO, VERB_DEBUG, 482 "(Data entry (MSB) for RPN %02x,%02x: %ld)", 483 rpn_msb[lastchan], rpn_lsb[lastchan], 484 b); 485 break; 486 } 487 break; 488 489 default: 490 ctl->cmsg(CMSG_INFO, VERB_DEBUG, 491 "(Control %d: %d)", a, b); 492 break; 493 } 494 if (control != 255) 495 { 496 MIDIEVENT(at, control, lastchan, b, 0); 497 } 498 } 499 break; 500 501 case 4: /* Program change */ 502 a &= 0x7f; 503 MIDIEVENT(at, ME_PROGRAM, lastchan, a, 0); 504 505 case 5: /* Channel pressure - NOT IMPLEMENTED */ 506 break; 507 508 case 6: /* Pitch wheel */ 509 SDL_RWread(rw,&b, 1,1); 510 b &= 0x7F; 511 MIDIEVENT(at, ME_PITCHWHEEL, lastchan, a, b); 512 513 default: 514 ctl->cmsg(CMSG_ERROR, VERB_NORMAL, 515 "*** Can't happen: status 0x%02X, channel 0x%02X", 516 laststatus, lastchan); 517 break; 518 } 519 } 520 } 521 522 return new; 523 } 524 525 #undef MIDIEVENT 526 527 /* Read a midi track into the linked list, either merging with any previous 528 tracks or appending to them. */ 529 static int read_track(int append) 530 { 531 MidiEventList *meep; 532 MidiEventList *next, *new; 533 int32 len, next_pos, pos; 534 char tmp[4]; 535 536 meep=evlist; 537 if (append && meep) 538 { 539 /* find the last event in the list */ 540 for (; meep->next; meep=meep->next) 541 ; 542 at=meep->event.time; 543 } 544 else 545 at=0; 546 547 /* Check the formalities */ 548 if ((SDL_RWread(rw,tmp,1,4) != 4) || (SDL_RWread(rw,&len,4,1) != 1)) 549 { 550 ctl->cmsg(CMSG_ERROR, VERB_NORMAL, 551 "%s: Can't read track header.", current_filename); 552 return -1; 553 } 554 len=BE_LONG(len); 555 next_pos = SDL_RWtell(rw) + len; 556 if (memcmp(tmp, "MTrk", 4)) 557 { 558 ctl->cmsg(CMSG_ERROR, VERB_NORMAL, 559 "%s: Corrupt MIDI file.", current_filename); 560 return -2; 561 } 562 563 for (;;) 564 { 565 if (!(new=read_midi_event())) /* Some kind of error */ 566 return -2; 567 568 if (new==MAGIC_EOT) /* End-of-track Hack. */ 569 { 570 pos = SDL_RWtell(rw); 571 if (pos < next_pos) 572 SDL_RWseek(rw, next_pos - pos, RW_SEEK_CUR); 573 return 0; 574 } 575 576 next=meep->next; 577 while (next && (next->event.time < new->event.time)) 578 { 579 meep=next; 580 next=meep->next; 581 } 582 583 new->next=next; 584 meep->next=new; 585 586 event_count++; /* Count the event. (About one?) */ 587 meep=new; 588 } 589 } 590 591 /* Free the linked event list from memory. */ 592 static void free_midi_list(void) 593 { 594 MidiEventList *meep, *next; 595 if (!(meep=evlist)) return; 596 while (meep) 597 { 598 next=meep->next; 599 free(meep); 600 meep=next; 601 } 602 evlist=0; 603 } 604 605 606 static void xremap_percussion(int *banknumpt, int *this_notept, int this_kit) { 607 int i, newmap; 608 int banknum = *banknumpt; 609 int this_note = *this_notept; 610 int newbank, newnote; 611 612 if (this_kit != 127 && this_kit != 126) return; 613 614 for (i = 0; i < XMAPMAX; i++) { 615 newmap = xmap[i][0]; 616 if (!newmap) return; 617 if (this_kit == 127 && newmap != XGDRUM) continue; 618 if (this_kit == 126 && newmap != SFXDRUM1) continue; 619 if (xmap[i][1] != banknum) continue; 620 if (xmap[i][3] != this_note) continue; 621 newbank = xmap[i][2]; 622 newnote = xmap[i][4]; 623 if (newbank == banknum && newnote == this_note) return; 624 if (!drumset[newbank]) return; 625 *banknumpt = newbank; 626 *this_notept = newnote; 627 return; 628 } 629 } 630 631 /* Allocate an array of MidiEvents and fill it from the linked list of 632 events, marking used instruments for loading. Convert event times to 633 samples: handle tempo changes. Strip unnecessary events from the list. 634 Free the linked list. */ 635 static MidiEvent *groom_list(int32 divisions,int32 *eventsp,int32 *samplesp) 636 { 637 MidiEvent *groomed_list, *lp; 638 MidiEventList *meep; 639 int32 i, our_event_count, tempo, skip_this_event, new_value; 640 int32 sample_cum, samples_to_do, at, st, dt, counting_time; 641 642 int current_bank[MAXCHAN], current_banktype[MAXCHAN], current_set[MAXCHAN], 643 current_kit[MAXCHAN], current_program[MAXCHAN]; 644 /* Or should each bank have its own current program? */ 645 int dset, dnote, drumsflag, mprog; 646 647 for (i=0; i<MAXCHAN; i++) 648 { 649 current_bank[i]=0; 650 current_banktype[i]=0; 651 current_set[i]=0; 652 current_kit[i]=channel[i].kit; 653 current_program[i]=default_program; 654 } 655 656 tempo=500000; 657 compute_sample_increment(tempo, divisions); 658 659 /* This may allocate a bit more than we need */ 660 groomed_list=lp=safe_malloc(sizeof(MidiEvent) * (event_count+1)); 661 meep=evlist; 662 663 our_event_count=0; 664 st=at=sample_cum=0; 665 counting_time=2; /* We strip any silence before the first NOTE ON. */ 666 667 for (i=0; i<event_count; i++) 668 { 669 skip_this_event=0; 670 ctl->cmsg(CMSG_INFO, VERB_DEBUG_SILLY, 671 "%6d: ch %2d: event %d (%d,%d)", 672 meep->event.time, meep->event.channel + 1, 673 meep->event.type, meep->event.a, meep->event.b); 674 675 if (meep->event.type==ME_TEMPO) 676 { 677 tempo= 678 meep->event.channel + meep->event.b * 256 + meep->event.a * 65536; 679 compute_sample_increment(tempo, divisions); 680 skip_this_event=1; 681 } 682 else if ((quietchannels & (1<<meep->event.channel))) 683 skip_this_event=1; 684 else switch (meep->event.type) 685 { 686 case ME_PROGRAM: 687 688 if (current_kit[meep->event.channel]) 689 { 690 if (current_kit[meep->event.channel]==126) 691 { 692 /* note request for 2nd sfx rhythm kit */ 693 if (meep->event.a && drumset[SFXDRUM2]) 694 { 695 current_kit[meep->event.channel]=125; 696 current_set[meep->event.channel]=SFXDRUM2; 697 new_value=SFXDRUM2; 698 } 699 else if (!meep->event.a && drumset[SFXDRUM1]) 700 { 701 current_set[meep->event.channel]=SFXDRUM1; 702 new_value=SFXDRUM1; 703 } 704 else 705 { 706 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE, 707 "XG SFX drum set is undefined"); 708 skip_this_event=1; 709 break; 710 } 711 } 712 if (drumset[meep->event.a]) /* Is this a defined drumset? */ 713 new_value=meep->event.a; 714 else 715 { 716 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE, 717 "Drum set %d is undefined", meep->event.a); 718 if (drumset[0]) 719 new_value=meep->event.a=0; 720 else 721 { 722 skip_this_event=1; 723 break; 724 } 725 } 726 if (current_set[meep->event.channel] != new_value) 727 current_set[meep->event.channel]=new_value; 728 else 729 skip_this_event=1; 730 } 731 else 732 { 733 new_value=meep->event.a; 734 if ((current_program[meep->event.channel] != SPECIAL_PROGRAM) 735 && (current_program[meep->event.channel] != new_value)) 736 current_program[meep->event.channel] = new_value; 737 else 738 skip_this_event=1; 739 } 740 break; 741 742 case ME_NOTEON: 743 if (counting_time) 744 counting_time=1; 745 746 drumsflag = current_kit[meep->event.channel]; 747 748 if (drumsflag) /* percussion channel? */ 749 { 750 dset = current_set[meep->event.channel]; 751 dnote=meep->event.a; 752 if (XG_System_On) xremap_percussion(&dset, &dnote, drumsflag); 753 754 /*if (current_config_pc42b) pcmap(&dset, &dnote, &mprog, &drumsflag);*/ 755 756 if (drumsflag) 757 { 758 /* Mark this instrument to be loaded */ 759 if (!(drumset[dset]->tone[dnote].layer)) 760 { 761 drumset[dset]->tone[dnote].layer= 762 MAGIC_LOAD_INSTRUMENT; 763 } 764 else drumset[dset]->tone[dnote].last_used 765 = current_tune_number; 766 if (!channel[meep->event.channel].name) channel[meep->event.channel].name= 767 drumset[dset]->name; 768 } 769 } 770 771 if (!drumsflag) /* not percussion */ 772 { 773 int chan=meep->event.channel; 774 int banknum; 775 776 if (current_banktype[chan]) banknum=SFXBANK; 777 else banknum=current_bank[chan]; 778 779 mprog = current_program[chan]; 780 781 if (mprog==SPECIAL_PROGRAM) 782 break; 783 784 if (XG_System_On && banknum==SFXBANK && !tonebank[SFXBANK] && tonebank[120]) 785 banknum = 120; 786 787 /*if (current_config_pc42b) pcmap(&banknum, &dnote, &mprog, &drumsflag);*/ 788 789 if (drumsflag) 790 { 791 /* Mark this instrument to be loaded */ 792 if (!(drumset[dset]->tone[dnote].layer)) 793 { 794 drumset[dset]->tone[dnote].layer=MAGIC_LOAD_INSTRUMENT; 795 } 796 else drumset[dset]->tone[dnote].last_used = current_tune_number; 797 if (!channel[meep->event.channel].name) channel[meep->event.channel].name= 798 drumset[dset]->name; 799 } 800 if (!drumsflag) 801 { 802 /* Mark this instrument to be loaded */ 803 if (!(tonebank[banknum]->tone[mprog].layer)) 804 { 805 tonebank[banknum]->tone[mprog].layer=MAGIC_LOAD_INSTRUMENT; 806 } 807 else tonebank[banknum]->tone[mprog].last_used = current_tune_number; 808 if (!channel[meep->event.channel].name) channel[meep->event.channel].name= 809 tonebank[banknum]->tone[mprog].name; 810 } 811 } 812 break; 813 814 case ME_TONE_KIT: 815 if (!meep->event.a || meep->event.a == 127) 816 { 817 new_value=meep->event.a; 818 if (current_kit[meep->event.channel] != new_value) 819 current_kit[meep->event.channel]=new_value; 820 else 821 skip_this_event=1; 822 break; 823 } 824 else if (meep->event.a == 126) 825 { 826 if (drumset[SFXDRUM1]) /* Is this a defined tone bank? */ 827 new_value=meep->event.a; 828 else 829 { 830 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE, 831 "XG rhythm kit %d is undefined", meep->event.a); 832 skip_this_event=1; 833 break; 834 } 835 current_set[meep->event.channel]=SFXDRUM1; 836 current_kit[meep->event.channel]=new_value; 837 break; 838 } 839 else if (meep->event.a != SFX_BANKTYPE) 840 { 841 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE, 842 "XG kit %d is impossible", meep->event.a); 843 skip_this_event=1; 844 break; 845 } 846 847 if (current_kit[meep->event.channel]) 848 { 849 skip_this_event=1; 850 break; 851 } 852 if (tonebank[SFXBANK] || tonebank[120]) /* Is this a defined tone bank? */ 853 new_value=SFX_BANKTYPE; 854 else 855 { 856 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE, 857 "XG Sfx bank is undefined"); 858 skip_this_event=1; 859 break; 860 } 861 if (current_banktype[meep->event.channel]!=new_value) 862 current_banktype[meep->event.channel]=new_value; 863 else 864 skip_this_event=1; 865 break; 866 867 case ME_TONE_BANK: 868 if (current_kit[meep->event.channel]) 869 { 870 skip_this_event=1; 871 break; 872 } 873 if (XG_System_On && meep->event.a > 0 && meep->event.a < 48) { 874 channel[meep->event.channel].variationbank=meep->event.a; 875 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE, 876 "XG variation bank %d", meep->event.a); 877 new_value=meep->event.a=0; 878 } 879 else if (tonebank[meep->event.a]) /* Is this a defined tone bank? */ 880 new_value=meep->event.a; 881 else 882 { 883 ctl->cmsg(CMSG_WARNING, VERB_VERBOSE, 884 "Tone bank %d is undefined", meep->event.a); 885 new_value=meep->event.a=0; 886 } 887 888 if (current_bank[meep->event.channel]!=new_value) 889 current_bank[meep->event.channel]=new_value; 890 else 891 skip_this_event=1; 892 break; 893 894 case ME_HARMONICCONTENT: 895 channel[meep->event.channel].harmoniccontent=meep->event.a; 896 break; 897 case ME_BRIGHTNESS: 898 channel[meep->event.channel].brightness=meep->event.a; 899 break; 900 901 } 902 903 /* Recompute time in samples*/ 904 if ((dt=meep->event.time - at) && !counting_time) 905 { 906 samples_to_do=sample_increment * dt; 907 sample_cum += sample_correction * dt; 908 if (sample_cum & 0xFFFF0000) 909 { 910 samples_to_do += ((sample_cum >> 16) & 0xFFFF); 911 sample_cum &= 0x0000FFFF; 912 } 913 st += samples_to_do; 914 } 915 else if (counting_time==1) counting_time=0; 916 if (!skip_this_event) 917 { 918 /* Add the event to the list */ 919 *lp=meep->event; 920 lp->time=st; 921 lp++; 922 our_event_count++; 923 } 924 at=meep->event.time; 925 meep=meep->next; 926 } 927 /* Add an End-of-Track event */ 928 lp->time=st; 929 lp->type=ME_EOT; 930 our_event_count++; 931 free_midi_list(); 932 933 *eventsp=our_event_count; 934 *samplesp=st; 935 return groomed_list; 936 } 937 938 MidiEvent *read_midi_file(SDL_RWops *mrw, int32 *count, int32 *sp) 939 { 940 int32 len, divisions; 941 int16 format, tracks, divisions_tmp; 942 int i; 943 char tmp[4]; 944 945 rw = mrw; 946 event_count=0; 947 at=0; 948 evlist=0; 949 950 GM_System_On=GS_System_On=XG_System_On=0; 951 /* vol_table = def_vol_table; */ 952 XG_System_reverb_type=XG_System_chorus_type=XG_System_variation_type=0; 953 memset(&drumvolume,-1,sizeof(drumvolume)); 954 memset(&drumchorusdepth,-1,sizeof(drumchorusdepth)); 955 memset(&drumreverberation,-1,sizeof(drumreverberation)); 956 memset(&drumpanpot,NO_PANNING,sizeof(drumpanpot)); 957 958 for (i=0; i<MAXCHAN; i++) 959 { 960 if (ISDRUMCHANNEL(i)) channel[i].kit = 127; 961 else channel[i].kit = 0; 962 channel[i].brightness = 64; 963 channel[i].harmoniccontent = 64; 964 channel[i].variationbank = 0; 965 channel[i].chorusdepth = 0; 966 channel[i].reverberation = 0; 967 channel[i].transpose = 0; 968 } 969 970 past_riff: 971 972 if ((SDL_RWread(rw,tmp,1,4) != 4) || (SDL_RWread(rw,&len,4,1) != 1)) 973 { 974 /* if (ferror(fp)) 975 { 976 ctl->cmsg(CMSG_ERROR, VERB_NORMAL, "%s: %s", current_filename, 977 strerror(errno)); 978 } 979 else*/ 980 ctl->cmsg(CMSG_ERROR, VERB_NORMAL, 981 "%s: Not a MIDI file!", current_filename); 982 return 0; 983 } 984 len=BE_LONG(len); 985 986 if (!memcmp(tmp, "RIFF", 4)) 987 { 988 SDL_RWread(rw,tmp,1,12); 989 goto past_riff; 990 } 991 if (memcmp(tmp, "MThd", 4) || len < 6) 992 { 993 ctl->cmsg(CMSG_ERROR, VERB_NORMAL, 994 "%s: Not a MIDI file!", current_filename); 995 return 0; 996 } 997 998 SDL_RWread(rw,&format, 2, 1); 999 SDL_RWread(rw,&tracks, 2, 1); 1000 SDL_RWread(rw,&divisions_tmp, 2, 1); 1001 format=BE_SHORT(format); 1002 tracks=BE_SHORT(tracks); 1003 track_info = tracks; 1004 curr_track = 0; 1005 curr_title_track = -1; 1006 divisions_tmp=BE_SHORT(divisions_tmp); 1007 1008 if (divisions_tmp<0) 1009 { 1010 /* SMPTE time -- totally untested. Got a MIDI file that uses this? */ 1011 divisions= 1012 (int32)(-(divisions_tmp/256)) * (int32)(divisions_tmp & 0xFF); 1013 } 1014 else divisions=(int32)(divisions_tmp); 1015 1016 if (len > 6) 1017 { 1018 ctl->cmsg(CMSG_WARNING, VERB_NORMAL, 1019 "%s: MIDI file header size %ld bytes", 1020 current_filename, len); 1021 SDL_RWseek(rw, len-6, RW_SEEK_CUR); /* skip the excess */ 1022 } 1023 if (format<0 || format >2) 1024 { 1025 ctl->cmsg(CMSG_ERROR, VERB_NORMAL, 1026 "%s: Unknown MIDI file format %d", current_filename, format); 1027 return 0; 1028 } 1029 ctl->cmsg(CMSG_INFO, VERB_VERBOSE, 1030 "Format: %d Tracks: %d Divisions: %d", format, tracks, divisions); 1031 1032 /* Put a do-nothing event first in the list for easier processing */ 1033 evlist=safe_malloc(sizeof(MidiEventList)); 1034 evlist->event.time=0; 1035 evlist->event.type=ME_NONE; 1036 evlist->next=0; 1037 event_count++; 1038 1039 switch(format) 1040 { 1041 case 0: 1042 if (read_track(0)) 1043 { 1044 free_midi_list(); 1045 return 0; 1046 } 1047 else curr_track++; 1048 break; 1049 1050 case 1: 1051 for (i=0; i<tracks; i++) 1052 if (read_track(0)) 1053 { 1054 free_midi_list(); 1055 return 0; 1056 } 1057 break; 1058 1059 case 2: /* We simply play the tracks sequentially */ 1060 for (i=0; i<tracks; i++) 1061 if (read_track(1)) 1062 { 1063 free_midi_list(); 1064 return 0; 1065 } 1066 else curr_track++; 1067 break; 1068 } 1069 return groom_list(divisions, count, sp); 1070 } 1071