Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/midiplay/midiplay.c	Lines:	0	197	0.0 %
Date:	2016-12-06	Branches:	0	117	0.0 %


/*	$OpenBSD: midiplay.c,v 1.18 2016/05/05 09:18:12 ratchov Exp $	*/
/*	$NetBSD: midiplay.c,v 1.8 1998/11/25 22:17:07 augustss Exp $	*/

/*
 * Copyright (c) 1998 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by Lennart Augustsson (augustss@netbsd.org).
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/types.h>
#include <sys/stat.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <limits.h>
#include <err.h>
#include <unistd.h>
#include <string.h>
#include <sndio.h>

struct track {
	u_char *start, *end;
	u_long curtime;
	u_char status;
};

#define MIDI_META 0xff

#define META_SEQNO	0x00
#define META_TEXT	0x01
#define META_COPYRIGHT	0x02
#define META_TRACK	0x03
#define META_INSTRUMENT	0x04
#define META_LYRIC	0x05
#define META_MARKER	0x06
#define META_CUE	0x07
#define META_CHPREFIX	0x20
#define META_EOT	0x2f
#define META_SET_TEMPO	0x51
#define META_KEY	0x59
#define META_SMPTE	0x54
#define META_TIMESIGN	0x58

char *metanames[] = {
	"", "Text", "Copyright", "Track", "Instrument",
	"Lyric", "Marker", "Cue",
};

static int midi_lengths[] = { 2,2,2,2,1,1,2,0 };
/* Number of bytes in a MIDI command */
#define MIDI_LENGTH(d) (midi_lengths[((d) >> 4) & 7])

#define MIDI_IS_STATUS(d)	((d) & 0x80)
#define MIDI_IS_COMMON(d)	((d) < 0xf0)
#define MIDI_SYSEX_START	0xf0
#define MIDI_SYSEX_STOP		0xf7

void usage(void);
void send_event(u_char, u_char *, u_int);
void dometa(u_int, u_char *, u_int);
void midireset(void);
u_long getvar(struct track *);
void playfile(FILE *, char *);
void playdata(u_char *, u_int, char *);
void sigalrm(int);
int main(int argc, char **argv);

extern char *__progname;

#define P(c) 1,0x90,c,0x7f,4,0x80,c,0
#define PL(c) 1,0x90,c,0x7f,8,0x80,c,0
#define C 0x3c
#define D 0x3e
#define E 0x40
#define F 0x41

u_char sample[] = {
	'M','T','h','d',  0,0,0,6,  0,1,  0,1,  0,8,
	'M','T','r','k',  0,0,0,4+13*8,
	P(C), P(C), P(C), P(E), P(D), P(D), P(D),
	P(F), P(E), P(E), P(D), P(D), PL(C),
	0, 0xff, 0x2f, 0
};
#undef P
#undef PL
#undef C
#undef D
#undef E
#undef F

#define MARK_HEADER "MThd"
#define MARK_TRACK "MTrk"
#define MARK_LEN 4

#define SIZE_LEN 4
#define HEADER_LEN 6

#define GET8(p) ((p)[0])
#define GET16(p) (((p)[0] << 8) | (p)[1])
#define GET24(p) (((p)[0] << 16) | ((p)[1] << 8) | (p)[2])
#define GET32(p) (((p)[0] << 24) | ((p)[1] << 16) | ((p)[2] << 8) | (p)[3])

void
usage(void)
{
	printf("usage: "
	       "%s [-gmqvx] [-f device] [-t tempo] [file ...]\n",
	       __progname);
	exit(1);
}

int showmeta = 0;
int verbose = 0;
u_int tempo = 60 * 1000000 / 100;	/* default tempo is 100bpm */
int play = 1;
struct mio_hdl *hdl;
struct timespec ts, ts_last;

void
send_event(u_char status, u_char *data, u_int len)
{
	u_int i;

	if (verbose > 1) {
		printf("MIDI %02x", status);
		for (i = 0; i < len; i++)
			printf(" %02x", data[i]);
		printf("\n");
	}
	if (play) {
		mio_write(hdl, &status, 1);
		mio_write(hdl, data, len);
	}
}

u_long
getvar(struct track *tp)
{
	u_long r, c;

	r = 0;
	do {
		c = *tp->start++;
		r = (r << 7) | (c & 0x7f);
	} while ((c & 0x80) && tp->start < tp->end);
	return (r);
}

void
dometa(u_int meta, u_char *p, u_int len)
{
	switch (meta) {
	case META_TEXT:
	case META_COPYRIGHT:
	case META_TRACK:
	case META_INSTRUMENT:
	case META_LYRIC:
	case META_MARKER:
	case META_CUE:
		if (showmeta) {
			printf("%s: ", metanames[meta]);
			fwrite(p, len, 1, stdout);
			printf("\n");
		}
		break;
	case META_SET_TEMPO:
		tempo = GET24(p);
		if (showmeta)
			printf("Tempo: %d us / quarter note\n", tempo);
		break;
	case META_TIMESIGN:
		if (showmeta) {
			int n = p[1];
			int d = 1;
			while (n-- > 0)
				d *= 2;
			printf("Time signature: %d/%d %d,%d\n",
			       p[0], d, p[2], p[3]);
		}
		break;
	case META_KEY:
		if (showmeta)
			printf("Key: %d %s\n", (char)p[0],
			       p[1] ? "minor" : "major");
		break;
	default:
		break;
	}
}

void
midireset(void)
{
	/* General MIDI reset sequence */
	static u_char gm_reset[] = { 0x7e, 0x7f, 0x09, 0x01, 0xf7 };

	send_event(MIDI_SYSEX_START, gm_reset, sizeof gm_reset);
}

void
playfile(FILE *f, char *name)
{
	u_char *buf, *newbuf;
	u_int tot, n, size, newsize, nread;

	/*
	 * We need to read the whole file into memory for easy processing.
	 * Using mmap() would be nice, but some file systems do not support
	 * it, nor does reading from e.g. a pipe.  The latter also precludes
	 * finding out the file size without reading it.
	 */
	size = 1000;
	buf = malloc(size);
	if (buf == NULL)
		err(1, "malloc() failed");
	nread = size;
	tot = 0;
	for (;;) {
		n = fread(buf + tot, 1, nread, f);
		tot += n;
		if (n < nread)
			break;
		/* There must be more to read. */
		nread = size;
		newsize = size * 2;
		newbuf = realloc(buf, newsize);
		if (newbuf == NULL)
			err(1, "realloc() failed");
		buf = newbuf;
		size = newsize;
	}
	playdata(buf, tot, name);
	free(buf);
}

void
sigalrm(int i)
{
}

void
playdata(u_char *buf, u_int tot, char *name)
{
	long long delta_nsec = 0;
	u_int delta_ticks;
	int format, ntrks, divfmt, ticks, t, besttrk = 0;
	u_int len, mlen;
	u_char *p, *end, byte, meta;
	struct track *tracks;
	u_long bestcur, now;
	struct track *tp;

	end = buf + tot;
	if (verbose)
		printf("Playing %s (%d bytes) ... \n", name, tot);

	if (memcmp(buf, MARK_HEADER, MARK_LEN) != 0) {
		warnx("Not a MIDI file, missing header");
		return;
	}
	if (GET32(buf + MARK_LEN) != HEADER_LEN) {
		warnx("Not a MIDI file, bad header");
		return;
	}
	format = GET16(buf + MARK_LEN + SIZE_LEN);
	ntrks = GET16(buf + MARK_LEN + SIZE_LEN + 2);
	divfmt = GET8(buf + MARK_LEN + SIZE_LEN + 4);
	ticks = GET8(buf + MARK_LEN + SIZE_LEN + 5);
	p = buf + MARK_LEN + SIZE_LEN + HEADER_LEN;
	if ((divfmt & 0x80) == 0)
		ticks |= divfmt << 8;
	else
		errx(1, "Absolute time codes not implemented yet");
	if (verbose > 1)
		printf("format=%d ntrks=%d divfmt=%x ticks=%d\n",
		       format, ntrks, divfmt, ticks);
	if (format != 0 && format != 1) {
		warnx("Cannnot play MIDI file of type %d", format);
		return;
	}
	if (ntrks == 0)
		return;
	tracks = calloc(ntrks, sizeof(struct track));
	if (tracks == NULL)
		err(1, "malloc() tracks failed");
	for (t = 0; t < ntrks; ) {
		if (p >= end - MARK_LEN - SIZE_LEN) {
			warnx("Cannot find track %d", t);
			goto ret;
		}
		len = GET32(p + MARK_LEN);
		if (len > end - (p + MARK_LEN + SIZE_LEN)) {
			warnx("Crazy track length");
			goto ret;
		}
		if (memcmp(p, MARK_TRACK, MARK_LEN) == 0) {
			tracks[t].start = p + MARK_LEN + SIZE_LEN;
			tracks[t].end = tracks[t].start + len;
			tracks[t].curtime = getvar(&tracks[t]);
			t++;
		}
		p += MARK_LEN + SIZE_LEN + len;
	}

	/*
	 * Play MIDI events by selecting the track with the lowest
	 * curtime.  Execute the event, update the curtime and repeat.
	 */

	now = 0;
	delta_nsec = 0;
	if (clock_gettime(CLOCK_MONOTONIC, &ts_last) < 0)
		err(1, "clock_gettime");
	for (;;) {
		/* Locate lowest curtime */
		bestcur = ULONG_MAX;
		for (t = 0; t < ntrks; t++) {
			if (tracks[t].curtime < bestcur) {
				bestcur = tracks[t].curtime;
				besttrk = t;
			}
		}
		if (bestcur == ULONG_MAX)
			break;
		if (verbose > 1) {
			printf("DELAY %4ld TRACK %2d ", bestcur-now, besttrk);
			fflush(stdout);
		}
		while (now < bestcur) {
			pause();
			if (clock_gettime(CLOCK_MONOTONIC, &ts) < 0)
				err(1, "clock_gettime");
			delta_nsec += 1000000000L * (ts.tv_sec - ts_last.tv_sec);
			delta_nsec += ts.tv_nsec - ts_last.tv_nsec;
			ts_last = ts;
			if (delta_nsec <= 0)
				continue;
			delta_ticks = delta_nsec * ticks / (1000LL * tempo);
			delta_nsec -= 1000LL * delta_ticks * tempo / ticks;
			now += delta_ticks;
		}
		tp = &tracks[besttrk];
		byte = *tp->start++;
		if (byte == MIDI_META) {
			meta = *tp->start++;
			mlen = getvar(tp);
			if (verbose > 1)
				printf("META %02x (%d)\n", meta, mlen);
			dometa(meta, tp->start, mlen);
			tp->start += mlen;
		} else {
			if (MIDI_IS_STATUS(byte))
				tp->status = byte;
			else
				tp->start--;
			if (MIDI_IS_COMMON(tp->status)) {
				mlen = MIDI_LENGTH(tp->status);
				send_event(tp->status, tp->start, mlen);
			} else if (tp->status == MIDI_SYSEX_START) {
				mlen = getvar(tp);
				send_event(MIDI_SYSEX_START, tp->start, mlen);
			} else if (tp->status == MIDI_SYSEX_STOP) {
				mlen = getvar(tp);
				/* Sorry, can't do this yet */;
			} else {
				if (verbose)
					printf("MIDI event 0x%02x ignored\n",
					       tp->status);
			}
			tp->start += mlen;
		}
		if (tp->start >= tp->end)
			tp->curtime = ULONG_MAX;
		else
			tp->curtime += getvar(tp);
	}
 ret:
	free(tracks);
}

int
main(int argc, char **argv)
{
	int ch;
	int example = 0;
	int gmreset = 0;
	char *file = NULL;
	FILE *f;
	const char *errstr;
	struct sigaction sa;
	struct itimerval it;

	while ((ch = getopt(argc, argv, "?d:f:glmqt:vx")) != -1) {
		switch (ch) {
		case 'f':
			file = optarg;
			break;
		case 'g':
			gmreset = 1;
			break;
		case 'm':
			showmeta = 1;
			break;
		case 'q':
			play = 0;
			break;
		case 't':
			tempo = 60 * 1000000 /
			    strtonum(optarg, 40, 240, &errstr);
			if (errstr)
				errx(1, "tempo is %s: %s", errstr, optarg);
			break;
		case 'v':
			verbose++;
			break;
		case 'x':
			example = 1;
			break;
		case '?':
		default:
			usage();
		}
	}
	argc -= optind;
	argv += optind;

	hdl = mio_open(file, MIO_OUT, 0);
	if (hdl == NULL)
		errx(1, "failed to open MIDI output");
	if (gmreset)
		midireset();

	sa.sa_flags = SA_RESTART;
	sa.sa_handler = sigalrm;
	sigfillset(&sa.sa_mask);
	if (sigaction(SIGALRM, &sa, NULL) < 0)
		err(1, "sigaction");
	it.it_interval.tv_sec = it.it_value.tv_sec = 0;
	it.it_interval.tv_usec = it.it_value.tv_usec = 1000;
	if (setitimer(ITIMER_REAL, &it, NULL) < 0)
		err(1, "setitimer");

	if (example)
		playdata(sample, sizeof sample, "<Gubben Noa>");
	else if (argc == 0)
		playfile(stdin, "<stdin>");
	else
		while (argc--) {
			f = fopen(*argv, "r");
			if (f == NULL)
				err(1, "%s", *argv);
			else {
				playfile(f, *argv);
				fclose(f);
			}
			argv++;
		}

	exit(0);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: midiplay.c,v 1.18 2016/05/05 09:18:12 ratchov Exp $ */
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
33			#include <sys/types.h>
34			#include <sys/stat.h>
35			#include <signal.h>
36			#include <stdio.h>
37			#include <stdlib.h>
38			#include <limits.h>
39			#include <err.h>
40			#include <unistd.h>
41			#include <string.h>
42			#include <sndio.h>
43
44			struct track {
45			u_char start, end;
46			u_long curtime;
47			u_char status;
48			};
49
50			#define MIDI_META 0xff
51
52			#define META_SEQNO 0x00
53			#define META_TEXT 0x01
54			#define META_COPYRIGHT 0x02
55			#define META_TRACK 0x03
56			#define META_INSTRUMENT 0x04
57			#define META_LYRIC 0x05
58			#define META_MARKER 0x06
59			#define META_CUE 0x07
60			#define META_CHPREFIX 0x20
61			#define META_EOT 0x2f
62			#define META_SET_TEMPO 0x51
63			#define META_KEY 0x59
64			#define META_SMPTE 0x54
65			#define META_TIMESIGN 0x58
66
67			char *metanames[] = {
68			"", "Text", "Copyright", "Track", "Instrument",
69			"Lyric", "Marker", "Cue",
70			};
71
72			static int midi_lengths[] = { 2,2,2,2,1,1,2,0 };
73			/* Number of bytes in a MIDI command */
74			#define MIDI_LENGTH(d) (midi_lengths[((d) >> 4) & 7])
75
76			#define MIDI_IS_STATUS(d) ((d) & 0x80)
77			#define MIDI_IS_COMMON(d) ((d) < 0xf0)
78			#define MIDI_SYSEX_START 0xf0
79			#define MIDI_SYSEX_STOP 0xf7
80
81			void usage(void);
82			void send_event(u_char, u_char *, u_int);
83			void dometa(u_int, u_char *, u_int);
84			void midireset(void);
85			u_long getvar(struct track *);
86			void playfile(FILE , char );
87			void playdata(u_char , u_int, char );
88			void sigalrm(int);
89			int main(int argc, char **argv);
90
91			extern char *__progname;
92
93			#define P(c) 1,0x90,c,0x7f,4,0x80,c,0
94			#define PL(c) 1,0x90,c,0x7f,8,0x80,c,0
95			#define C 0x3c
96			#define D 0x3e
97			#define E 0x40
98			#define F 0x41
99
100			u_char sample[] = {
101			'M','T','h','d', 0,0,0,6, 0,1, 0,1, 0,8,
102			'M','T','r','k', 0,0,0,4+13*8,
103			P(C), P(C), P(C), P(E), P(D), P(D), P(D),
104			P(F), P(E), P(E), P(D), P(D), PL(C),
105			0, 0xff, 0x2f, 0
106			};
107			#undef P
108			#undef PL
109			#undef C
110			#undef D
111			#undef E
112			#undef F
113
114			#define MARK_HEADER "MThd"
115			#define MARK_TRACK "MTrk"
116			#define MARK_LEN 4
117
118			#define SIZE_LEN 4
119			#define HEADER_LEN 6
120
121			#define GET8(p) ((p)[0])
122			#define GET16(p) (((p)[0] << 8) \| (p)[1])
123			#define GET24(p) (((p)[0] << 16) \| ((p)[1] << 8) \| (p)[2])
124			#define GET32(p) (((p)[0] << 24) \| ((p)[1] << 16) \| ((p)[2] << 8) \| (p)[3])
125
126			void
127			usage(void)
128			{
129			printf("usage: "
130			"%s [-gmqvx] [-f device] [-t tempo] [file ...]\n",
131			__progname);
132			exit(1);
133			}
134
135			int showmeta = 0;
136			int verbose = 0;
137			u_int tempo = 60 * 1000000 / 100; /* default tempo is 100bpm */
138			int play = 1;
139			struct mio_hdl *hdl;
140			struct timespec ts, ts_last;
141
142			void
143			send_event(u_char status, u_char *data, u_int len)
144			{
145			u_int i;
146
147			if (verbose > 1) {
148			printf("MIDI %02x", status);
149			for (i = 0; i < len; i++)
150			printf(" %02x", data[i]);
151			printf("\n");
152			}
153			if (play) {
154			mio_write(hdl, &status, 1);
155			mio_write(hdl, data, len);
156			}
157			}
158
159			u_long
160			getvar(struct track *tp)
161			{
162			u_long r, c;
163
164			r = 0;
165			do {
166			c = *tp->start++;
167			r = (r << 7) \| (c & 0x7f);
168			} while ((c & 0x80) && tp->start < tp->end);
169			return (r);
170			}
171
172			void
173			dometa(u_int meta, u_char *p, u_int len)
174			{
175			switch (meta) {
176			case META_TEXT:
177			case META_COPYRIGHT:
178			case META_TRACK:
179			case META_INSTRUMENT:
180			case META_LYRIC:
181			case META_MARKER:
182			case META_CUE:
183			if (showmeta) {
184			printf("%s: ", metanames[meta]);
185			fwrite(p, len, 1, stdout);
186			printf("\n");
187			}
188			break;
189			case META_SET_TEMPO:
190			tempo = GET24(p);
191			if (showmeta)
192			printf("Tempo: %d us / quarter note\n", tempo);
193			break;
194			case META_TIMESIGN:
195			if (showmeta) {
196			int n = p[1];
197			int d = 1;
198			while (n-- > 0)
199			d *= 2;
200			printf("Time signature: %d/%d %d,%d\n",
201			p[0], d, p[2], p[3]);
202			}
203			break;
204			case META_KEY:
205			if (showmeta)
206			printf("Key: %d %s\n", (char)p[0],
207			p[1] ? "minor" : "major");
208			break;
209			default:
210			break;
211			}
212			}
213
214			void
215			midireset(void)
216			{
217			/* General MIDI reset sequence */
218			static u_char gm_reset[] = { 0x7e, 0x7f, 0x09, 0x01, 0xf7 };
219
220			send_event(MIDI_SYSEX_START, gm_reset, sizeof gm_reset);
221			}
222
223			void
224			playfile(FILE f, char name)
225			{
226			u_char buf, newbuf;
227			u_int tot, n, size, newsize, nread;
228
229			/*
230			* We need to read the whole file into memory for easy processing.
231			* Using mmap() would be nice, but some file systems do not support
232			* it, nor does reading from e.g. a pipe. The latter also precludes
233			* finding out the file size without reading it.
234			*/
235			size = 1000;
236			buf = malloc(size);
237			if (buf == NULL)
238			err(1, "malloc() failed");
239			nread = size;
240			tot = 0;
241			for (;;) {
242			n = fread(buf + tot, 1, nread, f);
243			tot += n;
244			if (n < nread)
245			break;
246			/* There must be more to read. */
247			nread = size;
248			newsize = size * 2;
249			newbuf = realloc(buf, newsize);
250			if (newbuf == NULL)
251			err(1, "realloc() failed");
252			buf = newbuf;
253			size = newsize;
254			}
255			playdata(buf, tot, name);
256			free(buf);
257			}
258
259			void
260			sigalrm(int i)
261			{
262			}
263
264			void
265			playdata(u_char buf, u_int tot, char name)
266			{
267			long long delta_nsec = 0;
268			u_int delta_ticks;
269			int format, ntrks, divfmt, ticks, t, besttrk = 0;
270			u_int len, mlen;
271			u_char p, end, byte, meta;
272			struct track *tracks;
273			u_long bestcur, now;
274			struct track *tp;
275
276			end = buf + tot;
277			if (verbose)
278			printf("Playing %s (%d bytes) ... \n", name, tot);
279
280			if (memcmp(buf, MARK_HEADER, MARK_LEN) != 0) {
281			warnx("Not a MIDI file, missing header");
282			return;
283			}
284			if (GET32(buf + MARK_LEN) != HEADER_LEN) {
285			warnx("Not a MIDI file, bad header");
286			return;
287			}
288			format = GET16(buf + MARK_LEN + SIZE_LEN);
289			ntrks = GET16(buf + MARK_LEN + SIZE_LEN + 2);
290			divfmt = GET8(buf + MARK_LEN + SIZE_LEN + 4);
291			ticks = GET8(buf + MARK_LEN + SIZE_LEN + 5);
292			p = buf + MARK_LEN + SIZE_LEN + HEADER_LEN;
293			if ((divfmt & 0x80) == 0)
294			ticks \|= divfmt << 8;
295			else
296			errx(1, "Absolute time codes not implemented yet");
297			if (verbose > 1)
298			printf("format=%d ntrks=%d divfmt=%x ticks=%d\n",
299			format, ntrks, divfmt, ticks);
300			if (format != 0 && format != 1) {
301			warnx("Cannnot play MIDI file of type %d", format);
302			return;
303			}
304			if (ntrks == 0)
305			return;
306			tracks = calloc(ntrks, sizeof(struct track));
307			if (tracks == NULL)
308			err(1, "malloc() tracks failed");
309			for (t = 0; t < ntrks; ) {
310			if (p >= end - MARK_LEN - SIZE_LEN) {
311			warnx("Cannot find track %d", t);
312			goto ret;
313			}
314			len = GET32(p + MARK_LEN);
315			if (len > end - (p + MARK_LEN + SIZE_LEN)) {
316			warnx("Crazy track length");
317			goto ret;
318			}
319			if (memcmp(p, MARK_TRACK, MARK_LEN) == 0) {
320			tracks[t].start = p + MARK_LEN + SIZE_LEN;
321			tracks[t].end = tracks[t].start + len;
322			tracks[t].curtime = getvar(&tracks[t]);
323			t++;
324			}
325			p += MARK_LEN + SIZE_LEN + len;
326			}
327
328			/*
329			* Play MIDI events by selecting the track with the lowest
330			* curtime. Execute the event, update the curtime and repeat.
331			*/
332
333			now = 0;
334			delta_nsec = 0;
335			if (clock_gettime(CLOCK_MONOTONIC, &ts_last) < 0)
336			err(1, "clock_gettime");
337			for (;;) {
338			/* Locate lowest curtime */
339			bestcur = ULONG_MAX;
340			for (t = 0; t < ntrks; t++) {
341			if (tracks[t].curtime < bestcur) {
342			bestcur = tracks[t].curtime;
343			besttrk = t;
344			}
345			}
346			if (bestcur == ULONG_MAX)
347			break;
348			if (verbose > 1) {
349			printf("DELAY %4ld TRACK %2d ", bestcur-now, besttrk);
350			fflush(stdout);
351			}
352			while (now < bestcur) {
353			pause();
354			if (clock_gettime(CLOCK_MONOTONIC, &ts) < 0)
355			err(1, "clock_gettime");
356			delta_nsec += 1000000000L * (ts.tv_sec - ts_last.tv_sec);
357			delta_nsec += ts.tv_nsec - ts_last.tv_nsec;
358			ts_last = ts;
359			if (delta_nsec <= 0)
360			continue;
361			delta_ticks = delta_nsec * ticks / (1000LL * tempo);
362			delta_nsec -= 1000LL * delta_ticks * tempo / ticks;
363			now += delta_ticks;
364			}
365			tp = &tracks[besttrk];
366			byte = *tp->start++;
367			if (byte == MIDI_META) {
368			meta = *tp->start++;
369			mlen = getvar(tp);
370			if (verbose > 1)
371			printf("META %02x (%d)\n", meta, mlen);
372			dometa(meta, tp->start, mlen);
373			tp->start += mlen;
374			} else {
375			if (MIDI_IS_STATUS(byte))
376			tp->status = byte;
377			else
378			tp->start--;
379			if (MIDI_IS_COMMON(tp->status)) {
380			mlen = MIDI_LENGTH(tp->status);
381			send_event(tp->status, tp->start, mlen);
382			} else if (tp->status == MIDI_SYSEX_START) {
383			mlen = getvar(tp);
384			send_event(MIDI_SYSEX_START, tp->start, mlen);
385			} else if (tp->status == MIDI_SYSEX_STOP) {
386			mlen = getvar(tp);
387			/* Sorry, can't do this yet */;
388			} else {
389			if (verbose)
390			printf("MIDI event 0x%02x ignored\n",
391			tp->status);
392			}
393			tp->start += mlen;
394			}
395			if (tp->start >= tp->end)
396			tp->curtime = ULONG_MAX;
397			else
398			tp->curtime += getvar(tp);
399			}
400			ret:
401			free(tracks);
402			}
403
404			int
405			main(int argc, char **argv)
406			{
407			int ch;
408			int example = 0;
409			int gmreset = 0;
410			char *file = NULL;
411			FILE *f;
412			const char *errstr;
413			struct sigaction sa;
414			struct itimerval it;
415
416			while ((ch = getopt(argc, argv, "?d:f:glmqt:vx")) != -1) {
417			switch (ch) {
418			case 'f':
419			file = optarg;
420			break;
421			case 'g':
422			gmreset = 1;
423			break;
424			case 'm':
425			showmeta = 1;
426			break;
427			case 'q':
428			play = 0;
429			break;
430			case 't':
431			tempo = 60 * 1000000 /
432			strtonum(optarg, 40, 240, &errstr);
433			if (errstr)
434			errx(1, "tempo is %s: %s", errstr, optarg);
435			break;
436			case 'v':
437			verbose++;
438			break;
439			case 'x':
440			example = 1;
441			break;
442			case '?':
443			default:
444			usage();
445			}
446			}
447			argc -= optind;
448			argv += optind;
449
450			hdl = mio_open(file, MIO_OUT, 0);
451			if (hdl == NULL)
452			errx(1, "failed to open MIDI output");
453			if (gmreset)
454			midireset();
455
456			sa.sa_flags = SA_RESTART;
457			sa.sa_handler = sigalrm;
458			sigfillset(&sa.sa_mask);
459			if (sigaction(SIGALRM, &sa, NULL) < 0)
460			err(1, "sigaction");
461			it.it_interval.tv_sec = it.it_value.tv_sec = 0;
462			it.it_interval.tv_usec = it.it_value.tv_usec = 1000;
463			if (setitimer(ITIMER_REAL, &it, NULL) < 0)
464			err(1, "setitimer");
465
466			if (example)
467			playdata(sample, sizeof sample, "<Gubben Noa>");
468			else if (argc == 0)
469			playfile(stdin, "<stdin>");
470			else
471			while (argc--) {
472			f = fopen(*argv, "r");
473			if (f == NULL)
474			err(1, "%s", *argv);
475			else {
476			playfile(f, *argv);
477			fclose(f);
478			}
479			argv++;
480			}
481
482			exit(0);
483			}