MIDI 合成与播放

u32 midi_decode_api(void *strm, void **ppdec, void *p_dp_buf)
{
    dec_data_stream *p_strm = strm;
    dec_obj **p_dec = (dec_obj **)ppdec;
    u32 buff_len, sr;
    decoder_ops_t *ops;
    log_info("midi_decode_api file:0x%x\n", (u32)p_strm->strm_source);
    if (!midi_tone_tab) {
        return E_MIDI_NO_CFG;
    }

    local_irq_disable();
    memset(&dec_midi_hld, 0, sizeof(dec_obj));
    local_irq_enable();

    u32 cal_buf_len;
    void *p_cal_buf;
    if (MIDI_MAX_MARK_CNT) {
        cal_buf_len = sizeof(midi_decode_buff_full);
        p_cal_buf = midi_decode_buff_full;
    } else {
        cal_buf_len = sizeof(midi_decode_buff_nomark);
        p_cal_buf = midi_decode_buff_nomark;
    }
    memset(p_cal_buf, 0, cal_buf_len);

    dec_midi_hld.type = D_TYPE_MIDI;

    ops = get_midi_ops();
    buff_len = ops->need_dcbuf_size();
    if (buff_len > cal_buf_len) {
        log_info("MIDI_DEC Need Buff Len:%d > %d\n", buff_len, cal_buf_len);
        return E_MIDI_DBUF;
    }
    /******************************************/
    cbuf_init(&cbuf_midi, &obuf_midi[0], sizeof(obuf_midi));

    memcpy(&midi_dec_io0, p_strm->io, sizeof(struct if_decoder_io));
    midi_dec_io0.priv      = &dec_midi_hld;

    sound_stream_obj *psound_strm = p_strm->strm_source;
    dec_midi_hld.p_file = (void *)psound_strm;
    dec_midi_hld.sound.p_obuf = &cbuf_midi;
    dec_midi_hld.sound.info |= MIDI_DEC_TRACK;
    dec_midi_hld.p_dbuf = p_cal_buf;
    dec_midi_hld.dec_ops = ops;
    dec_midi_hld.event_tab = (u8 *)&midi_evt[0];
    ...
    ops->open(p_cal_buf, &midi_dec_io0, NULL);

    if (!(B_DEC_NO_CHECK & p_strm->strm_ctl)) {
        if (ops->format_check(p_cal_buf)) {
            return E_MIDIFORMAT;
        }
    }
    sr = dac_sr_read();
    memset((u8 *)&init_info, 0x00, sizeof(init_info));
    midi_init_info(&init_info, midi_musicsr_to_cfgsr(sr), midi_tone_tab, MAX_DEC_PLAYER_CNT);
    ops->dec_confing(p_cal_buf, CMD_INIT_CONFIG, &init_info);

    *p_dec = &dec_midi_hld;
    return 0;
}

int midi_decode_cfg_init(void)
{
    void *pvfs = 0;
    void *pvfile = 0;
    u32 err = 0;

    err = vfs_mount(&pvfs, (void *)NULL, (void *)NULL);
    if (err != 0) {
        return E_MOUNT;
    }

#if defined(MIDI_VER_4BYTE) && (MIDI_VER_SELECT == MIDI_VER_4BYTE)
    /* 4byte的音色库文件后缀是mdb */
    err = vfs_openbypath(pvfs, &pvfile, "/midi_cfg_ster1/00_MIDI.mdb");
#else
    err = vfs_openbypath(pvfs, &pvfile, "/midi_cfg/00_MIDI.mda");
#endif
    if (err != 0) {
        log_info("midi_dec mda open fail, try old midi_cfg.bin!\n");
        err = vfs_openbypath(pvfs, &pvfile, "/midi_cfg/midi_cfg.bin");
        if (err != 0) {
            vfs_fs_close(&pvfs);
            return E_OPENBYPATH;
        }
    }

    ///获取midi音色库的cache地址
    struct vfs_attr attr;
    vfs_get_attrs(pvfile, &attr);
    midi_tone_tab = boot_info.sfc.app_addr + attr.sclust;
    ...
    vfs_file_close(&pvfile);
    vfs_fs_close(&pvfs);
    return 0;
}

u32 midi_ctrl_decode_api(void *strm, void **ppdec, void *p_dp_buf)
{
    dec_data_stream *p_strm = strm;
    if (p_strm->strm_source != NULL) {
        return E_MIDI_FILEHDL;
    }
    ...
    midi_ctrl_t_parm.player_t = MAX_CTR_PLAYER_CNT;
    midi_ctrl_t_parm.sample_rate = midi_musicsr_to_cfgsr(sr);
    midi_ctrl_t_parm.spi_pos = (MIDI_CTRL_POS_TYPE)midi_ctrl_tone_tab;
#if defined(MIDI_VER_4BYTE) && (MIDI_VER_SELECT == MIDI_VER_4BYTE)
    midi_ctrl_t_parm.bitwidth = 16;
    midi_ctrl_t_parm.OutdataBit = 0;
    midi_ctrl_t_parm.out_channel = MIDI_CTRL_OUT_CHANNEL;
#endif

    midi_ctrl_parmt.output = (int (*)(void *, void *, int))p_strm->io->output;
    midi_ctrl_parmt.tempo = 1000;
    midi_ctrl_parmt.track_num = 1;
    midi_ctrl_parmt.priv = &dec_midi_ctrl_hld;

    memset(&midi_ctrl_dec_inf, 0, sizeof(midi_ctrl_dec_inf));
    midi_ctrl_dec_inf.sr = sr;
    midi_ctrl_dec_inf.nch = MIDI_CTRL_CHANNEL;

    ops->open(MIDI_CTRL_CAL_BUF, (const struct if_decoder_io *)&midi_ctrl_parmt, (u8 *)&midi_ctrl_t_parm);

    *p_dec = &dec_midi_ctrl_hld;
    midi_keyboard_function_switch = 0;
    return 0;
}

static u32 midi_tone_init(MIDI_DECODE_VAR *mid_dec_obj, MIDI_CONFIG_PARM *itt_info)
{
    int chn;
    u16 *cmporkind;
    cmporkind = itt_info->spi_pos;
    if (cmporkind[0] == 0xABCD) {
        mid_dec_obj->midi_spi_pos = (u8 *)&cmporkind[1];
        mid_dec_obj->compressIN = 1;
        mid_dec_obj->instr_spi = cmporkind[1];
        mid_dec_obj->instr_map = &cmporkind[130];
    } else {
        mid_dec_obj->midi_spi_pos = (u8 *)itt_info->spi_pos;
        mid_dec_obj->compressIN = 0;
        mid_dec_obj->instr_spi = cmporkind[0];
        mid_dec_obj->instr_map = &cmporkind[129];
    }
    mid_dec_obj->sample_rate = itt_info->sample_rate;
    mid_dec_obj->MAX_PLAYER_CNTt = itt_info->player_t;
    if (mid_dec_obj->MAX_PLAYER_CNTt > MAX_DEC_PLAYER_CNT) {
        mid_dec_obj->MAX_PLAYER_CNTt = MAX_DEC_PLAYER_CNT;
    }

    mid_dec_obj->spi_key_start = (unsigned char *)(&mid_dec_obj->midi_spi_pos[258 + mid_dec_obj->instr_spi * 2]);
    mid_dec_obj->spi_zone_start = mid_dec_obj->spi_key_start + 128 * mid_dec_obj->instr_spi;
    ...
    for (chn = 0; chn < MAX_CHANNEL_NUM; chn++) {
        mid_dec_obj->channel_mixer[chn].cc[MIDI_CTRL_VOL_CC] = 100;
        mid_dec_obj->channel_mixer[chn].cc[MIDI_CTRL_EXPR_CC] = 127;
        mid_dec_obj->channel_mixer[chn].cc[MIDI_CTRL_PAN_CC] = 64;
        mid_dec_obj->pitchBend_v[chn] = 256;
    }
    mid_dec_obj->dec_info.sr = smpl_rate_tab[mid_dec_obj->sample_rate];
    mid_dec_obj->dec_info.nch = 1;
    mid_dec_obj->dec_info.br = 1;
    return 0;
}

u32 midi_dec_confing(void *work_buf, u32 cmd, void *parm)
{
    MIDI_DECODE_VAR *mid_dec_obj = (MIDI_DECODE_VAR *)work_buf;

    if (cmd == CMD_MIDI_SEEK_BACK_N) {
        if (mid_dec_obj->save_ptr_enable) {
            MIDI_SEEK_BACK_STRUCT *t_obj = (MIDI_SEEK_BACK_STRUCT *)parm;
            ...
            int seek_back_n = t_obj->seek_back_n;
            if (seek_back_n > MAX_GO_BACK) {
                seek_back_n = MAX_GO_BACK;
            }
            int rd_cnt = mid_dec_obj->bk_wr_cnt - seek_back_n;
            if (rd_cnt < 0) {
                rd_cnt = rd_cnt + MAX_GO_BACK;
            }
            ...
            tmp_obj = &mid_dec_obj->bk_array_ptr[rd_cnt];
            memcpy(&mid_dec_obj->fpos_cnt, tmp_obj, sizeof(MIDI_SAVE_POS_STRUCT) - 8);
            mid_dec_obj->fpos_cnt -= tmp_obj->remain;
            mid_dec_obj->smf_data.rd_pos = 0;
            mid_dec_obj->smf_data.remain = 0;
            ...
        }
    } else if (cmd == CMD_MIDI_SET_CHN_PROG) {
        int zone_key_v, tbank;
        MIDI_PROG_CTRL_STRUCT *t_obj = (MIDI_PROG_CTRL_STRUCT *)parm;
        mid_dec_obj->ins_trk = t_obj->prog;
        mid_dec_obj->replace_mode = t_obj->replace_mode;
        mid_dec_obj->set_chvol_in = t_obj->ex_vol;
        tbank = mid_dec_obj->ins_trk;
        zone_key_v = mid_dec_obj->midi_spi_pos[2 + tbank];
        mid_dec_obj->instr_start_index_set = mid_dec_obj->instr_map[zone_key_v];
        mid_dec_obj->instr_key_map_set = (unsigned char *)(&mid_dec_obj->spi_key_start[zone_key_v * 128]);
    } else if (cmd == CMD_MIDI_CTRL_TEMPO) {
        midi_play_set_tempo(work_buf, (MIDI_PLAY_CTRL_TEMPO *)parm);
    } else if (cmd == CMD_MIDI_GOON) {
        midi_play_goon(work_buf);
    } else if (cmd == CMD_MIDI_CTRL_MODE) {
        ...
        midi_play_ctrl_on(work_buf, tparm);
    } else if (cmd == CMD_MIDI_SET_SWITCH) {
        u32 v_switch = *(u32 *)parm;
        midi_switch_control(work_buf, (u32)v_switch);
    } else if (cmd == CMD_MIDI_SET_EX_VOL) {
        EX_CH_VOL_PARM *tparm = (EX_CH_VOL_PARM *)parm;
        memcpy((u8 *)(&mid_dec_obj->ex_vol), tparm, sizeof(EX_CH_VOL_PARM));
    } else if (cmd == CMD_MIDI_MELODY_TRIGGER) {
        EX_MELODY_STRUCT *tparm = (EX_MELODY_STRUCT *)parm;
        memcpy((u8 *)(&mid_dec_obj->melody_trig), tparm, sizeof(EX_MELODY_STRUCT));
    } else if (cmd == CMD_INIT_CONFIG) {
        ...
        midi_tone_init(mid_dec_obj, &itt_info->init_info);
        midi_play_ctrl_on(work_buf, &itt_info->mode_info);
        midi_play_set_tempo(work_buf, (MIDI_PLAY_CTRL_TEMPO *)&itt_info->tempo_info);
        midi_switch_control(work_buf, itt_info->switch_info);
        ...
    } else if (cmd == CMD_MIDI_OKON_MODE) {
        MIDI_OKON_MODE *okon = (MIDI_OKON_MODE *)parm;
        mid_dec_obj->okon_mode = okon->OKON_Mode;
        mid_dec_obj->key_mode = okon->Melody_Key_Mode;
        ...
    } else if (cmd == CMD_MIDI_SET_SEMITONE) {
        MIDI_SEMITONE_CTRL_STRUCT *semitone_ctrl = (MIDI_SEMITONE_CTRL_STRUCT *)parm;
        memcpy(&mid_dec_obj->semitone_ctrl, semitone_ctrl, sizeof(MIDI_SEMITONE_CTRL_STRUCT));
    } else if (cmd == CMD_MIDI_LIMITER_TRIGGER) {
        MIDI_Limiter *limiter_trig = (MIDI_Limiter *)parm;
        memcpy(&mid_dec_obj->limiter_trig, limiter_trig, sizeof(MIDI_Limiter));
    } else if (cmd == CMD_MIDI_SET_MARK) {
        MIDI_MARK_PARAM *mark_info = (MIDI_MARK_PARAM *)parm;
        ...
        if (mark_start <= 0) {
            mark_enable = 0;
        }
        if (mark_start >= mark_end) {
            mark_enable = 0;
        }
    }
    ...
}

void  midi_play_set_tempo(void *work_buf, MIDI_PLAY_CTRL_TEMPO *tempo_obj)
{
    long long tmp64;
    MIDI_DECODE_VAR *mid_dec_obj = (MIDI_DECODE_VAR *)work_buf;
    u16 decayval0, decayval1;
    mid_dec_obj->midi_tempo_v = tempo_obj->tempo_val;
    MULSI(mid_dec_obj->now_srTicks, tmp64, mid_dec_obj->srTicks, mid_dec_obj->midi_tempo_v, 10);
    for (int i = 0; i < MAX_CHANNEL_NUM; i++) {
        decayval0 = tempo_obj->decay_val[i] & 0x7ff;
        decayval1 = tempo_obj->decay_val[i] >> 11;
        mid_dec_obj->decay_speed[i] = 32600 + ((168 * decayval0) >> 10);
        if (mid_dec_obj->decay_speed[i] > 32768) {
            mid_dec_obj->decay_speed[i] = 32768;
        }
    }
    mid_dec_obj->mute_threshold = tempo_obj->mute_threshold;
}