![[BACK]](/icons/back.gif){kind=icon}
Return to midi.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / src / usr.bin / sndiod|
Return to midi.c CVS log | Up to [local] / src / usr.bin / sndiod |
1.2 ! ratchov 1: /* $OpenBSD: midi.c,v 1.1 2012/11/23 07:03:28 ratchov Exp $ */
1.1 ratchov 2: /*
3: * Copyright (c) 2008-2012 Alexandre Ratchov <alex@caoua.org>
4: *
5: * Permission to use, copy, modify, and distribute this software for any
6: * purpose with or without fee is hereby granted, provided that the above
7: * copyright notice and this permission notice appear in all copies.
8: *
9: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16: */
17: /*
18: * TODO
19: *
20: * use shadow variables (to save NRPNs, LSB of controller)
21: * in the midi merger
22: */
23: #include <stdio.h>
24: #include <stdlib.h>
25: #include <string.h>
26:
27: #include "abuf.h"
28: #include "defs.h"
29: #include "dev.h"
30: #include "file.h"
31: #include "midi.h"
32: #include "miofile.h"
33: #include "sysex.h"
34: #include "utils.h"
35:
36: /*
37: * input data rate is XFER / TIMO (in bytes per microsecond),
38: * it must be slightly larger than the MIDI standard 3125 bytes/s
39: */
40: #define MIDI_XFER 1
41: #define MIDI_TIMO 100000
42:
43: int port_open(struct port *);
44: void port_imsg(void *, unsigned char *, int);
45: void port_omsg(void *, unsigned char *, int);
46: void port_fill(void *, int);
47: void port_exit(void *);
48:
49: struct midiops port_midiops = {
50: port_imsg,
51: port_omsg,
52: port_fill,
53: port_exit
54: };
55:
56: #define MIDI_NEP 32
57: struct midi midi_ep[MIDI_NEP];
58: struct timo midi_timo;
59: struct port *port_list = NULL;
60: unsigned int midi_portnum = 0;
61:
62: struct midithru {
1.2 ! ratchov 63: unsigned int txmask, rxmask;
1.1 ratchov 64: #define MIDITHRU_NMAX 32
65: } midithru[MIDITHRU_NMAX];
66:
67: /*
68: * length of voice and common messages (status byte included)
69: */
70: unsigned int voice_len[] = { 3, 3, 3, 3, 2, 2, 3 };
71: unsigned int common_len[] = { 0, 2, 3, 2, 0, 0, 1, 1 };
72:
73: void
74: midi_log(struct midi *ep)
75: {
76: log_puts("midi");
77: log_putu(ep - midi_ep);
78: }
79:
80: void
81: midi_ontimo(void *arg)
82: {
83: int i;
84: struct midi *ep;
85:
86: for (i = MIDI_NEP, ep = midi_ep; i > 0; i--, ep++) {
87: }
88: timo_add(&midi_timo, MIDI_TIMO);
89: }
90:
91: void
92: midi_init(void)
93: {
94: timo_set(&midi_timo, midi_ontimo, NULL);
95: timo_add(&midi_timo, MIDI_TIMO);
96: }
97:
98: void
99: midi_done(void)
100: {
101: timo_del(&midi_timo);
102: }
103:
104: struct midi *
105: midi_new(struct midiops *ops, void *arg, int mode)
106: {
107: int i;
108: struct midi *ep;
109:
110: for (i = 0, ep = midi_ep;; i++, ep++) {
111: if (i == MIDI_NEP)
112: return NULL;
113: if (ep->ops == NULL)
114: break;
115: }
116: ep->ops = ops;
117: ep->arg = arg;
118: ep->used = 0;
119: ep->len = 0;
120: ep->idx = 0;
121: ep->st = 0;
122: ep->txmask = 0;
1.2 ! ratchov 123: ep->self = 1 << i;
! 124: ep->tickets = 0;
1.1 ratchov 125: ep->mode = mode;
1.2 ! ratchov 126:
1.1 ratchov 127: /*
1.2 ! ratchov 128: * the output buffer is the client intput
1.1 ratchov 129: */
1.2 ! ratchov 130: if (ep->mode & MODE_MIDIIN)
1.1 ratchov 131: abuf_init(&ep->obuf, MIDI_BUFSZ);
1.2 ! ratchov 132: midi_tickets(ep);
1.1 ratchov 133: return ep;
134: }
135:
136: void
137: midi_del(struct midi *ep)
138: {
139: int i;
1.2 ! ratchov 140: struct midi *peer;
1.1 ratchov 141:
1.2 ! ratchov 142: ep->txmask = 0;
! 143: for (i = 0; i < MIDI_NEP; i++) {
! 144: peer = midi_ep + i;
! 145: if (peer->txmask & ep->self) {
! 146: peer->txmask &= ~ep->self;
! 147: midi_tickets(peer);
! 148: }
! 149: }
! 150: for (i = 0; i < MIDITHRU_NMAX; i++) {
! 151: midithru[i].txmask &= ~ep->self;
! 152: midithru[i].rxmask &= ~ep->self;
! 153: }
1.1 ratchov 154: ep->ops = NULL;
155: if (ep->mode & MODE_MIDIIN) {
156: abuf_done(&ep->obuf);
157: }
158: }
159:
160: /*
1.2 ! ratchov 161: * connect two midi endpoints
1.1 ratchov 162: */
163: void
1.2 ! ratchov 164: midi_link(struct midi *ep, struct midi *peer)
1.1 ratchov 165: {
1.2 ! ratchov 166: if (ep->mode & MODE_MIDIOUT) {
! 167: ep->txmask |= peer->self;
! 168: midi_tickets(ep);
! 169: }
! 170: if (ep->mode & MODE_MIDIIN) {
! 171: #ifdef DEBUG
! 172: if (ep->obuf.used > 0) {
! 173: midi_log(ep);
! 174: log_puts(": linked with non-empty buffer\n");
! 175: panic();
! 176: }
! 177: #endif
! 178: /* ep has empry buffer, so no need to call midi_tickets() */
! 179: peer->txmask |= ep->self;
1.1 ratchov 180: }
181: }
182:
183: /*
1.2 ! ratchov 184: * add the midi endpoint in the ``tag'' midi thru box
1.1 ratchov 185: */
186: void
1.2 ! ratchov 187: midi_tag(struct midi *ep, unsigned int tag)
1.1 ratchov 188: {
1.2 ! ratchov 189: struct midi *peer;
! 190: struct midithru *t = midithru + tag;
1.1 ratchov 191: int i;
192:
1.2 ! ratchov 193: if (ep->mode & MODE_MIDIOUT) {
! 194: ep->txmask |= t->txmask;
! 195: midi_tickets(ep);
! 196: }
! 197: if (ep->mode & MODE_MIDIIN) {
! 198: #ifdef DEBUG
! 199: if (ep->obuf.used > 0) {
! 200: midi_log(ep);
! 201: log_puts(": tagged with non-empty buffer\n");
! 202: panic();
! 203: }
! 204: #endif
! 205: for (i = 0; i < MIDI_NEP; i++) {
! 206: if (!(t->rxmask & (1 << i)))
! 207: continue;
! 208: peer = midi_ep + i;
! 209: peer->txmask |= ep->self;
! 210: }
1.1 ratchov 211: }
1.2 ! ratchov 212: if (ep->mode & MODE_MIDIOUT)
! 213: t->rxmask |= ep->self;
! 214: if (ep->mode & MODE_MIDIIN)
! 215: t->txmask |= ep->self;
1.1 ratchov 216: }
217:
218: /*
219: * broadcast the given message to other members of the thru box
220: */
221: void
222: midi_send(struct midi *iep, unsigned char *msg, int size)
223: {
224: struct midi *oep;
225: int i;
226:
227: #ifdef DEBUG
228: if (log_level >= 4) {
229: midi_log(iep);
230: log_puts(": sending:");
231: for (i = 0; i < size; i++) {
232: log_puts(" ");
233: log_putx(msg[i]);
234: }
235: log_puts("\n");
236: }
237: #endif
238: for (i = 0; i < MIDI_NEP ; i++) {
239: if ((iep->txmask & (1 << i)) == 0)
240: continue;
241: oep = midi_ep + i;
242: if (msg[0] <= 0x7f) {
243: if (oep->owner != iep)
244: continue;
245: } else if (msg[0] <= 0xf7)
246: oep->owner = iep;
247: #ifdef DEBUG
248: if (log_level >= 4) {
249: midi_log(iep);
250: log_puts(" -> ");
251: midi_log(oep);
252: log_puts("\n");
253: }
254: #endif
255: oep->ops->omsg(oep->arg, msg, size);
256: }
257: }
258:
259:
1.2 ! ratchov 260: /*
! 261: * determine if we have gained more input tickets, and if so call the
! 262: * fill() call-back to notify the i/o layer that it can send more data
! 263: */
! 264: void
! 265: midi_tickets(struct midi *iep)
! 266: {
! 267: int i, tickets, avail, maxavail;
! 268: struct midi *oep;
! 269:
! 270: maxavail = MIDI_BUFSZ;
! 271: for (i = 0; i < MIDI_NEP ; i++) {
! 272: if ((iep->txmask & (1 << i)) == 0)
! 273: continue;
! 274: oep = midi_ep + i;
! 275: avail = oep->obuf.len - oep->obuf.used;
! 276: if (maxavail > avail)
! 277: maxavail = avail;
! 278: }
! 279:
! 280: /*
! 281: * in the worst case output message is twice the
! 282: * input message (2-byte messages with running status)
! 283: */
! 284: tickets = maxavail / 2 - iep->tickets;
! 285: if (tickets > 0) {
! 286: iep->tickets += tickets;
! 287: iep->ops->fill(iep->arg, tickets);
! 288: }
! 289: }
! 290:
! 291: /*
! 292: * recalculate tickets of endpoints sending data to this one
! 293: */
1.1 ratchov 294: void
295: midi_fill(struct midi *oep)
296: {
1.2 ! ratchov 297: int i;
1.1 ratchov 298: struct midi *iep;
299:
1.2 ! ratchov 300: for (i = 0; i < MIDI_NEP; i++) {
1.1 ratchov 301: iep = midi_ep + i;
1.2 ! ratchov 302: if (iep->txmask & oep->self)
! 303: midi_tickets(iep);
1.1 ratchov 304: }
305: }
306:
307: /*
1.2 ! ratchov 308: * parse then give data chunk, and calling imsg() for each message
1.1 ratchov 309: */
310: void
1.2 ! ratchov 311: midi_in(struct midi *iep, unsigned char *idata, int icount)
1.1 ratchov 312: {
313: int i;
314: unsigned char c;
315:
316: for (i = 0; i < icount; i++) {
317: c = *idata++;
318: if (c >= 0xf8) {
319: if (c != MIDI_ACK)
320: iep->ops->imsg(iep->arg, &c, 1);
321: } else if (c == SYSEX_END) {
322: if (iep->st == SYSEX_START) {
323: iep->msg[iep->idx++] = c;
324: iep->ops->imsg(iep->arg, iep->msg, iep->idx);
325: }
326: iep->st = 0;
327: iep->idx = 0;
328: } else if (c >= 0xf0) {
329: iep->msg[0] = c;
330: iep->len = common_len[c & 7];
331: iep->st = c;
332: iep->idx = 1;
333: } else if (c >= 0x80) {
334: iep->msg[0] = c;
335: iep->len = voice_len[(c >> 4) & 7];
336: iep->st = c;
337: iep->idx = 1;
338: } else if (iep->st) {
339: if (iep->idx == 0 && iep->st != SYSEX_START)
340: iep->msg[iep->idx++] = iep->st;
341: iep->msg[iep->idx++] = c;
342: if (iep->idx == iep->len) {
343: iep->ops->imsg(iep->arg, iep->msg, iep->idx);
344: if (iep->st >= 0xf0)
345: iep->st = 0;
346: iep->idx = 0;
347: } else if (iep->idx == MIDI_MSGMAX) {
348: /* sysex continued */
349: iep->ops->imsg(iep->arg, iep->msg, iep->idx);
350: iep->idx = 0;
351: }
352: }
353: }
1.2 ! ratchov 354: iep->tickets -= icount;
! 355: if (iep->tickets < 0)
! 356: iep->tickets = 0;
1.1 ratchov 357: }
358:
359: /*
360: * store the given message in the output buffer
361: */
362: void
363: midi_out(struct midi *oep, unsigned char *idata, int icount)
364: {
365: unsigned char *odata;
366: int ocount;
367: #ifdef DEBUG
368: int i;
369: #endif
370:
371: while (icount > 0) {
372: if (oep->obuf.used == oep->obuf.len) {
373: #ifdef DEBUG
374: if (log_level >= 2) {
375: midi_log(oep);
1.2 ! ratchov 376: log_puts(": too slow, discarding ");
1.1 ratchov 377: log_putu(oep->obuf.used);
378: log_puts(" bytes\n");
379: }
380: #endif
381: abuf_rdiscard(&oep->obuf, oep->obuf.used);
382: oep->owner = NULL;
383: return;
384: }
385: odata = abuf_wgetblk(&oep->obuf, &ocount);
386: if (ocount > icount)
387: ocount = icount;
388: memcpy(odata, idata, ocount);
389: #ifdef DEBUG
390: if (log_level >= 4) {
391: midi_log(oep);
392: log_puts(": out: ");
393: for (i = 0; i < ocount; i++) {
394: log_puts(" ");
395: log_putx(odata[i]);
396: }
397: log_puts("\n");
398: }
399: #endif
400: abuf_wcommit(&oep->obuf, ocount);
401: icount -= ocount;
402: idata += ocount;
403: }
404: }
405:
406: #ifdef DEBUG
407: void
408: port_log(struct port *p)
409: {
410: midi_log(p->midi);
411: }
412: #endif
413:
414: void
415: port_imsg(void *arg, unsigned char *msg, int size)
416: {
417: struct port *p = arg;
418:
419: midi_send(p->midi, msg, size);
420: }
421:
422:
423: void
424: port_omsg(void *arg, unsigned char *msg, int size)
425: {
426: struct port *p = arg;
427:
428: midi_out(p->midi, msg, size);
429: }
430:
431: void
432: port_fill(void *arg, int count)
433: {
434: /* no flow control */
435: }
436:
437: void
438: port_exit(void *arg)
439: {
440: #ifdef DEBUG
441: struct port *p = arg;
442:
443: if (log_level >= 3) {
444: port_log(p);
445: log_puts(": exit\n");
446: }
447: #endif
448: }
449:
450: /*
451: * create a new midi port
452: */
453: struct port *
454: port_new(char *path, unsigned int mode)
455: {
456: struct port *c;
457:
458: c = xmalloc(sizeof(struct port));
459: c->path = path;
460: c->state = PORT_CFG;
461: c->midi = midi_new(&port_midiops, c, mode);
462: midi_portnum++;
463: c->next = port_list;
464: port_list = c;
465: return c;
466: }
467:
468: /*
469: * destroy the given midi port
470: */
471: void
472: port_del(struct port *c)
473: {
474: struct port **p;
475:
476: if (c->state != PORT_CFG)
477: port_close(c);
478: midi_del(c->midi);
479: for (p = &port_list; *p != c; p = &(*p)->next) {
480: #ifdef DEBUG
481: if (*p == NULL) {
482: log_puts("port to delete not on list\n");
483: panic();
484: }
485: #endif
486: }
487: *p = c->next;
488: xfree(c);
489: }
490:
491: struct port *
492: port_bynum(int num)
493: {
494: struct port *p;
495:
496: for (p = port_list; p != NULL; p = p->next) {
497: if (num-- == 0)
498: return p;
499: }
500: return NULL;
501: }
502:
503: int
504: port_open(struct port *c)
505: {
506: if (!port_mio_open(c)) {
507: if (log_level >= 1) {
508: log_puts(c->path);
509: log_puts(": failed to open midi port\n");
510: }
511: return 0;
512: }
513: c->state = PORT_INIT;
514: return 1;
515: }
516:
517: int
518: port_close(struct port *c)
519: {
520: #ifdef DEBUG
521: if (c->state == PORT_CFG) {
522: port_log(c);
523: log_puts(": can't close port (not opened)\n");
524: }
525: #endif
526: port_mio_close(c);
527: c->state = PORT_CFG;
528: return 1;
529: }
530:
531: int
532: port_init(struct port *c)
533: {
534: return port_open(c);
535: }
536:
537: void
538: port_done(struct port *c)
539: {
540: /* XXX: drain? */
541: if (c->state != PORT_CFG)
542: port_close(c);
543: }