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