![[BACK]](/icons/back.gif){kind=icon}
Return to midiplay.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / midiplay|
Return to midiplay.c CVS log | Up to [local] / src / usr.bin / midiplay |
1.10 ! ray 1: /* $OpenBSD: midiplay.c,v 1.9 2007/09/02 15:19:33 deraadt Exp $ */
1.1 niklas 2: /* $NetBSD: midiplay.c,v 1.8 1998/11/25 22:17:07 augustss Exp $ */
3:
4: /*
5: * Copyright (c) 1998 The NetBSD Foundation, Inc.
6: * All rights reserved.
7: *
8: * This code is derived from software contributed to The NetBSD Foundation
9: * by Lennart Augustsson (augustss@netbsd.org).
10: *
11: * Redistribution and use in source and binary forms, with or without
12: * modification, are permitted provided that the following conditions
13: * are met:
14: * 1. Redistributions of source code must retain the above copyright
15: * notice, this list of conditions and the following disclaimer.
16: * 2. Redistributions in binary form must reproduce the above copyright
17: * notice, this list of conditions and the following disclaimer in the
18: * documentation and/or other materials provided with the distribution.
19: *
20: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
21: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
22: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
23: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
24: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
25: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
26: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
27: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
28: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
29: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
30: * POSSIBILITY OF SUCH DAMAGE.
31: */
32:
1.5 tedu 33: #include <sys/types.h>
34: #include <sys/stat.h>
35: #include <sys/ioctl.h>
36: #include <sys/midiio.h>
37:
1.1 niklas 38: #include <stdio.h>
39: #include <stdlib.h>
1.5 tedu 40: #include <limits.h>
1.1 niklas 41: #include <fcntl.h>
42: #include <err.h>
43: #include <unistd.h>
44: #include <string.h>
45:
46: #define DEVMUSIC "/dev/music"
47:
48: struct track {
49: u_char *start, *end;
50: u_long curtime;
51: u_char status;
52: };
53:
54: #define MIDI_META 0xff
55:
56: #define META_SEQNO 0x00
57: #define META_TEXT 0x01
58: #define META_COPYRIGHT 0x02
59: #define META_TRACK 0x03
60: #define META_INSTRUMENT 0x04
61: #define META_LYRIC 0x05
62: #define META_MARKER 0x06
63: #define META_CUE 0x07
64: #define META_CHPREFIX 0x20
65: #define META_EOT 0x2f
66: #define META_SET_TEMPO 0x51
67: #define META_KEY 0x59
68: #define META_SMPTE 0x54
69: #define META_TIMESIGN 0x58
70:
71: char *metanames[] = {
72: "", "Text", "Copyright", "Track", "Instrument",
73: "Lyric", "Marker", "Cue",
74: };
75:
76: static int midi_lengths[] = { 2,2,2,2,1,1,2,0 };
77: /* Number of bytes in a MIDI command */
78: #define MIDI_LENGTH(d) (midi_lengths[((d) >> 4) & 7])
79:
1.2 millert 80: void usage(void);
81: void send_event(seq_event_rec *);
82: void dometa(u_int, u_char *, u_int);
83: void midireset(void);
84: void send_sysex(u_char *, u_int);
85: u_long getvar(struct track *);
86: void playfile(FILE *, char *);
87: void playdata(u_char *, u_int, char *);
88: int main(int argc, char **argv);
1.1 niklas 89:
90: extern char *__progname;
91:
92: #define P(c) 1,0x90,c,0x7f,4,0x80,c,0
93: #define PL(c) 1,0x90,c,0x7f,8,0x80,c,0
94: #define C 0x3c
95: #define D 0x3e
96: #define E 0x40
97: #define F 0x41
98:
99: u_char sample[] = {
100: 'M','T','h','d', 0,0,0,6, 0,1, 0,1, 0,8,
101: 'M','T','r','k', 0,0,0,4+13*8,
102: P(C), P(C), P(C), P(E), P(D), P(D), P(D),
103: P(F), P(E), P(E), P(D), P(D), PL(C),
104: 0, 0xff, 0x2f, 0
105: };
106: #undef P
107: #undef PL
108: #undef C
109: #undef D
110: #undef E
111: #undef F
112:
113: #define MARK_HEADER "MThd"
114: #define MARK_TRACK "MTrk"
115: #define MARK_LEN 4
116:
117: #define SIZE_LEN 4
118: #define HEADER_LEN 6
119:
120: #define GET8(p) ((p)[0])
121: #define GET16(p) (((p)[0] << 8) | (p)[1])
122: #define GET24(p) (((p)[0] << 16) | ((p)[1] << 8) | (p)[2])
123: #define GET32(p) (((p)[0] << 24) | ((p)[1] << 16) | ((p)[2] << 8) | (p)[3])
124:
125: void
1.4 deraadt 126: usage(void)
1.1 niklas 127: {
1.6 jmc 128: printf("Usage: %s [-lmqvx] [-d devno] [-f file] [-t tempo] "
129: "[file ...]\n", __progname);
1.1 niklas 130: exit(1);
131: }
132:
133: int showmeta = 0;
134: int verbose = 0;
135: #define BASETEMPO 400000
136: u_int tempo = BASETEMPO; /* microsec / quarter note */
137: u_int ttempo = 100;
138: int unit = 0;
139: int play = 1;
140: int fd;
141:
142: void
1.4 deraadt 143: send_event(seq_event_rec *ev)
1.1 niklas 144: {
145: /*
146: printf("%02x %02x %02x %02x %02x %02x %02x %02x\n",
147: ev->arr[0], ev->arr[1], ev->arr[2], ev->arr[3],
148: ev->arr[4], ev->arr[5], ev->arr[6], ev->arr[7]);
149: */
150: if (play)
151: write(fd, ev, sizeof *ev);
152: }
153:
154: u_long
1.4 deraadt 155: getvar(struct track *tp)
1.1 niklas 156: {
157: u_long r, c;
158:
159: r = 0;
160: do {
161: c = *tp->start++;
162: r = (r << 7) | (c & 0x7f);
163: } while ((c & 0x80) && tp->start < tp->end);
164: return (r);
165: }
166:
167: void
1.4 deraadt 168: dometa(u_int meta, u_char *p, u_int len)
1.1 niklas 169: {
170: switch (meta) {
171: case META_TEXT:
172: case META_COPYRIGHT:
173: case META_TRACK:
174: case META_INSTRUMENT:
175: case META_LYRIC:
176: case META_MARKER:
177: case META_CUE:
178: if (showmeta) {
179: printf("%s: ", metanames[meta]);
180: fwrite(p, len, 1, stdout);
181: printf("\n");
182: }
183: break;
184: case META_SET_TEMPO:
185: tempo = GET24(p);
186: if (showmeta)
187: printf("Tempo: %d us / quarter note\n", tempo);
188: break;
189: case META_TIMESIGN:
190: if (showmeta) {
191: int n = p[1];
192: int d = 1;
193: while (n-- > 0)
194: d *= 2;
195: printf("Time signature: %d/%d %d,%d\n",
196: p[0], d, p[2], p[3]);
197: }
198: break;
199: case META_KEY:
200: if (showmeta)
201: printf("Key: %d %s\n", (char)p[0],
202: p[1] ? "minor" : "major");
203: break;
204: default:
205: break;
206: }
207: }
208:
209: void
1.4 deraadt 210: midireset(void)
1.1 niklas 211: {
212: /* General MIDI reset sequence */
213: static u_char gm_reset[] = { 0x7e, 0x7f, 0x09, 0x01, 0xf7 };
214:
215: send_sysex(gm_reset, sizeof gm_reset);
216: }
217:
218: #define SYSEX_CHUNK 6
219: void
1.4 deraadt 220: send_sysex(u_char *p, u_int l)
1.1 niklas 221: {
222: seq_event_rec event;
223: u_int n;
224:
225: event.arr[0] = SEQ_SYSEX;
226: event.arr[1] = unit;
227: do {
228: n = SYSEX_CHUNK;
229: if (l < n) {
230: memset(&event.arr[2], 0xff, SYSEX_CHUNK);
231: n = l;
232: }
233: memcpy(&event.arr[2], p, n);
234: send_event(&event);
235: l -= n;
1.7 jsg 236: p += n;
1.1 niklas 237: } while (l > 0);
238: }
239:
240: void
1.4 deraadt 241: playfile(FILE *f, char *name)
1.1 niklas 242: {
1.5 tedu 243: u_char *buf, *newbuf;
244: u_int tot, n, size, newsize, nread;
1.1 niklas 245:
246: /*
247: * We need to read the whole file into memory for easy processing.
248: * Using mmap() would be nice, but some file systems do not support
249: * it, nor does reading from e.g. a pipe. The latter also precludes
250: * finding out the file size without reading it.
251: */
252: size = 1000;
253: buf = malloc(size);
1.5 tedu 254: if (buf == NULL)
255: err(1, "malloc() failed");
1.1 niklas 256: nread = size;
257: tot = 0;
258: for (;;) {
259: n = fread(buf + tot, 1, nread, f);
260: tot += n;
261: if (n < nread)
262: break;
263: /* There must be more to read. */
264: nread = size;
1.5 tedu 265: newsize = size * 2;
266: newbuf = realloc(buf, newsize);
267: if (newbuf == NULL)
268: err(1, "realloc() failed");
269: buf = newbuf;
270: size = newsize;
1.1 niklas 271: }
272: playdata(buf, tot, name);
273: free(buf);
274: }
275:
276: void
1.4 deraadt 277: playdata(u_char *buf, u_int tot, char *name)
1.1 niklas 278: {
279: int format, ntrks, divfmt, ticks, t, besttrk = 0;
280: u_int len, mlen, status, chan;
281: u_char *p, *end, byte, meta, *msg;
282: struct track *tracks;
283: u_long bestcur, now;
284: struct track *tp;
285: seq_event_rec event;
286:
287: end = buf + tot;
288: if (verbose)
289: printf("Playing %s (%d bytes) ... \n", name, tot);
290:
291: if (memcmp(buf, MARK_HEADER, MARK_LEN) != 0) {
1.3 mpech 292: warnx("Not a MIDI file, missing header");
1.1 niklas 293: return;
294: }
295: if (GET32(buf + MARK_LEN) != HEADER_LEN) {
1.3 mpech 296: warnx("Not a MIDI file, bad header");
1.1 niklas 297: return;
298: }
299: format = GET16(buf + MARK_LEN + SIZE_LEN);
300: ntrks = GET16(buf + MARK_LEN + SIZE_LEN + 2);
301: divfmt = GET8(buf + MARK_LEN + SIZE_LEN + 4);
302: ticks = GET8(buf + MARK_LEN + SIZE_LEN + 5);
303: p = buf + MARK_LEN + SIZE_LEN + HEADER_LEN;
304: if ((divfmt & 0x80) == 0)
305: ticks |= divfmt << 8;
306: else
1.3 mpech 307: errx(1, "Absolute time codes not implemented yet");
1.1 niklas 308: if (verbose > 1)
309: printf("format=%d ntrks=%d divfmt=%x ticks=%d\n",
310: format, ntrks, divfmt, ticks);
311: if (format != 0 && format != 1) {
1.3 mpech 312: warnx("Cannnot play MIDI file of type %d", format);
1.1 niklas 313: return;
314: }
315: if (ntrks == 0)
316: return;
1.9 deraadt 317: tracks = calloc(ntrks, sizeof(struct track));
1.1 niklas 318: if (tracks == NULL)
1.5 tedu 319: err(1, "malloc() tracks failed");
1.1 niklas 320: for (t = 0; t < ntrks; ) {
321: if (p >= end - MARK_LEN - SIZE_LEN) {
1.3 mpech 322: warnx("Cannot find track %d", t);
1.1 niklas 323: goto ret;
324: }
325: len = GET32(p + MARK_LEN);
326: if (len > 1000000) { /* a safe guard */
1.3 mpech 327: warnx("Crazy track length");
1.1 niklas 328: goto ret;
329: }
330: if (memcmp(p, MARK_TRACK, MARK_LEN) == 0) {
331: tracks[t].start = p + MARK_LEN + SIZE_LEN;
332: tracks[t].end = tracks[t].start + len;
333: tracks[t].curtime = getvar(&tracks[t]);
334: t++;
335: }
336: p += MARK_LEN + SIZE_LEN + len;
337: }
338:
339: /*
340: * Play MIDI events by selecting the track track with the lowest
341: * curtime. Execute the event, update the curtime and repeat.
342: */
343:
344: /*
345: * The ticks variable is the number of ticks that make up a quarter
346: * note and is used as a reference value for the delays between
347: * the MIDI events.
348: * The sequencer has two "knobs": the TIMEBASE and the TEMPO.
349: * The delay specified in TMR_WAIT_REL is specified in
350: * sequencer time units. The length of a unit is
351: * 60*1000000 / (TIMEBASE * TEMPO).
352: * Set it to 1ms/unit (adjusted by user tempo changes).
353: */
354: t = 500 * ttempo / 100;
355: if (ioctl(fd, SEQUENCER_TMR_TIMEBASE, &t) < 0)
356: err(1, "SEQUENCER_TMR_TIMEBASE");
357: t = 120;
358: if (ioctl(fd, SEQUENCER_TMR_TEMPO, &t) < 0)
359: err(1, "SEQUENCER_TMR_TEMPO");
360: if (ioctl(fd, SEQUENCER_TMR_START, 0) < 0)
361: err(1, "SEQUENCER_TMR_START");
362: now = 0;
363: for (;;) {
364: /* Locate lowest curtime */
365: bestcur = ~0;
366: for (t = 0; t < ntrks; t++) {
367: if (tracks[t].curtime < bestcur) {
368: bestcur = tracks[t].curtime;
369: besttrk = t;
370: }
371: }
372: if (bestcur == ~0)
373: break;
374: if (verbose > 1) {
375: printf("DELAY %4ld TRACK %2d ", bestcur-now, besttrk);
376: fflush(stdout);
377: }
378: if (now < bestcur) {
379: union {
380: u_int32_t i;
381: u_int8_t b[4];
382: } u;
383: u_int32_t delta = bestcur - now;
384: delta = (int)((double)delta * tempo / (1000.0*ticks));
385: u.i = delta;
386: if (delta != 0) {
387: event.arr[0] = SEQ_TIMING;
388: event.arr[1] = TMR_WAIT_REL;
389: event.arr[4] = u.b[0];
390: event.arr[5] = u.b[1];
391: event.arr[6] = u.b[2];
392: event.arr[7] = u.b[3];
393: send_event(&event);
394: }
395: }
396: now = bestcur;
397: tp = &tracks[besttrk];
398: byte = *tp->start++;
399: if (byte == MIDI_META) {
400: meta = *tp->start++;
401: mlen = getvar(tp);
402: if (verbose > 1)
403: printf("META %02x (%d)\n", meta, mlen);
404: dometa(meta, tp->start, mlen);
405: tp->start += mlen;
406: } else {
407: if (MIDI_IS_STATUS(byte))
408: tp->status = byte;
409: else
410: tp->start--;
411: mlen = MIDI_LENGTH(tp->status);
412: msg = tp->start;
413: if (verbose > 1) {
414: if (mlen == 1)
415: printf("MIDI %02x (%d) %02x\n",
416: tp->status, mlen, msg[0]);
417: else
418: printf("MIDI %02x (%d) %02x %02x\n",
419: tp->status, mlen, msg[0], msg[1]);
420: }
421: status = MIDI_GET_STATUS(tp->status);
422: chan = MIDI_GET_CHAN(tp->status);
423: switch (status) {
424: case MIDI_NOTEOFF:
425: case MIDI_NOTEON:
426: case MIDI_KEY_PRESSURE:
427: SEQ_MK_CHN_VOICE(&event, unit, status, chan,
428: msg[0], msg[1]);
429: send_event(&event);
430: break;
431: case MIDI_CTL_CHANGE:
432: SEQ_MK_CHN_COMMON(&event, unit, status, chan,
433: msg[0], 0, msg[1]);
434: send_event(&event);
435: break;
436: case MIDI_PGM_CHANGE:
437: case MIDI_CHN_PRESSURE:
438: SEQ_MK_CHN_COMMON(&event, unit, status, chan,
439: msg[0], 0, 0);
440: send_event(&event);
441: break;
442: case MIDI_PITCH_BEND:
443: SEQ_MK_CHN_COMMON(&event, unit, status, chan,
444: 0, 0,
445: (msg[0] & 0x7f) |
446: ((msg[1] & 0x7f) << 7));
447: send_event(&event);
448: break;
449: case MIDI_SYSTEM_PREFIX:
450: mlen = getvar(tp);
451: if (tp->status == MIDI_SYSEX_START)
452: send_sysex(tp->start, mlen);
453: else
454: /* Sorry, can't do this yet */;
455: break;
456: default:
457: if (verbose)
458: printf("MIDI event 0x%02x ignored\n",
459: tp->status);
460: }
461: tp->start += mlen;
462: }
463: if (tp->start >= tp->end)
464: tp->curtime = ~0;
465: else
466: tp->curtime += getvar(tp);
467: }
468: if (ioctl(fd, SEQUENCER_SYNC, 0) < 0)
469: err(1, "SEQUENCER_SYNC");
470:
471: ret:
472: free(tracks);
473: }
474:
475: int
1.4 deraadt 476: main(int argc, char **argv)
1.1 niklas 477: {
478: int ch;
479: int listdevs = 0;
480: int example = 0;
1.8 jsg 481: int gmreset = 0;
1.1 niklas 482: int nmidi;
483: char *file = DEVMUSIC;
484: struct synth_info info;
485: FILE *f;
1.5 tedu 486: const char *errstr;
1.1 niklas 487:
1.8 jsg 488: while ((ch = getopt(argc, argv, "?d:f:glmqt:vx")) != -1) {
1.5 tedu 489: switch (ch) {
1.1 niklas 490: case 'd':
1.5 tedu 491: unit = strtonum(optarg, 0, INT_MAX, &errstr);
492: if (errstr)
493: errx(1, "unit is %s: %s", errstr, optarg);
1.1 niklas 494: break;
495: case 'f':
496: file = optarg;
497: break;
1.8 jsg 498: case 'g':
499: gmreset++;
500: break;
1.1 niklas 501: case 'l':
502: listdevs++;
503: break;
504: case 'm':
505: showmeta++;
506: break;
507: case 'q':
508: play = 0;
509: break;
510: case 't':
1.5 tedu 511: ttempo = strtonum(optarg, 0, INT_MAX, &errstr);
512: if (errstr)
513: errx(1, "tempo is %s: %s", errstr, optarg);
1.1 niklas 514: break;
515: case 'v':
516: verbose++;
517: break;
518: case 'x':
519: example++;
520: break;
521: case '?':
522: default:
523: usage();
524: }
525: }
526: argc -= optind;
527: argv += optind;
528:
529: fd = open(file, O_WRONLY);
530: if (fd < 0)
531: err(1, "%s", file);
532: if (ioctl(fd, SEQUENCER_NRMIDIS, &nmidi) < 0)
533: err(1, "ioctl(SEQUENCER_NRMIDIS) failed, ");
534: if (nmidi == 0)
1.3 mpech 535: errx(1, "Sorry, no MIDI devices available");
1.1 niklas 536: if (listdevs) {
537: for (info.device = 0; info.device < nmidi; info.device++) {
538: if (ioctl(fd, SEQUENCER_INFO, &info) < 0)
539: err(1, "ioctl(SEQUENCER_INFO) failed, ");
540: printf("%d: %s\n", info.device, info.name);
541: }
542: exit(0);
543: }
1.8 jsg 544: if (gmreset)
545: midireset();
1.1 niklas 546: if (example)
547: playdata(sample, sizeof sample, "<Gubben Noa>");
548: else if (argc == 0)
549: playfile(stdin, "<stdin>");
550: else
551: while (argc--) {
552: f = fopen(*argv, "r");
553: if (f == NULL)
554: err(1, "%s", *argv);
555: else {
556: playfile(f, *argv);
557: fclose(f);
558: }
559: argv++;
560: }
561:
562: exit(0);
563: }