Annotation of sys/dev/midisyn.c, Revision 1.1.1.1
1.1 nbrk 1: /* $OpenBSD: midisyn.c,v 1.6 2006/04/07 22:41:32 jsg Exp $ */
2: /* $NetBSD: midisyn.c,v 1.5 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: * 3. All advertising materials mentioning features or use of this software
20: * must display the following acknowledgement:
21: * This product includes software developed by the NetBSD
22: * Foundation, Inc. and its contributors.
23: * 4. Neither the name of The NetBSD Foundation nor the names of its
24: * contributors may be used to endorse or promote products derived
25: * from this software without specific prior written permission.
26: *
27: * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
28: * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
29: * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
30: * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
31: * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
32: * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
33: * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
34: * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
35: * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
36: * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
37: * POSSIBILITY OF SUCH DAMAGE.
38: */
39:
40: #include <sys/param.h>
41: #include <sys/ioctl.h>
42: #include <sys/fcntl.h>
43: #include <sys/vnode.h>
44: #include <sys/selinfo.h>
45: #include <sys/proc.h>
46: #include <sys/malloc.h>
47: #include <sys/systm.h>
48: #include <sys/syslog.h>
49: #include <sys/kernel.h>
50: #include <sys/conf.h>
51: #include <sys/audioio.h>
52: #include <sys/midiio.h>
53: #include <sys/device.h>
54:
55: #include <dev/audio_if.h>
56: #include <dev/midi_if.h>
57: #include <dev/midivar.h>
58: #include <dev/midisynvar.h>
59:
60: #ifdef AUDIO_DEBUG
61: #define DPRINTF(x) if (midisyndebug) printf x
62: #define DPRINTFN(n,x) if (midisyndebug >= (n)) printf x
63: int midisyndebug = 0;
64: #else
65: #define DPRINTF(x)
66: #define DPRINTFN(n,x)
67: #endif
68:
69: int midisyn_findvoice(midisyn *, int, int);
70: void midisyn_freevoice(midisyn *, int);
71: int midisyn_allocvoice(midisyn *, u_int32_t, u_int32_t);
72: u_int32_t midisyn_note_to_freq(int);
73: u_int32_t midisyn_finetune(u_int32_t, int, int, int);
74:
75: int midisyn_open(void *, int,
76: void (*iintr)(void *, int),
77: void (*ointr)(void *), void *arg);
78: void midisyn_close(void *);
79: int midisyn_output(void *, int);
80: void midisyn_getinfo(void *, struct midi_info *);
81: int midisyn_ioctl(void *, u_long, caddr_t, int, struct proc *);
82:
83: struct midi_hw_if midisyn_hw_if = {
84: midisyn_open,
85: midisyn_close,
86: midisyn_output,
87: NULL, /* flush */
88: midisyn_getinfo,
89: midisyn_ioctl,
90: };
91:
92: static int midi_lengths[] = { 3,3,3,3,2,2,3,1 };
93: /* Number of bytes in a MIDI command, including status */
94: #define MIDI_LENGTH(d) (midi_lengths[((d) >> 4) & 7])
95:
96: int
97: midisyn_open(addr, flags, iintr, ointr, arg)
98: void *addr;
99: int flags;
100: void (*iintr)(void *, int);
101: void (*ointr)(void *);
102: void *arg;
103: {
104: midisyn *ms = addr;
105:
106: DPRINTF(("midisyn_open: ms=%p ms->mets=%p\n", ms, ms->mets));
107: if (ms->mets->open)
108: return (ms->mets->open(ms, flags));
109: else
110: return (0);
111: }
112:
113: void
114: midisyn_close(addr)
115: void *addr;
116: {
117: midisyn *ms = addr;
118: struct midisyn_methods *fs;
119: int v;
120:
121: DPRINTF(("midisyn_close: ms=%p ms->mets=%p\n", ms, ms->mets));
122: fs = ms->mets;
123: for (v = 0; v < ms->nvoice; v++)
124: if (ms->voices[v].inuse) {
125: fs->noteoff(ms, v, 0, 0);
126: midisyn_freevoice(ms, v);
127: }
128: if (fs->close)
129: fs->close(ms);
130: }
131:
132: void
133: midisyn_getinfo(addr, mi)
134: void *addr;
135: struct midi_info *mi;
136: {
137: midisyn *ms = addr;
138:
139: mi->name = ms->name;
140: mi->props = 0;
141: }
142:
143: int
144: midisyn_ioctl(maddr, cmd, addr, flag, p)
145: void *maddr;
146: u_long cmd;
147: caddr_t addr;
148: int flag;
149: struct proc *p;
150: {
151: midisyn *ms = maddr;
152:
153: if (ms->mets->ioctl)
154: return (ms->mets->ioctl(ms, cmd, addr, flag, p));
155: else
156: return (EINVAL);
157: }
158:
159: int
160: midisyn_findvoice(ms, chan, note)
161: midisyn *ms;
162: int chan, note;
163: {
164: u_int cn;
165: int v;
166:
167: if (!(ms->flags & MS_DOALLOC))
168: return (chan);
169: cn = MS_CHANNOTE(chan, note);
170: for (v = 0; v < ms->nvoice; v++)
171: if (ms->voices[v].chan_note == cn && ms->voices[v].inuse)
172: return (v);
173: return (-1);
174: }
175:
176: void
177: midisyn_attach(sc, ms)
178: struct midi_softc *sc;
179: midisyn *ms;
180: {
181: if (ms->flags & MS_DOALLOC) {
182: ms->voices = malloc(ms->nvoice * sizeof (struct voice),
183: M_DEVBUF, M_WAITOK);
184: memset(ms->voices, 0, ms->nvoice * sizeof (struct voice));
185: ms->seqno = 1;
186: if (ms->mets->allocv == 0)
187: ms->mets->allocv = &midisyn_allocvoice;
188: }
189: sc->hw_if = &midisyn_hw_if;
190: sc->hw_hdl = ms;
191: DPRINTF(("midisyn_attach: ms=%p\n", sc->hw_hdl));
192: }
193:
194: void
195: midisyn_freevoice(ms, voice)
196: midisyn *ms;
197: int voice;
198: {
199: if (!(ms->flags & MS_DOALLOC))
200: return;
201: ms->voices[voice].inuse = 0;
202: }
203:
204: int
205: midisyn_allocvoice(ms, chan, note)
206: midisyn *ms;
207: u_int32_t chan, note;
208: {
209: int bestv, v;
210: u_int bestseq, s;
211:
212: if (!(ms->flags & MS_DOALLOC))
213: return (chan);
214: /* Find a free voice, or if no free voice is found the oldest. */
215: bestv = 0;
216: bestseq = ms->voices[0].seqno + (ms->voices[0].inuse ? 0x40000000 : 0);
217: for (v = 1; v < ms->nvoice; v++) {
218: s = ms->voices[v].seqno;
219: if (ms->voices[v].inuse)
220: s += 0x40000000;
221: if (s < bestseq) {
222: bestseq = s;
223: bestv = v;
224: }
225: }
226: DPRINTFN(10,("midisyn_allocvoice: v=%d seq=%d cn=%x inuse=%d\n",
227: bestv, ms->voices[bestv].seqno,
228: ms->voices[bestv].chan_note,
229: ms->voices[bestv].inuse));
230: #ifdef AUDIO_DEBUG
231: if (ms->voices[bestv].inuse)
232: DPRINTFN(1,("midisyn_allocvoice: steal %x\n",
233: ms->voices[bestv].chan_note));
234: #endif
235: ms->voices[bestv].chan_note = MS_CHANNOTE(chan, note);
236: ms->voices[bestv].seqno = ms->seqno++;
237: ms->voices[bestv].inuse = 1;
238: return (bestv);
239: }
240:
241: int
242: midisyn_output(addr, b)
243: void *addr;
244: int b;
245: {
246: midisyn *ms = addr;
247: u_int8_t status, chan;
248: int voice = 0; /* initialize to keep gcc quiet */
249: struct midisyn_methods *fs;
250: u_int32_t note, vel;
251:
252: DPRINTF(("midisyn_output: ms=%p b=0x%02x\n", ms, b));
253: fs = ms->mets;
254: if (ms->pos < 0) {
255: /* Doing SYSEX */
256: DPRINTF(("midisyn_output: sysex 0x%02x\n", b));
257: if (fs->sysex)
258: fs->sysex(ms, b);
259: if (b == MIDI_SYSEX_END)
260: ms->pos = 0;
261: return (0);
262: }
263: if (ms->pos == 0 && !MIDI_IS_STATUS(b))
264: ms->pos++; /* repeat last status byte */
265: ms->buf[ms->pos++] = b;
266: status = ms->buf[0];
267: if (ms->pos < MIDI_LENGTH(status))
268: return (0);
269: /* Decode the MIDI command */
270: chan = MIDI_GET_CHAN(status);
271: note = ms->buf[1];
272: if (ms->flags & MS_FREQXLATE)
273: note = midisyn_note_to_freq(note);
274: vel = ms->buf[2];
275: switch (MIDI_GET_STATUS(status)) {
276: case MIDI_NOTEOFF:
277: voice = midisyn_findvoice(ms, chan, ms->buf[1]);
278: if (voice >= 0) {
279: fs->noteoff(ms, voice, note, vel);
280: midisyn_freevoice(ms, voice);
281: }
282: break;
283: case MIDI_NOTEON:
284: voice = fs->allocv(ms, chan, ms->buf[1]);
285: fs->noteon(ms, voice, note, vel);
286: break;
287: case MIDI_KEY_PRESSURE:
288: if (fs->keypres) {
289: voice = midisyn_findvoice(ms, voice, ms->buf[1]);
290: if (voice >= 0)
291: fs->keypres(ms, voice, note, vel);
292: }
293: break;
294: case MIDI_CTL_CHANGE:
295: if (fs->ctlchg)
296: fs->ctlchg(ms, chan, ms->buf[1], vel);
297: break;
298: case MIDI_PGM_CHANGE:
299: if (fs->pgmchg)
300: fs->pgmchg(ms, chan, ms->buf[1]);
301: break;
302: case MIDI_CHN_PRESSURE:
303: if (fs->chnpres) {
304: voice = midisyn_findvoice(ms, chan, ms->buf[1]);
305: if (voice >= 0)
306: fs->chnpres(ms, voice, note);
307: }
308: break;
309: case MIDI_PITCH_BEND:
310: if (fs->pitchb) {
311: voice = midisyn_findvoice(ms, chan, ms->buf[1]);
312: if (voice >= 0)
313: fs->pitchb(ms, chan, note, vel);
314: }
315: break;
316: case MIDI_SYSTEM_PREFIX:
317: if (fs->sysex)
318: fs->sysex(ms, status);
319: ms->pos = -1;
320: return (0);
321: }
322: ms->pos = 0;
323: return (0);
324: }
325:
326: /*
327: * Convert a MIDI note to the corresponding frequency.
328: * The frequency is scaled by 2^16.
329: */
330: u_int32_t
331: midisyn_note_to_freq(note)
332: int note;
333: {
334: int o, n, f;
335: #define BASE_OCTAVE 5
336: static u_int32_t notes[] = {
337: 17145893, 18165441, 19245614, 20390018, 21602472, 22887021,
338: 24247954, 25689813, 27217409, 28835840, 30550508, 32367136
339: };
340:
341:
342: o = note / 12;
343: n = note % 12;
344:
345: f = notes[n];
346:
347: if (o < BASE_OCTAVE)
348: f >>= (BASE_OCTAVE - o);
349: else if (o > BASE_OCTAVE)
350: f <<= (o - BASE_OCTAVE);
351: return (f);
352: }
353:
354: u_int32_t
355: midisyn_finetune(base_freq, bend, range, vibrato_cents)
356: u_int32_t base_freq;
357: int bend;
358: int range;
359: int vibrato_cents;
360: {
361: static u_int16_t semitone_tuning[24] =
362: {
363: /* 0 */ 10000, 10595, 11225, 11892, 12599, 13348, 14142, 14983,
364: /* 8 */ 15874, 16818, 17818, 18877, 20000, 21189, 22449, 23784,
365: /* 16 */ 25198, 26697, 28284, 29966, 31748, 33636, 35636, 37755
366: };
367: static u_int16_t cent_tuning[100] =
368: {
369: /* 0 */ 10000, 10006, 10012, 10017, 10023, 10029, 10035, 10041,
370: /* 8 */ 10046, 10052, 10058, 10064, 10070, 10075, 10081, 10087,
371: /* 16 */ 10093, 10099, 10105, 10110, 10116, 10122, 10128, 10134,
372: /* 24 */ 10140, 10145, 10151, 10157, 10163, 10169, 10175, 10181,
373: /* 32 */ 10187, 10192, 10198, 10204, 10210, 10216, 10222, 10228,
374: /* 40 */ 10234, 10240, 10246, 10251, 10257, 10263, 10269, 10275,
375: /* 48 */ 10281, 10287, 10293, 10299, 10305, 10311, 10317, 10323,
376: /* 56 */ 10329, 10335, 10341, 10347, 10353, 10359, 10365, 10371,
377: /* 64 */ 10377, 10383, 10389, 10395, 10401, 10407, 10413, 10419,
378: /* 72 */ 10425, 10431, 10437, 10443, 10449, 10455, 10461, 10467,
379: /* 80 */ 10473, 10479, 10485, 10491, 10497, 10503, 10509, 10515,
380: /* 88 */ 10521, 10528, 10534, 10540, 10546, 10552, 10558, 10564,
381: /* 96 */ 10570, 10576, 10582, 10589
382: };
383: u_int32_t amount;
384: int negative, semitones, cents, multiplier;
385:
386: if (range == 0)
387: return base_freq;
388:
389: if (base_freq == 0)
390: return base_freq;
391:
392: if (range >= 8192)
393: range = 8192;
394:
395: bend = bend * range / 8192;
396: bend += vibrato_cents;
397:
398: if (bend == 0)
399: return base_freq;
400:
401: if (bend < 0) {
402: bend = -bend;
403: negative = 1;
404: } else
405: negative = 0;
406:
407: if (bend > range)
408: bend = range;
409:
410: multiplier = 1;
411: while (bend > 2399) {
412: multiplier *= 4;
413: bend -= 2400;
414: }
415:
416: semitones = bend / 100;
417: if (semitones > 23)
418: semitones = 23;
419: cents = bend % 100;
420:
421: amount = semitone_tuning[semitones] * multiplier * cent_tuning[cents]
422: / 10000;
423:
424: if (negative)
425: return (base_freq * 10000 / amount); /* Bend down */
426: else
427: return (base_freq * amount / 10000); /* Bend up */
428: }
429:
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to midisyn.c CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / dev