Aren
/
NetBSD
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
NetBSD/sys/dev/midisyn.c

781 lines
22 KiB
C
Raw Permalink Blame History

/* $NetBSD: midisyn.c,v 1.25 2019/05/08 13:40:17 isaki Exp $ */
/*
* Copyright (c) 1998, 2008 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Lennart Augustsson (augustss@NetBSD.org), and by Andrew Doran.
*
* 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/cdefs.h>
__KERNEL_RCSID(0, "$NetBSD: midisyn.c,v 1.25 2019/05/08 13:40:17 isaki Exp $");
#include <sys/param.h>
#include <sys/ioctl.h>
#include <sys/fcntl.h>
#include <sys/vnode.h>
#include <sys/select.h>
#include <sys/proc.h>
#include <sys/kmem.h>
#include <sys/systm.h>
#include <sys/syslog.h>
#include <sys/kernel.h>
#include <sys/audioio.h>
#include <sys/midiio.h>
#include <sys/device.h>
#include <dev/audio/audio_if.h>
#include <dev/midi_if.h>
#include <dev/midivar.h>
#include <dev/midisynvar.h>
#ifdef AUDIO_DEBUG
#define DPRINTF(x) if (midisyndebug) printf x
#define DPRINTFN(n,x) if (midisyndebug >= (n)) printf x
int midisyndebug = 0;
#else
#define DPRINTF(x)
#define DPRINTFN(n,x)
#endif
static int midisyn_findvoice(midisyn *, int, int);
static void midisyn_freevoice(midisyn *, int);
static uint_fast16_t midisyn_allocvoice(midisyn *, uint_fast8_t, uint_fast8_t);
static void midisyn_attackv_vel(midisyn *, uint_fast16_t, midipitch_t,
int16_t, uint_fast8_t);
static midictl_notify midisyn_notify;
static midipitch_t midisyn_clamp_pitch(midipitch_t);
static int16_t midisyn_adj_level(midisyn *, uint_fast8_t);
static midipitch_t midisyn_adj_pitch(midisyn *, uint_fast8_t);
static void midisyn_chan_releasev(midisyn *, uint_fast8_t, uint_fast8_t);
static void midisyn_upd_level(midisyn *, uint_fast8_t);
static void midisyn_upd_pitch(midisyn *, uint_fast8_t);
static int midisyn_open(void *, int,
void (*iintr)(void *, int),
void (*ointr)(void *), void *arg);
static void midisyn_close(void *);
static int midisyn_sysrt(void *, int);
static void midisyn_getinfo(void *, struct midi_info *);
static int midisyn_ioctl(void *, u_long, void *, int, struct lwp *);
static void midisyn_get_locks(void *, kmutex_t **, kmutex_t **);
const struct midi_hw_if midisyn_hw_if = {
midisyn_open,
midisyn_close,
midisyn_sysrt,
midisyn_getinfo,
midisyn_ioctl,
midisyn_get_locks,
};
static int midisyn_channelmsg(void *, int, int, u_char *, int);
static int midisyn_commonmsg(void *, int, u_char *, int);
static int midisyn_sysex(void *, u_char *, int);
struct midi_hw_if_ext midisyn_hw_if_ext = {
.channel = midisyn_channelmsg,
.common = midisyn_commonmsg,
.sysex = midisyn_sysex,
};
struct channelstate { /* dyamically allocated in open() on account of size */
/* volume state components in centibels; just sum for overall level */
int16_t volume;
int16_t expression;
/* pitch state components in midipitch units; sum for overall effect */
midipitch_t bend;
midipitch_t tuning_fine;
midipitch_t tuning_coarse;
/* used by bend handlers */
int16_t bendraw;
int16_t pendingreset;
/* rearrange as more controls supported - 16 bits should last for a while */
#define PEND_VOL 1
#define PEND_EXP 2
#define PEND_LEVEL (PEND_VOL|PEND_EXP)
#define PEND_PBS 4
#define PEND_TNF 8
#define PEND_TNC 16
#define PEND_PITCH (PEND_PBS|PEND_TNF|PEND_TNC)
#define PEND_ALL (PEND_LEVEL|PEND_PITCH)
};
static int
midisyn_open(void *addr, int flags, void (*iintr)(void *, int),
void (*ointr)(void *), void *arg)
{
midisyn *ms = addr;
int rslt, error;
uint_fast8_t chan;
KASSERT(ms->lock != NULL);
KASSERT(mutex_owned(ms->lock));
DPRINTF(("midisyn_open: ms=%p ms->mets=%p\n", ms, ms->mets));
mutex_exit(ms->lock);
ms->ctl.lock = ms->lock;
error = midictl_open(&ms->ctl);
if (error != 0) {
mutex_enter(ms->lock);
return error;
}
ms->chnstate = kmem_alloc(MIDI_MAX_CHANS * sizeof(*ms->chnstate),
KM_SLEEP); /* init'd by RESET below */
mutex_enter(ms->lock);
rslt = 0;
if (ms->mets->open)
rslt = (ms->mets->open(ms, flags));
/*
* Make the right initial things happen by faking receipt of RESET on
* all channels. The hw driver's ctlnotice() will be called in turn.
*/
for ( chan = 0 ; chan < MIDI_MAX_CHANS ; ++ chan )
midisyn_notify(ms, MIDICTL_RESET, chan, 0);
return rslt;
}
static void
midisyn_close(void *addr)
{
midisyn *ms = addr;
struct midisyn_methods *fs;
int chan;
KASSERT(mutex_owned(ms->lock));
DPRINTF(("midisyn_close: ms=%p ms->mets=%p\n", ms, ms->mets));
fs = ms->mets;
for (chan = 0; chan < MIDI_MAX_CHANS; chan++)
midisyn_notify(ms, MIDICTL_SOUND_OFF, chan, 0);
if (fs->close)
fs->close(ms);
mutex_exit(ms->lock);
midictl_close(&ms->ctl);
kmem_free(ms->chnstate, MIDI_MAX_CHANS * sizeof(*ms->chnstate));
mutex_enter(ms->lock);
}
static void
midisyn_getinfo(void *addr, struct midi_info *mi)
{
midisyn *ms = addr;
KASSERT(mutex_owned(ms->lock));
mi->name = ms->name;
/*
* I was going to add a property here to suppress midi(4)'s warning
* about an output device that uses no transmit interrupt, on the
* assumption that as an onboard synth we handle "output" internally
* with nothing like the 320 us per byte busy wait of a dumb UART.
* Then I noticed that opl (at least as currently implemented) seems
* to need 40 us busy wait to set each register on an OPL2, and sets
* about 21 registers for every note-on. (Half of that is patch loading
* and could probably be reduced by different management of voices and
* patches.) For now I won't bother suppressing that warning....
*/
mi->props = 0;
midi_register_hw_if_ext(&midisyn_hw_if_ext);
}
static void
midisyn_get_locks(void *addr, kmutex_t **intr, kmutex_t **proc)
{
midisyn *ms = addr;
*intr = ms->lock;
*proc = NULL;
}
static int
midisyn_ioctl(void *maddr, u_long cmd, void *addr, int flag, struct lwp *l)
{
midisyn *ms = maddr;
KASSERT(mutex_owned(ms->lock));
if (ms->mets->ioctl)
return (ms->mets->ioctl(ms, cmd, addr, flag, l));
else
return (EINVAL);
}
static int
midisyn_findvoice(midisyn *ms, int chan, int note)
{
u_int cn;
int v;
KASSERT(mutex_owned(ms->lock));
cn = MS_CHANNOTE(chan, note);
for (v = 0; v < ms->nvoice; v++)
if (ms->voices[v].chan_note == cn && ms->voices[v].inuse)
return (v);
return (-1);
}
void
midisyn_init(midisyn *ms)
{
KASSERT(ms->lock != NULL);
/*
* XXX there should be a way for this function to indicate failure
* (other than panic) if some preconditions aren't met, for example
* if some nonoptional methods are missing.
*/
if (ms->mets->allocv == 0) {
ms->voices = kmem_zalloc(ms->nvoice * sizeof(struct voice),
KM_SLEEP);
ms->seqno = 1;
ms->mets->allocv = midisyn_allocvoice;
}
if (ms->mets->attackv_vel == 0 && ms->mets->attackv != 0)
ms->mets->attackv_vel = midisyn_attackv_vel;
ms->ctl = (midictl) {
.base_channel = 16,
.cookie = ms,
.notify = midisyn_notify
};
DPRINTF(("midisyn_init: ms=%p\n", ms));
}
static void
midisyn_freevoice(midisyn *ms, int voice)
{
KASSERT(mutex_owned(ms->lock));
if (ms->mets->allocv != midisyn_allocvoice)
return;
ms->voices[voice].inuse = 0;
}
static uint_fast16_t
midisyn_allocvoice(midisyn *ms, uint_fast8_t chan, uint_fast8_t note)
{
int bestv, v;
u_int bestseq, s;
KASSERT(mutex_owned(ms->lock));
/* Find a free voice, or if no free voice is found the oldest. */
bestv = 0;
bestseq = ms->voices[0].seqno + (ms->voices[0].inuse ? 0x40000000 : 0);
for (v = 1; v < ms->nvoice; v++) {
s = ms->voices[v].seqno;
if (ms->voices[v].inuse)
s += 0x40000000;
if (s < bestseq) {
bestseq = s;
bestv = v;
}
}
DPRINTFN(10,("midisyn_allocvoice: v=%d seq=%d cn=%x inuse=%d\n",
bestv, ms->voices[bestv].seqno,
ms->voices[bestv].chan_note,
ms->voices[bestv].inuse));
#ifdef AUDIO_DEBUG
if (ms->voices[bestv].inuse)
DPRINTFN(1,("midisyn_allocvoice: steal %x\n",
ms->voices[bestv].chan_note));
#endif
ms->voices[bestv].chan_note = MS_CHANNOTE(chan, note);
ms->voices[bestv].seqno = ms->seqno++;
ms->voices[bestv].inuse = 1;
return (bestv);
}
/* dummy attackv_vel that just adds vel into level for simple drivers */
static void
midisyn_attackv_vel(midisyn *ms, uint_fast16_t voice, midipitch_t mp,
int16_t level_cB, uint_fast8_t vel)
{
KASSERT(mutex_owned(ms->lock));
ms->voices[voice].velcB = midisyn_vol2cB((uint_fast16_t)vel << 7);
ms->mets->attackv(ms, voice, mp, level_cB + ms->voices[voice].velcB);
}
static int
midisyn_sysrt(void *addr, int b)
{
return 0;
}
static int
midisyn_channelmsg(void *addr, int status, int chan, u_char *buf, int len)
{
midisyn *ms = addr;
int voice = 0; /* initialize to keep gcc quiet */
struct midisyn_methods *fs;
KASSERT(mutex_owned(ms->lock));
DPRINTF(("midisyn_channelmsg: ms=%p status=%#02x chan=%d\n",
ms, status, chan));
fs = ms->mets;
switch (status) {
case MIDI_NOTEOFF:
/*
* for a device that leaves voice allocation to us--and that's
* all of 'em at the moment--the voice and release velocity
* should be the only necessary arguments to noteoff. what use
* are they making of note? checking... None. Cool.
* IF there is ever a device added that does its own allocation,
* extend the interface; this findvoice won't be what to do...
*/
voice = midisyn_findvoice(ms, chan, buf[1]);
if (voice >= 0) {
fs->releasev(ms, voice, buf[2]);
midisyn_freevoice(ms, voice);
}
break;
case MIDI_NOTEON:
/*
* what's called for here, given current drivers, is an i/f
* where midisyn computes a volume from vel*volume*expression*
* mastervolume and passes that result as a single arg. It can
* evolve later to support drivers that expose some of those
* bits separately (e.g. a driver could expose a mixer register
* on its sound card and use that for mastervolume).
*/
voice = fs->allocv(ms, chan, buf[1]);
ms->voices[voice].velcB = 0; /* assume driver handles vel */
fs->attackv_vel(ms, voice,
midisyn_clamp_pitch(MIDIPITCH_FROM_KEY(buf[1]) +
midisyn_adj_pitch(ms, chan)),
midisyn_adj_level(ms,chan), buf[2]);
break;
case MIDI_KEY_PRESSURE:
/*
* unimplemented by the existing drivers. if we are doing
* voice allocation, find the voice that corresponds to this
* chan/note and define a method that passes the voice and
* pressure to the driver ... not the note, /it/ doesn't matter.
* For a driver that does its own allocation, a different
* method may be needed passing pressure, chan, note so it can
* find the right voice on its own. Be sure that whatever is
* done here is undone when midisyn_notify sees MIDICTL_RESET.
*/
break;
case MIDI_CTL_CHANGE:
midictl_change(&ms->ctl, chan, buf+1);
break;
case MIDI_PGM_CHANGE:
if (fs->pgmchg)
fs->pgmchg(ms, chan, buf[1]);
break;
case MIDI_CHN_PRESSURE:
/*
* unimplemented by the existing drivers. if driver exposes no
* distinct method, can use KEY_PRESSURE method for each voice
* on channel. Be sure that whatever is
* done here is undone when midisyn_notify sees MIDICTL_RESET.
*/
break;
case MIDI_PITCH_BEND:
/*
* Will work for most drivers that simply render the midipitch
* as we pass it (but not cms, which chops all the bits after
* the note number and then computes its own pitch :( ). If the
* driver has a repitchv method for voices already sounding, so
* much the better.
* The bending logic lives in the handler for bend sensitivity,
* so fake a change to that to kick it off.
*/
ms->chnstate[chan].bendraw = buf[2]<<7 | buf[1];
ms->chnstate[chan].bendraw -= MIDI_BEND_NEUTRAL;
midisyn_notify(ms, MIDICTL_RPN, chan,
MIDI_RPN_PITCH_BEND_SENSITIVITY);
break;
}
return 0;
}
static int
midisyn_commonmsg(void *addr, int status, u_char *buf, int len)
{
return 0;
}
static int
midisyn_sysex(void *addr, u_char *buf, int len)
{
/*
* unimplemented by existing drivers. it is surely more sensible
* to do some parsing of well-defined sysex messages here, either
* handling them internally or calling specific methods on the
* driver after parsing out the details, than to ask every driver
* to deal with sysex messages poked at it a byte at a time.
*/
return 0;
}
static void
midisyn_notify(void *cookie, midictl_evt evt,
uint_fast8_t chan, uint_fast16_t key)
{
struct midisyn *ms;
int drvhandled;
ms = (struct midisyn *)cookie;
KASSERT(mutex_owned(ms->lock));
drvhandled = 0;
if ( ms->mets->ctlnotice )
drvhandled = ms->mets->ctlnotice(ms, evt, chan, key);
switch ( evt | key ) {
case MIDICTL_RESET:
/*
* Re-read all ctls we use, revert pitchbend state.
* Can do it by faking change notifications.
*/
ms->chnstate[chan].pendingreset |= PEND_ALL;
midisyn_notify(ms, MIDICTL_CTLR, chan,
MIDI_CTRL_CHANNEL_VOLUME_MSB);
midisyn_notify(ms, MIDICTL_CTLR, chan,
MIDI_CTRL_EXPRESSION_MSB);
ms->chnstate[chan].bendraw = 0; /* MIDI_BEND_NEUTRAL - itself */
midisyn_notify(ms, MIDICTL_RPN, chan,
MIDI_RPN_PITCH_BEND_SENSITIVITY);
midisyn_notify(ms, MIDICTL_RPN, chan,
MIDI_RPN_CHANNEL_FINE_TUNING);
midisyn_notify(ms, MIDICTL_RPN, chan,
MIDI_RPN_CHANNEL_COARSE_TUNING);
break;
case MIDICTL_NOTES_OFF:
if ( drvhandled )
break;
/* releasev all voices sounding on chan; use normal vel 64 */
midisyn_chan_releasev(ms, chan, 64);
break;
case MIDICTL_SOUND_OFF:
if ( drvhandled )
break;
/* releasev all voices sounding on chan; use max vel 127 */
/* it is really better for driver to handle this, instantly */
midisyn_chan_releasev(ms, chan, 127);
break;
case MIDICTL_CTLR | MIDI_CTRL_CHANNEL_VOLUME_MSB:
ms->chnstate[chan].pendingreset &= ~PEND_VOL;
if ( drvhandled ) {
ms->chnstate[chan].volume = 0;
break;
}
ms->chnstate[chan].volume = midisyn_vol2cB(
midictl_read(&ms->ctl, chan, key, 100<<7));
midisyn_upd_level(ms, chan);
break;
case MIDICTL_CTLR | MIDI_CTRL_EXPRESSION_MSB:
ms->chnstate[chan].pendingreset &= ~PEND_EXP;
if ( drvhandled ) {
ms->chnstate[chan].expression = 0;
break;
}
ms->chnstate[chan].expression = midisyn_vol2cB(
midictl_read(&ms->ctl, chan, key, 16383));
midisyn_upd_level(ms, chan);
break;
/*
* SOFT_PEDAL: supporting this will be trickier; must apply only
* to notes subsequently struck, and must remember which voices
* they are for follow-on adjustments. For another day....
*/
case MIDICTL_RPN | MIDI_RPN_PITCH_BEND_SENSITIVITY:
ms->chnstate[chan].pendingreset &= ~PEND_PBS;
if ( drvhandled )
ms->chnstate[chan].bend = 0;
else {
uint16_t w;
int8_t semis, cents;
w = midictl_rpn_read(&ms->ctl, chan, key, 2<<7);
semis = w>>7;
cents = w&0x7f;
/*
* Mathematically, multiply semis by
* MIDIPITCH_SEMITONE*bendraw/8192. Practically, avoid
* shifting significant bits off by observing that
* MIDIPITCH_SEMITONE == 1<<14 and 8192 == 1<<13, so
* just take semis*bendraw<<1. Do the same with cents
* except <<1 becomes /50 (but rounded).
*/
ms->chnstate[chan].bend =
( ms->chnstate[chan].bendraw * semis ) << 1;
ms->chnstate[chan].bend +=
((ms->chnstate[chan].bendraw * cents)/25 + 1) >> 1;
midisyn_upd_pitch(ms, chan);
}
break;
case MIDICTL_RPN | MIDI_RPN_CHANNEL_FINE_TUNING:
if ( drvhandled )
ms->chnstate[chan].tuning_fine = 0;
else {
midipitch_t mp;
mp = midictl_rpn_read(&ms->ctl, chan, key, 8192);
/*
* Mathematically, subtract 8192 and scale by
* MIDIPITCH_SEMITONE/8192. Practically, subtract 8192
* and then << 1.
*/
ms->chnstate[chan].tuning_fine = ( mp - 8192 ) << 1;
midisyn_upd_pitch(ms, chan);
}
break;
case MIDICTL_RPN | MIDI_RPN_CHANNEL_COARSE_TUNING:
ms->chnstate[chan].pendingreset &= ~PEND_TNC;
if ( drvhandled )
ms->chnstate[chan].tuning_coarse = 0;
else {
midipitch_t mp;
/*
* By definition only the MSB of this parameter is used.
* Subtract 64 for a signed count of semitones; << 14
* will convert to midipitch scale.
*/
mp = midictl_rpn_read(&ms->ctl, chan, key, 64<<7) >> 7;
ms->chnstate[chan].tuning_coarse = ( mp - 64 ) << 14;
midisyn_upd_pitch(ms, chan);
}
break;
}
}
static midipitch_t
midisyn_clamp_pitch(midipitch_t mp)
{
if ( mp <= 0 )
return 0;
if ( mp >= MIDIPITCH_MAX )
return MIDIPITCH_MAX;
return mp;
}
static int16_t
midisyn_adj_level(midisyn *ms, uint_fast8_t chan)
{
int32_t level;
KASSERT(mutex_owned(ms->lock));
level = ms->chnstate[chan].volume + ms->chnstate[chan].expression;
if ( level <= INT16_MIN )
return INT16_MIN;
return level;
}
static midipitch_t
midisyn_adj_pitch(midisyn *ms, uint_fast8_t chan)
{
struct channelstate *s = ms->chnstate + chan;
KASSERT(mutex_owned(ms->lock));
return s->bend + s->tuning_fine +s->tuning_coarse;
}
#define VOICECHAN_FOREACH_BEGIN(ms,vp,ch) \
{ \
struct voice *vp, *_end_##vp; \
for (vp=(ms)->voices,_end_##vp=vp+(ms)->nvoice; \
vp < _end_##vp; ++ vp) { \
if ( !vp->inuse ) \
continue; \
if ( MS_GETCHAN(vp) == (ch) ) \
; \
else \
continue;
#define VOICECHAN_FOREACH_END }}
static void
midisyn_chan_releasev(midisyn *ms, uint_fast8_t chan, uint_fast8_t vel)
{
KASSERT(mutex_owned(ms->lock));
VOICECHAN_FOREACH_BEGIN(ms,vp,chan)
ms->mets->releasev(ms, vp - ms->voices, vel);
midisyn_freevoice(ms, vp - ms->voices);
VOICECHAN_FOREACH_END
}
static void
midisyn_upd_level(midisyn *ms, uint_fast8_t chan)
{
int32_t level;
int16_t chan_level;
KASSERT(mutex_owned(ms->lock));
if ( NULL == ms->mets->relevelv )
return;
if ( ms->chnstate[chan].pendingreset & PEND_LEVEL )
return;
chan_level = midisyn_adj_level(ms, chan);
VOICECHAN_FOREACH_BEGIN(ms,vp,chan)
level = vp->velcB + chan_level;
ms->mets->relevelv(ms, vp - ms->voices,
level <= INT16_MIN ? INT16_MIN : level);
VOICECHAN_FOREACH_END
}
static void
midisyn_upd_pitch(midisyn *ms, uint_fast8_t chan)
{
midipitch_t chan_adj;
KASSERT(mutex_owned(ms->lock));
if ( NULL == ms->mets->repitchv )
return;
if ( ms->chnstate[chan].pendingreset & PEND_PITCH )
return;
chan_adj = midisyn_adj_pitch(ms, chan);
VOICECHAN_FOREACH_BEGIN(ms,vp,chan)
ms->mets->repitchv(ms, vp - ms->voices,
midisyn_clamp_pitch(chan_adj +
MIDIPITCH_FROM_KEY(vp->chan_note&0x7f)));
VOICECHAN_FOREACH_END
}
#undef VOICECHAN_FOREACH_END
#undef VOICECHAN_FOREACH_BEGIN
int16_t
midisyn_vol2cB(uint_fast16_t vol)
{
int16_t cB = 0;
int32_t v;
if ( 0 == vol )
return INT16_MIN;
/*
* Adjust vol to fall in the range 8192..16383. Each doubling is
* worth 12 dB.
*/
while ( vol < 8192 ) {
vol <<= 1;
cB -= 120;
}
v = vol; /* ensure evaluation in signed 32 bit below */
/*
* The GM vol-to-dB formula is dB = 40 log ( v / 127 ) for 7-bit v.
* The vol and expression controllers are in 14-bit space so the
* equivalent is 40 log ( v / 16256 ) - that is, MSB 127 LSB 0 because
* the LSB is commonly unused. MSB 127 LSB 127 would then be a tiny
* bit over.
* 1 dB resolution is a little coarser than we'd like, so let's shoot
* for centibels, i.e. 400 log ( v / 16256 ), and shift everything left
* as far as will fit in 32 bits, which turns out to be a shift of 22.
* This minimax polynomial approximation is good to about a centibel
* on the range 8192..16256, a shade worse (1.4 or so) above that.
* 26385/10166 is the 6th convergent of the coefficient for v^2.
*/
cB += ( v * ( 124828 - ( v * 26385 ) / 10166 ) - 1347349038 ) >> 22;
return cB;
}
/*
* MIDI RP-012 constitutes a MIDI Tuning Specification. The units are
* fractional-MIDIkeys, that is, the key number 00 - 7f left shifted
* 14 bits to provide a 14-bit fraction that divides each semitone. The
* whole thing is just a 21-bit number that is bent and tuned simply by
* adding and subtracting--the same offset is the same pitch change anywhere
* on the scale. One downside is that a cent is 163.84 of these units, so
* you can't expect a lengthy integer sum of cents to come out in tune; if you
* do anything in cents it is best to use them only for local adjustment of
* a pitch.
*
* This function converts a pitch in MIDItune units to Hz left-shifted 18 bits.
* That should leave you enough to shift down to whatever precision the hardware
* supports.
*
* Its prototype is exposed in <sys/midiio.h>.
*/
midihz18_t
midisyn_mp2hz18(midipitch_t mp)
{
int64_t t64a, t64b;
uint_fast8_t shift;
/*
* Scale from the logarithmic MIDI-Tuning units to Hz<<18. Uses the
* continued-fraction form of a 2/2 rational function derived to
* cover the highest octave (mt 1900544..2097151 or 74.00.00..7f.7f.7f
* in RP-012-speak, the dotted bits are 7 wide) to produce Hz shifted
* left just as far as the maximum Hz will fit in a uint32, which
* turns out to be 18. Just shift off the result for lower octaves.
* Fit is within 1/4 MIDI tuning unit throughout (disclaimer: the
* comparison relied on the double-precision log in libm).
*/
if ( 0 == mp )
return 2143236;
for ( shift = 0; mp < 1900544; ++ shift )
mp += MIDIPITCH_OCTAVE;
if ( 1998848 == mp )
return UINT32_C(2463438621) >> shift;
t64a = 0x5a1a0ee4; /* INT64_C(967879298788) gcc333: spurious warning */
t64a |= (int64_t)0xe1 << 32;
t64a /= mp - 1998848; /* here's why 1998848 is special-cased above ;) */
t64a += mp - 3704981;
t64b = 0x6763759d; /* INT64_C(8405905567872413) goofy warning again */
t64b |= (int64_t)0x1ddd20 << 32;
t64b /= t64a;
t64b += UINT32_C(2463438619);
return (uint32_t)t64b >> shift;
}
Reference in New Issue View Git Blame Copy Permalink