16/othersrc/lib/midi.c

   1 /* midi.c\r
   2  *\r
   3  * Adlib OPL2/OPL3 FM synthesizer chipset test program.\r
   4  * Play MIDI file using the OPLx synthesizer (well, poorly anyway)\r
   5  * (C) 2010-2012 Jonathan Campbell.\r
   6  * Hackipedia DOS library.\r
   7  *\r
   8  * This code is licensed under the LGPL.\r
   9  * <insert LGPL legal text here>\r
  10  *\r
  11  * Compiles for intended target environments:\r
  12  *   - MS-DOS [pure DOS mode, or Windows or OS/2 DOS Box]\r
  13  */\r
  14 \r
  15 #include "src/lib/midi.h"\r
  16 \r
  17 static unsigned int             midi_trk_count=0;\r
  18 struct midi_note                midi_notes[ADLIB_FM_VOICES];\r
  19 struct midi_channel             midi_ch[MIDI_MAX_CHANNELS];\r
  20 struct midi_track               midi_trk[MIDI_MAX_TRACKS];\r
  21 \r
  22 /* MIDI params. Nobody ever said it was a straightforward standard!\r
  23  * NTS: These are for reading reference. Internally we convert everything to 100Hz time base. */\r
  24 static unsigned int ticks_per_quarter_note=0;   /* "Ticks per beat" */\r
  25 \r
  26 #if TARGET_MSDOS == 16 && (defined(__LARGE__) || defined(__COMPACT__))\r
  27 static inline unsigned long farptr2phys(unsigned char far *p) { /* take 16:16 pointer convert to physical memory address */\r
  28         return ((unsigned long)FP_SEG(p) << 4UL) + ((unsigned long)FP_OFF(p));\r
  29 }\r
  30 #endif\r
  31 \r
  32 static inline unsigned char midi_trk_read(struct midi_track *t) {\r
  33         unsigned char c;\r
  34 \r
  35         /* NTS: 16-bit large/compact builds MUST compare pointers as unsigned long to compare FAR pointers correctly! */\r
  36         if (t->read == NULL || (unsigned long)t->read >= (unsigned long)t->fence) {\r
  37                 t->eof = 1;\r
  38                 return 0xFF;\r
  39         }\r
  40 \r
  41         c = *(t->read);\r
  42 #if TARGET_MSDOS == 16 && (defined(__LARGE__) || defined(__COMPACT__))\r
  43         if (FP_OFF(t->read) >= 0xF) /* 16:16 far pointer aware (NTS: Programs reassigning this pointer MUST normalize the FAR pointer) */\r
  44                 t->read = MK_FP(FP_SEG(t->read)+0x1,0);\r
  45         else\r
  46                 t->read++;\r
  47 #else\r
  48         t->read++;\r
  49 #endif\r
  50         return c;\r
  51 }\r
  52 \r
  53 void midi_trk_end(struct midi_track *t) {\r
  54         t->wait = ~0UL;\r
  55         t->read = t->fence;\r
  56 }\r
  57 \r
  58 void midi_trk_skip(struct midi_track *t,unsigned long len) {\r
  59         unsigned long rem;\r
  60 \r
  61         /* NTS: 16-bit large/compact builds MUST compare pointers as unsigned long to compare FAR pointers correctly! */\r
  62         if (t->read == NULL || (unsigned long)t->read >= (unsigned long)t->fence)\r
  63                 return;\r
  64 \r
  65         if (len > 0xFFF0UL) {\r
  66                 midi_trk_end(t);\r
  67                 return;\r
  68         }\r
  69 #if TARGET_MSDOS == 16 && (defined(__LARGE__) || defined(__COMPACT__))\r
  70         {\r
  71                 unsigned long tt;\r
  72 \r
  73                 tt = farptr2phys(t->read);\r
  74                 rem = farptr2phys(t->fence) - tt;\r
  75                 if (rem > len) rem = len;\r
  76                 tt += rem;\r
  77                 t->read = MK_FP(tt>>4,tt&0xF);\r
  78         }\r
  79 #else\r
  80         rem = (unsigned long)(t->fence - t->read);\r
  81         if (len > rem) len = rem;\r
  82         t->read += len;\r
  83 #endif\r
  84 }\r
  85 \r
  86 static const uint32_t midikeys_freqs[0x80] = {\r
  87         0x00082d01,     /* key 0 = 8.17579891564371Hz */\r
  88         0x0008a976,     /* key 1 = 8.66195721802725Hz */\r
  89         0x00092d51,     /* key 2 = 9.17702399741899Hz */\r
  90         0x0009b904,     /* key 3 = 9.72271824131503Hz */\r
  91         0x000a4d05,     /* key 4 = 10.3008611535272Hz */\r
  92         0x000ae9d3,     /* key 5 = 10.9133822322814Hz */\r
  93         0x000b8ff4,     /* key 6 = 11.5623257097386Hz */\r
  94         0x000c3ff6,     /* key 7 = 12.2498573744297Hz */\r
  95         0x000cfa70,     /* key 8 = 12.9782717993733Hz */\r
  96         0x000dc000,     /* key 9 = 13.75Hz */\r
  97         0x000e914f,     /* key 10 = 14.5676175474403Hz */\r
  98         0x000f6f11,     /* key 11 = 15.4338531642539Hz */\r
  99         0x00105a02,     /* key 12 = 16.3515978312874Hz */\r
 100         0x001152ec,     /* key 13 = 17.3239144360545Hz */\r
 101         0x00125aa2,     /* key 14 = 18.354047994838Hz */\r
 102         0x00137208,     /* key 15 = 19.4454364826301Hz */\r
 103         0x00149a0a,     /* key 16 = 20.6017223070544Hz */\r
 104         0x0015d3a6,     /* key 17 = 21.8267644645627Hz */\r
 105         0x00171fe9,     /* key 18 = 23.1246514194771Hz */\r
 106         0x00187fed,     /* key 19 = 24.4997147488593Hz */\r
 107         0x0019f4e0,     /* key 20 = 25.9565435987466Hz */\r
 108         0x001b8000,     /* key 21 = 27.5Hz */\r
 109         0x001d229e,     /* key 22 = 29.1352350948806Hz */\r
 110         0x001ede22,     /* key 23 = 30.8677063285078Hz */\r
 111         0x0020b404,     /* key 24 = 32.7031956625748Hz */\r
 112         0x0022a5d8,     /* key 25 = 34.647828872109Hz */\r
 113         0x0024b545,     /* key 26 = 36.7080959896759Hz */\r
 114         0x0026e410,     /* key 27 = 38.8908729652601Hz */\r
 115         0x00293414,     /* key 28 = 41.2034446141087Hz */\r
 116         0x002ba74d,     /* key 29 = 43.6535289291255Hz */\r
 117         0x002e3fd2,     /* key 30 = 46.2493028389543Hz */\r
 118         0x0030ffda,     /* key 31 = 48.9994294977187Hz */\r
 119         0x0033e9c0,     /* key 32 = 51.9130871974931Hz */\r
 120         0x00370000,     /* key 33 = 55Hz */\r
 121         0x003a453d,     /* key 34 = 58.2704701897612Hz */\r
 122         0x003dbc44,     /* key 35 = 61.7354126570155Hz */\r
 123         0x00416809,     /* key 36 = 65.4063913251497Hz */\r
 124         0x00454bb0,     /* key 37 = 69.295657744218Hz */\r
 125         0x00496a8b,     /* key 38 = 73.4161919793519Hz */\r
 126         0x004dc820,     /* key 39 = 77.7817459305202Hz */\r
 127         0x00526829,     /* key 40 = 82.4068892282175Hz */\r
 128         0x00574e9b,     /* key 41 = 87.307057858251Hz */\r
 129         0x005c7fa4,     /* key 42 = 92.4986056779086Hz */\r
 130         0x0061ffb5,     /* key 43 = 97.9988589954373Hz */\r
 131         0x0067d380,     /* key 44 = 103.826174394986Hz */\r
 132         0x006e0000,     /* key 45 = 110Hz */\r
 133         0x00748a7b,     /* key 46 = 116.540940379522Hz */\r
 134         0x007b7888,     /* key 47 = 123.470825314031Hz */\r
 135         0x0082d012,     /* key 48 = 130.812782650299Hz */\r
 136         0x008a9760,     /* key 49 = 138.591315488436Hz */\r
 137         0x0092d517,     /* key 50 = 146.832383958704Hz */\r
 138         0x009b9041,     /* key 51 = 155.56349186104Hz */\r
 139         0x00a4d053,     /* key 52 = 164.813778456435Hz */\r
 140         0x00ae9d36,     /* key 53 = 174.614115716502Hz */\r
 141         0x00b8ff49,     /* key 54 = 184.997211355817Hz */\r
 142         0x00c3ff6a,     /* key 55 = 195.997717990875Hz */\r
 143         0x00cfa700,     /* key 56 = 207.652348789973Hz */\r
 144         0x00dc0000,     /* key 57 = 220Hz */\r
 145         0x00e914f6,     /* key 58 = 233.081880759045Hz */\r
 146         0x00f6f110,     /* key 59 = 246.941650628062Hz */\r
 147         0x0105a025,     /* key 60 = 261.625565300599Hz */\r
 148         0x01152ec0,     /* key 61 = 277.182630976872Hz */\r
 149         0x0125aa2e,     /* key 62 = 293.664767917408Hz */\r
 150         0x01372082,     /* key 63 = 311.126983722081Hz */\r
 151         0x0149a0a7,     /* key 64 = 329.62755691287Hz */\r
 152         0x015d3a6d,     /* key 65 = 349.228231433004Hz */\r
 153         0x0171fe92,     /* key 66 = 369.994422711634Hz */\r
 154         0x0187fed4,     /* key 67 = 391.995435981749Hz */\r
 155         0x019f4e00,     /* key 68 = 415.304697579945Hz */\r
 156         0x01b80000,     /* key 69 = 440Hz */\r
 157         0x01d229ec,     /* key 70 = 466.16376151809Hz */\r
 158         0x01ede220,     /* key 71 = 493.883301256124Hz */\r
 159         0x020b404a,     /* key 72 = 523.251130601197Hz */\r
 160         0x022a5d81,     /* key 73 = 554.365261953744Hz */\r
 161         0x024b545c,     /* key 74 = 587.329535834815Hz */\r
 162         0x026e4104,     /* key 75 = 622.253967444162Hz */\r
 163         0x0293414f,     /* key 76 = 659.25511382574Hz */\r
 164         0x02ba74da,     /* key 77 = 698.456462866008Hz */\r
 165         0x02e3fd24,     /* key 78 = 739.988845423269Hz */\r
 166         0x030ffda9,     /* key 79 = 783.990871963499Hz */\r
 167         0x033e9c01,     /* key 80 = 830.60939515989Hz */\r
 168         0x03700000,     /* key 81 = 880Hz */\r
 169         0x03a453d8,     /* key 82 = 932.32752303618Hz */\r
 170         0x03dbc440,     /* key 83 = 987.766602512248Hz */\r
 171         0x04168094,     /* key 84 = 1046.50226120239Hz */\r
 172         0x0454bb03,     /* key 85 = 1108.73052390749Hz */\r
 173         0x0496a8b8,     /* key 86 = 1174.65907166963Hz */\r
 174         0x04dc8208,     /* key 87 = 1244.50793488832Hz */\r
 175         0x0526829e,     /* key 88 = 1318.51022765148Hz */\r
 176         0x0574e9b5,     /* key 89 = 1396.91292573202Hz */\r
 177         0x05c7fa49,     /* key 90 = 1479.97769084654Hz */\r
 178         0x061ffb53,     /* key 91 = 1567.981743927Hz */\r
 179         0x067d3802,     /* key 92 = 1661.21879031978Hz */\r
 180         0x06e00000,     /* key 93 = 1760Hz */\r
 181         0x0748a7b1,     /* key 94 = 1864.65504607236Hz */\r
 182         0x07b78880,     /* key 95 = 1975.5332050245Hz */\r
 183         0x082d0128,     /* key 96 = 2093.00452240479Hz */\r
 184         0x08a97607,     /* key 97 = 2217.46104781498Hz */\r
 185         0x092d5171,     /* key 98 = 2349.31814333926Hz */\r
 186         0x09b90410,     /* key 99 = 2489.01586977665Hz */\r
 187         0x0a4d053c,     /* key 100 = 2637.02045530296Hz */\r
 188         0x0ae9d36b,     /* key 101 = 2793.82585146403Hz */\r
 189         0x0b8ff493,     /* key 102 = 2959.95538169308Hz */\r
 190         0x0c3ff6a7,     /* key 103 = 3135.96348785399Hz */\r
 191         0x0cfa7005,     /* key 104 = 3322.43758063956Hz */\r
 192         0x0dc00000,     /* key 105 = 3520Hz */\r
 193         0x0e914f62,     /* key 106 = 3729.31009214472Hz */\r
 194         0x0f6f1100,     /* key 107 = 3951.06641004899Hz */\r
 195         0x105a0250,     /* key 108 = 4186.00904480958Hz */\r
 196         0x1152ec0e,     /* key 109 = 4434.92209562995Hz */\r
 197         0x125aa2e3,     /* key 110 = 4698.63628667852Hz */\r
 198         0x13720820,     /* key 111 = 4978.03173955329Hz */\r
 199         0x149a0a79,     /* key 112 = 5274.04091060592Hz */\r
 200         0x15d3a6d6,     /* key 113 = 5587.65170292806Hz */\r
 201         0x171fe927,     /* key 114 = 5919.91076338615Hz */\r
 202         0x187fed4e,     /* key 115 = 6271.92697570799Hz */\r
 203         0x19f4e00a,     /* key 116 = 6644.87516127912Hz */\r
 204         0x1b800000,     /* key 117 = 7040Hz */\r
 205         0x1d229ec4,     /* key 118 = 7458.62018428944Hz */\r
 206         0x1ede2200,     /* key 119 = 7902.13282009799Hz */\r
 207         0x20b404a1,     /* key 120 = 8372.01808961916Hz */\r
 208         0x22a5d81c,     /* key 121 = 8869.84419125991Hz */\r
 209         0x24b545c7,     /* key 122 = 9397.27257335704Hz */\r
 210         0x26e41040,     /* key 123 = 9956.06347910659Hz */\r
 211         0x293414f2,     /* key 124 = 10548.0818212118Hz */\r
 212         0x2ba74dac,     /* key 125 = 11175.3034058561Hz */\r
 213         0x2e3fd24f,     /* key 126 = 11839.8215267723Hz */\r
 214         0x30ffda9c      /* key 127 = 12543.853951416Hz */\r
 215 };\r
 216 \r
 217 static uint32_t midi_note_freq(struct midi_channel *ch,unsigned char key) {\r
 218         return midikeys_freqs[key&0x7F];\r
 219 }\r
 220 \r
 221 static struct midi_note *get_fm_note(struct midi_track *t,struct midi_channel *ch,unsigned char key,unsigned char do_alloc) {\r
 222         unsigned int tch = (unsigned int)(t - midi_trk); /* pointer math */\r
 223         unsigned int ach = (unsigned int)(ch - midi_ch); /* pointer math */\r
 224         unsigned int i,freen=~0;\r
 225 \r
 226         for (i=0;i < ADLIB_FM_VOICES;i++) {\r
 227                 if (midi_notes[i].busy) {\r
 228                         if (midi_notes[i].note_channel == ach && midi_notes[i].note_track == tch && midi_notes[i].note_number == key)\r
 229                                 return &midi_notes[i];\r
 230                 }\r
 231                 else {\r
 232                         if (freen == ~0) freen = i;\r
 233                 }\r
 234         }\r
 235 \r
 236         if (do_alloc && freen != ~0) return &midi_notes[freen];\r
 237         return NULL;\r
 238 }\r
 239 \r
 240 static void drop_fm_note(struct midi_channel *ch,unsigned char key) {\r
 241         unsigned int ach = (unsigned int)(ch - midi_ch); /* pointer math */\r
 242         unsigned int i;\r
 243 \r
 244         for (i=0;i < ADLIB_FM_VOICES;i++) {\r
 245                 if (midi_notes[i].busy && midi_notes[i].note_channel == ach) {\r
 246                         midi_notes[i].busy = 0;\r
 247                         break;\r
 248                 }\r
 249         }\r
 250 }\r
 251 \r
 252 static inline void on_key_aftertouch(struct midi_track *t,struct midi_channel *ch,unsigned char key,unsigned char vel) {\r
 253         struct midi_note *note = get_fm_note(t,ch,key,/*do_alloc*/0);\r
 254         uint32_t freq = midi_note_freq(ch,key);\r
 255         unsigned int ach;\r
 256 \r
 257         if (note == NULL) return;\r
 258 \r
 259         note->busy = 1;\r
 260         note->note_number = key;\r
 261         note->note_velocity = vel;\r
 262         note->note_track = (unsigned int)(t - midi_trk);\r
 263         note->note_channel = (unsigned int)(ch - midi_ch);\r
 264         ach = (unsigned int)(note - midi_notes); /* which FM channel? */\r
 265         adlib_freq_to_fm_op(&adlib_fm[ach].mod,(double)freq / 65536);\r
 266         adlib_fm[ach].mod.attack_rate = vel >> 3; /* 0-127 to 0-15 */\r
 267         adlib_fm[ach].mod.sustain_level = vel >> 3;\r
 268         adlib_fm[ach].mod.key_on = 1;\r
 269         adlib_update_groupA0(ach,&adlib_fm[ach]);\r
 270 }\r
 271 \r
 272 static inline void on_key_on(struct midi_track *t,struct midi_channel *ch,unsigned char key,unsigned char vel) {\r
 273         struct midi_note *note = get_fm_note(t,ch,key,/*do_alloc*/1);\r
 274         uint32_t freq = midi_note_freq(ch,key);\r
 275         unsigned int ach;\r
 276 \r
 277         /* HACK: Ignore percussion */\r
 278         if ((ch->program >= 8 && ch->program <= 15)/*Chromatic percussion*/ ||\r
 279                 (ch->program >= 112 && ch->program <= 119)/*Percussive*/ ||\r
 280                 ch == &midi_ch[9]/*MIDI channel 10 (DAMN YOU 1-BASED COUNTING)*/)\r
 281                 return;\r
 282 \r
 283         if (note == NULL) {\r
 284                 /* then we'll have to knock one off to make room */\r
 285                 drop_fm_note(ch,key);\r
 286                 note = get_fm_note(t,ch,key,1);\r
 287                 if (note == NULL) return;\r
 288         }\r
 289 \r
 290         note->busy = 1;\r
 291         note->note_number = key;\r
 292         note->note_velocity = vel;\r
 293         note->note_track = (unsigned int)(t - midi_trk);\r
 294         note->note_channel = (unsigned int)(ch - midi_ch);\r
 295         ach = (unsigned int)(note - midi_notes); /* which FM channel? */\r
 296         adlib_freq_to_fm_op(&adlib_fm[ach].mod,(double)freq / 65536);\r
 297         adlib_fm[ach].mod.attack_rate = vel >> 3; /* 0-127 to 0-15 */\r
 298         adlib_fm[ach].mod.sustain_level = vel >> 3;\r
 299         adlib_fm[ach].mod.key_on = 1;\r
 300         adlib_update_groupA0(ach,&adlib_fm[ach]);\r
 301 }\r
 302 \r
 303 static inline void on_key_off(struct midi_track *t,struct midi_channel *ch,unsigned char key,unsigned char vel) {\r
 304         struct midi_note *note = get_fm_note(t,ch,key,/*do_alloc*/0);\r
 305         uint32_t freq = midi_note_freq(ch,key);\r
 306         unsigned int ach;\r
 307 \r
 308         if (note == NULL) return;\r
 309 \r
 310         note->busy = 0;\r
 311         ach = (unsigned int)(note - midi_notes); /* which FM channel? */\r
 312         adlib_freq_to_fm_op(&adlib_fm[ach].mod,(double)freq / 65536);\r
 313         adlib_fm[ach].mod.attack_rate = vel >> 3; /* 0-127 to 0-15 */\r
 314         adlib_fm[ach].mod.sustain_level = vel >> 3;\r
 315         adlib_fm[ach].mod.key_on = 0;\r
 316         adlib_update_groupA0(ach,&adlib_fm[ach]);\r
 317 }\r
 318 \r
 319 static inline void on_control_change(struct midi_track *t,struct midi_channel *ch,unsigned char num,unsigned char val) {\r
 320 }\r
 321 \r
 322 static inline void on_program_change(struct midi_track *t,struct midi_channel *ch,unsigned char inst) {\r
 323         ch->program = inst;\r
 324 }\r
 325 \r
 326 static inline void on_channel_aftertouch(struct midi_track *t,struct midi_channel *ch,unsigned char velocity) {\r
 327 }\r
 328 \r
 329 static inline void on_pitch_bend(struct midi_track *t,struct midi_channel *ch,int bend/*-8192 to 8192*/) {\r
 330 }\r
 331 \r
 332 unsigned long midi_trk_read_delta(struct midi_track *t) {\r
 333         unsigned long tc = 0;\r
 334         unsigned char c = 0,b;\r
 335 \r
 336         /* NTS: 16-bit large/compact builds MUST compare pointers as unsigned long to compare FAR pointers correctly! */\r
 337         if (t->read == NULL || (unsigned long)t->read >= (unsigned long)t->fence)\r
 338                 return tc;\r
 339 \r
 340         while (c < 4) {\r
 341                 b = midi_trk_read(t);\r
 342                 tc = (tc << 7UL) + (unsigned long)(b&0x7F);\r
 343                 if (!(b&0x80)) break;\r
 344                 c++;\r
 345         }\r
 346 \r
 347         return tc;\r
 348 }\r
 349 \r
 350 void midi_tick_track(unsigned int i) {\r
 351         struct midi_track *t = midi_trk + i;\r
 352         struct midi_channel *ch;\r
 353         unsigned char b,c,d;\r
 354         int cnt=0;\r
 355 \r
 356         /* NTS: 16-bit large/compact builds MUST compare pointers as unsigned long to compare FAR pointers correctly! */\r
 357         if (t->read == NULL || (unsigned long)t->read >= (unsigned long)t->fence) {\r
 358                 t->eof = 1;\r
 359                 return;\r
 360         }\r
 361 \r
 362         t->us_tick_cnt_mtpq += 10000UL * (unsigned long)ticks_per_quarter_note;\r
 363         while (t->us_tick_cnt_mtpq >= t->us_per_quarter_note) {\r
 364                 t->us_tick_cnt_mtpq -= t->us_per_quarter_note;\r
 365                 cnt++;\r
 366 \r
 367                 while (t->wait == 0) {\r
 368                         if ((unsigned long)t->read >= (unsigned long)t->fence) {\r
 369                                 t->eof = 1;\r
 370                                 break;\r
 371                         }\r
 372 \r
 373                         /* read pointer should be pointing at MIDI event bytes, just after the time delay */\r
 374                         b = midi_trk_read(t);\r
 375                         if (b&0x80) {\r
 376                                 if (b < 0xF8) {\r
 377                                         if (b >= 0xF0)\r
 378                                                 t->last_status = 0;\r
 379                                         else\r
 380                                                 t->last_status = b;\r
 381                                 }\r
 382                                 if (b != 0x00 && ((b&0xF8) != 0xF0))\r
 383                                         c = midi_trk_read(t);\r
 384                         }\r
 385                         else {\r
 386                                 /* blegh. last status */\r
 387                                 c = b;\r
 388                                 b = t->last_status;\r
 389                         }\r
 390                         switch (b>>4) {\r
 391                                 case 0x8: { /* note off */\r
 392                                         d = midi_trk_read(t);\r
 393                                         ch = midi_ch + (b&0xF); /* c=key d=velocity */\r
 394                                         on_key_off(t,ch,c,d);\r
 395                                         } break;\r
 396                                 case 0x9: { /* note on */\r
 397                                         d = midi_trk_read(t);\r
 398                                         ch = midi_ch + (b&0xF); /* c=key d=velocity */\r
 399                                         if (d != 0) on_key_on(t,ch,c,d); /* "A Note On with a velocity of 0 is actually a note off" Bleh, really? */\r
 400                                         else on_key_off(t,ch,c,d);\r
 401                                         } break;\r
 402                                 case 0xA: { /* polyphonic aftertouch */\r
 403                                         d = midi_trk_read(t);\r
 404                                         ch = midi_ch + (b&0xF); /* c=key d=velocity */\r
 405                                         on_key_aftertouch(t,ch,c,d);\r
 406                                         } break;\r
 407                                 case 0xB: { /* control change */\r
 408                                         d = midi_trk_read(t);\r
 409                                         ch = midi_ch + (b&0xF); /* c=key d=velocity */\r
 410                                         on_control_change(t,ch,c,d);\r
 411                                         } break;\r
 412                                 case 0xC: { /* program change */\r
 413                                         on_program_change(t,ch,c); /* c=instrument d=not used */\r
 414                                         } break;\r
 415                                 case 0xD: { /* channel aftertouch */\r
 416                                         on_channel_aftertouch(t,ch,c); /* c=velocity d=not used */\r
 417                                         } break;\r
 418                                 case 0xE: { /* pitch bend */\r
 419                                         d = midi_trk_read(t);\r
 420                                         on_pitch_bend(t,ch,((c&0x7F)|((d&0x7F)<<7))-8192); /* c=LSB d=MSB */\r
 421                                         } break;\r
 422                                 case 0xF: { /* event */\r
 423                                         if (b == 0xFF) {\r
 424                                                 if (c == 0x7F) { /* c=type d=len */\r
 425                                                         unsigned long len = midi_trk_read_delta(t);\r
 426 //====\r
 427                                                         fprintf(stderr,"Type 0x7F len=%lu %p/%p/%p\n",len,t->raw,t->read,t->fence);\r
 428 //====\r
 429                                                         if (len < 512UL) {\r
 430                                                                 /* unknown */\r
 431                                                                 midi_trk_skip(t,len);\r
 432                                                         }\r
 433                                                         else {\r
 434                                                                 midi_trk_end(t);\r
 435                                                         }\r
 436                                                 }\r
 437                                                 else if (c < 0x7F) {\r
 438                                                         d = midi_trk_read(t);\r
 439 \r
 440                                                         if (c == 0x51 && d >= 3) {\r
 441                                                                 d -= 3;\r
 442                                                                 t->us_per_quarter_note = ((unsigned long)midi_trk_read(t)<<16UL)+\r
 443                                                                         ((unsigned long)midi_trk_read(t)<<8UL)+\r
 444                                                                         ((unsigned long)midi_trk_read(t)<<0UL);\r
 445 \r
 446                                                                 if (1/*TODO: If format 0 or format 1*/) {\r
 447                                                                         /* Ugh. Unless format 2, the tempo applies to all tracks */\r
 448                                                                         int j;\r
 449 \r
 450                                                                         for (j=0;j < midi_trk_count;j++) {\r
 451                                                                                 if (j != i) midi_trk[j].us_per_quarter_note =\r
 452                                                                                         t->us_per_quarter_note;\r
 453                                                                         }\r
 454                                                                 }\r
 455                                                         }\r
 456                                                         else {\r
 457 //====\r
 458                                                                 fprintf(stderr,"Type 0x%02x len=%lu %p/%p/%p\n",c,d,t->raw,t->read,t->fence);\r
 459 //====\r
 460                                                         }\r
 461 \r
 462                                                         midi_trk_skip(t,d);\r
 463                                                 }\r
 464                                                 else {\r
 465                                                         fprintf(stderr,"t=%u Unknown MIDI f message 0x%02x 0x%02x %p/%p/%p\n",i,b,c,t->raw,t->read,t->fence);\r
 466                                                 }\r
 467                                         }\r
 468                                         else {\r
 469                                                 unsigned long len = midi_trk_read_delta(t);\r
 470 //====\r
 471                                                 fprintf(stderr,"Sysex len=%lu %p/%p/%p\n",len,t->raw,t->read,t->fence);\r
 472 //====\r
 473                                                 midi_trk_skip(t,len);\r
 474                                         }\r
 475                                         } break;\r
 476                                 default:\r
 477                                         if (b != 0x00) {\r
 478                                                 fprintf(stderr,"t=%u Unknown MIDI message 0x%02x at %p/%p/%p\n",i,b,t->raw,t->read,t->fence);\r
 479                                                 midi_trk_end(t);\r
 480                                         }\r
 481                                         break;\r
 482                         };\r
 483 \r
 484                         /* and then read the next event */\r
 485                         t->wait = midi_trk_read_delta(t);\r
 486                 }\r
 487                 if (t->wait != 0) {\r
 488                         t->wait--;\r
 489                 }\r
 490         }\r
 491 }\r
 492 \r
 493 //void adlib_shut_up();\r
 494 void midi_reset_tracks();\r
 495 void midi_reset_channels();\r
 496 \r
 497 void midi_tick() {\r
 498         if (midi_playing) {\r
 499                 unsigned int i;\r
 500                 int eof=0;\r
 501 \r
 502                 for (i=0;i < midi_trk_count;i++) {\r
 503                         midi_tick_track(i);\r
 504                         eof += midi_trk[i].eof?1:0;\r
 505                 }\r
 506 \r
 507                 if (eof >= midi_trk_count) {\r
 508                         adlib_shut_up();\r
 509                         midi_reset_tracks();\r
 510                         midi_reset_channels();\r
 511                 }\r
 512         }\r
 513 }\r
 514 \r
 515 /* WARNING: subroutine call in interrupt handler. make sure you compile with -zu flag for large/compact memory models */\r
 516 void interrupt irq0() {\r
 517 //      midi_tick();\r
 518         irq0_ticks++;\r
 519         if ((irq0_cnt += irq0_add) >= irq0_max) {\r
 520                 irq0_cnt -= irq0_max;\r
 521                 old_irq0();\r
 522         }\r
 523         else {\r
 524                 p8259_OCW2(0,P8259_OCW2_NON_SPECIFIC_EOI);\r
 525         }\r
 526 }\r
 527 \r
 528 void adlib_shut_up() {\r
 529         int i;\r
 530 \r
 531         memset(adlib_fm,0,sizeof(adlib_fm));\r
 532         memset(&adlib_reg_bd,0,sizeof(adlib_reg_bd));\r
 533         for (i=0;i < adlib_fm_voices;i++) {\r
 534                 struct adlib_fm_operator *f;\r
 535                 f = &adlib_fm[i].mod;\r
 536                 f->ch_a = f->ch_b = f->ch_c = f->ch_d = 1;\r
 537                 f = &adlib_fm[i].car;\r
 538                 f->ch_a = f->ch_b = f->ch_c = f->ch_d = 1;\r
 539         }\r
 540 \r
 541         for (i=0;i < adlib_fm_voices;i++) {\r
 542                 struct adlib_fm_operator *f;\r
 543 \r
 544                 midi_notes[i].busy = 0;\r
 545                 midi_notes[i].note_channel = 0;\r
 546 \r
 547                 f = &adlib_fm[i].mod;\r
 548                 f->mod_multiple = 1;\r
 549                 f->total_level = 63 - 16;\r
 550                 f->attack_rate = 15;\r
 551                 f->decay_rate = 4;\r
 552                 f->sustain_level = 0;\r
 553                 f->release_rate = 8;\r
 554                 f->f_number = 400;\r
 555                 f->sustain = 1;\r
 556                 f->octave = 4;\r
 557                 f->key_on = 0;\r
 558 \r
 559                 f = &adlib_fm[i].car;\r
 560                 f->mod_multiple = 1;\r
 561                 f->total_level = 63 - 16;\r
 562                 f->attack_rate = 15;\r
 563                 f->decay_rate = 4;\r
 564                 f->sustain_level = 0;\r
 565                 f->release_rate = 8;\r
 566                 f->f_number = 0;\r
 567                 f->sustain = 1;\r
 568                 f->octave = 0;\r
 569                 f->key_on = 0;\r
 570         }\r
 571 \r
 572         adlib_apply_all();\r
 573 }\r
 574 \r
 575 void midi_reset_track(unsigned int i) {\r
 576         struct midi_track *t;\r
 577 \r
 578         if (i >= MIDI_MAX_TRACKS) return;\r
 579         t = &midi_trk[i];\r
 580         t->eof = 0;\r
 581         t->last_status = 0;\r
 582         t->us_tick_cnt_mtpq = 0;\r
 583         t->us_per_quarter_note = (60000000UL / 120UL); /* 120BPM */\r
 584         t->read = midi_trk[i].raw;\r
 585         t->wait = midi_trk_read_delta(t); /* and then the read pointer will point at the MIDI event when wait counts down */\r
 586 }\r
 587 \r
 588 void midi_reset_tracks() {\r
 589         int i;\r
 590 \r
 591         for (i=0;i < midi_trk_count;i++)\r
 592                 midi_reset_track(i);\r
 593 }\r
 594 \r
 595 void midi_reset_channels() {\r
 596         int i;\r
 597 \r
 598         for (i=0;i < MIDI_MAX_CHANNELS;i++) {\r
 599                 midi_ch[i].program = 0;\r
 600         }\r
 601 }\r
 602 \r
 603 int load_midi_file(const char *path) {\r
 604         unsigned char tmp[256];\r
 605         unsigned int tracks=0;\r
 606         unsigned int tracki=0;\r
 607         int fd;\r
 608 \r
 609         fd = open(path,O_RDONLY|O_BINARY);\r
 610         if (fd < 0) {\r
 611                 printf("Failed to load file %s\n",path);\r
 612                 return 0;\r
 613         }\r
 614 \r
 615         ticks_per_quarter_note = 0;\r
 616         while (read(fd,tmp,8) == 8) {\r
 617                 uint32_t sz;\r
 618 \r
 619                 sz =    ((uint32_t)tmp[4] << (uint32_t)24) |\r
 620                         ((uint32_t)tmp[5] << (uint32_t)16) |\r
 621                         ((uint32_t)tmp[6] << (uint32_t)8) |\r
 622                         ((uint32_t)tmp[7] << (uint32_t)0);\r
 623                 if (!memcmp(tmp,"MThd",4)) {\r
 624                         unsigned short t,tdiv;\r
 625 \r
 626                         if (sz < 6 || sz > 255) {\r
 627                                 fprintf(stderr,"Invalid MThd size %lu\n",(unsigned long)sz);\r
 628                                 goto err;\r
 629                         }\r
 630                         if (read(fd,tmp,(int)sz) != (int)sz) {\r
 631                                 fprintf(stderr,"MThd read error\n");\r
 632                                 goto err;\r
 633                         }\r
 634 \r
 635                         /* byte 0-1 = format type (0,1 or 2) */\r
 636                         /* byte 2-3 = number of tracks */\r
 637                         /* byte 4-5 = time divison */\r
 638                         t = tmp[1] | (tmp[0] << 8);\r
 639                         if (t > 1) {\r
 640                                 fprintf(stderr,"MThd type %u not supported\n",t);\r
 641                                 goto err; /* we only take type 0 or 1, don't support 2 */\r
 642                         }\r
 643                         tracks = tmp[3] | (tmp[2] << 8);\r
 644                         if (tracks > MIDI_MAX_TRACKS) {\r
 645                                 fprintf(stderr,"MThd too many (%u) tracks\n",tracks);\r
 646                                 goto err;\r
 647                         }\r
 648                         tdiv = tmp[5] | (tmp[4] << 8);\r
 649                         if (tdiv & 0x8000) {\r
 650                                 fprintf(stderr,"MThd SMPTE time division not supported\n");\r
 651                                 goto err; /* we do not support the SMPTE form */\r
 652                         }\r
 653                         if (tdiv == 0) {\r
 654                                 fprintf(stderr,"MThd time division == 0\n");\r
 655                                 goto err;\r
 656                         }\r
 657                         ticks_per_quarter_note = tdiv;\r
 658                 }\r
 659                 else if (!memcmp(tmp,"MTrk",4)) {\r
 660                         if (sz == 0UL) continue;\r
 661 #if TARGET_MSDOS == 16 && (defined(__LARGE__) || defined(__COMPACT__))\r
 662                         if (sz > (640UL << 10UL)) goto err; /* 640KB */\r
 663 #elif TARGET_MSDOS == 32\r
 664                         if (sz > (1UL << 20UL)) goto err; /* 1MB */\r
 665 #else\r
 666                         if (sz > (60UL << 10UL)) goto err; /* 60KB */\r
 667 #endif\r
 668                         if (tracki >= MIDI_MAX_TRACKS) goto err;\r
 669 #if TARGET_MSDOS == 16 && (defined(__LARGE__) || defined(__COMPACT__))\r
 670                         {\r
 671                                 unsigned segv;\r
 672 \r
 673                                 /* NTS: _fmalloc() is still limited to 64KB sizes */\r
 674                                 if (_dos_allocmem((unsigned)((sz+15UL)>>4UL),&segv) != 0) goto err;\r
 675                                 midi_trk[tracki].raw = MK_FP(segv,0);\r
 676                         }\r
 677 #else\r
 678                         midi_trk[tracki].raw = malloc(sz);\r
 679 #endif\r
 680                         if (midi_trk[tracki].raw == NULL) goto err;\r
 681                         midi_trk[tracki].read = midi_trk[tracki].raw;\r
 682 #if TARGET_MSDOS == 16 && (defined(__LARGE__) || defined(__COMPACT__))\r
 683                         {\r
 684                                 unsigned char far *p = midi_trk[tracki].raw;\r
 685                                 unsigned long rem = (unsigned long)sz;\r
 686                                 unsigned long cando;\r
 687                                 unsigned read;\r
 688 \r
 689                                 while (rem != 0UL) {\r
 690                                         read = 0;\r
 691 \r
 692                                         cando = 0x10000UL - (unsigned long)FP_OFF(p);\r
 693                                         if (cando > rem) cando = rem;\r
 694                                         if (cando > 0xFFFFUL) cando = 0xFFFFUL; /* we're limited to 64KB-1 of reading */\r
 695 \r
 696                                         if (_dos_read(fd,p,(unsigned)cando,&read) != 0) goto err;\r
 697                                         if (read != (unsigned)cando) goto err;\r
 698 \r
 699                                         rem -= cando;\r
 700                                         if ((((unsigned long)FP_OFF(p))+cando) == 0x10000UL)\r
 701                                                 p = MK_FP(FP_SEG(p)+0x1000,0);\r
 702                                         else\r
 703                                                 p += (unsigned)cando;\r
 704                                 }\r
 705 \r
 706                                 cando = farptr2phys(p);\r
 707                                 midi_trk[tracki].fence = MK_FP(cando>>4,cando&0xF);\r
 708                         }\r
 709 #else\r
 710                         midi_trk[tracki].fence = midi_trk[tracki].raw + (unsigned)sz;\r
 711                         if (read(fd,midi_trk[tracki].raw,(unsigned)sz) != (int)sz) goto err;\r
 712 #endif\r
 713                         tracki++;\r
 714                 }\r
 715                 else {\r
 716                         fprintf(stderr,"Unknown MIDI chunk %c%c%c%c\n",tmp[0],tmp[1],tmp[2],tmp[3]);\r
 717                         goto err;\r
 718                 }\r
 719         }\r
 720         if (tracki == 0 || ticks_per_quarter_note == 0) goto err;\r
 721         midi_trk_count = tracki;\r
 722 \r
 723         fprintf(stderr,"Ticks per quarter note: %u\n",ticks_per_quarter_note);\r
 724 \r
 725         close(fd);\r
 726         return 1;\r
 727 err:\r
 728         close(fd);\r
 729         return 0;\r
 730 }\r