![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to playmidifile.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [NeXTSTEP 3.3 examples] / Examples / SoundAndMusic / MidiDriver|
Return to playmidifile.c CVS log | Up to [NeXTSTEP 3.3 examples] / Examples / SoundAndMusic / MidiDriver |
1.1 root 1: /*
2: * This example test program reads a standard Level 0 Midifile (.midi suffix)
3: * as defined by the Midi Manufacturer's Association, and plays it
4: * through the MIDI Driver. Level 1 and level 2 files are not supported
5: * in this example.
6: *
7: * Original written by Gregg Kellogg and Danna Massie.
8: * Rewritten for release 3.0 MIDI driver by David Jaffe
9: */
10: #import <mach/mach.h>
11: #import <stdio.h>
12: #import <stdlib.h>
13: #import <mach/mach_error.h>
14: #import <signal.h>
15: #import <servers/netname.h>
16: #import <libc.h>
17: #import <mididriver/midi_driver.h>
18: #import <mididriver/midi_spec.h>
19: #import "midifile.h"
20:
21: static port_t driverPort; /* Port for driver on particular host. */
22: static port_t ownerPort; /* Port that represents ownership */
23: static port_t queuePort; /* Port for output queue notification messages */
24: static port_t exceptionPort; /* Port for timing exceptions */
25: static int maxQueueSize; /* Maximum output queue size */
26: static boolean_t allRead; /* Flag signaling all data read from file. */
27: static boolean_t allSent; /* Flag signaling all data sent to driver. */
28: static boolean_t someSent; /* Flag signaling if data was sent to driver.*/
29: static NXStream *s; /* Stream for reading input file */
30: static int tempo = 60;
31: static int unit = MIDI_PORT_A_UNIT; /* Serial port to send to */
32: static port_set_name_t ports;/* Port set to listen for messages from driver */
33:
34: /* Forward references */
35: static void usage(void);
36: static void checkForError(char *msg,int errorReturn);
37: static port_t allocPort(void);
38: static port_t createPortSet(port_t queuePort, port_t exceptionPort);
39: static void initFile(void);
40: static void setTempo(int newTempo);
41: static void myExceptionReply(port_t replyPort, int exception);
42: static void myQueueReply(port_t replyPort, short unit);
43: static void cleanup();
44:
45: main(int argc, char **argv)
46: {
47: int i;
48: int synchToTimeCode = FALSE;
49: kern_return_t r;
50: int synchUnit; /* Serial port to listen for time code */
51: char *filename = NULL;
52: MIDIReplyFunctions funcs = {0};
53: signal (SIGINT, cleanup); /* Control-C routine to clean up gracefully */
54: while ((i = getopt(argc, argv, "p:f:t:s:")) != EOF)
55: switch (i) {
56: case 'p':
57: unit = ((!strcmp (optarg ,"a") || !strcmp(optarg,"A")) ?
58: MIDI_PORT_A_UNIT : MIDI_PORT_B_UNIT);
59: break;
60: case 'f':
61: filename = optarg ;
62: break;
63: case 't':
64: tempo = atoi(optarg) ;
65: fprintf(stderr,"tempo= %d\n",tempo);
66: break;
67: case 's':
68: synchToTimeCode = TRUE;
69: synchUnit = (!strcmp (optarg ,"a")) ? MIDI_PORT_A_UNIT : MIDI_PORT_B_UNIT;
70: break;
71: case 'h':
72: case '?':
73: default:
74: usage();
75: exit(1);
76: }
77:
78: if (filename == NULL) {
79: fprintf(stderr,"No filename specified...\n");
80: usage();
81: exit(1);
82: }
83: fprintf(stderr,"using midi port: ");
84: fprintf(stderr,unit == MIDI_PORT_A_UNIT ? "A\n" : "B\n");
85: if (synchToTimeCode) {
86: fprintf(stderr,"Synching to MIDI time code on port: ");
87: fprintf(stderr,unit == MIDI_PORT_A_UNIT ? "A\n" : "B\n");
88: }
89: s = NXMapFile(filename,NX_READONLY);
90: if (!s) {
91: fprintf(stderr,"Cannot open file : %s\n", filename);
92: exit(1);
93: }
94: initFile();
95:
96: /* Set up MIDI driver */
97: r = netname_look_up(name_server_port, "","mididriver", &driverPort);
98: checkForError("playmidifile: netname_look_up error",r);
99: r = MIDIBecomeOwner(driverPort,ownerPort = allocPort());
100: checkForError("MIDIBecomeOwner",r);
101: r = MIDIClaimUnit(driverPort, ownerPort,unit);
102: checkForError("MIDIClaimUnit",r);
103: if (synchToTimeCode && synchUnit != unit) {
104: r = MIDIClaimUnit(driverPort, ownerPort,synchUnit);
105: checkForError("MIDIClaimUnit",r);
106: }
107: r = MIDISetClockMode(driverPort, ownerPort, synchUnit,
108: (synchToTimeCode ? MIDI_CLOCK_MODE_MTC_SYNC :
109: MIDI_CLOCK_MODE_INTERNAL));
110: checkForError("MIDISetClockMode",r);
111: r = MIDISetClockQuantum(driverPort, ownerPort, 1000);
112: checkForError("MIDISetClockQuantum",r);
113: ports = createPortSet(queuePort=allocPort(), exceptionPort=allocPort());
114: r = MIDIRequestExceptions(driverPort, ownerPort, exceptionPort);
115: checkForError("MIDIRequestExceptions",r);
116: r = MIDIGetAvailableQueueSize(driverPort, ownerPort, unit, &maxQueueSize);
117: checkForError("MIDIGetAvailableQueueSize",r);
118: if (!synchToTimeCode) {
119: r = MIDISetClockTime(driverPort, ownerPort, 0);
120: checkForError("MIDISetClockTime",r);
121: /* We start clock now. Alternatively, we could first queue up
122: * some messages and then start time. That would insure that
123: * the first few notes come out correctly.
124: */
125: r = MIDIStartClock(driverPort, ownerPort);
126: checkForError("MIDIStartTime",r);
127: }
128: /*
129: * We play the file by chaining invocations of myQueueReply(). To
130: * start the process, we ask the driver to invoke myQueueReply() when
131: * the queue is fully available (which will be immediately, since nothing
132: * has been sent yet.)
133: *
134: * Note: If this code is included in an Application, you must either
135: * run MIDIAwaitReply() in a separate Mach thread or use MIDIHandleReply()
136: * instead of MIDIAwaitReply() and register the port set with DPSAddPort().
137: * See <mididriver/midi_driver.h> for details.
138: */
139: r = MIDIRequestQueueNotification(driverPort, ownerPort, unit, queuePort,
140: maxQueueSize);
141: checkForError("MIDIRequestQueueNotification",r);
142: funcs.exceptionReply = myExceptionReply;
143: funcs.queueReply = myQueueReply;
144: if (synchToTimeCode)
145: fprintf(stderr,"Waiting for time code to start...\n");
146: allSent = FALSE;
147: allRead = FALSE;
148: someSent = TRUE;
149: while (!allSent) { /* Here's where the work happens */
150: r = MIDIAwaitReply(ports,&funcs,MIDI_NO_TIMEOUT);
151: checkForError("MIDIAwaitReply",r);
152: }
153:
154: /* Wait for our output to drain. */
155: r = MIDIRequestQueueNotification(driverPort, ownerPort, unit, queuePort,
156: maxQueueSize);
157: checkForError("MIDIRequestQueueNotification",r);
158: funcs.queueReply = NULL;
159: r = MIDIAwaitReply(ports,&funcs,MIDI_NO_TIMEOUT);
160: checkForError("MIDIAwaitReply",r);
161: cleanup();
162: }
163:
164: static MIDIRawEvent events[MIDI_MAX_EVENT];
165: static byteIndex = 0;
166:
167: static void *fileStruct; /* Used by MIDIFILE routines. */
168: static MIDIFILEReadStruct fileEvent = {0};
169:
170: static int getNextFileByte(void)
171: {
172: static int fileEventCtr = 0;
173: if (fileEventCtr == 0)
174: if (!MIDIFILEReadEvent(fileStruct))
175: return FALSE;
176: if (fileEvent.metaEventFlag)
177: fileEventCtr = 0;
178: else {
179: events[byteIndex].time = fileEvent.quanta;
180: events[byteIndex].byte = fileEvent.data[fileEventCtr++];
181: byteIndex++;
182: if (fileEventCtr == fileEvent.nData)
183: fileEventCtr = 0;
184: }
185: return TRUE;
186: }
187:
188: static int sendData(void)
189: /* Sends the data. Returns FALSE if the driver's buffer is full. */
190: {
191: kern_return_t r =
192: MIDISendData(driverPort, ownerPort, unit, events, byteIndex);
193: if (r == MIDI_ERROR_QUEUE_FULL) {
194: /* Request notification when at least half the queue is available */
195: r = MIDIRequestQueueNotification(driverPort, ownerPort,
196: unit, queuePort,
197: maxQueueSize/2);
198: checkForError("MIDIRequestQueueNotification",r);
199: return FALSE;
200: } else checkForError("MIDISendData",r);
201: byteIndex = 0;
202: return TRUE;
203: }
204:
205: static void myQueueReply(port_t replyPort, short unit)
206: /* This gets invoked when the queue has enough room for more data. */
207: {
208: for (;;) {
209: if (byteIndex == MIDI_MAX_EVENT-1)
210: if (!sendData())
211: return;
212: if (!allRead)
213: allRead = !getNextFileByte();
214: if (allRead) {
215: if (sendData())
216: allSent = TRUE;
217: return;
218: }
219: }
220: }
221:
222: static void myExceptionReply(port_t replyPort, int exception)
223: /* This gets invoked when exceptions occur. */
224: {
225: switch (exception) {
226: case MIDI_EXCEPTION_MTC_STOPPED:
227: fprintf(stderr,"MIDI time code stopped.\n");
228: break;
229: case MIDI_EXCEPTION_MTC_STARTED_FORWARD:
230: fprintf(stderr,"MIDI time code started (forward).\n");
231: break;
232: case MIDI_EXCEPTION_MTC_STARTED_REVERSE:
233: fprintf(stderr,"MIDI time code started (reverse).\n");
234: break;
235: default:
236: break;
237: }
238: }
239:
240: static void usage(void)
241: {
242: fprintf(stderr,
243: "usage: playmidifile -f file.midi [-p {A, B}] [-s {A, B}]\n"
244: " -p is the serial port to send the MIDI\n"
245: " -s is the serial port to receive MIDI time code, if any.\n");
246: }
247:
248: static void checkForError(char *msg,int errorReturn)
249: /* Checks for error. If error, prints message and quits. */
250: {
251: if (errorReturn != KERN_SUCCESS) {
252: switch (errorReturn) {
253: case MIDI_ERROR_BUSY:
254: printf("%s: %s",msg,"MIDI driver busy.\n");
255: break;
256: case MIDI_ERROR_NOT_OWNER:
257: printf("%s: %s",msg,"You must be owner of the MIDI driver.\n");
258: break;
259: case MIDI_ERROR_QUEUE_FULL:
260: printf("%s: %s",msg,"MIDI driver queue full.\n");
261: break;
262: case MIDI_ERROR_BAD_MODE:
263: printf("%s: %s",msg,"Bad MIDI driver clock mode.\n");
264: break;
265: case MIDI_ERROR_UNIT_UNAVAILABLE:
266: printf("%s: %s",msg,"MIDI driver unit unavailable.\n");
267: break;
268: case MIDI_ERROR_ILLEGAL_OPERATION:
269: printf("%s: %s",msg,"MIDI driver illegal operation.\n");
270: break;
271: default:
272: mach_error(msg,errorReturn);
273: }
274: exit(1);
275: }
276: }
277:
278: static port_t allocPort(void)
279: /* Allocates a port and returns it. */
280: {
281: port_t aPort;
282: int r = port_allocate(task_self(), &aPort);
283: checkForError("allocPort",r);
284: return aPort;
285: }
286:
287: static port_t createPortSet(port_t queuePort, port_t exceptionPort)
288: /* Creates the port set and adds the two ports. */
289: {
290: port_set_name_t aPortSet;
291: int r = port_set_allocate(task_self(), &aPortSet);
292: checkForError("createPortSet",r);
293: r = port_set_add(task_self(), aPortSet, queuePort);
294: checkForError("createPortSet",r);
295: r = port_set_add(task_self(), aPortSet, exceptionPort);
296: checkForError("createPortSet",r);
297: return aPortSet;
298: }
299:
300: static void setTempo(int newTempo)
301: {
302: MIDIFILESetReadQuantaSize(fileStruct,(tempo = newTempo)/60.0 * 1000);
303: }
304:
305: static void initFile(void)
306: {
307: int level,trackCount;
308: fileStruct = MIDIFILEBeginReading(s,&fileEvent);
309: if (MIDIFILEReadPreamble(fileStruct,&level,&trackCount)) {
310: if (level != 0) {
311: fprintf(stderr,"playmidifile cannot play level %d files.\n",level);
312: exit(1);
313: }
314: }
315: else {
316: fprintf(stderr,"failed to read preamble!\n");
317: exit(1);
318: }
319: setTempo(tempo);
320: }
321:
322: static void allNotesOff(void) {
323: #define NOTEOFF_ARRAY_SIZE (128*2) /* Use running status */
324: MIDIRawEvent arr[NOTEOFF_ARRAY_SIZE];
325: kern_return_t r;
326: int chan = 0;
327: int bytesToSend,i;
328: MIDIRawEvent op;
329: MIDIReplyFunctions funcs = {0};
330: for (i=0; i<128; i++) { /* Initialize array */
331: arr[i*2].byte = i; /* KeyNum */
332: arr[i*2+1].byte = 0; /* Velocity */
333: }
334:
335: while (MIDIAwaitReply(ports,&funcs,1) == KERN_SUCCESS)
336: ; /* Empty out ports of any old notification messages. */
337: r = MIDIClearQueue(driverPort,ownerPort,unit);
338: checkForError("MIDIClearQueue",r);
339: for (chan = 0; chan < 16; chan++) {
340: op.byte = MIDI_NOTEOFF | chan;
341: r = MIDISendData(driverPort,ownerPort,unit,&op,1);
342: checkForError("MIDISendData",r);
343: for (i = 0; i < NOTEOFF_ARRAY_SIZE; i += MIDI_MAX_EVENT) {
344: bytesToSend = NOTEOFF_ARRAY_SIZE - i;
345: if (bytesToSend > MIDI_MAX_EVENT)
346: bytesToSend = MIDI_MAX_EVENT;
347: r = MIDISendData(driverPort,ownerPort,unit,&arr[i],bytesToSend);
348: checkForError("MIDISendData",r);
349: }
350: r = MIDIFlushQueue(driverPort,ownerPort,unit);
351: checkForError("MIDIFlushQueue",r);
352: r = MIDIRequestQueueNotification(driverPort, ownerPort,unit,
353: queuePort,
354: ((chan==15) ? maxQueueSize :
355: NOTEOFF_ARRAY_SIZE+1));
356: checkForError("MIDIRequestQueueNotification",r);
357: r = MIDIAwaitReply(ports,&funcs,MIDI_NO_TIMEOUT);
358: checkForError("MIDIAwaitReply",r);
359: }
360: }
361:
362: static void cleanup() {
363: kern_return_t r;
364: if (!driverPort || !ownerPort)
365: exit(0);
366: if (someSent)
367: allNotesOff();
368: r = MIDIReleaseOwnership(driverPort,ownerPort);
369: checkForError("MIDIReleaseOwnership",r);
370: exit(0);
371: }
372:
373:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.