MIDI 文件（.mid/.midi）是一种二进制文件，采用分层结构存储音乐数据，不是简单的对象存储。它包含多个”块”(chunks)，每个块有特定的格式。

一、文件整体结构

MIDI文件 = 头块(Header Chunk) + 一个或多个音轨块(Track Chunks)

二、头块(Header Chunk) – 14字节

struct HeaderChunk {
    char chunkID[4];      // "MThd"（4字节ASCII码）
    uint32_t length;      // 固定为6（4字节，大端序）
    uint16_t format;      // 格式：0,1,2（2字节）
    uint16_t tracks;      // 音轨数（2字节）
    uint16_t division;    // 时间划分（2字节）
}; // 总共14字节

时间划分(division)说明：

• 最高位为0：表示每四分音符的ticks数
• 例：0x00C0 = 192 ticks/四分音符
• 最高位为1：表示SMPTE时间码
• 例：0xE250 = 每秒25帧，每帧80 ticks

三、音轨块(Track Chunk)

struct TrackChunk {
    char chunkID[4];      // "MTrk"（4字节）
    uint32_t length;      // 音轨数据长度（4字节）
    uint8_t data[];       // 事件数据（可变长度）
};

四、事件结构 – 可变长度

事件格式：Δt + 事件类型 + 参数

1. 时间差(Δt) – 可变长度编码(VLQ)

• 每个字节最高位是标志位（1表示还有后续字节）
• 例：值300的编码过程：

  300 = 0x12C
  分解为7位组：[0000010][1001100]
  编码为：10000101 00101100 = 0x85 0x2C

2. MIDI通道事件（占3-4字节）

格式：状态字节(0x80-0xEF) + 数据字节1 + [数据字节2]

注：n = 通道号(0-15)

3. 元事件(Meta Events) – 可变长度

格式：0xFF + 类型 + 长度(VLQ) + 数据

常见元事件：

• 轨道结束(0x2F)：FF 2F 00（3字节）
• 设置速度(0x51)：FF 51 03 tt tt tt（6字节）
• tt tt tt = 微秒/四分音符（24位）
• 拍号(0x58)：FF 58 04 nn dd cc bb（8字节）
• nn=分子, dd=分母(2^dd), cc=ticks/节拍, bb=32分音符/四分音符
• 调号(0x59)：FF 59 02 sf mi（5字节）
• sf=升降号, mi=大小调(0=大调,1=小调)

4. 系统专有事件(SysEx) – 可变长度

格式：0xF0 + 长度(VLQ) + 厂商数据 + 0xF7

五、运行状态(Running Status)

为节省空间，如果连续事件类型相同，可省略状态字节：

Δt1 状态 数据1 数据2
Δt2 -- 数据1 数据2    ← 省略状态字节

六、完整示例分析

// 头块
4D 54 68 64  // "MThd"
00 00 00 06  // 长度=6
00 01        // 格式1
00 02        // 2个音轨
00 60        // 96 ticks/四分音符

// 音轨1（控制信息）
4D 54 72 6B  // "MTrk"
00 00 00 13  // 长度=19字节

00 FF 03 04 54 65 6D 70  // 设置音轨名"Temp"
00 FF 51 03 07 A1 20     // 速度=500000μs/beat=120BPM
00 FF 58 04 04 02 18 08  // 拍号4/4，24ticks/beat
83 00 FF 2F 00           // Δt=384，轨道结束

// 音轨2（音符数据）
4D 54 72 6B  // "MTrk"
00 00 00 0F  // 长度=15字节

00 90 3C 64  // Δt=0，音符开启(C4，力度100)
60 90 3C 00  // Δt=96，音符关闭(力度=0即Note Off)
00 FF 2F 00  // Δt=0，轨道结束

七、文件格式类型

1. 格式0：单音轨，所有事件在一个音轨中
2. 格式1：多音轨，多个音轨同时播放
3. 格式2：多音轨，独立播放（较少用）

八、特点总结

• 二进制编码：紧凑高效
• 分层结构：头块 + 多个音轨块
• 可变长度：Δt和部分数据使用VLQ编码
• 事件驱动：基于Δt的时间轴
• 通道分离：16个逻辑通道
• 非音频数据：只存储演奏信息，文件很小

/*
    Project Name : midi-parser-js
    Project Url  : https://github.com/colxi/midi-parser-js/
    Author       : colxi
    Author URL   : http://www.colxi.info/
    Description  : MidiParser library reads .MID binary files, Base64 encoded MIDI Data,
    or UInt8 Arrays, and outputs as a readable and structured JS object.
*/

(function(){
    'use strict';

    /**
     * CROSSBROWSER & NODEjs POLYFILL for ATOB() -
     * By: https://github.com/MaxArt2501 (modified)
     * @param  {string} string [description]
     * @return {[type]}        [description]
     */
    const _atob = function(string) {
        // base64 character set, plus padding character (=)
        let b64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
        // Regular expression to check formal correctness of base64 encoded strings
        let b64re = /^(?:[A-Za-z\d+\/]{4})*?(?:[A-Za-z\d+\/]{2}(?:==)?|[A-Za-z\d+\/]{3}=?)?$/;
        // remove data type signatures at the begining of the string
        // eg :  "data:audio/mid;base64,"
        string = string.replace( /^.*?base64,/ , '');
        // atob can work with strings with whitespaces, even inside the encoded part,
        // but only \t, \n, \f, \r and ' ', which can be stripped.
        string = String(string).replace(/[\t\n\f\r ]+/g, '');
        if (!b64re.test(string))
            throw new TypeError('Failed to execute _atob() : The string to be decoded is not correctly encoded.');

        // Adding the padding if missing, for semplicity
        string += '=='.slice(2 - (string.length & 3));
        let bitmap, result = '';
        let r1, r2, i = 0;
        for (; i < string.length;) {
            bitmap = b64.indexOf(string.charAt(i++)) << 18 | b64.indexOf(string.charAt(i++)) << 12
                    | (r1 = b64.indexOf(string.charAt(i++))) << 6 | (r2 = b64.indexOf(string.charAt(i++)));

            result += r1 === 64 ? String.fromCharCode(bitmap >> 16 & 255)
                    : r2 === 64 ? String.fromCharCode(bitmap >> 16 & 255, bitmap >> 8 & 255)
                    : String.fromCharCode(bitmap >> 16 & 255, bitmap >> 8 & 255, bitmap & 255);
        }
        return result;
    };


    /**
     * [MidiParser description]
     * @type {Object}
     */
    const MidiParser  = {
        // debug (bool), when enabled will log in console unimplemented events
        // warnings and internal handled errors.
        debug: false,

        /**
         * [parse description]
         * @param  {[type]} input     [description]
         * @param  {[type]} _callback [description]
         * @return {[type]}           [description]
         */
        parse: function(input, _callback){
            if(input instanceof Uint8Array) return MidiParser.Uint8(input);
            else if(typeof input === 'string') return MidiParser.Base64(input);
            else if(input instanceof HTMLElement && input.type === 'file') return MidiParser.addListener(input , _callback);
            else throw new Error('MidiParser.parse() : Invalid input provided');
        },

        /**
         * addListener() should be called in order attach a listener to the INPUT HTML element
         * that will provide the binary data automating the conversion, and returning
         * the structured data to the provided callback function.
         */
        addListener: function(_fileElement, _callback){
            if(!File || !FileReader) throw new Error('The File|FileReader APIs are not supported in this browser. Use instead MidiParser.Base64() or MidiParser.Uint8()');

            // validate provided element
            if( _fileElement === undefined ||
                !(_fileElement instanceof HTMLElement) ||
                _fileElement.tagName !== 'INPUT' ||
                _fileElement.type.toLowerCase() !== 'file' 
            ){
                console.warn('MidiParser.addListener() : Provided element is not a valid FILE INPUT element');
                return false;
            }
            _callback = _callback || function(){};

            _fileElement.addEventListener('change', function(InputEvt){             // set the 'file selected' event handler
                if (!InputEvt.target.files.length) return false;                    // return false if no elements where selected
                console.log('MidiParser.addListener() : File detected in INPUT ELEMENT processing data..');
                let reader = new FileReader();                                      // prepare the file Reader
                reader.readAsArrayBuffer(InputEvt.target.files[0]);                 // read the binary data
                reader.onload =  function(e){
                    _callback( MidiParser.Uint8(new Uint8Array(e.target.result)));  // encode data with Uint8Array and call the parser
                };
            });
        },

        /**
         * Base64() : convert baset4 string into uint8 array buffer, before performing the
         * parsing subroutine.
         */
        Base64 : function(b64String){
            b64String = String(b64String);

            let raw = _atob(b64String);
            let rawLength = raw.length;
            let t_array = new Uint8Array(new ArrayBuffer(rawLength));

            for(let i=0; i<rawLength; i++) t_array[i] = raw.charCodeAt(i);
            return  MidiParser.Uint8(t_array) ;
        },

        /**
         * parse() : function reads the binary data, interpreting and spliting each chuck
         * and parsing it to a structured Object. When job is finised returns the object
         * or 'false' if any error was generated.
         */
        Uint8: function(FileAsUint8Array){
            let file = {
                data: null,
                pointer: 0,
                movePointer: function(_bytes){                                      // move the pointer negative and positive direction
                    this.pointer += _bytes;
                    return this.pointer;
                },
                readInt: function(_bytes){                                          // get integer from next _bytes group (big-endian)
                    _bytes = Math.min(_bytes, this.data.byteLength-this.pointer);
                    if (_bytes < 1) return -1;                                                                      // EOF
                    let value = 0;
                    if(_bytes > 1){
                        for(let i=1; i<= (_bytes-1); i++){
                            value += this.data.getUint8(this.pointer) * Math.pow(256, (_bytes - i));
                            this.pointer++;
                        }
                    }
                    value += this.data.getUint8(this.pointer);
                    this.pointer++;
                    return value;
                },
                readStr: function(_bytes){                                          // read as ASCII chars, the followoing _bytes
                    let text = '';
                    for(let char=1; char <= _bytes; char++) text +=  String.fromCharCode(this.readInt(1));
                    return text;
                },
                readIntVLV: function(){                                             // read a variable length value
                    let value = 0;
                    if ( this.pointer >= this.data.byteLength ){
                        return -1;                                                  // EOF
                    }else if(this.data.getUint8(this.pointer) < 128){               // ...value in a single byte
                        value = this.readInt(1);
                    }else{                                                          // ...value in multiple bytes
                        let FirstBytes = [];
                        while(this.data.getUint8(this.pointer) >= 128){
                            FirstBytes.push(this.readInt(1) - 128);
                        }
                        let lastByte  = this.readInt(1);
                        for(let dt = 1; dt <= FirstBytes.length; dt++){
                            value += FirstBytes[FirstBytes.length - dt] * Math.pow(128, dt);
                        }
                        value += lastByte;
                    }
                    return value;
                }
            };

            file.data = new DataView(FileAsUint8Array.buffer, FileAsUint8Array.byteOffset, FileAsUint8Array.byteLength);                                            // 8 bits bytes file data array
            //  ** read FILE HEADER
            if(file.readInt(4) !== 0x4D546864){
                console.warn('Header validation failed (not MIDI standard or file corrupt.)');
                return false;                                                       // Header validation failed (not MIDI standard or file corrupt.)
            }
            let headerSize          = file.readInt(4);                              // header size (unused var), getted just for read pointer movement
            let MIDI                = {};                                           // create new midi object
            MIDI.formatType         = file.readInt(2);                              // get MIDI Format Type
            MIDI.tracks             = file.readInt(2);                              // get ammount of track chunks
            MIDI.track              = [];                                           // create array key for track data storing
            let timeDivisionByte1   = file.readInt(1);                              // get Time Division first byte
            let timeDivisionByte2   = file.readInt(1);                              // get Time Division second byte
            if(timeDivisionByte1 >= 128){                                           // discover Time Division mode (fps or tpf)
                MIDI.timeDivision    = [];
                MIDI.timeDivision[0] = timeDivisionByte1 - 128;                     // frames per second MODE  (1st byte)
                MIDI.timeDivision[1] = timeDivisionByte2;                           // ticks in each frame     (2nd byte)
            }else MIDI.timeDivision  = (timeDivisionByte1 * 256) + timeDivisionByte2;// else... ticks per beat MODE  (2 bytes value)

            //  ** read TRACK CHUNK
            for(let t=1; t <= MIDI.tracks; t++){
                MIDI.track[t-1]     = {event: []};                                  // create new Track entry in Array
                let headerValidation = file.readInt(4);
                if ( headerValidation === -1 ) break;                               // EOF
                if(headerValidation !== 0x4D54726B) return false;                   // Track chunk header validation failed.
                file.readInt(4);                                                    // move pointer. get chunk size (bytes length)
                let e               = 0;                                            // init event counter
                let endOfTrack      = false;                                        // FLAG for track reading secuence breaking
                // ** read EVENT CHUNK
                let statusByte;
                let laststatusByte;
                while(!endOfTrack){
                    e++;                                                            // increase by 1 event counter
                    MIDI.track[t-1].event[e-1] = {};                                // create new event object, in events array
                    MIDI.track[t-1].event[e-1].deltaTime  = file.readIntVLV();      // get DELTA TIME OF MIDI event (Variable Length Value)
                    statusByte = file.readInt(1);                                   // read EVENT TYPE (STATUS BYTE)
                    if(statusByte === -1) break;                                    // EOF
                    else if(statusByte >= 128) laststatusByte = statusByte;         // NEW STATUS BYTE DETECTED
                    else{                                                           // 'RUNNING STATUS' situation detected
                        statusByte = laststatusByte;                                // apply last loop, Status Byte
                        file.movePointer(-1);                                       // move back the pointer (cause readed byte is not status byte)
                    }


                    //
                    // ** IS META EVENT
                    //
                    if(statusByte === 0xFF){                                        // Meta Event type
                        MIDI.track[t-1].event[e-1].type = 0xFF;                     // assign metaEvent code to array
                        MIDI.track[t-1].event[e-1].metaType =  file.readInt(1);     // assign metaEvent subtype
                        let metaEventLength = file.readIntVLV();                    // get the metaEvent length
                        switch(MIDI.track[t-1].event[e-1].metaType){
                            case 0x2F:                                              // end of track, has no data byte
                            case -1:                                                // EOF
                                endOfTrack = true;                                  // change FLAG to force track reading loop breaking
                                break;
                            case 0x01:                                              // Text Event
                            case 0x02:                                              // Copyright Notice
                            case 0x03:
                            case 0x04:                                              // Instrument Name
                            case 0x05:                                              // Lyrics)
                            case 0x07:                                              // Cue point                                         // Sequence/Track Name (documentation: http://www.ta7.de/txt/musik/musi0006.htm)
                            case 0x06:                                              // Marker
                                MIDI.track[t-1].event[e-1].data = file.readStr(metaEventLength);
                                break;
                            case 0x21:                                              // MIDI PORT
                            case 0x59:                                              // Key Signature
                            case 0x51:                                              // Set Tempo
                                MIDI.track[t-1].event[e-1].data = file.readInt(metaEventLength);
                                break;
                            case 0x54:                                              // SMPTE Offset
                                MIDI.track[t-1].event[e-1].data    = [];
                                MIDI.track[t-1].event[e-1].data[0] = file.readInt(1);
                                MIDI.track[t-1].event[e-1].data[1] = file.readInt(1);
                                MIDI.track[t-1].event[e-1].data[2] = file.readInt(1);
                                MIDI.track[t-1].event[e-1].data[3] = file.readInt(1);
                                MIDI.track[t-1].event[e-1].data[4] = file.readInt(1);
                                break;
                            case 0x58:                                              // Time Signature
                                MIDI.track[t-1].event[e-1].data    = [];
                                MIDI.track[t-1].event[e-1].data[0] = file.readInt(1);
                                MIDI.track[t-1].event[e-1].data[1] = file.readInt(1);
                                MIDI.track[t-1].event[e-1].data[2] = file.readInt(1);
                                MIDI.track[t-1].event[e-1].data[3] = file.readInt(1);
                                break;
                            default :
                                // if user provided a custom interpreter, call it
                                // and assign to event the returned data
                                if( this.customInterpreter !== null){
                                    MIDI.track[t-1].event[e-1].data = this.customInterpreter( MIDI.track[t-1].event[e-1].metaType, file, metaEventLength);
                                }
                                // if no customInterpretr is provided, or returned
                                // false (=apply default), perform default action
                                if(this.customInterpreter === null || MIDI.track[t-1].event[e-1].data === false){
                                    file.readInt(metaEventLength);
                                    MIDI.track[t-1].event[e-1].data = file.readInt(metaEventLength);
                                    if (this.debug) console.info('Unimplemented 0xFF meta event! data block readed as Integer');
                                }
                        }
                    }

                    //
                    // IS REGULAR EVENT
                    //
                    else{                                                           // MIDI Control Events OR System Exclusive Events
                        statusByte = statusByte.toString(16).split('');             // split the status byte HEX representation, to obtain 4 bits values
                        if(!statusByte[1]) statusByte.unshift('0');                 // force 2 digits
                        MIDI.track[t-1].event[e-1].type = parseInt(statusByte[0], 16);// first byte is EVENT TYPE ID
                        MIDI.track[t-1].event[e-1].channel = parseInt(statusByte[1], 16);// second byte is channel
                        switch(MIDI.track[t-1].event[e-1].type){
                            case 0xF:{                                              // System Exclusive Events

                                // if user provided a custom interpreter, call it
                                // and assign to event the returned data
                                if( this.customInterpreter !== null){
                                    MIDI.track[t-1].event[e-1].data = this.customInterpreter( MIDI.track[t-1].event[e-1].type, file , false);
                                }

                                // if no customInterpretr is provided, or returned
                                // false (=apply default), perform default action
                                if(this.customInterpreter === null || MIDI.track[t-1].event[e-1].data === false){
                                    let event_length = file.readIntVLV();
                                    MIDI.track[t-1].event[e-1].data = file.readInt(event_length);
                                    if (this.debug) console.info('Unimplemented 0xF exclusive events! data block readed as Integer');
                                }
                                break;
                            }
                            case 0xA:                                               // Note Aftertouch
                            case 0xB:                                               // Controller
                            case 0xE:                                               // Pitch Bend Event
                            case 0x8:                                               // Note off
                            case 0x9:                                               // Note On
                                MIDI.track[t-1].event[e-1].data = [];
                                MIDI.track[t-1].event[e-1].data[0] = file.readInt(1);
                                MIDI.track[t-1].event[e-1].data[1] = file.readInt(1);
                                break;
                            case 0xC:                                               // Program Change
                            case 0xD:                                               // Channel Aftertouch
                                MIDI.track[t-1].event[e-1].data = file.readInt(1);
                                break;
                            case -1:                                                // EOF
                                endOfTrack = true;                                  // change FLAG to force track reading loop breaking
                                break;
                            default:
                                // if user provided a custom interpreter, call it
                                // and assign to event the returned data
                                if( this.customInterpreter !== null){
                                    MIDI.track[t-1].event[e-1].data = this.customInterpreter( MIDI.track[t-1].event[e-1].metaType, file , false);
                                }

                                // if no customInterpretr is provided, or returned
                                // false (=apply default), perform default action
                                if(this.customInterpreter === null || MIDI.track[t-1].event[e-1].data === false){
                                    console.log('Unknown EVENT detected... reading cancelled!');
                                    return false;
                                }
                        }
                    }
                }
            }
            return MIDI;
        },

        /**
         * custom function to handle unimplemented, or custom midi messages.
         * If message is a meta-event, the value of metaEventLength will be >0.
         * Function must return the value to store, and pointer of dataView needs
         * to be manually increased
         * If you want default action to be performed, return false
         */
        customInterpreter : null // function( e_type , arrayByffer, metaEventLength){ return e_data_int }
    };


    // if running in NODE export module
    if(typeof module !== 'undefined') module.exports = MidiParser;
    else{
        // if running in Browser, set a global variable.
        let _global = typeof window === 'object' && window.self === window && window ||
                    typeof self === 'object' && self.self === self && self ||
                    typeof global === 'object' && global.global === global && global;

        _global.MidiParser = MidiParser;
    }


    
})();

{
  打击乐类: {
    0: { id: 0, label: "Percussion 打击乐" },
  },
  钢琴类: {
    1: { id: 1, label: "Acoustic Grand Piano 大钢琴（声学钢琴）" },
    2: { id: 2, label: "Bright Acoustic Piano 明亮的钢琴" },
    3: { id: 3, label: "Electric Grand Piano 电钢琴" },
    4: { id: 4, label: "Honky-tonk Piano 酒吧钢琴" },
    5: { id: 5, label: "Rhodes Piano 柔和的电钢琴" },
    6: { id: 6, label: "Chorused Piano 加合唱效果的电钢琴" },
    7: { id: 7, label: "Harpsichord 羽管键琴（拨弦古钢琴）" },
    8: { id: 8, label: "Clavichord 科拉维科特琴（击弦古钢琴）" },
  },
  色彩打击乐器类: {
    9: { id: 9, label: "Celesta 钢片琴" },
    10: { id: 10, label: "Glockenspiel 钟琴" },
    11: { id: 11, label: "Music box 八音盒" },
    12: { id: 12, label: "Vibraphone 颤音琴" },
    13: { id: 13, label: "Marimba 马林巴琴" },
    14: { id: 14, label: "Xylophone 木琴" },
    15: { id: 15, label: "Tubular Bells 管钟" },
    16: { id: 16, label: "Dulcimer 大扬琴" },
  },
  风琴类: {
    17: { id: 17, label: "Hammond Organ 击杆风琴" },
    18: { id: 18, label: "Percussive Organ 打击式风琴" },
    19: { id: 19, label: "Rock Organ 摇滚风琴" },
    20: { id: 20, label: "Church Organ 教堂风琴" },
    21: { id: 21, label: "Reed Organ 簧管风琴" },
    22: { id: 22, label: "Accordian 手风琴" },
    23: { id: 23, label: "Harmonica 口琴" },
    24: { id: 24, label: "Tango Accordian 探戈手风琴" },
  },
  吉他类: {
    25: { id: 25, label: "Acoustic Guitar (nylon) 尼龙弦吉他" },
    26: { id: 26, label: "Acoustic Guitar (steel) 钢弦吉他" },
    27: { id: 27, label: "Electric Guitar (jazz) 爵士电吉他" },
    28: { id: 28, label: "Electric Guitar (clean) 清音电吉他" },
    29: { id: 29, label: "Electric Guitar (muted) 闷音电吉他" },
    30: { id: 30, label: "Overdriven Guitar 加驱动效果的电吉他" },
    31: { id: 31, label: "Distortion Guitar 加失真效果的电吉他" },
    32: { id: 32, label: "Guitar Harmonics 吉他和音" },
  },
  贝司类: {
    33: { id: 33, label: "Acoustic Bass 大贝司（声学贝司）" },
    34: { id: 34, label: "Electric Bass(finger) 电贝司（指弹）" },
    35: { id: 35, label: "Electric Bass (pick) 电贝司（拨片）" },
    36: { id: 36, label: "Fretless Bass 无品贝司" },
    37: { id: 37, label: "Slap Bass 1 掌击贝司 1" },
    38: { id: 38, label: "Slap Bass 2 掌击贝司 2" },
    39: { id: 39, label: "Synth Bass 1 电子合成贝司 1" },
    40: { id: 40, label: "Synth Bass 2 电子合成贝司 2" },
  },
  弦乐类: {
    41: { id: 41, label: "Violin 小提琴" },
    42: { id: 42, label: "Viola 中提琴" },
    43: { id: 43, label: "Cello 大提琴" },
    44: { id: 44, label: "Contrabass 低音大提琴" },
    45: { id: 45, label: "Tremolo Strings 弦乐群颤音" },
    46: { id: 46, label: "Pizzicato Strings 弦乐群拨弦" },
    47: { id: 47, label: "Orchestral Harp 竖琴" },
    48: { id: 48, label: "Timpani 定音鼓" },
  },
  "合奏 / 合唱类": {
    49: { id: 49, label: "String Ensemble 1 弦乐合奏 1" },
    50: { id: 50, label: "String Ensemble 2 弦乐合奏 2" },
    51: { id: 51, label: "Synth Strings 1 合成弦乐合奏 1" },
    52: { id: 52, label: "Synth Strings 2 合成弦乐合奏 2" },
    53: { id: 53, label: "Choir Aahs 人声合唱“啊”" },
    54: { id: 54, label: "Voice Oohs 人声“嘟”" },
    55: { id: 55, label: "Synth Voice 合成人声" },
    56: { id: 56, label: "Orchestra Hit 管弦乐敲击齐奏" },
  },
  铜管类: {
    57: { id: 57, label: "Trumpet 小号" },
    58: { id: 58, label: "Trombone 长号" },
    59: { id: 59, label: "Tuba 大号" },
    60: { id: 60, label: "Muted Trumpet 加弱音器小号" },
    61: { id: 61, label: "French Horn 法国号（圆号）" },
    62: { id: 62, label: "Brass Section 铜管组（铜管乐器合奏音色）" },
    63: { id: 63, label: "Synth Brass 1 合成铜管音色 1" },
    64: { id: 64, label: "Synth Brass 2 合成铜管音色 2" },
  },
  簧管类: {
    65: { id: 65, label: "Soprano Sax 高音萨克斯风" },
    66: { id: 66, label: "Alto Sax 中音萨克斯风" },
    67: { id: 67, label: "Tenor Sax 次中音萨克斯风" },
    68: { id: 68, label: "Baritone Sax 低音萨克斯风" },
    69: { id: 69, label: "Oboe 双簧管" },
    70: { id: 70, label: "English Horn 英国管" },
    71: { id: 71, label: "Bassoon 巴松（大管）" },
    72: { id: 72, label: "Clarinet 单簧管（黑管）" },
  },
  笛类: {
    73: { id: 73, label: "Piccolo 短笛" },
    74: { id: 74, label: "Flute 长笛" },
    75: { id: 75, label: "Recorder 竖笛" },
    76: { id: 76, label: "Pan Flute 排箫" },
    77: { id: 77, label: "Bottle Blow 芦笛" },
    78: { id: 78, label: "Shakuhachi 日本尺八" },
    79: { id: 79, label: "Whistle 口哨声" },
    80: { id: 80, label: "Ocarina 奥卡雷那" },
  },
  合成主音类: {
    81: { id: 81, label: "Lead 1 (square) 合成主音 1 （方波）" },
    82: { id: 82, label: "Lead 2 (sawtooth) 合成主音 2 （锯齿波）" },
    83: { id: 83, label: "Lead 3 (caliope lead) 合成主音 3" },
    84: { id: 84, label: "Lead 4 (chiff lead) 合成主音 4" },
    85: { id: 85, label: "Lead 5 (charang) 合成主音 5" },
    86: { id: 86, label: "Lead 6 (voice) 合成主音 6 （人声）" },
    87: { id: 87, label: "Lead 7 (fifths) 合成主音 7 （平行五度）" },
    88: { id: 88, label: "Lead 8 (bass+lead) 合成主音 8 （贝司加主音）" },
  },
  合成音色类: {
    89: { id: 89, label: "Pad 1 (new age) 合成音色 1 （新世纪）" },
    90: { id: 90, label: "Pad 2 (warm) 合成音色 2  （温暖）" },
    91: { id: 91, label: "Pad 3 (polysynth) 合成音色 3" },
    92: { id: 92, label: "Pad 4 (choir) 合成音色 4  （合唱）" },
    93: { id: 93, label: "Pad 5 (bowed) 合成音色 5" },
    94: { id: 94, label: "Pad 6 (metallic) 合成音色 6  （金属声）" },
    95: { id: 95, label: "Pad 7 (halo) 合成音色 7  （光环）" },
    96: { id: 96, label: "Pad 8 (sweep) 合成音色 8" },
  },
  合成效果类: {
    97: { id: 97, label: "FX 1 (rain) 合成效果 1 雨声" },
    98: { id: 98, label: "FX 2 (soundtrack) 合成效果 2 音轨" },
    99: { id: 99, label: "FX 3 (crystal) 合成效果 3 水晶" },
    100: { id: 100, label: "FX 4 (atmosphere) 合成效果 4 大气" },
    101: { id: 101, label: "FX 5 (brightness) 合成效果 5 明亮" },
    102: { id: 102, label: "FX 6 (goblins) 合成效果 6 鬼怪" },
    103: { id: 103, label: "FX 7 (echoes) 合成效果 7 回声" },
    104: { id: 104, label: "FX 8 (sci-fi) 合成效果 8 科幻" },
  },
  民间乐器类: {
    105: { id: 105, label: "Sitar 西塔尔（印度）" },
    106: { id: 106, label: "Banjo 班卓琴（美洲）" },
    107: { id: 107, label: "Shamisen 三昧线（日本）" },
    108: { id: 108, label: "Koto 十三弦筝（日本）" },
    109: { id: 109, label: "Kalimba 卡林巴" },
    110: { id: 110, label: "Bagpipe 风笛" },
    111: { id: 111, label: "Fiddle 民族提琴" },
    112: { id: 112, label: "Shanai 山奈" },
  },
  打击乐器类: {
    113: { id: 113, label: "Tinkle Bell 叮当铃" },
    114: { id: 114, label: "Agogo Agogo" },
    115: { id: 115, label: "Steel Drums 钢鼓" },
    116: { id: 116, label: "Woodblock 木鱼" },
    117: { id: 117, label: "Taiko Drum 太鼓" },
    118: { id: 118, label: "Melodic Tom 通通鼓" },
    119: { id: 119, label: "Synth Drum 合成鼓" },
    120: { id: 120, label: "Reverse Cymbal 铜钹" },
  },
}