notation/public/jianpu/snd-1.js

// abc2svg - ABC to SVG translator
// @source: https://chiselapp.com/user/moinejf/repository/abc2svg
// Copyright (C) 2014-2023 Jean-Francois Moine - LGPL3+
//snd-1.js-file to include in html pages with abc2svg-1.js for playing
function AbcPlay(i_conf) {
    var conf = i_conf, init = {}, audio = ToAudio(), audio5, midi5, current, abcplay = {
        clear: audio.clear, add: audio.add, set_sfu: function (v) {
            if (v == undefined)
                return conf.sfu
            conf.sfu = v
        }, set_speed: function (v) {
            if (v == undefined)
                return conf.speed
            conf.new_speed = v
        }, set_vol: function (v) {
            if (v == undefined)
                return conf.gain; conf.gain = v
            if (current && current.set_vol)
                current.set_vol(v)
        }, play: play, stop: vf
    }
    function vf() { }
    function play(istart, i_iend, a_e) {
        init.istart = istart; init.i_iend = i_iend; init.a_e = a_e
        if (midi5)
            midi5.get_outputs(play2)
        else
            play2()
    }
    function play2(out) {
        var o
        if (!out)
            out = []
        o = audio5.get_outputs()
        if (o)
            Array.prototype.push.apply(out, o)
        if (out.length == 0) {
            if (conf.onend)
                conf.onend()
            return
        }
        if (out.length == 1) { o = 0 } else {
            o = -1
            var pr = "Use"
            for (var i = 0; i < out.length; i++)
                pr += "\n " + i + ": " + out[i]
            var res = window.prompt(pr, '0')
            if (res) {
                o = Number(res)
                if (isNaN(o) || o < 0 || o >= out.length)
                    o = -1
            }
            if (!res || o < 0) {
                if (conf.onend)
                    conf.onend()
                return
            }
        }
        current = out[o] == 'sf2' ? audio5 : midi5; abcplay.play = current.play; abcplay.stop = current.stop
        if (current.set_output)
            current.set_output(out[o]); abcplay.play(init.istart, init.i_iend, init.a_e)
    }
    conf.gain = 0.7; conf.speed = 1; (function () {
        var v
        try {
            if (!localStorage)
                return
        } catch (e) { return }
        if (!conf.sfu) {
            v = localStorage.getItem("sfu")
            if (v)
                conf.sfu = v
        }
        v = localStorage.getItem("volume")
        if (v)
            conf.gain = Number(v)
    })()
    if (typeof Midi5 == "function")
        midi5 = Midi5(conf)
    if (typeof Audio5 == "function")
        audio5 = Audio5(conf); return abcplay
}
if (typeof module == 'object' && typeof exports == 'object')
    exports.AbcPlay = AbcPlay
if (!abc2svg)
    var abc2svg = {}
function ToAudio() {
    return {
        add: function (first, voice_tb, cfmt) {
            var toaud = this, C = abc2svg.C, p_time = 0, abc_time = 0, play_fac = C.BLEN / 4 * 120 / 60, i, n, dt, d, v, s = first, rst = s, rst_fac, rsk = [], b_tim, b_typ
            function get_beat() {
                var s = first.p_v.meter
                if (!s.a_meter[0])
                    return C.BLEN / 4
                if (!s.a_meter[0].bot)
                    return (s.a_meter[1] && s.a_meter[1].top == '|') ? C.BLEN / 2 : C.BLEN / 4
                if (s.a_meter[0].bot == "8" && s.a_meter[0].top % 3 == 0)
                    return C.BLEN / 8 * 3
                return C.BLEN / s.a_meter[0].bot | 0
            }
            function def_beats() {
                var i, s2, s3, tim, last_d, beat = get_beat(), d = first.p_v.meter.wmeasure, nb = d / beat | 0, v = voice_tb.length, p_v = { id: "_beats", v: v, sym: { type: C.BLOCK, v: v, subtype: "midiprog", chn: 9, instr: 16384, ts_prev: first } }, s = { type: C.NOTE, v: v, p_v: p_v, dur: beat, nhd: 0, notes: [{ midi: 37 }] }
                for (s2 = first; s2; s2 = s2.ts_next) {
                    if (s2.bar_type && s2.time) {
                        nb = (2 * d - s2.time) / beat | 0
                        last_d = beat - s2.time
                        break
                    }
                }
                s2 = p_v.sym
                for (s3 = first; s3 && !s3.time; s3 = s3.ts_next) {
                    if (s3.type == C.TEMPO) {
                        s3 = Object.create(s3)
                        s3.v = v
                        s3.p_v = p_v
                        s3.prev = s3.ts_prev = s2
                        s2.next = s2.ts_next = s3
                        s2 = s3
                        play_fac = set_tempo(s2)
                        break
                    }
                }
                voice_tb[v] = p_v
                p_v.sym.p_v = p_v
                tim = abc_time = -d
                first.time = s2.time = tim
                if (s3)
                    p_v.sym.time = tim
                for (i = 0; i < nb; i++) {
                    s3 = Object.create(s)
                    s3.time = tim
                    s3.prev = s2
                    s2.next = s3
                    s3.ts_prev = s2
                    s2.ts_next = s3
                    s2 = s3
                    if (last_d && i == nb - 1) { s3.dur = s3.dur_orig = s3.notes[0].dur = last_d }
                    tim += beat
                }
                s2.ts_next = first.ts_next
                s2.ts_next.ts_prev = s2
                first.ts_next = p_v.sym
            }
            function build_parts(first) {
                var i, j, c, n, v, s = first, p = s.parts, st = [], r = ""
                for (i = 0; i < p.length; i++) {
                    c = p[i]
                    switch (c) {
                        case '.': continue
                        case '(': st.push(r.length)
                            continue
                        case ')': j = st.pop()
                            if (j == undefined)
                                j = r.length
                            continue
                    }
                    if (c >= 'A' && c <= 'Z') {
                        j = r.length
                        r += c
                        continue
                    }
                    n = Number(c)
                    if (isNaN(n))
                        break
                    v = r.slice(j)
                    if (r.length + v.length * n > 128)
                        continue
                    while (--n > 0)
                        r += v
                }
                s.parts = r
                s.p_s = []
                while (1) {
                    if (!s.ts_next) {
                        s.part1 = first
                        break
                    }
                    s = s.ts_next
                    if (s.part) {
                        s.part1 = first
                        v = s.part.text[0]
                        for (i = 0; i < first.parts.length; i++) {
                            if (first.parts[i] == v)
                                first.p_s[i] = s
                        }
                    }
                }
            }
            function gen_grace(s) {
                var g, i, n, t, d, s2, next = s.next
                if (s.sappo) { d = C.BLEN / 16 } else if ((!next || next.type != C.NOTE) && s.prev && s.prev.type == C.NOTE) { d = s.prev.dur / 2 } else {
                    d = next.dur / 12
                    if (!(d & (d - 1)))
                        d = next.dur / 2
                    else
                        d = next.dur / 3
                    if (s.p_v.key.k_bagpipe)
                        d /= 2
                    next.time += d
                    next.dur -= d
                }
                n = 0
                for (g = s.extra; g; g = g.next)
                    n++
                d /= n * play_fac
                t = p_time
                for (g = s.extra; g; g = g.next) {
                    g.ptim = t
                    g.pdur = d
                    t += d
                }
            }
            function set_tempo(s) {
                var i, d = 0, n = s.tempo_notes.length
                for (i = 0; i < n; i++)
                    d += s.tempo_notes[i]
                return d * s.tempo / 60
            }
            function set_variant(s) {
                var d, n = s.text.match(/[1-8]-[2-9]|[1-9,.]|[^\s]+$/g)
                while (1) {
                    d = n.shift()
                    if (!d)
                        break
                    if (d[1] == '-')
                        for (i = d[0]; i <= d[2]; i++)
                            rsk[i] = s
                    else if (d >= '1' && d <= '9')
                        rsk[Number(d)] = s
                    else if (d != ',')
                        rsk.push(s)
                }
            }
            if (cfmt.chord)
                abc2svg.chord(first, voice_tb, cfmt)
            if (cfmt.playbeats)
                def_beats()
            if (s.parts)
                build_parts(s)
            rst_fac = play_fac
            while (s) {
                if (s.noplay) {
                    s = s.ts_next
                    continue
                }
                dt = s.time - abc_time
                if (dt != 0) {
                    p_time += dt / play_fac
                    abc_time = s.time
                }
                s.ptim = p_time
                if (s.part) {
                    rst = s
                    rst_fac = play_fac
                }
                switch (s.type) {
                    case C.BAR: if (s.time != b_tim) {
                        b_tim = s.time
                        b_typ = 0
                    }
                        if (s.text && rsk.length > 1 && s.text[0] != '1') {
                            if (b_typ & 1)
                                break
                            b_typ |= 1
                            set_variant(s)
                            play_fac = rst_fac
                            rst = rsk[0]
                        }
                        if (s.bar_type[0] == ':') {
                            if (b_typ & 2)
                                break
                            b_typ |= 2
                            s.rep_p = rst
                            if (rst == rsk[0])
                                s.rep_v = rsk
                        }
                        if (s.text) {
                            if (s.text[0] == '1') {
                                if (b_typ & 1)
                                    break
                                b_typ |= 1
                                s.rep_s = rsk = [rst]
                                if (rst.bar_type && rst.bar_type.slice(-1) != ':')
                                    rst.bar_type += ':'
                                set_variant(s)
                                rst_fac = play_fac
                            }
                        } else if (s.bar_type.slice(-1) == ':') {
                            if (b_typ & 4)
                                break
                            b_typ |= 4
                            rst = s
                            rst_fac = play_fac
                        } else if (s.rbstop == 2) {
                            if (b_typ & 8)
                                break
                            b_typ |= 8
                            rst = s
                            rst_fac = play_fac
                        }
                        break
                    case C.GRACE: if (s.time == 0 && abc_time == 0) {
                        dt = 0
                        if (s.sappo)
                            dt = C.BLEN / 16
                        else if (!s.next || s.next.type != C.NOTE)
                            dt = d / 2
                        abc_time -= dt
                    }
                        gen_grace(s)
                        break
                    case C.REST: case C.NOTE: d = s.dur
                        if (s.next && s.next.type == C.GRACE) {
                            dt = 0
                            if (s.next.sappo)
                                dt = C.BLEN / 16
                            else if (!s.next.next || s.next.next.type != C.NOTE)
                                dt = d / 2
                            s.next.time -= dt
                            d -= dt
                        }
                        d /= play_fac
                        s.pdur = d
                        v = s.v
                        break
                    case C.TEMPO: if (s.tempo)
                        play_fac = set_tempo(s)
                        break
                }
                s = s.ts_next
            }
        }
    }
}
abc2svg.play_next = function (po) {
    function do_tie(not_s, d) {
        var i, s = not_s.s, C = abc2svg.C, v = s.v, end_time = s.time + s.dur, repv = po.repv
        while (1) {
            s = s.ts_next
            if (!s || s.time > end_time)
                break
            if (s.type == C.BAR) {
                if (s.rep_p) {
                    if (!po.repn) {
                        s = s.rep_p
                        end_time = s.time
                    }
                }
                if (s.rep_s) {
                    if (!s.rep_s[repv])
                        break
                    s = s.rep_s[repv++]
                    end_time = s.time
                }
                while (s.ts_next && !s.ts_next.dur)
                    s = s.ts_next
                continue
            }
            if (s.time < end_time || !s.ti2)
                continue
            i = s.notes.length
            while (--i >= 0) {
                note = s.notes[i]
                if (note.tie_s == not_s) {
                    d += s.pdur / po.conf.speed
                    return note.tie_e ? do_tie(note, d) : d
                }
            }
        }
        return d
    }
    function set_ctrl(po, s2, t) {
        var i, p_v = s2.p_v, s = { subtype: "midictl", p_v: p_v, v: s2.v }
        for (i in p_v.midictl) {
            s.ctrl = Number(i)
            s.val = p_v.midictl[i]
            po.midi_ctrl(po, s, t)
        }
        for (s = p_v.sym; s != s2; s = s.next) {
            if (s.subtype == "midictl")
                po.midi_ctrl(po, s, t)
            else if (s.subtype == 'midiprog')
                po.midi_prog(po, s)
        }
        i = po.v_c[s2.v]
        if (i == undefined)
            po.v_c[s2.v] = i = s2.v < 9 ? s2.v : s2.v + 1
        if (po.c_i[i] == undefined)
            po.c_i[i] = 0
        po.p_v[s2.v] = true
    }
    function play_cont(po) {
        var d, i, st, m, note, g, s2, t, maxt, now, C = abc2svg.C, s = po.s_cur
        function var_end(s) {
            var i, s2, s3, a = s.rep_v || s.rep_s
            ti = 0
            for (i = 1; i < a.length; i++) {
                s2 = a[i]
                if (s2.time > ti) {
                    ti = s2.time
                    s3 = s2
                }
            }
            for (s = s3; s != po.s_end; s = s.ts_next) {
                if (s.time == ti)
                    continue
                if (s.rbstop == 2)
                    break
            }
            po.repv = 1
            return s
        }
        if (po.stop) {
            if (po.onend)
                po.onend(po.repv)
            return
        }
        while (s.noplay) {
            s = s.ts_next
            if (!s || s == po.s_end) {
                if (po.onend)
                    po.onend(po.repv)
                return
            }
        }
        t = po.stim + s.ptim / po.conf.speed
        now = po.get_time(po)
        if (po.conf.new_speed) {
            po.stim = now - (now - po.stim) * po.conf.speed / po.conf.new_speed
            po.conf.speed = po.conf.new_speed
            po.conf.new_speed = 0
            t = po.stim + s.ptim / po.conf.speed
        }
        maxt = t + po.tgen
        po.timouts = []
        while (1) {
            if (!po.p_v[s.v])
                set_ctrl(po, s, t)
            switch (s.type) {
                case C.BAR: s2 = null
                    if (s.rep_p) {
                        po.repv++
                        if (!po.repn && (!s.rep_v || po.repv <= s.rep_v.length)) {
                            s2 = s.rep_p
                            po.repn = true
                        } else {
                            if (s.rep_v)
                                s2 = var_end(s)
                            po.repn = false
                        }
                    }
                    if (s.rep_s) {
                        s2 = s.rep_s[po.repv]
                        if (s2) {
                            po.repn = false
                            if (s2 == s)
                                s2 = null
                        } else {
                            s2 = var_end(s)
                            if (s2 == po.s_end)
                                break
                        }
                    }
                    if (s.bar_type.slice(-1) == ':' && s.bar_type[0] != ':')
                        po.repv = 1
                    if (s2) {
                        po.stim += (s.ptim - s2.ptim) / po.conf.speed
                        s = s2
                        while (s && !s.dur)
                            s = s.ts_next
                        if (!s)
                            break
                        t = po.stim + s.ptim / po.conf.speed
                        break
                    }
                    if (!s.part1) {
                        while (s.ts_next && !s.ts_next.seqst) {
                            s = s.ts_next
                            if (s.part1)
                                break
                        }
                        if (!s.part1)
                            break
                    }
                default: if (s.part1 && po.i_p != undefined) {
                    s2 = s.part1.p_s[++po.i_p]
                    if (s2) {
                        po.stim += (s.ptim - s2.ptim) / po.conf.speed
                        s = s2
                        t = po.stim + s.ptim / po.conf.speed
                    } else { s = po.s_end }
                    po.repv = 1
                }
                    break
            }
            if (s && s != po.s_end) {
                switch (s.type) {
                    case C.BAR: break
                    case C.BLOCK: if (s.subtype == "midictl")
                        po.midi_ctrl(po, s, t)
                    else if (s.subtype == 'midiprog')
                        po.midi_prog(po, s)
                        break
                    case C.GRACE: for (g = s.extra; g; g = g.next) {
                        d = g.pdur / po.conf.speed
                        for (m = 0; m <= g.nhd; m++) {
                            note = g.notes[m]
                            if (!note.noplay)
                                po.note_run(po, g, note.midi, t + g.ptim - s.ptim, d)
                        }
                    }
                        break
                    case C.NOTE: case C.REST: d = s.pdur / po.conf.speed
                        if (s.type == C.NOTE) {
                            for (m = 0; m <= s.nhd; m++) {
                                note = s.notes[m]
                                if (note.tie_s || note.noplay)
                                    continue
                                po.note_run(po, s, note.midi, t, note.tie_e ? do_tie(note, d) : d)
                            }
                        }
                        if (po.onnote && s.istart) {
                            i = s.istart
                            st = (t - now) * 1000
                            po.timouts.push(setTimeout(po.onnote, st, i, true))
                            if (d > 2)
                                d -= .1
                            setTimeout(po.onnote, st + d * 1000, i, false)
                        }
                        break
                }
            }
            while (1) {
                if (!s || s == po.s_end || !s.ts_next) {
                    if (po.onend)
                        setTimeout(po.onend, (t - now + d) * 1000, po.repv)
                    po.s_cur = s
                    return
                }
                s = s.ts_next
                if (!s.noplay)
                    break
            }
            t = po.stim + s.ptim / po.conf.speed
            if (t > maxt)
                break
        }
        po.s_cur = s
        po.timouts.push(setTimeout(play_cont, (t - now) * 1000
            - 300, po))
    }
    function get_part(po) {
        var s, i, s_p
        for (s = po.s_cur; s; s = s.ts_prev) {
            if (s.parts) {
                po.i_p = -1
                return
            }
            s_p = s.part1
            if (!s_p || !s_p.p_s)
                continue
            for (i = 0; i < s_p.p_s.length; i++) {
                if (s_p.p_s[i] == s) {
                    po.i_p = i
                    return
                }
            }
        }
    }
    get_part(po)
    po.stim = po.get_time(po) + .3
        - po.s_cur.ptim * po.conf.speed
    po.p_v = []
    if (!po.repv)
        po.repv = 1
    play_cont(po)
}
if (typeof module == 'object' && typeof exports == 'object')
    exports.ToAudio = ToAudio
var abcsf2 = []
function Audio5(i_conf) {
    var po, conf = i_conf, empty = function () { }, errmsg, ac, gain, model, parser, presets, instr = [], params = [], rates = [], w_instr = 0
    var b64d = []
    function init_b64d() {
        var b64l = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/', l = b64l.length
        for (var i = 0; i < l; i++)
            b64d[b64l[i]] = i
        b64d['='] = 0
    }
    function b64dcod(s) {
        var i, t, dl, a, l = s.length, j = 0
        dl = l * 3 / 4
        if (s[l - 1] == '=') {
            if (s[l - 2] == '=')
                dl--
            dl--
            l -= 4
        }
        a = new Uint8Array(dl)
        for (i = 0; i < l; i += 4) {
            t = (b64d[s[i]] << 18) +
            (b64d[s[i + 1]] << 12) +
            (b64d[s[i + 2]] << 6) +
            b64d[s[i + 3]]
            a[j++] = (t >> 16) & 0xff
            a[j++] = (t >> 8) & 0xff
            a[j++] = t & 0xff
        }
        if (l != s.length) {
            t = (b64d[s[i]] << 18) +
            (b64d[s[i + 1]] << 12) +
            (b64d[s[i + 2]] << 6) +
            b64d[s[i + 3]]
            a[j++] = (t >> 16) & 0xff
            if (j < dl)
                a[j++] = (t >> 8) & 0xff
        }
        return a
    }
    function sample_cp(b, s) {
        var i, n, a = b.getChannelData(0)
        for (i = 0; i < s.length; i++)
            a[i] = s[i] / 196608
    }
    function sf2_create(instr, sf2par, sf2pre) {
        function get_instr(i) {
            var instrument = sf2par.instrument, zone = sf2par.instrumentZone, j = instrument[i].instrumentBagIndex, jl = instrument[i + 1] ? instrument[i + 1].instrumentBagIndex : zone.length, info = []
            while (j < jl) {
                instrumentGenerator = sf2par.createInstrumentGenerator_(zone, j)
                info.push({ generator: instrumentGenerator.generator, })
                j++
            }
            return { info: info }
        }
        var i, j, k, sid, gen, parm, gparm, sample, infos, sampleRate, scale, b = instr >> 7, p = instr % 128, pr = sf2pre
        rates[instr] = []
        for (i = 0; i < pr.length; i++) {
            gen = pr[i].header
            if (gen.preset == p && gen.bank == b)
                break
        }
        pr = pr[i]
        if (!pr) {
            errmsg('unknown instrument ' + b + ':' + p)
            return
        }
        pr = pr.info
        for (k = 0; k < pr.length; k++) {
            if (!pr[k].generator.instrument)
                continue
            gparm = null
            infos = get_instr(pr[k].generator.instrument.amount).info
            for (i = 0; i < infos.length; i++) {
                gen = infos[i].generator
                if (!gparm) { parm = gparm = { attack: .001, hold: .001, decay: .001, sustain: 0 } } else {
                    parm = Object.create(gparm)
                    if (!gen.sampleID)
                        gparm = parm
                }
                if (gen.attackVolEnv)
                    parm.attack = Math.pow(2, gen.attackVolEnv.amount / 1200)
                if (gen.holdVolEnv)
                    parm.hold = Math.pow(2, gen.holdVolEnv.amount / 1200)
                if (gen.decayVolEnv)
                    parm.decay = Math.pow(2, gen.decayVolEnv.amount / 1200) / 3
                if (gen.sustainVolEnv)
                    parm.sustain = gen.sustainVolEnv.amount / 1000
                if (gen.sampleModes && gen.sampleModes.amount & 1)
                    parm.sm = 1
                if (!gen.sampleID)
                    continue
                sid = gen.sampleID.amount
                sampleRate = sf2par.sampleHeader[sid].sampleRate
                sample = sf2par.sample[sid]
                parm.buffer = ac.createBuffer(1, sample.length, sampleRate)
                parm.hold += parm.attack
                parm.decay += parm.hold
                if (parm.sustain >= .4)
                    parm.sustain = 0.01
                else
                    parm.sustain = 1 - parm.sustain / .4
                sample_cp(parm.buffer, sample)
                if (parm.sm) {
                    parm.loopStart = sf2par.sampleHeader[sid].startLoop / sampleRate
                    parm.loopEnd = sf2par.sampleHeader[sid].endLoop / sampleRate
                }
                scale = (gen.scaleTuning ? gen.scaleTuning.amount : 100) / 100, tune = (gen.coarseTune ? gen.coarseTune.amount : 0) +
                    (gen.fineTune ? gen.fineTune.amount : 0) / 100 +
                    sf2par.sampleHeader[sid].pitchCorrection / 100 -
                    (gen.overridingRootKey ? gen.overridingRootKey.amount : sf2par.sampleHeader[sid].originalPitch)
                for (j = gen.keyRange.lo; j <= gen.keyRange.hi; j++) {
                    rates[instr][j] = Math.pow(Math.pow(2, 1 / 12), (j + tune) * scale)
                    params[instr][j] = parm
                }
            }
        }
    }
    function load_instr(instr) {
        w_instr++
        abc2svg.loadjs(conf.sfu + '/' + instr + '.js', function () {
            var sf2par = new sf2.Parser(b64dcod(abcsf2[instr]))
            sf2par.parse()
            var sf2pre = sf2par.getPresets()
            sf2_create(instr, sf2par, sf2pre)
            if (--w_instr == 0)
                play_start()
        }, function () {
            errmsg('could not find the instrument ' +
                ((instr / 128) | 0).toString() + '-' +
                (instr % 128).toString())
            if (--w_instr == 0)
                play_start()
        })
    }
    function def_instr(s, f, sf2par, sf2pre) {
        var i, bk = [], nv = -1, vb = 0
        s = s.p_v.sym
        while (s.ts_prev)
            s = s.ts_prev
        for (; s; s = s.ts_next) {
            if (s.v > nv) {
                nv = s.v
                bk[nv] = 0
                if (s.p_v.midictl) {
                    if (s.p_v.midictl[0])
                        bk[s.v] = (bk[s.v] & ~0x1fc000)
                            + (s.p_v.midictl[0] << 14)
                    if (s.p_v.midictl[32])
                        bk[s.v] = (bk[s.v] & ~0x3f80)
                            + (s.p_v.midictl[32] << 7)
                }
            }
            switch (s.subtype) {
                case "midiprog": break
                case "midictl": if (s.ctrl != 0 && s.ctrl != 32)
                    continue
                    if (bk[s.v] == undefined)
                        bk[s.v] = 0
                    if (s.ctrl == 0)
                        bk[s.v] = (bk[s.v] & ~0x1fc000)
                            + (s.val << 14)
                    else
                        bk[s.v] = (bk[s.v] & ~0x3f80)
                            + (s.val << 7)
                default: continue
            }
            vb |= 1 << s.v
            i = s.instr
            if (i == undefined) {
                if (s.chn != 9)
                    continue
                i = bk[s.v] ? 0 : 128 * 128
            }
            if (bk[s.v])
                i += bk[s.v]
            if (!params[i]) {
                params[i] = []
                f(i, sf2par, sf2pre)
            }
        }
        nv = (2 << nv) - 1
        if (nv != vb && !params[0]) {
            params[0] = []
            f(0, sf2par, sf2pre)
        }
    }
    function load_res(s) {
        if (abc2svg.sf2 || conf.sfu.slice(-4) == ".sf2" || conf.sfu.slice(-3) == ".js") {
            if (abc2svg.sf2) {
                if (!parser) {
                    parser = new sf2.Parser(b64dcod(abc2svg.sf2))
                    parser.parse()
                    presets = parser.getPresets()
                }
            } else if (!parser) {
                w_instr++
                if (conf.sfu.slice(-3) == ".js") {
                    abc2svg.loadjs(conf.sfu, function () {
                        load_res(s)
                        if (--w_instr == 0)
                            play_start()
                    }, function () {
                        errmsg('could not load the sound file '
                            + conf.sfu)
                        if (--w_instr == 0)
                            play_start()
                    })
                    return
                }
                var r = new XMLHttpRequest()
                r.open('GET', conf.sfu, true)
                r.responseType = "arraybuffer"
                r.onload = function () {
                    if (r.status === 200) {
                        parser = new sf2.Parser(new Uint8Array(r.response))
                        parser.parse()
                        presets = parser.getPresets()
                        load_res(s)
                        if (--w_instr == 0)
                            play_start()
                    } else {
                        errmsg('could not load the sound file '
                            + conf.sfu)
                        if (--w_instr == 0)
                            play_start()
                    }
                }
                r.onerror = function () {
                    errmsg('could not load the sound file '
                        + conf.sfu)
                    if (--w_instr == 0)
                        play_start()
                }
                r.send()
                return
            }
            def_instr(s, sf2_create, parser, presets)
        } else { def_instr(s, load_instr) }
    }
    function get_time(po) { return po.ac.currentTime }
    function midi_ctrl(po, s, t) {
        switch (s.ctrl) {
            case 0: if (po.v_b[s.v] == undefined)
                po.v_b[s.v] = 0
                po.v_b[s.v] = (po.v_b[s.v] & ~0x1fc000)
                    + (s.val << 14)
                break
            case 7: s.p_v.vol = s.val / 127
                break
            case 32: if (po.v_b[s.v] == undefined)
                po.v_b[s.v] = 0
                po.v_b[s.v] = (po.v_b[s.v] & ~0x3f80)
                    + (s.val << 7)
                break
        }
    }
    function midi_prog(po, s) {
        var i = s.instr
        po.v_c[s.v] = s.chn
        if (i == undefined) {
            if (s.chn != 9)
                return
            i = po.v_b[s.v] ? 0 : 128 * 128
        }
        if (po.v_b[s.v])
            i += po.v_b[s.v]
        po.c_i[s.chn] = i
    }
    function note_run(po, s, key, t, d) {
        var g, st, c = po.v_c[s.v], instr = po.c_i[c], k = key | 0, parm = params[instr][k], o = po.ac.createBufferSource(), v = s.p_v.vol == undefined ? 1 : s.p_v.vol
        if (!v || !parm)
            return
        o.buffer = parm.buffer
        if (parm.loopStart) {
            o.loop = true
            o.loopStart = parm.loopStart
            o.loopEnd = parm.loopEnd
        }
        if (o.detune) {
            var dt = (key * 100) % 100
            if (dt)
                o.detune.value = dt
        }
        o.playbackRate.value = po.rates[instr][k]
        g = po.ac.createGain()
        if (parm.hold < 0.002) { g.gain.setValueAtTime(v, t) } else {
            if (parm.attack < 0.002) { g.gain.setValueAtTime(v, t) } else {
                g.gain.setValueAtTime(0, t)
                g.gain.linearRampToValueAtTime(v, t + parm.attack)
            }
            g.gain.setValueAtTime(v, t + parm.hold)
        }
        g.gain.exponentialRampToValueAtTime(parm.sustain * v, t + parm.decay)
        o.connect(g)
        g.connect(po.gain)
        o.start(t)
        o.stop(t + d)
    }
    function play_start() {
        if (po.stop) {
            po.onend(repv)
            return
        }
        gain.connect(ac.destination)
        abc2svg.play_next(po)
    }
    init_b64d()
    if (!conf.sfu)
        conf.sfu = "Scc1t2"
    if (navigator.userAgentData && navigator.userAgentData.getHighEntropyValues)
        navigator.userAgentData.getHighEntropyValues(['model']).then(function (ua) { model = ua.model })
    else
        model = navigator.userAgent
    return {
        get_outputs: function () { return (window.AudioContext || window.webkitAudioContext) ? ['sf2'] : null }, play: function (i_start, i_end, i_lvl) {
            errmsg = conf.errmsg || alert
            function play_unlock() {
                var buf = ac.createBuffer(1, 1, 22050), src = ac.createBufferSource()
                src.buffer = buf
                src.connect(ac.destination)
                src.start(0)
            }
            if (!gain) {
                ac = conf.ac
                if (!ac) {
                    conf.ac = ac = new (window.AudioContext || window.webkitAudioContext)
                    if (/iPad|iPhone|iPod/.test(model))
                        play_unlock()
                }
                gain = ac.createGain()
                gain.gain.value = conf.gain
            }
            while (i_start.noplay)
                i_start = i_start.ts_next
            po = { conf: conf, onend: conf.onend || empty, onnote: conf.onnote || empty, s_end: i_end, s_cur: i_start, repv: i_lvl || 0, tgen: 2, get_time: get_time, midi_ctrl: midi_ctrl, midi_prog: midi_prog, note_run: note_run, timouts: [], v_c: [], c_i: [], v_b: [], ac: ac, gain: gain, rates: rates }
            w_instr++
            load_res(i_start)
            if (--w_instr == 0)
                play_start()
        }, stop: function () {
            po.stop = true
            po.timouts.forEach(function (id) { clearTimeout(id) })
            abc2svg.play_next(po)
            if (gain) {
                gain.disconnect()
                gain = null
            }
        }, set_vol: function (v) {
            if (gain)
                gain.gain.value = v
        }
    }
}
(function (root, factory) { if (typeof exports === "object") { root.sf2 = exports; factory(exports) } else if (typeof define === "function" && define.amd) { define(["exports"], function (exports) { root.sf2 = exports; return (root.sf2, factory(exports)) }) } else { root.sf2 = {}; factory(root.sf2) } }(this, function (sf2) {
    "use strict"; sf2.Parser = function (input, options) { options = options || {}; this.input = input; this.parserOptions = options.parserOptions }; sf2.Parser.prototype.parse = function () {
        var parser = new sf2.Riff.Parser(this.input, this.parserOptions), chunk; parser.parse(); if (parser.chunkList.length !== 1)
            throw new Error('wrong chunk length'); chunk = parser.getChunk(0); if (chunk === null)
            throw new Error('chunk not found'); this.parseRiffChunk(chunk); this.input = null
    }; sf2.Parser.prototype.parseRiffChunk = function (chunk) {
        var parser, data = this.input, ip = chunk.offset, signature; if (chunk.type !== 'RIFF')
            throw new Error('invalid chunk type:' + chunk.type); signature = String.fromCharCode(data[ip++], data[ip++], data[ip++], data[ip++]); if (signature !== 'sfbk')
            throw new Error('invalid signature:' + signature); parser = new sf2.Riff.Parser(data, { 'index': ip, 'length': chunk.size - 4 }); parser.parse(); if (parser.getNumberOfChunks() !== 3)
            throw new Error('invalid sfbk structure'); this.parseInfoList(parser.getChunk(0)); this.parseSdtaList(parser.getChunk(1)); this.parsePdtaList(parser.getChunk(2))
    }; sf2.Parser.prototype.parseInfoList = function (chunk) {
        var parser, data = this.input, ip = chunk.offset, signature; if (chunk.type !== 'LIST')
            throw new Error('invalid chunk type:' + chunk.type); signature = String.fromCharCode(data[ip++], data[ip++], data[ip++], data[ip++]); if (signature !== 'INFO')
            throw new Error('invalid signature:' + signature); parser = new sf2.Riff.Parser(data, { 'index': ip, 'length': chunk.size - 4 }); parser.parse()
    }; sf2.Parser.prototype.parseSdtaList = function (chunk) {
        var parser, data = this.input, ip = chunk.offset, signature; if (chunk.type !== 'LIST')
            throw new Error('invalid chunk type:' + chunk.type); signature = String.fromCharCode(data[ip++], data[ip++], data[ip++], data[ip++]); if (signature !== 'sdta')
            throw new Error('invalid signature:' + signature); parser = new sf2.Riff.Parser(data, { 'index': ip, 'length': chunk.size - 4 }); parser.parse(); if (parser.chunkList.length !== 1)
            throw new Error('TODO'); this.samplingData = parser.getChunk(0)
    }; sf2.Parser.prototype.parsePdtaList = function (chunk) {
        var parser, data = this.input, ip = chunk.offset, signature; if (chunk.type !== 'LIST')
            throw new Error('invalid chunk type:' + chunk.type); signature = String.fromCharCode(data[ip++], data[ip++], data[ip++], data[ip++]); if (signature !== 'pdta')
            throw new Error('invalid signature:' + signature); parser = new sf2.Riff.Parser(data, { 'index': ip, 'length': chunk.size - 4 }); parser.parse(); if (parser.getNumberOfChunks() !== 9)
            throw new Error('invalid pdta chunk'); this.parsePhdr((parser.getChunk(0))); this.parsePbag((parser.getChunk(1))); this.parsePmod((parser.getChunk(2))); this.parsePgen((parser.getChunk(3))); this.parseInst((parser.getChunk(4))); this.parseIbag((parser.getChunk(5))); this.parseImod((parser.getChunk(6))); this.parseIgen((parser.getChunk(7))); this.parseShdr((parser.getChunk(8)))
    }; sf2.Parser.prototype.parsePhdr = function (chunk) {
        var data = this.input, ip = chunk.offset, presetHeader = this.presetHeader = [], size = chunk.offset + chunk.size; if (chunk.type !== 'phdr')
            throw new Error('invalid chunk type:' + chunk.type); while (ip < size) { presetHeader.push({ presetName: String.fromCharCode.apply(null, data.subarray(ip, ip += 20)), preset: data[ip++] | (data[ip++] << 8), bank: data[ip++] | (data[ip++] << 8), presetBagIndex: data[ip++] | (data[ip++] << 8), library: (data[ip++] | (data[ip++] << 8) | (data[ip++] << 16) | (data[ip++] << 24)) >>> 0, genre: (data[ip++] | (data[ip++] << 8) | (data[ip++] << 16) | (data[ip++] << 24)) >>> 0, morphology: (data[ip++] | (data[ip++] << 8) | (data[ip++] << 16) | (data[ip++] << 24)) >>> 0 }) }
    }; sf2.Parser.prototype.parsePbag = function (chunk) {
        var data = this.input, ip = chunk.offset, presetZone = this.presetZone = [], size = chunk.offset + chunk.size; if (chunk.type !== 'pbag')
            throw new Error('invalid chunk type:' + chunk.type); while (ip < size) { presetZone.push({ presetGeneratorIndex: data[ip++] | (data[ip++] << 8), presetModulatorIndex: data[ip++] | (data[ip++] << 8) }) }
    }; sf2.Parser.prototype.parsePmod = function (chunk) {
        if (chunk.type !== 'pmod')
            throw new Error('invalid chunk type:' + chunk.type); this.presetZoneModulator = this.parseModulator(chunk)
    }; sf2.Parser.prototype.parsePgen = function (chunk) {
        if (chunk.type !== 'pgen')
            throw new Error('invalid chunk type:' + chunk.type); this.presetZoneGenerator = this.parseGenerator(chunk)
    }; sf2.Parser.prototype.parseInst = function (chunk) {
        var data = this.input, ip = chunk.offset, instrument = this.instrument = [], size = chunk.offset + chunk.size; if (chunk.type !== 'inst')
            throw new Error('invalid chunk type:' + chunk.type); while (ip < size) { instrument.push({ instrumentName: String.fromCharCode.apply(null, data.subarray(ip, ip += 20)), instrumentBagIndex: data[ip++] | (data[ip++] << 8) }) }
    }; sf2.Parser.prototype.parseIbag = function (chunk) {
        var data = this.input, ip = chunk.offset, instrumentZone = this.instrumentZone = [], size = chunk.offset + chunk.size; if (chunk.type !== 'ibag')
            throw new Error('invalid chunk type:' + chunk.type); while (ip < size) { instrumentZone.push({ instrumentGeneratorIndex: data[ip++] | (data[ip++] << 8), instrumentModulatorIndex: data[ip++] | (data[ip++] << 8) }) }
    }; sf2.Parser.prototype.parseImod = function (chunk) {
        if (chunk.type !== 'imod')
            throw new Error('invalid chunk type:' + chunk.type); this.instrumentZoneModulator = this.parseModulator(chunk)
    }; sf2.Parser.prototype.parseIgen = function (chunk) {
        if (chunk.type !== 'igen')
            throw new Error('invalid chunk type:' + chunk.type); this.instrumentZoneGenerator = this.parseGenerator(chunk)
    }; sf2.Parser.prototype.parseShdr = function (chunk) {
        var data = this.input, ip = chunk.offset, samples = this.sample = [], sampleHeader = this.sampleHeader = [], size = chunk.offset + chunk.size, sampleName, start, end, startLoop, endLoop, sampleRate, originalPitch, pitchCorrection, sampleLink, sampleType; if (chunk.type !== 'shdr')
            throw new Error('invalid chunk type:' + chunk.type); while (ip < size) {
                sampleName = String.fromCharCode.apply(null, data.subarray(ip, ip += 20)); start = (data[ip++] << 0) | (data[ip++] << 8) | (data[ip++] << 16) | (data[ip++] << 24); end = (data[ip++] << 0) | (data[ip++] << 8) | (data[ip++] << 16) | (data[ip++] << 24); startLoop = (data[ip++] << 0) | (data[ip++] << 8) | (data[ip++] << 16) | (data[ip++] << 24); endLoop = (data[ip++] << 0) | (data[ip++] << 8) | (data[ip++] << 16) | (data[ip++] << 24); sampleRate = (data[ip++] << 0) | (data[ip++] << 8) | (data[ip++] << 16) | (data[ip++] << 24); originalPitch = data[ip++]; pitchCorrection = (data[ip++] << 24) >> 24; sampleLink = data[ip++] | (data[ip++] << 8); sampleType = data[ip++] | (data[ip++] << 8); var sample = new Int16Array(new Uint8Array(data.subarray(this.samplingData.offset + start * 2, this.samplingData.offset + end * 2)).buffer); startLoop -= start; endLoop -= start; if (sampleRate > 0) { var adjust = this.adjustSampleData(sample, sampleRate); sample = adjust.sample; sampleRate *= adjust.multiply; startLoop *= adjust.multiply; endLoop *= adjust.multiply }
                samples.push(sample); sampleHeader.push({ sampleName: sampleName, startLoop: startLoop, endLoop: endLoop, sampleRate: sampleRate, originalPitch: originalPitch, pitchCorrection: pitchCorrection, sampleLink: sampleLink, sampleType: sampleType })
            }
    }; sf2.Parser.prototype.adjustSampleData = function (sample, sampleRate) {
        var newSample, i, il, j, multiply = 1; while (sampleRate < 22050) {
            newSample = new Int16Array(sample.length * 2); for (i = j = 0, il = sample.length; i < il; ++i) { newSample[j++] = sample[i]; newSample[j++] = sample[i] }
            sample = newSample; multiply *= 2; sampleRate *= 2
        }
        return { sample: sample, multiply: multiply }
    }; sf2.Parser.prototype.parseModulator = function (chunk) {
        var data = this.input, ip = chunk.offset, size = chunk.offset + chunk.size, code, key, output = []; while (ip < size) {
            ip += 2; code = data[ip++] | (data[ip++] << 8); key = sf2.Parser.GeneratorEnumeratorTable[code]; if (key === undefined) { output.push({ type: key, value: { code: code, amount: data[ip] | (data[ip + 1] << 8) << 16 >> 16, lo: data[ip++], hi: data[ip++] } }) } else { switch (key) { case 'keyRange': case 'velRange': case 'keynum': case 'velocity': output.push({ type: key, value: { lo: data[ip++], hi: data[ip++] } }); break; default: output.push({ type: key, value: { amount: data[ip++] | (data[ip++] << 8) << 16 >> 16 } }); break } }
            ip += 2; ip += 2
        }
        return output
    }; sf2.Parser.prototype.parseGenerator = function (chunk) {
        var data = this.input, ip = chunk.offset, size = chunk.offset + chunk.size, code, key, output = []; while (ip < size) {
            code = data[ip++] | (data[ip++] << 8); key = sf2.Parser.GeneratorEnumeratorTable[code]; if (key === undefined) { output.push({ type: key, value: { code: code, amount: data[ip] | (data[ip + 1] << 8) << 16 >> 16, lo: data[ip++], hi: data[ip++] } }); continue }
            switch (key) { case 'keynum': case 'keyRange': case 'velRange': case 'velocity': output.push({ type: key, value: { lo: data[ip++], hi: data[ip++] } }); break; default: output.push({ type: key, value: { amount: data[ip++] | (data[ip++] << 8) << 16 >> 16 } }); break }
        }
        return output
    }; sf2.Parser.prototype.getPresets = function () {
        var preset = this.presetHeader, zone = this.presetZone, output = [], bagIndex, bagIndexEnd, zoneInfo, presetGenerator, presetModulator, i, il, j, jl
        for (i = 0, il = preset.length; i < il; ++i) {
            j = preset[i].presetBagIndex
            jl = preset[i + 1] ? preset[i + 1].presetBagIndex : zone.length
            zoneInfo = []; for (; j < jl; ++j) { presetGenerator = this.createPresetGenerator_(zone, j); presetModulator = this.createPresetModulator_(zone, j); zoneInfo.push({ generator: presetGenerator.generator, modulator: presetModulator.modulator, }) }
            output.push({ info: zoneInfo, header: preset[i], })
        }
        return output
    }; sf2.Parser.prototype.createInstrumentGenerator_ = function (zone, index) { var modgen = this.createBagModGen_(zone, zone[index].instrumentGeneratorIndex, zone[index + 1] ? zone[index + 1].instrumentGeneratorIndex : this.instrumentZoneGenerator.length, this.instrumentZoneGenerator); return { generator: modgen.modgen, } }; sf2.Parser.prototype.createInstrumentModulator_ = function (zone, index) { var modgen = this.createBagModGen_(zone, zone[index].presetModulatorIndex, zone[index + 1] ? zone[index + 1].instrumentModulatorIndex : this.instrumentZoneModulator.length, this.instrumentZoneModulator); return { modulator: modgen.modgen } }; sf2.Parser.prototype.createPresetGenerator_ = function (zone, index) { var modgen = this.createBagModGen_(zone, zone[index].presetGeneratorIndex, zone[index + 1] ? zone[index + 1].presetGeneratorIndex : this.presetZoneGenerator.length, this.presetZoneGenerator); return { generator: modgen.modgen, } }; sf2.Parser.prototype.createPresetModulator_ = function (zone, index) { var modgen = this.createBagModGen_(zone, zone[index].presetModulatorIndex, zone[index + 1] ? zone[index + 1].presetModulatorIndex : this.presetZoneModulator.length, this.presetZoneModulator); return { modulator: modgen.modgen, } }; sf2.Parser.prototype.createBagModGen_ = function (zone, indexStart, indexEnd, zoneModGen) {
        var modgen = { unknown: [], 'keyRange': { hi: 127, lo: 0 } }; var info, i, il; for (i = indexStart, il = indexEnd; i < il; ++i) {
            info = zoneModGen[i]; if (info.type === 'unknown')
                modgen.unknown.push(info.value); else
                modgen[info.type] = info.value
        }
        return { modgen: modgen }
    }; sf2.Parser.GeneratorEnumeratorTable = ['startAddrsOffset', 'endAddrsOffset', 'startloopAddrsOffset', 'endloopAddrsOffset', 'startAddrsCoarseOffset', 'modLfoToPitch', 'vibLfoToPitch', 'modEnvToPitch', 'initialFilterFc', 'initialFilterQ', 'modLfoToFilterFc', 'modEnvToFilterFc', 'endAddrsCoarseOffset', 'modLfoToVolume', undefined, 'chorusEffectsSend', 'reverbEffectsSend', 'pan', undefined, undefined, undefined, 'delayModLFO', 'freqModLFO', 'delayVibLFO', 'freqVibLFO', 'delayModEnv', 'attackModEnv', 'holdModEnv', 'decayModEnv', 'sustainModEnv', 'releaseModEnv', 'keynumToModEnvHold', 'keynumToModEnvDecay', 'delayVolEnv', 'attackVolEnv', 'holdVolEnv', 'decayVolEnv', 'sustainVolEnv', 'releaseVolEnv', 'keynumToVolEnvHold', 'keynumToVolEnvDecay', 'instrument', undefined, 'keyRange', 'velRange', 'startloopAddrsCoarseOffset', 'keynum', 'velocity', 'initialAttenuation', undefined, 'endloopAddrsCoarseOffset', 'coarseTune', 'fineTune', 'sampleID', 'sampleModes', undefined, 'scaleTuning', 'exclusiveClass', 'overridingRootKey']; sf2.Riff = {}; sf2.Riff.Parser = function (input, options) { options = options || {}; this.input = input; this.ip = options.index || 0; this.length = options.length || input.length - this.ip; this.offset = this.ip; this.padding = options.padding !== undefined ? options.padding : true; this.bigEndian = options.bigEndian !== undefined ? options.bigEndian : false }; sf2.Riff.Chunk = function (type, size, offset) { this.type = type; this.size = size; this.offset = offset }; sf2.Riff.Parser.prototype.parse = function () {
        var length = this.length + this.offset; this.chunkList = []; while (this.ip < length)
            this.parseChunk()
    }; sf2.Riff.Parser.prototype.parseChunk = function () {
        var input = this.input, ip = this.ip, size; this.chunkList.push(new sf2.Riff.Chunk(String.fromCharCode(input[ip++], input[ip++], input[ip++], input[ip++]), (size = this.bigEndian ? ((input[ip++] << 24) | (input[ip++] << 16) | (input[ip++] << 8) | (input[ip++])) : ((input[ip++]) | (input[ip++] << 8) | (input[ip++] << 16) | (input[ip++] << 24))), ip)); ip += size; if (this.padding && ((ip - this.offset) & 1) === 1)
            ip++; this.ip = ip
    }; sf2.Riff.Parser.prototype.getChunk = function (index) {
        var chunk = this.chunkList[index]; if (chunk === undefined)
            return null; return chunk
    }; sf2.Riff.Parser.prototype.getNumberOfChunks = function () { return this.chunkList.length }; return sf2
})); function Midi5(i_conf) {
    var po, conf = i_conf, empty = function () { }, rf, op
    function get_time(po) { return window.performance.now() / 1000 }
    function note_run(po, s, k, t, d) {
        var j, a = (k * 100) % 100, c = po.v_c[s.v], i = po.c_i[c]
        k |= 0
        t *= 1000
        d *= 1000
        if (a && Midi5.ma.sysexEnabled) { po.op.send(new Uint8Array([0xf0, 0x7f, 0x7f, 0x08, 0x02, i & 0x7f, 0x01, k, k, a / .78125, 0, 0xf7]), t) }
        po.op.send(new Uint8Array([0x90 + c, k, 127]), t)
        po.op.send(new Uint8Array([0x80 + c, k, 0]), t + d - 20)
    }
    function midi_ctrl(po, s, t) { po.op.send(new Uint8Array([0xb0 + po.v_c[s.v], s.ctrl, s.val]), t * 1000) }
    function midi_prog(po, s) {
        var i, c = s.chn
        po.v_c[s.v] = c
        if (po.c_i[c] == undefined) {
            po.op.send(new Uint8Array([0xb0 + c, 121, 0]))
            if (0) {
                if (s.p_v.midictl) {
                    for (i in s.p_v.midictl)
                        po.op.send(new Uint8Array([0xb0 + c, i, s.p_v.midictl[i]]))
                }
            }
        }
        i = s.instr
        if (i != undefined) {
            po.c_i[c] = i
            po.op.send(new Uint8Array([0xc0 + c, i & 0x7f]))
        }
    }
    function send_outputs(access) {
        var o, os, out = []
        Midi5.ma = access
        if (access && access.outputs.size > 0) {
            os = access.outputs.values()
            while (1) {
                o = os.next()
                if (!o || o.done)
                    break
                out.push(o.value.name)
            }
        }
        rf(out)
    }
    return {
        get_outputs: function (f) {
            if (!navigator.requestMIDIAccess) {
                f()
                return
            }
            rf = f
            navigator.requestMIDIAccess({ sysex: true }).then(send_outputs, function (msg) { navigator.requestMIDIAccess().then(send_outputs, function (msg) { rf() }) })
        }, set_output: function (name) {
            if (!Midi5.ma)
                return
            var o, os = Midi5.ma.outputs.values()
            while (1) {
                o = os.next()
                if (!o || o.done)
                    break
                if (o.value.name == name) {
                    op = o.value
                    break
                }
            }
        }, play: function (i_start, i_end, i_lvl) {
            po = { conf: conf, onend: conf.onend || empty, onnote: conf.onnote || empty, s_end: i_end, s_cur: i_start, repv: i_lvl || 0, tgen: 2, get_time: get_time, midi_ctrl: midi_ctrl, midi_prog: midi_prog, note_run: note_run, timouts: [], op: op, v_c: [], c_i: [] }
            if (0) { op.send(new Uint8Array([0xf0, 0x7f, 0x7f, 0x08, 0x02, 0x00, 0x01, 0x69, 0x69, 0x00, 0, 0xf7]), t) }
            abc2svg.play_next(po)
        }, stop: function () {
            po.stop = true
            po.timouts.forEach(function (id) { clearTimeout(id) })
            abc2svg.play_next(po)
            if (op && op.clear)
                op.clear()
        }
    }
}
function follow(abc, user, playconf) {
    var keep_types = { note: true, rest: true }
    user.anno_stop = function (type, start, stop, x, y, w, h) {
        if (!keep_types[type])
            return
        abc.out_svg('<rect class="abcr _' + start + '_" x="'); abc.out_sxsy(x, '" y="', y); abc.out_svg('" width="' + w.toFixed(2) + '" height="' + abc.sh(h).toFixed(2) + '"/>\n')
    }
    playconf.onnote = function (i, on) {
        var b, i, e, elts, x = 0, y = 0
        if (abc2svg.mu)
            elts = abc2svg.mu.d.getElementsByClassName('_' + i + '_')
        else
            elts = document.getElementsByClassName('_' + i + '_')
        if (!elts || !elts.length)
            return
        e = elts[0]
        e.style.fillOpacity = on ? 0.4 : 0
        if (on && !window.no_scroll) {
            b = e.getBoundingClientRect()
            if (b.top < 0 || b.bottom > window.innerHeight * .8)
                y = b.top - window.innerHeight * .3
            if (b.left < 0 || b.right > window.innerWidth * .8)
                x = b.left - window.innerWidth * .3
            if (x || y)
                window.scrollBy({ top: y, left: x, behavior: (x < 0 || y) ? 'instant' : 'smooth' })
        }
    }
}
(function () {
    var sty = document.createElement("style")
    sty.innerHTML = ".abcr {fill: #d00000; fill-opacity: 0; z-index: 15}"
    document.head.appendChild(sty)
})()
abc2svg.ch_names = { '': ["C-E G C+", "E-C G C+", "G-C E G "], m: ["C-e G C+", "e-C G C+", "G-C e G "], '7': ["C-b-E G ", "E-C G b ", "G-E b C+", "b-E G C+"], m7: ["C-b-e G ", "e-C G b ", "G-e b C+", "b-e G C+"], m7b5: ["C-b-e g ", "e-C g b ", "g-e b C+", "b-e g C+"], M7: ["C-B-E G ", "E-C G B ", "G-E B C+", "B-E G C+"], '6': ["C-A-E G ", "E-C A B ", "A-E B C+", "B-E A C+"], m6: ["C-A-e G ", "e-C A B ", "A-e B C+", "B-e A C+"], aug: ["C-E a C+", "E-C a C+", "a-C E a "], aug7: ["C-b-E a ", "E-C a b ", "a-E b C+", "b-E a C+"], dim: ["C-E g C+", "E-C g C+", "g-C E g "], dim7: ["C-e g A ", "e-C g A ", "g-e A C+", "A-C e G "], '9': ["C-b-E G D+", "E-C G b D+", "G-E b C+D+", "b-E G C+D+", "D-G-C E b "], m9: ["C-b-e G D+", "e-C G b D+", "G-e b C+D+", "b-e G C+D+", "D-G-C e b "], maj9: ["C-B-E G D+", "E-C G B D+", "G-E B C+D+", "B-E G C+D+", "D-G-C E B "], M9: ["C-B-E G D+", "E-C G B D+", "G-C E B D+", "B-E G C+D+", "D-G-C E B "], '11': ["C-b-E G D+F+", "E-C G b D+F+", "G-E b C+D+F+", "b-E G C+D+F+", "D-G-C E b F+", "F-D-G-C E b D+"], dim9: ["C-A-e g d+", "e-C g A d+", "g-C e A d+", "A-C e g d+", "D-g-C e A "], sus4: ["C-F G C+", "F-C G C+", "G-C F G "], sus9: ["C-D G C+", "D-C G C+", "G-C D G "], '7sus4': ["C-b-F G ", "F-C G b ", "G-F b C+", "b-C F G "], '7sus9': ["C-b-D G ", "D-C G b ", "G-D b C+", "b-C D G "], '5': ["C-G C+", "G-G C+"] }
abc2svg.midlet = "CdDeEFgGaAbB"
abc2svg.letmid = { C: 0, d: 1, D: 2, e: 3, E: 4, F: 5, g: 6, G: 7, a: 8, A: 9, b: 10, B: 11 }
abc2svg.chord = function (first, voice_tb, cfmt) {
    var chnm, i, k, vch, s, gchon, C = abc2svg.C, trans = 48 + (cfmt.chord.trans ? cfmt.chord.trans * 12 : 0)
    function chcr(b, ch) {
        var i, v, r = []
        b = abc2svg.midlet[b]
        i = ch.length
        while (--i > 0) {
            if (ch[i][0] == b)
                break
        }
        ch = ch[i]
        for (i = 0; i < ch.length; i += 2) {
            v = abc2svg.letmid[ch[i]]
            switch (ch[i + 1]) {
                case '+': v += 12; break
                case '-': v -= 12; break
            }
            r.push(v)
        }
        return r
    }
    function filter(a_cs) {
        var i, cs, t
        for (i = 0; i < a_cs.length; i++) {
            cs = a_cs[i]
            if (cs.type != 'g')
                continue
            t = cs.otext
            if (t.slice(-1) == ')')
                t = t.replace(/\(.*/, '')
            return t.replace(/\(|\)|\[|\]/g, '')
        }
    }
    function gench(sb) {
        var r, ch, b, m, n, not, a = filter(sb.a_gch), s = { v: vch.v, p_v: vch, type: C.NOTE, time: sb.time, notes: [] }
        if (!a)
            return
        a = a.match(/([A-GN])([#♯b♭]?)([^/]*)\/?(.*)/)
        if (!a)
            return
        r = abc2svg.letmid[a[1]]
        if (r == undefined) {
            if (a[1] != "N")
                return
            s.type = C.REST
            ch = [0]
            r = 0
        } else {
            switch (a[2]) {
                case "#": case "♯": r++; break
                case "b": case "♭": r--; break
            }
            if (!a[3]) { ch = chnm[""] } else {
                ch = abc2svg.ch_alias[a[3]]
                if (ch == undefined)
                    ch = a[3]
                ch = chnm[ch]
                if (!ch)
                    ch = a[3][0] == 'm' ? chnm.m : chnm[""]
            }
            if (a[4]) {
                b = a[4][0].toUpperCase()
                b = abc2svg.letmid[b]
                if (b != undefined) {
                    switch (a[4][1]) {
                        case "#": case "♯": b++; if (b >= 12) b = 0; break
                        case "b": case "♭": b--; if (b < 0) b = 11; break
                    }
                }
            }
        }
        if (b == undefined)
            b = 0
        ch = chcr(b, ch)
        n = ch.length
        r += trans
        if (sb.p_v.tr_snd)
            r += sb.p_v.tr_snd
        for (m = 0; m < n; m++) {
            not = { midi: r + ch[m] }
            s.notes.push(not)
        }
        s.nhd = n - 1
        s.prev = vch.last_sym
        vch.last_sym.next = s
        s.ts_next = sb.ts_next
        sb.ts_next = s
        s.ts_prev = sb
        if (s.ts_next)
            s.ts_next.ts_prev = s
        vch.last_sym = s
    }
    if (cfmt.chord.names) {
        chnm = Object.create(abc2svg.ch_names)
        for (k in cfmt.chord.names) {
            vch = ""
            for (i = 0; i < cfmt.chord.names[k].length; i++) {
                s = cfmt.chord.names[k][i]
                vch += abc2svg.midlet[s % 12]
                vch += i == 0 ? "-" : (s >= 12 ? "+" : " ")
            }
            chnm[k] = [vch]
        }
    } else { chnm = abc2svg.ch_names }
    k = 0
    for (i = 0; i < voice_tb.length; i++) {
        if (k < voice_tb[i].chn)
            k = voice_tb[i].chn
    }
    if (k == 8)
        k++
    vch = { v: voice_tb.length, id: "_chord", time: 0, sym: { type: C.BLOCK, subtype: "midiprog", chn: k + 1, instr: cfmt.chord.prog || 0, time: 0, ts_prev: first, ts_next: first.ts_next }, vol: cfmt.chord.vol || .6 }
    vch.sym.p_v = vch
    vch.sym.v = vch.v
    vch.last_sym = vch.sym
    voice_tb.push(vch)
    first.ts_next = vch.sym
    gchon = cfmt.chord.gchon
    s = first
    while (1) {
        if (!s.ts_next) {
            if (gchon)
                vch.last_sym.dur = s.time - vch.last_sym.time
            break
        }
        s = s.ts_next
        if (!s.a_gch) {
            if (s.subtype == "midigch") {
                if (gchon && !s.on)
                    vch.last_sym.dur = s.time - vch.last_sym.time
                gchon = s.on
            }
            continue
        }
        if (!gchon)
            continue
        for (i = 0; i < s.a_gch.length; i++) {
            gch = s.a_gch[i]
            if (gch.type != 'g')
                continue
            vch.last_sym.dur = s.time - vch.last_sym.time
            gench(s)
            break
        }
    }
}