开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Windows编程 > 多媒体编程 > 查看源码
readmidi.c
资源名称：SDL_mixer-1.2.11.tar.gz　[点击查看]
上传用户：nini_0081
上传日期：2022-07-21
资源大小：2628k
文件大小：28k
源码类别：

多媒体编程

开发平台：

DOS

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