diff options
Diffstat (limited to 'fmdriver/fmdriver_pmd.c')
| -rw-r--r-- | fmdriver/fmdriver_pmd.c | 4674 |
1 files changed, 4674 insertions, 0 deletions
diff --git a/fmdriver/fmdriver_pmd.c b/fmdriver/fmdriver_pmd.c new file mode 100644 index 0000000..76a97ba --- /dev/null +++ b/fmdriver/fmdriver_pmd.c @@ -0,0 +1,4674 @@ +#include "fmdriver_pmd.h" +#include "fmdriver_common.h" + +enum { + SSG_ENV_STATE_OLD_AL, + SSG_ENV_STATE_OLD_SR, + SSG_ENV_STATE_OLD_RR, + SSG_ENV_STATE_OLD_OFF, + SSG_ENV_STATE_OLD_NEW = 0xff +}; + +enum { + SSG_ENV_STATE_NEW_OFF, + SSG_ENV_STATE_NEW_AR, + SSG_ENV_STATE_NEW_DR, + SSG_ENV_STATE_NEW_SR, + SSG_ENV_STATE_NEW_RR +}; + +enum { + SSG_ENV_PARAM_NEW_AR, + SSG_ENV_PARAM_NEW_DR, + SSG_ENV_PARAM_NEW_SR, + SSG_ENV_PARAM_NEW_RR +}; + +enum { + SSG_ENV_PARAM_OLD_AL, + SSG_ENV_PARAM_OLD_AD, + SSG_ENV_PARAM_OLD_SR, + SSG_ENV_PARAM_OLD_RR +}; + +enum { + LFO_WF_TRIANGLE1, + LFO_WF_SAWTOOTH, + LFO_WF_SQUARE, + LFO_WF_RANDOM, + LFO_WF_TRIANGLE2, + LFO_WF_TRIANGLE3, + LFO_WF_ONESHOT +}; + +// 3447 +static void pmd_reg_write(struct fmdriver_work *work, + struct driver_pmd *pmd, + uint8_t addr, uint8_t data + ) { + work->opna_writereg(work, addr | (pmd->opna_a1 ? 0x100:0), data); +} + +// 132b +static void pmd_opna_a1_on(struct driver_pmd *pmd) { + pmd->opna_a1 = true; +} + +// 133d +static void pmd_opna_a1_off(struct driver_pmd *pmd) { + pmd->opna_a1 = false; +} + +// 346f +static uint8_t pmd_opna_read_ssgout(struct fmdriver_work *work) { + return work->opna_readreg(work, 0x07); +} + +// 331f +static void pmd_stop_sound(struct fmdriver_work *work, + struct driver_pmd *pmd) { + // stop all FM sound except fm effect (CH6) + + // set release rate to 0xff + bool fmeff = pmd->fmeff_playing; + for (int a1 = 0; a1 < 2; a1++) { + a1 ? pmd_opna_a1_on(pmd) : pmd_opna_a1_off(pmd); + for (int s = 0; s < 4; s++) { + for (int c = 0; c < 3; c++) { + if (a1 && fmeff && (c == 2)) continue; + pmd_reg_write(work, pmd, 0x80|c|(s<<2), 0xff); + } + } + } + // 3353 + // keyoff + for (int c = 0; c < 3; c++) { + work->opna_writereg(work, 0x28, 0x00|c); + } + for (int c = 0; c < 3; c++) { + if (fmeff && (c == 2)) continue; + work->opna_writereg(work, 0x28, 0x04|c); + } + // 3375 + // stop SSG sound + if (!pmd->ssgeff_num) { + if (pmd->ppsdrv_enabled) { + // TODO: PPSDRV + } + work->opna_writereg(work, 0x07, 0xbf); + } else { + // 338f + // don't stop ssg effect when playing + uint8_t ssgout = pmd_opna_read_ssgout(work); + ssgout &= 0x3f; + ssgout |= 0x9b; + work->opna_writereg(work, 0x07, ssgout); + } + // 33a2 + // stop ADPCM + if (!pmd->adpcmeff_playing && !pmd->adpcm_disabled) { + work->opna_writereg(work, 0x101, 0x02); + work->opna_writereg(work, 0x100, 0x01); + work->opna_writereg(work, 0x110, 0x80); + work->opna_writereg(work, 0x110, 0x18); + } + // 33c8 + // stop PPZ8 + if (work->ppz8_functbl) { + for (int c = 0; c < 8; c++) { + work->ppz8_functbl->channel_stop(work->ppz8, c); + } + } +} + +// 11df +static void pmd_mstop(struct fmdriver_work *work, + struct driver_pmd *pmd) { + pmd->playing = false; + pmd->paused = false; + pmd->fadeout_speed = 0; + pmd->status2 = 0xff; + pmd->fadeout_vol = 0xff; + pmd_stop_sound(work, pmd); +} + +// 1058 +static void pmd_reset_state(struct driver_pmd *pmd) { + pmd->fadeout_vol = 0; + pmd->fadeout_speed = 0; + pmd->faded_out = false; + for (struct pmd_part *p = pmd->parts; p < (&pmd->parts[PMD_PART_NUM]); p++) { + /* + bool ext = p->mask.ext; + bool effect = p->mask.effect; + bool mml = p->mask.mml; + bool ff = p->mask.ff; + uint8_t note_proc = p->note_proc; + zero reset part structure + */ + p->actual_note = 0xff; + p->curr_note = 0xff; + } + // 1090 + pmd->no_keyoff = false; + pmd->status1 = 0; + pmd->status2 = 0; + pmd->meas_cnt = 0; + pmd->tick_cnt = 0; + pmd->timera_cnt = 0; + pmd->timera_cnt_b = 0; + for (int i = 0; i < 6; i++) pmd->fm_slotkey[i] = 0; + pmd->fm3ex_fb_alg = 0; + pmd->tonemask_fb_alg = false; + pmd->adpcm_start = 0; + pmd->adpcm_stop = 0; + // TODO: pmd->42c1 = 0x8000; + pmd->ssgrhythm = 0; + pmd->opnarhythm = 0; + pmd->rand = 0; + pmd->fm3ex_force = false; + for (int s = 0; s < 4; s++) { + pmd->fm3ex_det[s] = 0; + } + pmd->fm3ex_needed = 0; + pmd->fm3ex_mode = 0x3f; + pmd->opna_a1 = false; + pmd->meas_len = 96; + pmd->fm_voldown = pmd->fm_voldown_orig; + pmd->ssg_voldown = pmd->ssg_voldown_orig; + pmd->adpcm_voldown = pmd->adpcm_voldown_orig; + pmd->ppz8_voldown = pmd->ppz8_voldown_orig; + pmd->opnarhythm_voldown = pmd->opnarhythm_voldown_orig; + pmd->pcm86_vol_spb = pmd->pcm86_vol_spb_orig; +} + +// 0fa9 +static bool pmd_data_init(struct driver_pmd *pmd) { + if (pmd->data[-1] > 1) return false; + pmd->opm_flag = pmd->data[-1]; + if (pmd->datalen < 0x18) return false; + if (pmd->data[0] != 0x18) { + if (pmd->datalen < (0x18+2)) return false; + pmd->tone_ptr = read16le(&pmd->data[0x18]); + pmd->tone_included = true; + } else { + pmd->tone_included = false; + } + // 0fcd + for (int pi = 0; pi <= PMD_PART_RHYTHM; pi++) { + struct pmd_part *p = &pmd->parts[pi]; + p->ptr = read16le(&pmd->data[pi*2]); + if (pmd->datalen < (p->ptr + 1)) return false; + p->len_cnt = 1; + p->keystatus.off = true; + p->keystatus.off_mask = true; + p->md_cnt = 0xff; + p->md_cnt_set = 0xff; + p->md_cnt_b = 0xff; + p->md_cnt_set_b = 0xff; + p->actual_note = 0xff; + p->curr_note = 0xff; + if (pi <= PMD_PART_FM_6) { + p->vol = 108; + p->fm_pan_ams_pms = 0xc0; + p->fm_slotmask = 0xf0; + p->fm_tone_slotmask = 0xff; + } else if (pi <= PMD_PART_SSG_3) { + p->vol = 8; + p->ssg_mix = 0x07; + p->ssg_env_state_old = SSG_ENV_STATE_OLD_OFF; + } else if (pi == PMD_PART_ADPCM) { + p->vol = 128; + p->fm_pan_ams_pms = 0xc0; + } else if (pi == PMD_PART_RHYTHM) { + p->vol = 15; + } + } + // 1049 + // part R + pmd->r_offset = read16le(&pmd->data[0x16]); + pmd->r_ptr = 0; + return true; +} + +// 111c +static void pmd_reset_opna( + struct fmdriver_work *work, + struct driver_pmd *pmd +) { + // enable FM 4-6ch and set IRQ mask + work->opna_writereg(work, 0x29, 0x83); + // set ssg noise freq to 0 and write + pmd->ssg_noise_freq = 0; + if (!pmd->ssgeff_priority) { + work->opna_writereg(work, 0x06, 0x00); + pmd->ssg_noise_freq_wrote = 0; + } + // 1139 + // reset pan/ams/pms + for (int a = 0; a < 2; a++) { + a ? pmd_opna_a1_on(pmd) : pmd_opna_a1_off(pmd); + for (int c = 0; c < 3; c++) { + pmd_reg_write(work, pmd, 0xb4+c, 0xc0); + } + } + pmd_opna_a1_off(pmd); + // 1166 + // reset HLFO + pmd->opna_last22 = 0x00; + work->opna_writereg(work, 0x22, 0x00); + // 1170 + // reset opnarhythm + for (int i = 0; i < 6; i++) { + pmd->opnarhythm_ilpan[i] = 0xcf; + } + work->opna_writereg(work, 0x10, 0xff); + if (pmd->opnarhythm_voldown) { + pmd->opnarhythm_tl = (0xc0 * (0x100-pmd->opnarhythm_voldown)) >> 10; + } else { + pmd->opnarhythm_tl = 0x30; + } + work->opna_writereg(work, 0x11, pmd->opnarhythm_tl); + // 11a0 + // adpcm: set limit address to 0xffff + if (!pmd->adpcm_disabled) { + work->opna_writereg(work, 0x10c, 0xff); + work->opna_writereg(work, 0x10d, 0xff); + } + // 11b3 + // reset ppz8 pan + // dx=5 ah=0x13 al=i-1 call 0790 + if (work->ppz8_functbl) { + for (int c = 0; c < 8; c++) { + work->ppz8_functbl->channel_pan(work->ppz8, c, 5); + } + } +} + +// 2329 +static void pmd_calc_tempo( + struct driver_pmd *pmd +) { + uint8_t timerb = 0x100 - pmd->timerb; + int tempo = 0xff; + if (timerb) { + tempo = 0x112c / timerb; + if ((0x112c % timerb) & 0x80) tempo++; + if (tempo > 0xff) tempo = 0xff; + } + pmd->tempo = tempo; + pmd->tempo_bak = tempo; +} + +// 2348 +static void pmd_calc_tempo_rev( + struct driver_pmd *pmd +) { + uint8_t tempo = pmd->tempo; + int timerb = 0; + if (tempo) { + timerb = 0x112c / tempo; + if (0x112c % tempo) timerb++; + timerb = 0x100 - timerb; + if (timerb < 0) timerb = 0; + } + pmd->timerb = timerb; + pmd->timerb_bak = timerb; +} + +// 3e43 +static void pmd_timerb_write( + struct fmdriver_work *work, + struct driver_pmd *pmd +) { + // fast forward not implemented + pmd->timerb_wrote = pmd->timerb; + work->opna_writereg(work, 0x26, pmd->timerb); +} + +// 32eb +static void pmd_reset_timer( + struct fmdriver_work *work, + struct driver_pmd *pmd +) { + pmd->timerb = 200; + pmd->timerb_bak = pmd->timerb; + pmd_calc_tempo(pmd); + pmd_timerb_write(work, pmd); + // set timera to 0x000 + // enable both timers + work->opna_writereg(work, 0x25, 0x00); + work->opna_writereg(work, 0x24, 0x00); + work->opna_writereg(work, 0x27, 0x3f); + pmd->tick_cnt = 0; + pmd->meas_cnt = 0; + pmd->meas_len = 96; +} + +// 2cf6 +static void pmd_part_off_ssg( + struct pmd_part *part +) { + if (part->actual_note == 0xff) return; + if (part->ssg_env_state_old == SSG_ENV_STATE_OLD_NEW) { + part->ssg_env_state_new = SSG_ENV_STATE_NEW_RR; + } else { + part->ssg_env_state_old = SSG_ENV_STATE_OLD_RR; + } +} + +// 3102 +static void pmd_lfo_reset( + struct pmd_part *part +) { + part->lfo_diff = 0; + part->lfo = part->lfo_set; + part->md_cnt = part->md_cnt_set; + if (part->lfo_waveform == LFO_WF_SQUARE || + part->lfo_waveform == LFO_WF_RANDOM) { + part->lfo.speed = 1; + } else { + part->lfo.speed++; + } +} + +// 26ec +static void pmd_opnarhythm_tl_write( + struct fmdriver_work *work, + struct driver_pmd *pmd, + uint8_t vol +) { + uint8_t outvol = pmd->fadeout_vol; + if (outvol) { + outvol = ((uint16_t)vol * (0x100-outvol)) >> 8; + } + work->opna_writereg(work, 0x11, outvol); +} + +static uint8_t pmd_part_cmdload( + struct driver_pmd *pmd, + struct pmd_part *part +) { + if (!part->ptr || (pmd->datalen < (part->ptr + 1))) { + part->ptr = 0; + return 0x80; + } + return pmd->data[part->ptr++]; +} + +// 2f5a +static void pmd_part_md_tick( + struct pmd_part *part +) { + if (--part->md_speed) return; + part->md_speed = part->md_speed_set; + if (!part->md_cnt) return; + if (!(part->md_cnt & 0x80)) part->md_cnt--; + // 2f73 + uint8_t step = part->lfo.step; + if (step & 0x80) { + // 2f7a + step = -step; + step += part->md_depth; + if (step & 0x80) { + // 2f87 + step = 0; + if (part->md_depth & 0x80) step = 0x81; + } else { + // 2f81 + step = -step; + } + } else { + // 2f93 + step += part->md_depth; + if (step & 0x80) { + step = 0; + if (part->md_depth & 0x80) step = 0x7f; + } + } + part->lfo.step = step; +} + +// 2fa8 +static uint16_t pmd_rand( + struct driver_pmd *pmd, + uint16_t range +) { + uint16_t rand = pmd->rand * 0x103u; + rand += 3; + rand &= 0x7fffu; + pmd->rand = rand; + uint32_t mul = (uint32_t)rand * range; + return mul / 0x7fffu; +} + +// 2e7f +static void pmd_lfo_tick_waveform( + struct driver_pmd *pmd, + struct pmd_part *part +) { + if (part->lfo.speed != 1) { + if (part->lfo.speed != 0xff) { + part->lfo.speed--; + } + return; + } + part->lfo.speed = part->lfo_set.speed; + switch (part->lfo_waveform) { + case LFO_WF_TRIANGLE1: + case LFO_WF_TRIANGLE2: + case LFO_WF_TRIANGLE3: + { + int16_t deptha = u8s8(part->lfo.step); + if (part->lfo_waveform == LFO_WF_TRIANGLE3) { + deptha *= (deptha > 0) ? deptha : -deptha; + } + // 2ec6 + part->lfo_diff = u16s16((uint16_t)part->lfo_diff + (uint16_t)deptha); + if (!part->lfo_diff) pmd_part_md_tick(part); + if (part->lfo.times != 0xff) { + if (!--part->lfo.times) { + uint8_t times = part->lfo_set.times; + if (part->lfo_waveform != LFO_WF_TRIANGLE2) times *= 2; + part->lfo.times = times; + part->lfo.step = -part->lfo.step; + } + } + } + break; + case LFO_WF_SAWTOOTH: + { + int16_t deptha = u8s8(part->lfo.step); + part->lfo_diff = u16s16((uint16_t)part->lfo_diff + (uint16_t)deptha); + if (part->lfo.times != 0xff) { + if (!--part->lfo.times) { + // 2f09 + part->lfo_diff = -part->lfo_diff; + pmd_part_md_tick(part); + part->lfo.times = part->lfo_set.times * 2; + } + } + } + break; + case LFO_WF_SQUARE: + part->lfo_diff = u8s8(part->lfo.step) * u8s8(part->lfo.times); + pmd_part_md_tick(part); + part->lfo.step = -part->lfo.step; + break; + case LFO_WF_RANDOM: + { + // 2f40 + int deptha = u8s8(part->lfo.step); + if (deptha < 0) deptha = -deptha; + uint16_t range = (unsigned)deptha * part->lfo.times; + uint16_t rand = pmd_rand(pmd, range*2); + rand -= range; + part->lfo_diff = rand; + pmd_part_md_tick(part); + } + break; + case LFO_WF_ONESHOT: + if (part->lfo.times) { + if (part->lfo.times != 0xff) { + part->lfo.times--; + } + part->lfo_diff = u16s16((uint16_t)part->lfo_diff + (uint16_t)u8s8(part->lfo.step)); + } + break; + } +} + +// 2e48 +// returns true if lfo_diff updated +static bool pmd_lfo_tick( + struct driver_pmd *pmd, + struct pmd_part *part +) { + if (part->lfo.delay) { + part->lfo.delay--; + return false; + } + int16_t lfo_diff_prev = part->lfo_diff; + if (part->flagext.lfo) { + // 2e58 + uint8_t cnt = pmd->timera_cnt - pmd->timera_cnt_b; + for (int i = 0; i < cnt; i++) { + pmd_lfo_tick_waveform(pmd, part); + } + } else { + // 2e6f + pmd_lfo_tick_waveform(pmd, part); + } + // 2e76 + return part->lfo_diff != lfo_diff_prev; +} + +// 2493 +static void pmd_part_lfo_flip(struct pmd_part *part) { + int16_t tmpi16; + uint8_t tmpu8; + struct pmd_lfo tmplfo; + struct pmd_part_lfo_flags tmplfof; + struct pmd_part_flagext tmpflagext; + + tmpi16 = part->lfo_diff_b; + part->lfo_diff_b = part->lfo_diff; + part->lfo_diff = tmpi16; + tmplfof = part->lfof_b; + part->lfof_b = part->lfof; + part->lfof = tmplfof; + tmpflagext = part->flagext_b; + part->flagext_b = part->flagext; + part->flagext = tmpflagext; + tmplfo = part->lfo_b; + part->lfo_b = part->lfo; + part->lfo = tmplfo; + tmplfo = part->lfo_set_b; + part->lfo_set_b = part->lfo_set; + part->lfo_set = tmplfo; + tmpu8 = part->md_depth_b; + part->md_depth_b = part->md_depth; + part->md_depth = tmpu8; + tmpu8 = part->md_speed_b; + part->md_speed_b = part->md_speed; + part->md_speed = tmpu8; + tmpu8 = part->md_speed_set_b; + part->md_speed_set_b = part->md_speed_set; + part->md_speed_set = tmpu8; + tmpu8 = part->lfo_waveform_b; + part->lfo_waveform_b = part->lfo_waveform; + part->lfo_waveform = tmpu8; + tmpu8 = part->md_cnt_b; + part->md_cnt_b = part->md_cnt; + part->md_cnt = tmpu8; + tmpu8 = part->md_cnt_set_b; + part->md_cnt_set_b = part->md_cnt_set; + part->md_cnt_set = tmpu8; +} + +// 30a6 +static void pmd_lfo_tick_if_needed_hlfo( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { + part->hlfo_delay = part->hlfo_delay_set; + if (part->hlfo_delay) { + pmd_reg_write(work, pmd, 0xb3+pmd->proc_ch, part->fm_pan_ams_pms & 0xc0); + } + // 30c0 + part->slot_delay_cnt = part->slot_delay; + if (part->lfof.freq || part->lfof.vol) { + if (!part->lfof.sync) { + pmd_lfo_reset(part); + } + pmd_lfo_tick(pmd, part); + } + // 30db + if (part->lfof_b.freq || part->lfof_b.vol) { + if (!part->lfof_b.sync) { + pmd_part_lfo_flip(part); + pmd_lfo_reset(part); + pmd_part_lfo_flip(part); + } + pmd_part_lfo_flip(part); + pmd_lfo_tick(pmd, part); + pmd_part_lfo_flip(part); + } +} + +// 3086 +static void pmd_lfo_tick_if_needed( + struct driver_pmd *pmd, + struct pmd_part *part +) { + if (part->lfof.freq || part->lfof.vol) { + pmd_lfo_tick(pmd, part); + } + // 3091 + if (part->lfof_b.freq || part->lfof_b.vol) { + pmd_part_lfo_flip(part); + pmd_lfo_tick(pmd, part); + pmd_part_lfo_flip(part); + } +} + +// 31ce +static void pmd_ssg_env_tick_new( + struct pmd_part *part +) { + switch (part->ssg_env_state_new) { + case SSG_ENV_STATE_NEW_AR: + // 31d2 + { + uint8_t ar = part->ssg_env_param[SSG_ENV_PARAM_NEW_AR]; + if (((unsigned)(ar-1)) & 0x80) { + // 31ff + if (part->ssg_env_param_set[SSG_ENV_PARAM_NEW_AR]) { + part->ssg_env_param[SSG_ENV_PARAM_NEW_AR]++; + } + } else { + // 31d9 + part->ssg_env_vol = u8s8(part->ssg_env_vol + ar); + if (part->ssg_env_vol <= 0xf) { + // 31e4 + part->ssg_env_param[SSG_ENV_PARAM_NEW_AR] = + part->ssg_env_param_set[SSG_ENV_PARAM_NEW_AR] - 0x10; + } else { + // 31ee + part->ssg_env_vol = 0xf; + part->ssg_env_state_new = SSG_ENV_STATE_NEW_DR; + if (part->ssg_env_param_sl == 0xf) { + part->ssg_env_state_new = SSG_ENV_STATE_NEW_SR; + } + } + } + } + break; + case SSG_ENV_STATE_NEW_DR: + // 320d + { + uint8_t dr = part->ssg_env_param[SSG_ENV_PARAM_NEW_DR]; + if (((unsigned)(dr-1)) & 0x80) { + // 3238 + if (part->ssg_env_param_set[SSG_ENV_PARAM_NEW_DR]) { + part->ssg_env_param[SSG_ENV_PARAM_NEW_DR]++; + } + } else { + // 3214 + part->ssg_env_vol = u8s8(part->ssg_env_vol - dr); + uint8_t sl = part->ssg_env_param_sl; + if ((part->ssg_env_vol >= 0) && (part->ssg_env_vol >= sl)) { + // 3223 + uint8_t newdr = part->ssg_env_param_set[SSG_ENV_PARAM_NEW_DR] - 0x10; + if (newdr & 0x80) newdr += newdr; + part->ssg_env_param[SSG_ENV_PARAM_NEW_DR] = newdr; + } else { + // 3231 + part->ssg_env_vol = sl; + part->ssg_env_state_new = SSG_ENV_STATE_NEW_SR; + } + } + } + break; + case SSG_ENV_STATE_NEW_SR: + // 3246 + { + uint8_t sr = part->ssg_env_param[SSG_ENV_PARAM_NEW_SR]; + if (((unsigned)(sr-1)) & 0x80) { + // 3266 + if (part->ssg_env_param_set[SSG_ENV_PARAM_NEW_SR]) { + part->ssg_env_param[SSG_ENV_PARAM_NEW_SR]++; + } + } else { + // 324d + part->ssg_env_vol = u8s8(part->ssg_env_vol - sr); + if (part->ssg_env_vol < 0) part->ssg_env_vol = 0; + uint8_t newsr = part->ssg_env_param_set[SSG_ENV_PARAM_NEW_SR] - 0x10; + if (newsr & 0x80) newsr += newsr; + part->ssg_env_param[SSG_ENV_PARAM_NEW_SR] = newsr; + } + } + break; + default: // SSG_ENV_STATE_NEW_RR + // 3273 + { + uint8_t rr = part->ssg_env_param[SSG_ENV_PARAM_NEW_RR]; + if (((unsigned)(rr-1)) & 0x80) { + // 3291 + if (part->ssg_env_param_set[SSG_ENV_PARAM_NEW_RR]) { + part->ssg_env_param[SSG_ENV_PARAM_NEW_RR]++; + } + } else { + // 327a + part->ssg_env_vol = u8s8((unsigned)part->ssg_env_vol - rr); + if (part->ssg_env_vol < 0) part->ssg_env_vol = 0; + uint8_t newrr = part->ssg_env_param_set[SSG_ENV_PARAM_NEW_RR]; + newrr += newrr; + newrr -= 0x10; + part->ssg_env_param[SSG_ENV_PARAM_NEW_RR] = newrr; + } + } + break; + } +} + +// 31b9 +// returns true if volume update needed +static bool pmd_ssg_env_tick_new_check( + struct pmd_part *part +) { + if (part->ssg_env_state_new == SSG_ENV_STATE_NEW_OFF) return false; + int8_t prev_vol = part->ssg_env_vol; + pmd_ssg_env_tick_new(part); + return part->ssg_env_vol != prev_vol; +} + +// 3060 +static void pmd_part_lfo_init_fm( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part, + uint8_t note +) { + uint8_t n = note & 0xf; + if (n == 0xc) { + note = part->curr_note; + n = note & 0xf; + } + // 3072 + part->curr_note = note; + + if (n == 0xf) { + pmd_lfo_tick_if_needed(pmd, part); + return; + } + part->portamento_diff = 0; + + if (pmd->no_keyoff) { + pmd_lfo_tick_if_needed(pmd, part); + } else { + pmd_lfo_tick_if_needed_hlfo(work, pmd, part); + } +} + +// 2fc4 +static void pmd_part_lfo_init_ssg( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part, + uint8_t note +) { + uint8_t n = note & 0xf; + if (n == 0xc) { + note = part->curr_note; + n = note & 0xf; + } + // 2fd6 + part->curr_note = note; + if (n == 0xf) { + pmd_lfo_tick_if_needed(pmd, part); + return; + } + // 2fe1 + part->portamento_diff = 0; + if (pmd->no_keyoff) { + pmd_lfo_tick_if_needed(pmd, part); + return; + } + if (part->ssg_env_state_old != SSG_ENV_STATE_OLD_NEW) { + // 2ff6 + part->ssg_env_state_old = SSG_ENV_STATE_OLD_AL; + part->ssg_env_vol = 0; + // isn't this reversed? + uint8_t al = part->ssg_env_param_set[SSG_ENV_PARAM_OLD_AL] = + part->ssg_env_param[SSG_ENV_PARAM_OLD_AL]; + if (!al) { + // 3008 + part->ssg_env_state_old = SSG_ENV_STATE_OLD_SR; + part->ssg_env_vol = part->ssg_env_param[SSG_ENV_PARAM_OLD_AD]; + } + // 3012 + part->ssg_env_param_set[SSG_ENV_PARAM_OLD_SR] = + part->ssg_env_param[SSG_ENV_PARAM_OLD_SR]; + part->ssg_env_param_set[SSG_ENV_PARAM_OLD_RR] = + part->ssg_env_param[SSG_ENV_PARAM_OLD_RR]; + pmd_lfo_tick_if_needed_hlfo(work, pmd, part); + return; + } else { + // 3021 + part->ssg_env_param[SSG_ENV_PARAM_NEW_AR] = + part->ssg_env_param_set[SSG_ENV_PARAM_NEW_AR] - 0x10; + int dr = part->ssg_env_param_set[SSG_ENV_PARAM_NEW_DR] - 0x10; + if (dr < 0) dr += dr; + part->ssg_env_param[SSG_ENV_PARAM_NEW_DR] = dr; + int sr = part->ssg_env_param_set[SSG_ENV_PARAM_NEW_SR] - 0x10; + if (sr < 0) sr += sr; + part->ssg_env_param[SSG_ENV_PARAM_NEW_SR] = sr; + uint8_t rr = part->ssg_env_param_set[SSG_ENV_PARAM_NEW_RR]; + rr += rr; + rr -= 0x10; + part->ssg_env_param[SSG_ENV_PARAM_NEW_RR] = rr; + // 304f + part->ssg_env_vol = part->ssg_env_param_al; + part->ssg_env_state_new = SSG_ENV_STATE_NEW_AR; + // 31b9 + pmd_ssg_env_tick_new_check(part); + pmd_lfo_tick_if_needed_hlfo(work, pmd, part); + return; + } +} + +// 0e5e +static void pmd_ssgeff_stop( + struct fmdriver_work *work, + struct driver_pmd *pmd +) { + // TODO: PPSDRV + work->opna_writereg(work, 0x0a, 0x00); + uint8_t ssgout = pmd_opna_read_ssgout(work); + ssgout |= (1<<2) | (1<<5); + work->opna_writereg(work, 0x07, ssgout); + pmd->ssgeff_priority = 0; + pmd->ssgeff_num = 0xff; + pmd->ssgeff_on = false; +} + +// 0def +static void pmd_ssgeff_advance( + struct fmdriver_work *work, + struct driver_pmd *pmd +) { + const struct pmd_ssgeff_data *ssgeff = pmd->ssgeff_ptr; + if (ssgeff->wait == 0xff) { + pmd_ssgeff_stop(work, pmd); + return; + } + pmd->ssgeff_wait = ssgeff->wait; + pmd->ssgeff_tonefreq = ssgeff->tone_freq; + work->opna_writereg(work, 0x04, pmd->ssgeff_tonefreq); + work->opna_writereg(work, 0x05, pmd->ssgeff_tonefreq>>8); + pmd->ssgeff_noisefreq = ssgeff->noise_freq; + work->opna_writereg(work, 0x06, pmd->ssgeff_noisefreq); + pmd->ssg_noise_freq_wrote = pmd->ssgeff_noisefreq; + uint8_t ssgout = pmd_opna_read_ssgout(work); + ssgout &= ~((1<<2) | (1<<5)); + ssgout |= ((!ssgeff->tone_mix)<<2) | ((!ssgeff->noise_mix)<<5); + pmd->ssgeff_tone_mix = ssgeff->tone_mix; + pmd->ssgeff_noise_mix = ssgeff->noise_mix; + work->opna_writereg(work, 0x07, ssgout); + work->opna_writereg(work, 0x0a, ssgeff->env_level); + work->opna_writereg(work, 0x0b, ssgeff->env_freq); + work->opna_writereg(work, 0x0c, ssgeff->env_freq>>8); + work->opna_writereg(work, 0x0d, ssgeff->env_waveform); + pmd->ssgeff_tonefreq_add = ssgeff->tonefreq_add; + pmd->ssgeff_noisefreq_add = ssgeff->noisefreq_add; + pmd->ssgeff_noisefreq_cnt_set = ssgeff->noisefreq_wait; + pmd->ssgeff_noisefreq_cnt = pmd->ssgeff_noisefreq_cnt_set; + pmd->ssgeff_ptr++; +} + +// 0e8d +static void pmd_ssgeff_tick_idle( + struct fmdriver_work *work, + struct driver_pmd *pmd +) { + pmd->ssgeff_tonefreq += pmd->ssgeff_tonefreq_add; + work->opna_writereg(work, 0x04, pmd->ssgeff_tonefreq); + work->opna_writereg(work, 0x05, pmd->ssgeff_tonefreq>>8); + // pmd_opna_read_ssgout(work); + if (!pmd->ssgeff_noisefreq_add && !pmd->ssgeff_noisefreq_cnt_set) return; + if (--pmd->ssgeff_noisefreq_cnt) return; + pmd->ssgeff_noisefreq_cnt = pmd->ssgeff_noisefreq_cnt_set; + pmd->ssgeff_noisefreq += pmd->ssgeff_noisefreq_add; + work->opna_writereg(work, 0x06, pmd->ssgeff_noisefreq); + pmd->ssg_noise_freq_wrote = pmd->ssgeff_noisefreq; +} + +// 0dde +static void pmd_ssgeff_tick( + struct fmdriver_work *work, + struct driver_pmd *pmd +) { + if (--pmd->ssgeff_wait) { + pmd_ssgeff_tick_idle(work, pmd); + } else { + pmd_ssgeff_advance(work, pmd); + } +} + +// 2dda +static uint8_t *pmd_get_toneptr( + struct driver_pmd *pmd, + uint8_t tonenum +) { + if (pmd->tone_included) { + for (uint16_t toneptr = pmd->tone_ptr; ; toneptr += 0x1a) { + if (pmd->datalen < (toneptr+0x1a)) return 0; + if (pmd->data[toneptr] == tonenum) { + return &pmd->data[toneptr+1]; + } + } + } + // TODO: external tone + return 0; +} + +// 2cbc +static void pmd_part_do_keyoff_fm( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { + uint8_t out = pmd->proc_ch-1; + int ch_ind = pmd->proc_ch-1; + if (pmd->opna_a1) { + ch_ind += 3; + out |= 4; + } + pmd->fm_slotkey[ch_ind] &= ~part->fm_slotmask; + out |= pmd->fm_slotkey[ch_ind]; + work->opna_writereg(work, 0x28, out); +} + +// 2e15 +static bool pmd_part_tone_slotmask_stop( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { + uint8_t mask = part->fm_tone_slotmask; + if (!mask) return false; + uint8_t addr = 0x3f + pmd->proc_ch; + for (int s = 0; s < 4; s++, addr += 4) { + if (!(mask & (1<<(7-s)))) continue; + // TL + pmd_reg_write(work, pmd, addr, 0x7f); + // SL/RR (why 0x7f instead of 0xff?) + pmd_reg_write(work, pmd, addr+0x40, 0x7f); + } + pmd_part_do_keyoff_fm(work, pmd, part); + return true; +} + +// 3ee7 +static const uint8_t pmd_alg_output_slot_table[8] = { + 0x80, 0x80, 0x80, 0x80, 0xa0, 0xe0, 0xe0, 0xf0 +}; +// 3eef +static const uint8_t pmd_alg_tone_slot_table[8] = { + 0xee, 0xee, 0xee, 0xee, 0xcc, 0x88, 0x88, 0x00 +}; + +// 2dce +static void pmd_part_tone_tl_update( + struct pmd_part *part, + uint8_t const *toneptr +) { + for (int s = 0; s < 4; s++) { + part->fm_tone_tl[s] = toneptr[0x04+s]; + } +} + +// 2d0d +static void pmd_part_tone_fm( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { + uint8_t const * const toneptr = pmd_get_toneptr(pmd, part->tonenum); + if (!toneptr) return; + if (!pmd_part_tone_slotmask_stop(work, pmd, part)) { + // 2d15 + //toneptr += 4; + } else { + // 2d1b + uint8_t fb_alg = toneptr[0x18]; + if (pmd->tonemask_fb_alg) fb_alg = part->fb_alg; + if (!pmd->opna_a1 && pmd->proc_ch == 3) { + if (pmd->tonemask_fb_alg) { + // 2d43 + fb_alg = pmd->fm3ex_fb_alg; + } else { + // 2d49 + if (!(part->fm_slotmask & 0x10)) { + fb_alg &= 0x7; + fb_alg |= pmd->fm3ex_fb_alg & 0x38; + } + // 2d59 + pmd->fm3ex_fb_alg = fb_alg; + } + } + // 2d5d + pmd_reg_write(work, pmd, 0xaf+pmd->proc_ch, fb_alg); + part->fb_alg = fb_alg; + uint8_t outslot = pmd_alg_output_slot_table[fb_alg&7]; + if (!(part->vol_lfo_slotmask & 0xf)) { + part->vol_lfo_slotmask = outslot; + } + if (!(part->vol_lfo_slotmask_b & 0xf)) { + part->vol_lfo_slotmask_b = outslot; + } + // 2d83 + part->fm_slotout = outslot; + uint8_t tone_slotmask = part->fm_tone_slotmask; + uint8_t tl_slotmask = pmd_alg_tone_slot_table[fb_alg&7] & tone_slotmask; + for (int s = 0; s < 4; s++) { + if (tone_slotmask & (1<<(7-s))) { + pmd_reg_write(work, pmd, 0x2f+pmd->proc_ch+s*4, toneptr[0x00+s]); + } + } + for (int s = 0; s < 4; s++) { + if (tl_slotmask & (1<<(7-s))) { + pmd_reg_write(work, pmd, 0x3f+pmd->proc_ch+s*4, toneptr[0x04+s]); + } + } + for (int s = 0; s < 4; s++) { + if (tone_slotmask & (1<<(3-s))) { + pmd_reg_write(work, pmd, 0x4f+pmd->proc_ch+s*4, toneptr[0x08+s]); + pmd_reg_write(work, pmd, 0x6f+pmd->proc_ch+s*4, toneptr[0x10+s]); + } + if (tone_slotmask & (1<<(7-s))) { + pmd_reg_write(work, pmd, 0x5f+pmd->proc_ch+s*4, toneptr[0x0c+s]); + pmd_reg_write(work, pmd, 0x7f+pmd->proc_ch+s*4, toneptr[0x14+s]); + } + } + } + // 2dce + pmd_part_tone_tl_update(part, toneptr); +} + +// 0d28, 0d09 +static void pmd_ssg_effect( + struct fmdriver_work *work, + struct driver_pmd *pmd, + uint8_t effnum +) { + if (effnum > PMD_SSGEFF_CNT) return; + pmd->ssgeff_internal = true; + if (pmd->ssgeff_disabled) return; + // TODO: PPSDRV + // 0da4 + pmd->ssgeff_num = effnum; + // 3ef7 + if (pmd->ssgeff_priority > pmd_ssgeff_table[effnum].priority) return; + // TODO: PPSDRV + // 0dc5 + pmd->ssgeff_ptr = pmd_ssgeff_table[effnum].data; + pmd->parts[PMD_PART_SSG_3].mask.effect = true; + pmd_ssgeff_advance(work, pmd); + pmd->ssgeff_priority = pmd_ssgeff_table[effnum].priority; + pmd->ssgeff_on = true; +} + +// 1a58 +static void pmd_cmd_null_16( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { + for (int i = 0; i < 16; i++) { + pmd_part_cmdload(pmd, part); + } +} + +// 1a5b +static void pmd_cmd_null_6( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { + for (int i = 0; i < 6; i++) { + pmd_part_cmdload(pmd, part); + } +} + +// 1a5c +static void pmd_cmd_null_5( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { + for (int i = 0; i < 5; i++) { + pmd_part_cmdload(pmd, part); + } +} + +// 1a5d +static void pmd_cmd_null_4( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { + for (int i = 0; i < 4; i++) { + pmd_part_cmdload(pmd, part); + } +} + +// 1a5e +static void pmd_cmd_null_3( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { + for (int i = 0; i < 3; i++) { + pmd_part_cmdload(pmd, part); + } +} + +// 1a5f +static void pmd_cmd_null_2( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { + for (int i = 0; i < 2; i++) { + pmd_part_cmdload(pmd, part); + } +} + +// 1a60 +static void pmd_cmd_null_1( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { + pmd_part_cmdload(pmd, part); +} + +// 1a61 +static void pmd_cmd_null_0( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { +} + +// 271a +static uint8_t pmd_part_note_transpose( + struct pmd_part *part, + uint8_t note +) { + if (note == 0x0f) return note; + int8_t transpose = u8s8((uint8_t)(part->transpose + part->transpose_master)); + if (!transpose) return note; + uint8_t octave = note >> 4; + note &= 0x0f; + if (transpose < 0) { + int newnote = note + transpose; + while (newnote < 0) { + octave--; + newnote += 0xc; + } + note = newnote; + } else { + int newnote = note + transpose; + while (newnote >= 0xc) { + octave++; + newnote -= 0xc; + } + note = newnote; + } + return octave<<4 | note; +} + +// 2771 +static void pmd_note_freq_fm( + struct pmd_part *part, + uint8_t note +) { + if ((note & 0xf) == 0xf) { + // 2798 + part->actual_note = 0xff; + if (!part->lfof.freq && !part->lfof_b.freq) { + part->actual_freq = 0; + } + return; + } + // 277b + part->actual_note = note; + static const uint16_t fm_tonetable[0x10] = { + // 3eb7 + // round(144*440*(2**((-9+i)/12))*(1<<17)/7987200) + 0x026a, + 0x028f, + 0x02b6, + 0x02df, + 0x030b, + 0x0339, + 0x036a, + 0x039e, + 0x03d5, + 0x0410, + 0x044e, + 0x048f, + 0, 0, 0, 0 + }; + uint16_t freq = fm_tonetable[note & 0x0f]; + freq |= (note & 0x70) << 7; + part->actual_freq = freq; +} + +// 27a8 +static void pmd_note_freq_ssg( + struct pmd_part *part, + uint8_t note +) { + if ((note & 0xf) == 0xf) { + part->actual_note = 0xff; + if (!part->lfof.freq && !part->lfof_b.freq) { + part->actual_freq = 0; + } + return; + } + part->actual_note = note; + static const uint16_t ssg_tonetable[0x10] = { + // 3ecf + // round(7987200/(64*440*(2**-4)*(2.0**((3+i)/12)))) + 0x0ee8, + 0x0e12, + 0x0d48, + 0x0c89, + 0x0bd5, + 0x0b2b, + 0x0a8a, + 0x09f3, + 0x0964, + 0x08dd, + 0x085e, + 0x07e6, + 0, 0, 0, 0 + }; + uint8_t octave = note >> 4; + uint16_t tonefreq = ssg_tonetable[note & 0x0f]; + if (octave) { + tonefreq >>= (octave-1); + bool inc = tonefreq & 1; + tonefreq >>= 1; + tonefreq += inc; + } + part->actual_freq = tonefreq; +} + +// 14a0 +static void pmd_part_calc_gate( + struct driver_pmd *pmd, + struct pmd_part *part +) { + if (pmd->datalen < (part->ptr + 1)) { + if (pmd->data[part->ptr] == 0xc1) { + part->ptr++; + part->gate = 0; + return; + } + } + uint8_t gate = part->gate_abs; + if (part->gate_rel) { + // 14ae + gate += ((uint16_t)part->len_cnt * part->gate_rel) >> 8; + } + // 14b8 + if (part->gate_rand_range) { + // 14be + uint16_t range = part->gate_rand_range & 0x7f; + range++; + uint16_t rand = pmd_rand(pmd, range); + if (part->gate_rand_range & 0x80) { + gate -= rand; + } else { + gate += rand; + } + } + // 14de + if (part->gate_min) { + int len = part->len_cnt - part->gate_min; + if (len < 0) { + part->gate = 0; + return; + } + if (gate >= len) { + gate = len; + } + } + // 14f2 + part->gate = gate; +} + +// 2b4c +// bl = slotmask +// al = vol +static void pmd_fm_vol_out_sub( + uint8_t slotmask, + uint8_t *table, + uint8_t vol +) { + for (int s = 0; s < 4; s++) { + if (!(slotmask & (1<<(7-s)))) continue; + if (!(vol & 0x80)) { + int newvol = table[s] - vol; + if (newvol < 0) newvol = 0; + table[s] = newvol; + } else { + int newvol = table[s] + (uint8_t)(-vol); + if (newvol > 0xff) newvol = 0xff; + table[s] = newvol; + } + } +} + +// 2a38 +static void pmd_fm_vol_out( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { + uint8_t slotmask = part->fm_slotmask; + if (!slotmask) return; + uint8_t vol = part->volume_save; + if (vol) { + vol--; + } else { + vol = part->vol; + } + // 2a4e + if (part != &pmd->parts[PMD_PART_FM_EFF]) { + // 2a56 + if (pmd->fm_voldown) { + uint8_t voldown = -pmd->fm_voldown; + vol = (vol * voldown) >> 8; + } + if (pmd->fadeout_vol) { + uint8_t fadeout = -pmd->fadeout_vol; + vol = (vol * fadeout) >> 8; + } + } + // 2a72 + // 4, 3, 2, 1 + uint8_t table[4] = { + 0x80, 0x80, 0x80, 0x80 + }; + vol ^= 0xff; + uint8_t oslotmask = slotmask & part->fm_slotout; + uint8_t update_slots = oslotmask; + for (int s = 0; s < 4; s++) { + if (oslotmask & (1<<(7-s))) table[s] = vol; + } + // 2aa8 + if (vol != 0xff) { + if (part->lfof.vol) { + uint8_t lslotmask = slotmask & part->vol_lfo_slotmask; + update_slots |= lslotmask; + pmd_fm_vol_out_sub(lslotmask, table, part->lfo_diff); + } + if (part->lfof_b.vol) { + uint8_t lslotmask = slotmask & part->vol_lfo_slotmask_b; + update_slots |= lslotmask; + pmd_fm_vol_out_sub(lslotmask, table, part->lfo_diff_b); + } + } + // 2ad3 + for (int s = 0; s < 4; s++) { + if (!(update_slots & (1<<(7-s)))) continue; + static const uint8_t tladdr[4] = { + 0x4b, 0x43, 0x47, 0x3f + }; + static const uint8_t toneind[4] = { + 3, 1, 2, 0 + }; + int sout = table[s] + part->fm_tone_tl[toneind[s]]; + if (sout > 0xff) sout = 0xff; + sout -= 0x80; + if (sout < 0) sout = 0; + pmd_reg_write(work, pmd, tladdr[s]+pmd->proc_ch, sout); + } +} + +// 2b70 +static void pmd_ssg_vol_out( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { + if (part->ssg_env_state_old == SSG_ENV_STATE_OLD_OFF || + (part->ssg_env_state_old == SSG_ENV_STATE_OLD_NEW && + part->ssg_env_state_new == SSG_ENV_STATE_NEW_OFF)) { + return; + } + uint8_t vol = part->volume_save; + if (vol) { + vol--; + } else { + vol = part->vol; + } + // 2b91 + if (pmd->ssg_voldown) { + uint8_t voldown = -pmd->ssg_voldown; + vol = vol * voldown >> 8; + } + if (pmd->fadeout_vol) { + uint8_t fadeout = -pmd->fadeout_vol; + vol = vol * fadeout >> 8; + } + // 2bad + if (vol) { + if (part->ssg_env_state_old == SSG_ENV_STATE_OLD_NEW) { + // 2bb7 + uint8_t envvol = part->ssg_env_vol; + if (!envvol) { + // 2bd9 + vol = 0; + // -> 2c0f + } else { + vol = (vol * (envvol+1)) >> 3; + if (vol & 1) { + vol >>= 1; + vol++; + } else { + vol >>= 1; + } + } + } else { + // 2bd4 + vol += part->ssg_env_vol; + if (vol & 0x80) vol = 0; // -> 2c0f + if (vol > 0xf) vol = 0xf; + } + if (vol) { + // 2be4 + if (part->lfof.vol || part->lfof_b.vol) { + int32_t lfovol = 0; + // TODO: + if (part->lfof.vol) vol += part->lfo_diff; + if (part->lfof_b.vol) vol += part->lfo_diff_b; + lfovol += vol; + vol = u8s8(lfovol); + if (lfovol < 0) { + vol = 0; + } else if (lfovol > 0xf) { + vol = 0xf; + } + } + } + } + // 2c0f + work->opna_writereg(work, 0x07+pmd->proc_ch, vol); +} + +// 2985 +static void pmd_ssg_freq_out( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { + uint16_t freq = part->actual_freq; + if (!freq) return; + freq += (unsigned)part->portamento_diff; + if (!part->flagext.detune) { + // 2996 + freq += (unsigned)(-part->detune); + if (part->lfof.freq) { + freq += (unsigned)(-part->lfo_diff); + } + if (part->lfof_b.freq) { + freq += (unsigned)(-part->lfo_diff_b); + } + } else { + // 29ad + if (part->detune) { + int32_t det = (((int32_t)freq) * ((int32_t)part->detune)) >> 12; + if (det >= 0) { + det++; + } else { + det--; + } + freq += (uint16_t)(-det); + } + if (part->lfof.freq || part->lfof_b.freq) { + // 29db + int32_t lfo = 0; + if (part->lfof.freq) lfo += part->lfo_diff; + if (part->lfof_b.freq) lfo += part->lfo_diff_b; + if (lfo) { + lfo = (((int32_t)freq) * lfo) >> 12; + if (lfo >= 0) { + lfo++; + } else { + lfo--; + } + freq += (uint16_t)(-lfo); + } + } + // 2a0d + } + // 2a10 + if (freq >= 0x8000) freq = 0; + if (freq >= 0x1000) freq = 0x0fff; + // 2a20 + part->output_freq = freq; + work->opna_writereg(work, (pmd->proc_ch-1)*2, freq); + work->opna_writereg(work, (pmd->proc_ch-1)*2+1, freq>>8); +} + +// 2c9f +static uint16_t pmd_part_ssg_readout( + struct fmdriver_work *work, + struct driver_pmd *pmd +) { + uint16_t ret = 0x0900<<(pmd->proc_ch-1); + ret |= pmd_opna_read_ssgout(work); + return ret; +} + +// 2c67 +static void pmd_ssg_note_noise_out( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { + if (part->actual_note == 0xff) return; + uint16_t noteout = pmd_part_ssg_readout(work, pmd); + uint8_t ssgout = noteout | (noteout >> 8); + uint8_t pmdout = (noteout >> 8) & part->ssg_mix; + ssgout &= ~pmdout; + work->opna_writereg(work, 0x07, ssgout); + if (pmd->ssg_noise_freq != pmd->ssg_noise_freq_wrote) { + if (pmd->ssgeff_num & 0x80) { + work->opna_writereg(work, 0x06, pmd->ssg_noise_freq); + pmd->ssg_noise_freq_wrote = pmd->ssg_noise_freq; + } + } +} + +// 148b +static void pmd_part_loop_check( + struct driver_pmd *pmd, + struct pmd_part *part +) { + pmd->loop.looped &= part->loop.looped; + pmd->loop.ended &= part->loop.ended; + pmd->loop.env &= part->loop.env; +} + +// 2c19 +static void pmd_part_fm_keyon( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { + if (part->actual_note == 0xff) return; + uint8_t *slotkey = &pmd->fm_slotkey[pmd->proc_ch-1+(3*pmd->opna_a1)]; + *slotkey |= part->fm_slotmask; + if (part->slot_delay_cnt) { + *slotkey &= part->slot_delay_mask; + } + work->opna_writereg(work, 0x28, *slotkey | (pmd->proc_ch-1) | (pmd->opna_a1<<2)); +} + +// 2942 +static uint32_t pmd_blkfnum_normalize( + uint16_t blk, + uint16_t fnum +) { + for (;;) { + if ((fnum & 0x8000) || (fnum < 0x26a)) { + int32_t iblk = (int32_t)blk - 0x0800; + if (iblk < 0) { + // 2976 + blk = 0; + if (fnum & 0x8000) fnum = 0x0008; + if (fnum < 0x0008) fnum = 0x0008; + break; + } + blk = iblk; + fnum += 0x26a; + continue; + } + if (fnum < 0x4d4) break; + // 2950 + blk += 0x0800; + if (blk != 0x4000) { + fnum -= 0x26a; + continue; + } + blk = 0x3800; + if (fnum > 0x07ff) fnum = 0x7ff; + break; + } + return (((uint32_t)blk) << 16) | fnum; +} + +// 27d8 +static void pmd_fm_freq_out( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { + uint16_t fnum = part->actual_freq; + if (!fnum) return; + if (!part->fm_slotmask) return; + uint16_t blk = fnum & 0x3800; + fnum &= 0x7ff; + fnum += (uint16_t)part->portamento_diff; + fnum += (uint16_t)part->detune; + if (pmd->proc_ch != 3 || pmd->opna_a1 || pmd->fm3ex_mode == 0x3f) { + // 280c + if (part->lfof.freq) fnum += (uint16_t)part->lfo_diff; + if (part->lfof_b.freq) fnum += (uint16_t)part->lfo_diff_b; + uint32_t blkfnum = pmd_blkfnum_normalize(blk, fnum); + blkfnum |= blkfnum >> 16; + blkfnum &= 0xffff; + part->output_freq = blkfnum; + pmd_reg_write(work, pmd, pmd->proc_ch + 0xa3, blkfnum >> 8); + pmd_reg_write(work, pmd, pmd->proc_ch + 0x9f, blkfnum); + + } else { + // 2837 + uint8_t fm_slotmask = part->fm_slotmask; + uint8_t lfo_slotmask = part->vol_lfo_slotmask; + if (!(lfo_slotmask & 0x0f)) { + lfo_slotmask = 0xf0; + } + uint8_t lfo_slotmask_b = part->vol_lfo_slotmask_b; + if (!(lfo_slotmask_b & 0x0f)) { + lfo_slotmask_b = 0xf0; + } + static const uint8_t slot_addr[2][4] = { + {0xad, 0xae, 0xac, 0xa6}, {0xa9, 0xaa, 0xa8, 0xa2} + }; + for (int s = 3; s >= 0; s--) { + const uint8_t slot_bit = (1 << (4+s)); + if (fm_slotmask & slot_bit) { + // 2858 + uint16_t fnums = fnum + (uint16_t)pmd->fm3ex_det[s]; + if ((lfo_slotmask & slot_bit) && part->lfof.freq) fnums += (uint16_t)part->lfo_diff; + if ((lfo_slotmask_b & slot_bit) && part->lfof_b.freq) fnums += (uint16_t)part->lfo_diff_b; + uint32_t blkfnum = pmd_blkfnum_normalize(blk, fnums); + blkfnum |= blkfnum >> 16; + blkfnum &= 0xffff; + part->output_freq = blkfnum; + pmd_reg_write(work, pmd, slot_addr[0][s], blkfnum >> 8); + pmd_reg_write(work, pmd, slot_addr[1][s], blkfnum); + } + } + } +} + +// 13b5 +static void pmd_part_fm_out( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { + if (part->volume_save && part->actual_note != 0xff) { + if (!pmd->volume_saved) { + part->volume_save = 0; + } + pmd->volume_saved = false; + } + pmd_fm_vol_out(work, pmd, part); + pmd_fm_freq_out(work, pmd, part); + pmd_part_fm_keyon(work, pmd, part); + part->note_proc++; + pmd->no_keyoff = false; + pmd->volume_saved = false; + part->keystatus.off = false; + part->keystatus.off_mask = false; + if (pmd->datalen > (part->ptr + 1)) { + if (pmd->data[part->ptr] == 0xfb) { + part->keystatus.off_mask = true; + } + } + pmd_part_loop_check(pmd, part); +} + +// 15d4 +static void pmd_part_ssg_out( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { + if (part->volume_save && part->actual_note != 0xff) { + if (!pmd->volume_saved) { + part->volume_save = 0; + } + pmd->volume_saved = false; + } + // 15ef + pmd_ssg_vol_out(work, pmd, part); + pmd_ssg_freq_out(work, pmd, part); + pmd_ssg_note_noise_out(work, pmd, part); + part->note_proc++; + pmd->no_keyoff = false; + pmd->volume_saved = 0; + part->keystatus.off = false; + part->keystatus.off_mask = false; + if (pmd->datalen > (part->ptr + 1)) { + if (pmd->data[part->ptr] == 0xfb) { + part->keystatus.off_mask = true; + } + } + pmd_part_loop_check(pmd, part); +} + +// none +static bool pmd_part_masked( + const struct pmd_part *part +) { + return part->mask.ext || part->mask.effect || part->mask.disabled + || part->mask.slot || part->mask.mml || part->mask.ff; +} + +// 1f7e +static void pmd_fm_freq_out_mask( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { + if (!pmd_part_masked(part)) { + pmd_fm_freq_out(work, pmd, part); + } +} + +// 1ee3 +static void pmd_fm3ex_mode_update( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { + int partbit; + if (part == &pmd->parts[PMD_PART_FM_3]) partbit = 1; + else if (part == &pmd->parts[PMD_PART_FM_3B]) partbit = 2; + else if (part == &pmd->parts[PMD_PART_FM_3C]) partbit = 4; + else partbit = 8; + + bool fm3ex; + if (!(part->fm_slotmask & 0xf0)) fm3ex = false; + else if (part->fm_slotmask != 0xf0) fm3ex = true; + else if (!(part->vol_lfo_slotmask & 0x0f)) fm3ex = false; + else if (part->lfof.freq) fm3ex = true; + else if (!(part->vol_lfo_slotmask_b & 0x0f)) fm3ex = false; + else if (part->lfof_b.freq) fm3ex = true; + else fm3ex = false; + if (!fm3ex) { + pmd->fm3ex_needed &= ~partbit; + } else { + pmd->fm3ex_needed |= partbit; + } + uint8_t fm3ex_mode; + if (pmd->fm3ex_needed || pmd->fm3ex_force) { + fm3ex_mode = 0x7f; + } else { + fm3ex_mode = 0x3f; + } + if (fm3ex_mode == pmd->fm3ex_mode) return; + pmd->fm3ex_mode = fm3ex_mode; + // output to 0x27 to update fm3exmode + // but mask with 0xcf to prevent timer resetting + work->opna_writereg(work, 0x27, fm3ex_mode & 0xcf); + if (fm3ex_mode == 0x3f) return; + if (part == &pmd->parts[PMD_PART_FM_3]) return; + pmd_fm_freq_out_mask(work, pmd, &pmd->parts[PMD_PART_FM_3]); + if (part == &pmd->parts[PMD_PART_FM_3B]) return; + pmd_fm_freq_out_mask(work, pmd, &pmd->parts[PMD_PART_FM_3B]); + if (part == &pmd->parts[PMD_PART_FM_3C]) return; + pmd_fm_freq_out_mask(work, pmd, &pmd->parts[PMD_PART_FM_3C]); +} + +// 1d7b +static bool pmd_fm3ex_mode_update_check( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { + if (pmd->proc_ch == 3 && !pmd->opna_a1) { + pmd_fm3ex_mode_update(work, pmd, part); + return true; + } + return false; +} + +// 2268 +static void pmd_cmdff_tonenum( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t tonenum = pmd_part_cmdload(pmd, part); + part->tonenum = tonenum; + if (!pmd_part_masked(part)) { + pmd_part_tone_fm(work, pmd, part); + return; + } + // 2277 + uint8_t const * const toneptr = pmd_get_toneptr(pmd, tonenum); + if (!toneptr) return; + part->fb_alg = toneptr[0x18]; + pmd_part_tone_tl_update(part, toneptr); + if (pmd->proc_ch == 3 && part->fm_tone_slotmask && !pmd->opna_a1) { + uint8_t fb_alg = part->fb_alg; + if (!(part->fm_slotmask & 0x10)) { + fb_alg &= 0x07; + fb_alg |= pmd->fm3ex_fb_alg & 0x38; + } + pmd->fm3ex_fb_alg = fb_alg; + part->fb_alg = fb_alg; + } +} + +// 22b3 +static void pmd_cmdfe_gate_abs( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + (void)work; + part->gate_abs = pmd_part_cmdload(pmd, part); + part->gate_rand_range = 0; +} + +// 22cb +static void pmd_cmdfd_vol( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + (void)work; + part->vol = pmd_part_cmdload(pmd, part); +} + +// 22d0 +static void pmd_cmdfc_tempo( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + (void)work; + uint8_t val = pmd_part_cmdload(pmd, part); + if (val < 0xfb) { + pmd->timerb = val; + pmd->timerb_bak = val; + pmd_calc_tempo(pmd); + } else if (val == 0xff) { + // 22e1 + uint8_t tempo = pmd_part_cmdload(pmd, part); + if (tempo < 0x12) tempo = 0x12; + pmd->tempo = tempo; + pmd->tempo_bak = tempo; + pmd_calc_tempo_rev(pmd); + } else if (val == 0xfe) { + // 22f0 + int timerbdiff = u8s8(pmd_part_cmdload(pmd, part)); + int timerb = pmd->timerb_bak + timerbdiff; + if (timerb > 0xfa) timerb = 0xfa; + if (timerb < 0) timerb = 0; + pmd->timerb = timerb; + pmd->timerb_bak = timerb; + pmd_calc_tempo(pmd); + } else { + // 2313 + int tempodiff = u8s8(pmd_part_cmdload(pmd, part)); + int tempo = pmd->tempo_bak + tempodiff; + if (tempo > 0xff) tempo = 0xff; + if (tempo < 0x12) tempo = 0x12; + pmd->tempo = tempo; + pmd->tempo_bak = tempo; + pmd_calc_tempo_rev(pmd); + } +} + +// 236b +static void pmd_cmdfb_tie( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + pmd->no_keyoff = true; +} + +// 2371, 2376 +static void pmd_cmdfa_d5_det( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + (void)work; + uint16_t val = pmd_part_cmdload(pmd, part); + val |= ((uint16_t)(pmd_part_cmdload(pmd, part)) << 8); + part->detune = u16s16(val); +} + +// 237b +static void pmd_cmdf9_repeat_reset( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint16_t ptr = pmd_part_cmdload(pmd, part); + ptr |= ((uint16_t)(pmd_part_cmdload(pmd, part)) << 8); + ptr++; + if (pmd->datalen < (ptr+1)) { + // TODO: better error handling + part->ptr = 0; + } else { + pmd->data[ptr] = 0; + } +} + +// 2391 +static void pmd_cmdf8_repeat( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t repeat = pmd_part_cmdload(pmd, part); + if (repeat) { + // 0xf8 repeat cnt ptr + if (pmd->datalen < (part->ptr+1)) { + part->ptr = 0; + return; + } + pmd->data[part->ptr]++; + uint8_t repeatcnt = pmd_part_cmdload(pmd, part); + if (repeat == repeatcnt) { + part->ptr += 2; + return; + } + } else { + // 0xf8 0x00 0x00 ptr + part->ptr++; + part->loop.looped = true; + part->loop.ended = false; + } + // 23a7 + uint16_t ptr = pmd_part_cmdload(pmd, part); + ptr |= ((uint16_t)(pmd_part_cmdload(pmd, part)) << 8); + ptr += 2; + part->ptr = ptr; +} + +// 23bd +static void pmd_cmdf7_repeat_exit( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint16_t ptr = pmd_part_cmdload(pmd, part); + ptr |= ((uint16_t)(pmd_part_cmdload(pmd, part)) << 8); + if (pmd->datalen < (ptr+2)) { + part->ptr = 0; + return; + } + uint8_t repeat = pmd->data[ptr]; + uint8_t repeatcnt = pmd->data[ptr+1]; + if (repeatcnt == (repeat-1)) { + part->ptr = ptr+4; + } +} + +// 23de +static void pmd_cmdf6_set_loop( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + part->loop_ptr = part->ptr; +} + +// 23e2 +static void pmd_cmdf5_transpose( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + part->transpose = pmd_part_cmdload(pmd, part); +} + +// 23f4 +static void pmd_cmdf4_volinc_fm( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + part->vol += 4; + if (part->vol > 0x7f) part->vol = 0x7f; +} + +// 2409 +static void pmd_cmdf4_volinc_ssg( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + if (part->vol < 0xf) part->vol++; +} + +// 241c +static void pmd_cmdf3_voldec_fm( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + int vol = part->vol - 4; + if (vol < 0) vol = 0; + part->vol = vol; +} + +// 2435 +static void pmd_cmdf3_voldec_ssg( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + if (part->vol) part->vol--; +} + +// 24ea +static void pmd_cmdf2_lfo( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + part->lfo_set.delay = pmd_part_cmdload(pmd, part); + part->lfo_set.speed = pmd_part_cmdload(pmd, part); + part->lfo_set.step = pmd_part_cmdload(pmd, part); + part->lfo_set.times = pmd_part_cmdload(pmd, part); + part->lfo = part->lfo_set; + pmd_lfo_reset(part); +} + +// 2513 +static void pmd_cmdf1_lfo_switch( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t val = pmd_part_cmdload(pmd, part); + if (val & 0xf8) val = 1; + part->lfof.freq = val & (1<<0); + part->lfof.vol = val & (1<<1); + part->lfof.sync = val & (1<<2); + pmd_lfo_reset(part); +} + +// 2526 +static void pmd_cmdf1_lfo_switch_fm( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + pmd_cmdf1_lfo_switch(work, pmd, part); + pmd_fm3ex_mode_update_check(work, pmd, part); +} + +// 1d31 +static void pmd_cmdf1_ppsdrv( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t data = pmd_part_cmdload(pmd, part); + // TODO: PPSDRV +} + +// 252c +static void pmd_cmdf0_env_old( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t val; + val = pmd_part_cmdload(pmd, part); + part->ssg_env_param_set[SSG_ENV_PARAM_OLD_AL] = val; + part->ssg_env_param[SSG_ENV_PARAM_OLD_AL] = val; + val = pmd_part_cmdload(pmd, part); + part->ssg_env_param_set[SSG_ENV_PARAM_OLD_AD] = val; + val = pmd_part_cmdload(pmd, part); + part->ssg_env_param_set[SSG_ENV_PARAM_OLD_SR] = val; + part->ssg_env_param[SSG_ENV_PARAM_OLD_SR] = val; + val = pmd_part_cmdload(pmd, part); + part->ssg_env_param_set[SSG_ENV_PARAM_OLD_RR] = val; + part->ssg_env_param[SSG_ENV_PARAM_OLD_RR] = val; + if (part->ssg_env_state_old == SSG_ENV_STATE_OLD_NEW) { + part->ssg_env_state_old = SSG_ENV_STATE_OLD_RR; + part->ssg_env_vol = -15; + } +} + +// 2554 +static void pmd_cmdef_poke( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t reg = pmd_part_cmdload(pmd, part); + uint8_t data = pmd_part_cmdload(pmd, part); + pmd_reg_write(work, pmd, reg, data); +} + +// 255c +static void pmd_cmdee_noise_freq( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + pmd->ssg_noise_freq = pmd_part_cmdload(pmd, part); +} + +// 2576 +static void pmd_cmded_ssgmix( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + part->ssg_mix = pmd_part_cmdload(pmd, part); +} + +// 25cc +static uint8_t pmd_hlfo_delay_check( + struct pmd_part *part, + uint8_t pan_ams_pms +) { + if (part->hlfo_delay) pan_ams_pms &= 0xc0; + return pan_ams_pms; +} + +// 257c +static void pmd_part_set_pan( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part, + uint8_t pan +){ + uint8_t pan_ams_pms = (pan & 3) << 6; + pan_ams_pms |= part->fm_pan_ams_pms & 0x3f; + part->fm_pan_ams_pms = pan_ams_pms; + // 258e + if (pmd->proc_ch == 3 && !pmd->opna_a1) { + pmd->parts[PMD_PART_FM_3].fm_pan_ams_pms = pan_ams_pms; + pmd->parts[PMD_PART_FM_3B].fm_pan_ams_pms = pan_ams_pms; + pmd->parts[PMD_PART_FM_3C].fm_pan_ams_pms = pan_ams_pms; + pmd->parts[PMD_PART_FM_3D].fm_pan_ams_pms = pan_ams_pms; + } + // 25b6 + if (pmd_part_masked(part)) return; + pan_ams_pms = pmd_hlfo_delay_check(part, pan_ams_pms); + pmd_reg_write(work, pmd, 0xb3+pmd->proc_ch, pan_ams_pms); +} + +// 257b +static void pmd_cmdec_pan( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + pmd_part_set_pan(work, pmd, part, pmd_part_cmdload(pmd, part)); +} + +// 265d +static void pmd_opnarhythm_inc(uint8_t *incdata, uint8_t val) { + for (int i = 0; i < 6; i++) { + if (val & (1<<i)) { + incdata[i]++; + } + } +} + +// 25ed +static void pmd_cmdeb_opnarhythm( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t val = pmd_part_cmdload(pmd, part); + val &= pmd->opnarhythm_mask; + if (!val) return; + if (pmd->fadeout_vol) { + pmd_opnarhythm_tl_write(work, pmd, pmd->opnarhythm_tl); + } + if (!(val & 0x80)) { + // 260c + for (int i = 0; i < 6; i++) { + if (val & (1<<i)) { + work->opna_writereg(work, 0x18+i, pmd->opnarhythm_ilpan[i]); + } + } + } + // 2626 + work->opna_writereg(work, 0x10, val); + if (val & 0x80) { + // 262d + pmd_opnarhythm_inc(pmd->opnarhythm_dump_inc, val); + pmd->opnarhythm &= val ^ 0xff; + } else { + // 263b + pmd_opnarhythm_inc(pmd->opnarhythm_shot_inc, val); + pmd->opnarhythm |= val; + } +} + +// 266c +static void pmd_cmdea_opnarhythm_il( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t val = pmd_part_cmdload(pmd, part); + uint8_t i = (val >> 5) - 1; + if (i >= 6) return; + uint8_t ilpan = pmd->opnarhythm_ilpan[i]; + ilpan &= ~0x1fu; + ilpan |= val & 0x1f; + pmd->opnarhythm_ilpan[i] = ilpan; + work->opna_writereg(work, 0x18+i, ilpan); +} + +// 26c8 +static void pmd_cmde9_opnarhythm_pan( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t val = pmd_part_cmdload(pmd, part); + uint8_t i = (val >> 5) - 1; + if (i >= 6) return; + uint8_t ilpan = pmd->opnarhythm_ilpan[i]; + ilpan &= ~0xc0u; + ilpan |= (val & 0x3) << 6; + pmd->opnarhythm_ilpan[i] = ilpan; + work->opna_writereg(work, 0x18+i, ilpan); +} + +// 26d8 +static void pmd_cmde8_opnarhythm_tl( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t tl = pmd_part_cmdload(pmd, part); + if (pmd->opnarhythm_voldown) { + tl = ((uint16_t)tl * (0x100-pmd->opnarhythm_voldown)) >> 8; + } + pmd->opnarhythm_tl = tl; + if (pmd->fadeout_vol) { + tl = ((uint16_t)tl * (0x100-pmd->fadeout_vol)) >> 8; + } + work->opna_writereg(work, 0x11, tl); +} + +// 23e7 +static void pmd_cmde7_transpose_rel( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + part->transpose += pmd_part_cmdload(pmd, part); +} + +// 26fe +static void pmd_cmde6_opnarhythm_tl_rel( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + int tl = pmd->opnarhythm_tl + u8s8(pmd_part_cmdload(pmd, part)); + if (tl > 0x3f) tl = 0x3f; + if (tl < 0) tl = 0; + pmd->opnarhythm_tl = tl; + if (pmd->fadeout_vol) { + tl = ((uint16_t)tl * (0x100-pmd->fadeout_vol)) >> 8; + } + work->opna_writereg(work, 0x11, tl); +} + +// 2695 +static void pmd_cmde5_opnarhythm_il_rel( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t i = pmd_part_cmdload(pmd, part) - 1; + if (i >= 6) { + part->ptr++; + return; + } + int il = pmd->opnarhythm_ilpan[i] & 0x1f; + il += u8s8(pmd_part_cmdload(pmd, part)); + if (il > 0x1f) il = 0x1f; + if (il < 0) il = 0; + pmd->opnarhythm_ilpan[i] &= ~0x1fu; + pmd->opnarhythm_ilpan[i] |= il; + work->opna_writereg(work, 0x18+i, pmd->opnarhythm_ilpan[i]); +} + +// 225e +static void pmd_cmde4_hlfo_delay( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + part->hlfo_delay_set = pmd_part_cmdload(pmd, part); +} + +// 2403 +static void pmd_cmde3_vol_add_fm( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t vol = part->vol + pmd_part_cmdload(pmd, part); + if (vol > 0x7f) vol = 0x7f; + part->vol = vol; +} + +// 2416 +static void pmd_cmde3_vol_add_ssg( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t vol = part->vol + pmd_part_cmdload(pmd, part); + if (vol > 0xf) vol = 0xf; + part->vol = vol; +} + +// FM: 2427 +// SSG: 2440 +static void pmd_cmde2_vol_sub( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + int vol = part->vol - pmd_part_cmdload(pmd, part); + if (vol < 0) vol = 0; + part->vol = vol; +} + +// 2209 +static void pmd_cmde1_ams_pms( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t pan_ams_pms = pmd_part_cmdload(pmd, part); + pan_ams_pms |= part->fm_pan_ams_pms & 0xc0; + part->fm_pan_ams_pms = pan_ams_pms; + if (pmd->proc_ch == 3 && !pmd->opna_a1) { + pmd->parts[PMD_PART_FM_3].fm_pan_ams_pms = pan_ams_pms; + pmd->parts[PMD_PART_FM_3B].fm_pan_ams_pms = pan_ams_pms; + pmd->parts[PMD_PART_FM_3C].fm_pan_ams_pms = pan_ams_pms; + pmd->parts[PMD_PART_FM_3D].fm_pan_ams_pms = pan_ams_pms; + } + if (pmd_part_masked(part)) return; + pan_ams_pms = pmd_hlfo_delay_check(part, pan_ams_pms); + pmd_reg_write(work, pmd, 0xb3+pmd->proc_ch, pan_ams_pms); +} + +// 2252 +static void pmd_cmde0_hlfo( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t hlfo = pmd_part_cmdload(pmd, part); + pmd->opna_last22 = hlfo; + work->opna_writereg(work, 0x22, hlfo); +} + +// 2263 +static void pmd_cmddf_meas_len( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + pmd->meas_len = pmd_part_cmdload(pmd, part); +} + +// 21cc +static void pmd_cmdde_echo_init_add_fm( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t vol = part->vol + pmd_part_cmdload(pmd, part); + if (vol > 0x7f) vol = 0x7f; + part->volume_save = vol+1; + pmd->volume_saved = true; +} + +// 21e1 +static void pmd_cmdde_echo_init_add_ssg( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t vol = part->vol + pmd_part_cmdload(pmd, part); + if (vol > 0xf) vol = 0xf; + part->volume_save = vol+1; + pmd->volume_saved = true; +} + +// 21fb +static void pmd_cmddd_echo_init_sub( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + int vol = part->vol - pmd_part_cmdload(pmd, part); + if (vol < 0) vol = 0; + part->volume_save = vol+1; + pmd->volume_saved = true; +} + +// 21be +static void pmd_cmddc_status1( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + pmd->status1 = pmd_part_cmdload(pmd, part); +} + +// 21c3 +static void pmd_cmddb_status1_add( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + pmd->status1 += pmd_part_cmdload(pmd, part); +} + +// 2104 +static void pmd_cmdda_portamento_fm( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t note = pmd_part_cmdload(pmd, part); + if (pmd_part_masked(part)) { + return; + } + pmd_part_lfo_init_fm(work, pmd, part, note); + note = pmd_part_note_transpose(part, note); + pmd_note_freq_fm(part, note); + uint16_t f1 = part->actual_freq; + uint8_t n1 = part->actual_note; + note = pmd_part_cmdload(pmd, part); + note = pmd_part_note_transpose(part, note); + pmd_note_freq_fm(part, note); + uint16_t f2 = part->actual_freq; + part->actual_freq = f1; + part->actual_note = n1; + uint8_t f2blk = f2 >> 11; + uint8_t f1blk = f1 >> 11; + f1 &= 0x7ff; + f2 &= 0x7ff; + int32_t blkdiff = (int32_t)(f2blk - f1blk) * 0x26a; + int32_t freqdiff = f2 - f1 + blkdiff; + uint8_t clocks = pmd_part_cmdload(pmd, part); + part->len = part->len_cnt = clocks; + pmd_part_calc_gate(pmd, part); + int16_t p_add = 0; + int16_t p_rem = 0; + if (clocks) { + p_add = freqdiff / clocks; + p_rem = freqdiff % clocks; + } + part->portamento_add = p_add; + part->portamento_rem = p_rem; + part->lfof.portamento = true; + pmd_part_fm_out(work, pmd, part); +} + +// 2176 +static void pmd_cmdda_portamento_ssg( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t note = pmd_part_cmdload(pmd, part); + if (pmd_part_masked(part)) { + return; + } + pmd_part_lfo_init_ssg(work, pmd, part, note); + note = pmd_part_note_transpose(part, note); + pmd_note_freq_ssg(part, note); + uint16_t f1 = part->actual_freq; + uint8_t n1 = part->actual_note; + note = pmd_part_cmdload(pmd, part); + note = pmd_part_note_transpose(part, note); + pmd_note_freq_ssg(part, note); + uint16_t f2 = part->actual_freq; + part->actual_freq = f1; + part->actual_note = n1; + uint8_t clocks = pmd_part_cmdload(pmd, part); + part->len = part->len_cnt = clocks; + int freqdiff = f2 - f1; + pmd_part_calc_gate(pmd, part); + int16_t p_add = 0; + int16_t p_rem = 0; + if (clocks) { + p_add = freqdiff / clocks; + p_rem = freqdiff % clocks; + } + part->portamento_add = p_add; + part->portamento_rem = p_rem; + part->lfof.portamento = true; + pmd_part_ssg_out(work, pmd, part); +} + +// 20bf +static void pmd_cmdd6_md( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + part->md_speed = pmd_part_cmdload(pmd, part); + part->md_speed_set = part->md_speed; + part->md_depth = pmd_part_cmdload(pmd, part); +} + +// 2054 +static void pmd_cmdd4_ssgeff( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t cmd = pmd_part_cmdload(pmd, part); + if (pmd_part_masked(part)) return; + if (cmd) { + pmd_ssg_effect(work, pmd, cmd); + } else { + pmd_ssgeff_stop(work, pmd); + } +} + +// 206f +static void pmd_cmdd3_fmeff( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + // TODO: 42ae + uint8_t val = pmd_part_cmdload(pmd, part); + if (pmd_part_masked(part)) return; + bool a1 = pmd->opna_a1; + if (val) { + //3be1(); + } else { + //3c43(); + } + pmd->opna_a1 = a1; +} + +// 20b6 +static void pmd_cmdd2_fadeout( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + // TODO + pmd_part_cmdload(pmd, part); +} + +// 2561 +static void pmd_cmdd0_ssgnoisefreqadd( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + int nf = pmd->ssg_noise_freq + u8s8(pmd_part_cmdload(pmd, part)); + if (nf < 0) nf = 0; + if (nf > 0x1f) nf = 0x1f; + pmd->ssg_noise_freq = nf; +} + +// 2044 +static void pmd_part_fm_keyon_if_not_masked( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { + if (!pmd_part_masked(part) && !part->keystatus.off_mask) + pmd_part_fm_keyon(work, pmd, part); +} + +// 1f88 +static void pmd_cmdcf_slotmask( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t data = pmd_part_cmdload(pmd, part); + if (data & 0x0f) { + part->fm_slotout = data << 4; + } else { + // 1f9c + uint8_t alg = 0; + if (pmd->proc_ch == 3 && !pmd->opna_a1) { + alg = pmd->fm3ex_fb_alg; + } else { + // 2dda + const uint8_t *toneptr = pmd_get_toneptr(pmd, part->tonenum); + if (toneptr) { + alg = toneptr[0x18]; + } + } + alg &= 7; + part->fm_slotout = pmd_alg_output_slot_table[alg]; + } + // 1fc9 + data &= 0xf0; + if (data == part->fm_slotmask) return; + // 1fd1 + part->fm_slotmask = data; + part->mask.slot = !data; + // 1fe3 + if (pmd_fm3ex_mode_update_check(work, pmd, part) + && part != &pmd->parts[PMD_PART_FM_3]) { + pmd_part_fm_keyon_if_not_masked(work, pmd, &pmd->parts[PMD_PART_FM_3]); + if (part != &pmd->parts[PMD_PART_FM_3B]) { + pmd_part_fm_keyon_if_not_masked(work, pmd, &pmd->parts[PMD_PART_FM_3B]); + if (part != &pmd->parts[PMD_PART_FM_3C]) { + pmd_part_fm_keyon_if_not_masked(work, pmd, &pmd->parts[PMD_PART_FM_3C]); + } + } + } + // 2012 + uint8_t tonemask = 0; + if (part->fm_slotmask & 0x80) tonemask |= 0x11; + if (part->fm_slotmask & 0x40) tonemask |= 0x44; + if (part->fm_slotmask & 0x20) tonemask |= 0x22; + if (part->fm_slotmask & 0x10) tonemask |= 0x88; + part->fm_tone_slotmask = tonemask; + part->proc_masked = pmd_part_masked(part); +} + +// 1e1b +static void pmd_cmdcd_env_new( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + part->ssg_env_param_set[SSG_ENV_PARAM_NEW_AR] = pmd_part_cmdload(pmd, part) & 0x1f; + part->ssg_env_param_set[SSG_ENV_PARAM_NEW_DR] = pmd_part_cmdload(pmd, part) & 0x1f; + part->ssg_env_param_set[SSG_ENV_PARAM_NEW_SR] = pmd_part_cmdload(pmd, part) & 0x1f; + uint8_t data = pmd_part_cmdload(pmd, part); + part->ssg_env_param_set[SSG_ENV_PARAM_NEW_RR] = data & 0xf; + part->ssg_env_param_sl = (data >> 4) ^ 0xf; + part->ssg_env_param_al = pmd_part_cmdload(pmd, part) & 0xf; + if (part->ssg_env_state_old != SSG_ENV_STATE_OLD_NEW) { + part->ssg_env_state_old = SSG_ENV_STATE_OLD_NEW; + part->ssg_env_state_new = SSG_ENV_STATE_NEW_RR; + part->ssg_env_vol = 0; + } +} + +// 1def +static void pmd_cmdcc_det_ext( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + part->flagext.detune = pmd_part_cmdload(pmd, part) & 1; +} + +// 1e16 +static void pmd_cmdcb_lfo_waveform( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + part->lfo_waveform = pmd_part_cmdload(pmd, part); +} + +// 1dfa +static void pmd_cmdca_lfo_ext( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + part->flagext.lfo = pmd_part_cmdload(pmd, part) & 1; +} + +// 1e07 +static void pmd_cmdc9_env_ext( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + part->flagext.env = pmd_part_cmdload(pmd, part) & 1; +} + +// 1e99 +static void pmd_cmdc8_fm3ex_det( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + if (pmd->proc_ch != 3 || pmd->opna_a1) { + pmd_cmd_null_3(work, pmd, part); + return; + } + // 1ead + uint8_t mask = pmd_part_cmdload(pmd, part); + uint16_t val16 = pmd_part_cmdload(pmd, part); + val16 |= ((uint16_t)pmd_part_cmdload(pmd, part)) << 8; + int16_t det = u16s16(val16); + for (int s = 0; s < 4; s++) { + if (mask & (1<<s)) { + pmd->fm3ex_det[s] = det; + } + } + // 1ecd + pmd->fm3ex_force = false; + for (int s = 0; s < 4; s++) { + if (pmd->fm3ex_det[s]) pmd->fm3ex_force = true; + } + pmd_fm3ex_mode_update(work, pmd, part); +} + +// 1e5f +static void pmd_cmdc7_fm3ex_det_add( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + if (pmd->proc_ch != 3 || pmd->opna_a1) { + pmd_cmd_null_3(work, pmd, part); + return; + } + // 1e73 + uint8_t mask = pmd_part_cmdload(pmd, part); + uint16_t det = pmd_part_cmdload(pmd, part); + det |= ((uint16_t)pmd_part_cmdload(pmd, part)) << 8; + for (int s = 0; s < 4; s++) { + if (mask & (1<<s)) { + pmd->fm3ex_det[s] = u16s16((uint16_t)pmd->fm3ex_det[s] + det); + } + } + pmd->fm3ex_force = false; + for (int s = 0; s < 4; s++) { + if (pmd->fm3ex_det[s]) pmd->fm3ex_force = true; + } + pmd_fm3ex_mode_update(work, pmd, part); +} + +// 1dc0 +static void pmd_fm3ex_init( + struct driver_pmd *pmd, + struct pmd_part *part, + uint16_t ptr +) { + part->ptr = ptr; + part->len = part->len_cnt = 1; + part->keystatus.off = true; + part->keystatus.off_mask = true; + part->md_cnt = 0xff; + part->md_cnt_set = 0xff; + part->md_cnt_b = 0xff; + part->md_cnt_set_b = 0xff; + part->actual_note = 0xff; + part->curr_note = 0xff; + part->vol = 0x6c; + part->fm_pan_ams_pms = pmd->parts[PMD_PART_FM_3].fm_pan_ams_pms; + part->mask.slot = true; +} + +// 1d90 +static void pmd_cmdc6_fm3ex_init( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + for (int i = 0; i < 3; i++) { + uint16_t ptr = pmd_part_cmdload(pmd, part); + ptr |= ((uint16_t)pmd_part_cmdload(pmd, part)) << 8; + if (!ptr) continue; + pmd_fm3ex_init(pmd, &pmd->parts[PMD_PART_FM_3B+i], ptr); + } +} + +// 1d45 +static void pmd_cmdc5_lfo_slotmask( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t mask = pmd_part_cmdload(pmd, part); + mask &= 0x0f; + if (mask) { + // 1d4a + mask <<= 4; + mask |= 0x0f; + part->vol_lfo_slotmask = mask; + } else { + // 1d59 + part->vol_lfo_slotmask = part->fm_slotout; + } + // 1d7b + pmd_fm3ex_mode_update_check(work, pmd, part); +} + +// 1d61 +static void pmd_cmdba_lfo2_slotmask( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t mask = pmd_part_cmdload(pmd, part); + mask &= 0x0f; + if (mask) { + // 1d4a + mask <<= 4; + mask |= 0x0f; + part->vol_lfo_slotmask_b = mask; + } else { + // 1d59 + part->vol_lfo_slotmask_b = part->fm_slotout; + } + // 1d7b + pmd_fm3ex_mode_update_check(work, pmd, part); +} + +// 22c6 +static void pmd_cmdc4_gate_rel( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + part->gate_rel = pmd_part_cmdload(pmd, part); +} + +// 25d9 +static void pmd_cmdc3_pan_ex( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t data = pmd_part_cmdload(pmd, part); + pmd_part_cmdload(pmd, part); + uint8_t pan; + if (data == 0) pan = 3; + else if (data & 0x80) pan = 1; + else pan = 2; + pmd_part_set_pan(work, pmd, part, pan); +} + +// 2509 +static void pmd_cmdc2_lfo_delay( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t d = pmd_part_cmdload(pmd, part); + part->lfo.delay = d; + part->lfo_set.delay = d; + pmd_lfo_reset(part); +} + +// 1a95 +// DF +static void pmd_cmdc0_ff_fm_voldown( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + pmd->fm_voldown = pmd_part_cmdload(pmd, part); +} + +// 1ab0 +// DF +/- +static void pmd_cmdc0_fe_fm_voldown_rel( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t vol = pmd_part_cmdload(pmd, part); + if (!vol) { + pmd->fm_voldown = pmd->fm_voldown_orig; + } else { + int newvol = pmd->fm_voldown + u8s8(vol); + if (newvol > 0xff) newvol = 0xff; + if (newvol < 0) newvol = 0; + pmd->fm_voldown = newvol; + } +} + +// 1a9c +// DS +static void pmd_cmdc0_fd_ssg_voldown( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + pmd->ssg_voldown = pmd_part_cmdload(pmd, part); +} + +// 1ad6 +// DS +/- +static void pmd_cmdc0_fc_ssg_voldown_rel( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t vol = pmd_part_cmdload(pmd, part); + if (!vol) { + pmd->ssg_voldown = pmd->ssg_voldown_orig; + } else { + int newvol = pmd->ssg_voldown + u8s8(vol); + if (newvol > 0xff) newvol = 0xff; + if (newvol < 0) newvol = 0; + pmd->ssg_voldown = newvol; + } +} + +// 1aa1 +// DP +static void pmd_cmdc0_fb_adpcm_voldown( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + pmd->adpcm_voldown = pmd_part_cmdload(pmd, part); +} + +// 1ade +// DP +/- +static void pmd_cmdc0_fa_adpcm_voldown_rel( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t vol = pmd_part_cmdload(pmd, part); + if (!vol) { + pmd->adpcm_voldown = pmd->adpcm_voldown_orig; + } else { + int newvol = pmd->adpcm_voldown + u8s8(vol); + if (newvol > 0xff) newvol = 0xff; + if (newvol < 0) newvol = 0; + pmd->adpcm_voldown = newvol; + } +} + +// 1aa6 +// DR +static void pmd_cmdc0_f9_opnarhythm_voldown( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + pmd->opnarhythm_voldown = pmd_part_cmdload(pmd, part); +} + +// 1ae6 +// DR +/- +static void pmd_cmdc0_f8_opnarhythm_voldown_rel( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t vol = pmd_part_cmdload(pmd, part); + if (!vol) { + pmd->opnarhythm_voldown = pmd->opnarhythm_voldown_orig; + } else { + int newvol = pmd->opnarhythm_voldown + u8s8(vol); + if (newvol > 0xff) newvol = 0xff; + if (newvol < 0) newvol = 0; + pmd->opnarhythm_voldown = newvol; + } +} + +// 1a8e +// probably A +static void pmd_cmdc0_f7_pcm86_vol( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + pmd->pcm86_vol_spb = pmd_part_cmdload(pmd, part) & 1; +} + + +// 1aab +// unimplemented (disabled in PMDPPZ.COM) +static void pmd_cmdc0_f6_ppz8_voldown( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + pmd->ppz8_voldown = pmd_part_cmdload(pmd, part); +} + +// 1aee +// unimplemented (disabled in PMDPPZ.COM) +static void pmd_cmdc0_f5_ppz8_voldown_rel( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t vol = pmd_part_cmdload(pmd, part); + if (!vol) { + pmd->ppz8_voldown = pmd->ppz8_voldown_orig; + } else { + int newvol = pmd->ppz8_voldown + u8s8(vol); + if (newvol > 0xff) newvol = 0xff; + if (newvol < 0) newvol = 0; + pmd->ppz8_voldown = newvol; + } +} + +typedef void (*pmd_cmd_func) ( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +); + +static const pmd_cmd_func pmd_cmd_table_c0[] = { + pmd_cmdc0_ff_fm_voldown, + pmd_cmdc0_fe_fm_voldown_rel, + pmd_cmdc0_fd_ssg_voldown, + pmd_cmdc0_fc_ssg_voldown_rel, + pmd_cmdc0_fb_adpcm_voldown, + pmd_cmdc0_fa_adpcm_voldown_rel, + pmd_cmdc0_f9_opnarhythm_voldown, + pmd_cmdc0_f8_opnarhythm_voldown_rel, + pmd_cmdc0_f7_pcm86_vol, + // f6, f5 is disabled + pmd_cmdc0_f6_ppz8_voldown, + pmd_cmdc0_f5_ppz8_voldown_rel, +}; + +// 1a62 +static void pmd_cmdc0_extended( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part, + uint8_t data +) { + if (data < 0xf7) { + part->ptr = 0; + return; + } + pmd_cmd_table_c0[data^0xff](work, pmd, part); +} + +// 1cc0 +static void pmd_part_fm_unmask( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { + if (!part->fm_tone_slotmask) return; + //uint8_t tonenum = part->tonenum; + uint8_t fm_tone_tl[4]; + for (int i = 0; i < 4; i++) { + fm_tone_tl[i] = part->fm_tone_tl[i]; + } + pmd->tonemask_fb_alg = true; + pmd_part_tone_fm(work, pmd, part); + pmd->tonemask_fb_alg = false; + for (int i = 0; i < 4; i++) { + part->fm_tone_tl[i] = fm_tone_tl[i]; + } + uint8_t slotmask = (part->fm_slotout ^ 0xff) & part->fm_slotmask; + if (slotmask) { + for (int s = 0; s < 4; s++) { + if (!(slotmask & (1<<(7-s)))) continue; + static const uint8_t regoff[4] = {3, 1, 2, 0}; + pmd_reg_write(work, pmd, 0x3f+regoff[s]*4+pmd->proc_ch, fm_tone_tl[regoff[s]]); + } + } + // 1d23 + pmd_reg_write(work, pmd, 0xb3+pmd->proc_ch, pmd_hlfo_delay_check(part, part->fm_pan_ams_pms)); +} + +// 1c50 +static void pmd_cmdc0_mml_mask_fm( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t data = pmd_part_cmdload(pmd, part); + if (data >= 2) { + pmd_cmdc0_extended(work, pmd, part, data); + return; + } else if (data == 1) { + // 1c5c + part->mask.mml = false; + bool masked = pmd_part_masked(part); + part->mask.mml = true; + if (!masked) { + pmd_part_tone_slotmask_stop(work, pmd, part); + } + // 1c9c + part->proc_masked = true; + } else { + // 1ca0 + part->mask.mml = false; + if (pmd_part_masked(part)) { + part->proc_masked = true; + } else { + pmd_part_fm_unmask(work, pmd, part); + part->proc_masked = false; + } + } +} + +// 1c7a +static void pmd_cmdc0_mml_mask_ssg( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t data = pmd_part_cmdload(pmd, part); + if (data >= 2) { + pmd_cmdc0_extended(work, pmd, part, data); + return; + } else if (data == 1) { + // 1c86 + part->mask.mml = false; + bool masked = pmd_part_masked(part); + part->mask.mml = true; + if (!masked) { + // 1c90 + uint16_t ssgout = pmd_part_ssg_readout(work, pmd); + ssgout |= ssgout>>8; + work->opna_writereg(work, 0x07, ssgout); + } + // 1c9c + part->proc_masked = true; + } else { + // 1ca0 + part->mask.mml = false; + part->proc_masked = pmd_part_masked(part); + } +} + +// 1caa +static void pmd_cmdc0_mml_mask_rhythm( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t data = pmd_part_cmdload(pmd, part); + if (data >= 2) { + pmd_cmdc0_extended(work, pmd, part, data); + return; + } else if (data == 1) { + part->mask.mml = true; + } else { + part->mask.mml = false; + } +} + +// 244e +static void pmd_cmdbf_lfo2( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + pmd_part_lfo_flip(part); + pmd_cmdf2_lfo(work, pmd, part); + pmd_part_lfo_flip(part); +} + +// 2473 +static void pmd_cmdbe_lfo2_switch( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t val = pmd_part_cmdload(pmd, part); + part->lfof_b.freq = val & (1<<0); + part->lfof_b.vol = val & (1<<1); + part->lfof_b.sync = val & (1<<2); + pmd_part_lfo_flip(part); + pmd_lfo_reset(part); + pmd_part_lfo_flip(part); +} + +// 248d +static void pmd_cmdbe_lfo2_switch_fm( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + pmd_cmdbe_lfo2_switch(work, pmd, part); + pmd_fm3ex_mode_update_check(work, pmd, part); +} + +// 245f +static void pmd_cmdbd_lfo2_md( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + pmd_part_lfo_flip(part); + pmd_cmdd6_md(work, pmd, part); + pmd_part_lfo_flip(part); +} + +// 2464 +static void pmd_cmdbc_lfo2_waveform( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + pmd_part_lfo_flip(part); + pmd_cmdcb_lfo_waveform(work, pmd, part); + pmd_part_lfo_flip(part); +} + +// 2469 +static void pmd_cmdbb_lfo2_ext( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + pmd_part_lfo_flip(part); + pmd_cmdca_lfo_ext(work, pmd, part); + pmd_part_lfo_flip(part); +} + +// 246e +static void pmd_cmdb9_lfo2_delay( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + pmd_part_lfo_flip(part); + pmd_cmdc2_lfo_delay(work, pmd, part); + pmd_part_lfo_flip(part); +} + +// 1b87 +// command O +static void pmd_cmdb8_slottl( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t data = pmd_part_cmdload(pmd, part); + uint8_t slotmask = data & 0xf & (part->fm_slotmask>>4); + uint8_t val = pmd_part_cmdload(pmd, part); + bool masked = pmd_part_masked(part); + bool relative = data & 0x80; + static const uint8_t slottable[4] = {0, 2, 1, 3}; + for (int s = 0; s < 4; s++) { + if (!(slotmask & (1<<s))) continue; + if (!relative) { + part->fm_tone_tl[slottable[s]] = val & 0x7f; + } else { + uint8_t vol = part->fm_tone_tl[slottable[s]] + val; + if (vol & 0x80) { + if (val & 0x80) vol = 0; + else vol = 0x7f; + } + part->fm_tone_tl[slottable[s]] = vol; + } + if (!masked) { + pmd_reg_write(work, pmd, 0x3f+pmd->proc_ch+8*s, part->fm_tone_tl[slottable[s]]); + } + } +} + +// 20cb +static void pmd_cmdb7_lfo_md_cnt( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t data = pmd_part_cmdload(pmd, part); + bool b = data & 0x80; + data &= 0x7f; + if (!data) data = 0xff; + if (!b) { + part->md_cnt = part->md_cnt_set = data; + } else { + part->md_cnt_b = part->md_cnt_set_b = data; + } +} + +// 1b19 +static void pmd_part_write_fb( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part, + uint8_t data +) { + uint8_t newfb = (data & 7) << 3; + uint8_t fbalg; + if ((pmd->proc_ch == 3) && (!pmd->opna_a1)) { + pmd->fm3ex_fb_alg &= 7; + pmd->fm3ex_fb_alg |= newfb; + fbalg = pmd->fm3ex_fb_alg; + } else { + part->fb_alg &= 7; + part->fb_alg |= newfb; + fbalg = part->fb_alg; + } + if ((pmd->proc_ch == 3) && (!pmd->opna_a1) && (!(part->fm_slotmask & 0x10))) return; + pmd_reg_write(work, pmd, 0xaf+pmd->proc_ch, fbalg); + part->fb_alg = fbalg; +} + +// 1b0e +static void pmd_cmdb6_fb( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t data = pmd_part_cmdload(pmd, part); + uint8_t fbalg; + if (!(data & 0x80)) { + pmd_part_write_fb(work, pmd, part, data); + } else { + // 1b51 + if (!(data & 0x40)) data &= 7; + if ((pmd->proc_ch == 3) && (!pmd->opna_a1)) { + fbalg = pmd->fm3ex_fb_alg; + } else { + fbalg = part->fb_alg; + } + fbalg >>= 3; + fbalg &= 7; + fbalg += data; + if (fbalg & 0x80) { + pmd_part_write_fb(work, pmd, part, 0); + } else if (fbalg > 7) { + pmd_part_write_fb(work, pmd, part, 7); + } else { + pmd_part_write_fb(work, pmd, part, fbalg); + } + } +} + +// 1af6 +static void pmd_cmdb5_slot_delay( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + uint8_t data = pmd_part_cmdload(pmd, part); + data = (~data) & 0xf; + data <<= 4; + part->slot_delay_mask = data; + part->slot_delay = pmd_part_cmdload(pmd, part); + part->slot_delay_cnt = part->slot_delay; +} + +// 22bc +static void pmd_cmdb3_gate_min( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + part->gate_min = pmd_part_cmdload(pmd, part); +} + +// 23ef +static void pmd_cmdb2_transpose_master( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + part->transpose_master = pmd_part_cmdload(pmd, part); +} + +// 22c1 +static void pmd_cmdb1_gate_rand_range( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +){ + part->gate_rand_range = pmd_part_cmdload(pmd, part); +} + +enum { + PMD_CMD_CNT = 0x100-0xb1 +}; + +static const pmd_cmd_func pmd_cmd_table_fm[PMD_CMD_CNT] = { + pmd_cmdff_tonenum, + pmd_cmdfe_gate_abs, + pmd_cmdfd_vol, + pmd_cmdfc_tempo, + pmd_cmdfb_tie, + pmd_cmdfa_d5_det, + pmd_cmdf9_repeat_reset, + pmd_cmdf8_repeat, + pmd_cmdf7_repeat_exit, + pmd_cmdf6_set_loop, + pmd_cmdf5_transpose, + pmd_cmdf4_volinc_fm, + pmd_cmdf3_voldec_fm, + pmd_cmdf2_lfo, + pmd_cmdf1_lfo_switch_fm, + pmd_cmd_null_4, + pmd_cmdef_poke, + pmd_cmd_null_1, + pmd_cmd_null_1, + pmd_cmdec_pan, + pmd_cmdeb_opnarhythm, + pmd_cmdea_opnarhythm_il, + pmd_cmde9_opnarhythm_pan, + pmd_cmde8_opnarhythm_tl, + pmd_cmde7_transpose_rel, + pmd_cmde6_opnarhythm_tl_rel, + pmd_cmde5_opnarhythm_il_rel, + pmd_cmde4_hlfo_delay, + pmd_cmde3_vol_add_fm, + pmd_cmde2_vol_sub, + pmd_cmde1_ams_pms, + pmd_cmde0_hlfo, + pmd_cmddf_meas_len, + pmd_cmdde_echo_init_add_fm, + pmd_cmddd_echo_init_sub, + pmd_cmddc_status1, + pmd_cmddb_status1_add, + pmd_cmdda_portamento_fm, + pmd_cmd_null_1, + pmd_cmd_null_1, + pmd_cmd_null_1, + pmd_cmdd6_md, + pmd_cmdfa_d5_det, + pmd_cmdd4_ssgeff, + pmd_cmdd3_fmeff, + pmd_cmdd2_fadeout, + pmd_cmd_null_1, + pmd_cmd_null_1, + pmd_cmdcf_slotmask, + pmd_cmd_null_6, + pmd_cmd_null_5, + pmd_cmd_null_1, + pmd_cmdcb_lfo_waveform, + pmd_cmdca_lfo_ext, + pmd_cmd_null_1, + pmd_cmdc8_fm3ex_det, + pmd_cmdc7_fm3ex_det_add, + pmd_cmdc6_fm3ex_init, + pmd_cmdc5_lfo_slotmask, + pmd_cmdc4_gate_rel, + pmd_cmdc3_pan_ex, + pmd_cmdc2_lfo_delay, + pmd_cmd_null_0, + pmd_cmdc0_mml_mask_fm, + pmd_cmdbf_lfo2, + pmd_cmdbe_lfo2_switch_fm, + pmd_cmdbd_lfo2_md, + pmd_cmdbc_lfo2_waveform, + pmd_cmdbb_lfo2_ext, + pmd_cmdba_lfo2_slotmask, + pmd_cmdb9_lfo2_delay, + pmd_cmdb8_slottl, + pmd_cmdb7_lfo_md_cnt, + pmd_cmdb6_fb, + pmd_cmdb5_slot_delay, + pmd_cmd_null_16, + pmd_cmdb3_gate_min, + pmd_cmdb2_transpose_master, + pmd_cmdb1_gate_rand_range +}; + +static const pmd_cmd_func pmd_cmd_table_ssg[PMD_CMD_CNT] = { + pmd_cmd_null_1, + pmd_cmdfe_gate_abs, + pmd_cmdfd_vol, + pmd_cmdfc_tempo, + pmd_cmdfb_tie, + pmd_cmdfa_d5_det, + pmd_cmdf9_repeat_reset, + pmd_cmdf8_repeat, + pmd_cmdf7_repeat_exit, + pmd_cmdf6_set_loop, + pmd_cmdf5_transpose, + pmd_cmdf4_volinc_ssg, + pmd_cmdf3_voldec_ssg, + pmd_cmdf2_lfo, + pmd_cmdf1_lfo_switch, + pmd_cmdf0_env_old, + pmd_cmdef_poke, + pmd_cmdee_noise_freq, + pmd_cmded_ssgmix, + pmd_cmd_null_1, + pmd_cmdeb_opnarhythm, + pmd_cmdea_opnarhythm_il, + pmd_cmde9_opnarhythm_pan, + pmd_cmde8_opnarhythm_tl, + pmd_cmde7_transpose_rel, + pmd_cmde6_opnarhythm_tl_rel, + pmd_cmde5_opnarhythm_il_rel, + pmd_cmd_null_1, + pmd_cmde3_vol_add_ssg, + pmd_cmde2_vol_sub, + pmd_cmd_null_1, + pmd_cmd_null_1, + pmd_cmddf_meas_len, + pmd_cmdde_echo_init_add_ssg, + pmd_cmddd_echo_init_sub, + pmd_cmddc_status1, + pmd_cmddb_status1_add, + pmd_cmdda_portamento_ssg, + pmd_cmd_null_1, + pmd_cmd_null_1, + pmd_cmd_null_1, + pmd_cmdd6_md, + pmd_cmdfa_d5_det, + pmd_cmdd4_ssgeff, + pmd_cmdd3_fmeff, + pmd_cmdd2_fadeout, + pmd_cmd_null_1, + pmd_cmdd0_ssgnoisefreqadd, + pmd_cmd_null_1, + pmd_cmd_null_6, + pmd_cmdcd_env_new, + pmd_cmdcc_det_ext, + pmd_cmdcb_lfo_waveform, + pmd_cmdca_lfo_ext, + pmd_cmdc9_env_ext, + pmd_cmd_null_3, + pmd_cmd_null_3, + pmd_cmd_null_6, + pmd_cmd_null_1, + pmd_cmdc4_gate_rel, + pmd_cmd_null_2, + pmd_cmdc2_lfo_delay, + pmd_cmd_null_0, + pmd_cmdc0_mml_mask_ssg, + pmd_cmdbf_lfo2, + pmd_cmdbe_lfo2_switch, + pmd_cmdbd_lfo2_md, + pmd_cmdbc_lfo2_waveform, + pmd_cmdbb_lfo2_ext, + pmd_cmd_null_1, + pmd_cmdb9_lfo2_delay, + pmd_cmd_null_2, + pmd_cmdb7_lfo_md_cnt, + pmd_cmd_null_1, + pmd_cmd_null_2, + pmd_cmd_null_16, + pmd_cmdb3_gate_min, + pmd_cmdb2_transpose_master, + pmd_cmdb1_gate_rand_range +}; + +static const pmd_cmd_func pmd_cmd_table_rhythm[PMD_CMD_CNT] = { + pmd_cmd_null_1, + pmd_cmd_null_1, + pmd_cmdfd_vol, + pmd_cmdfc_tempo, + pmd_cmdfb_tie, + pmd_cmdfa_d5_det, + pmd_cmdf9_repeat_reset, + pmd_cmdf8_repeat, + pmd_cmdf7_repeat_exit, + pmd_cmdf6_set_loop, + pmd_cmd_null_1, + pmd_cmdf4_volinc_ssg, + pmd_cmdf3_voldec_ssg, + pmd_cmd_null_4, + pmd_cmdf1_ppsdrv, + pmd_cmd_null_4, + pmd_cmdef_poke, + pmd_cmd_null_1, + pmd_cmd_null_1, + pmd_cmd_null_1, + pmd_cmdeb_opnarhythm, + pmd_cmdea_opnarhythm_il, + pmd_cmde9_opnarhythm_pan, + pmd_cmde8_opnarhythm_tl, + pmd_cmd_null_1, + pmd_cmde6_opnarhythm_tl_rel, + pmd_cmde5_opnarhythm_il_rel, + pmd_cmd_null_1, + pmd_cmde3_vol_add_ssg, + pmd_cmde2_vol_sub, + pmd_cmd_null_1, + pmd_cmd_null_1, + pmd_cmddf_meas_len, + pmd_cmdde_echo_init_add_ssg, + pmd_cmddd_echo_init_sub, + pmd_cmddc_status1, + pmd_cmddb_status1_add, + pmd_cmd_null_1, + pmd_cmd_null_1, + pmd_cmd_null_1, + pmd_cmd_null_1, + pmd_cmd_null_2, + pmd_cmdfa_d5_det, + pmd_cmdd4_ssgeff, + pmd_cmdd3_fmeff, + pmd_cmdd2_fadeout, + pmd_cmd_null_1, + pmd_cmd_null_1, // d0 + pmd_cmd_null_1, + pmd_cmd_null_6, + pmd_cmd_null_5, + pmd_cmd_null_1, + pmd_cmd_null_1, + pmd_cmd_null_1, + pmd_cmd_null_1, + pmd_cmd_null_3, // c8 + pmd_cmd_null_3, + pmd_cmd_null_6, + pmd_cmd_null_1, + pmd_cmd_null_1, + pmd_cmd_null_2, + pmd_cmd_null_1, + pmd_cmd_null_0, + pmd_cmdc0_mml_mask_rhythm, // c0 + pmd_cmd_null_4, + pmd_cmd_null_1, + pmd_cmd_null_2, + pmd_cmd_null_1, + pmd_cmd_null_1, + pmd_cmd_null_1, + pmd_cmd_null_1, + pmd_cmd_null_2, // b8 + pmd_cmd_null_1, + pmd_cmd_null_1, + pmd_cmd_null_2, + pmd_cmd_null_16, + pmd_cmd_null_1, + pmd_cmd_null_1, + pmd_cmd_null_1 +}; + +// 1857 +static void pmd_part_cmd_ssg( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part, + uint8_t cmd +) { + if (cmd < 0xb1) { + part->ptr = 0; + return; + } + pmd_cmd_table_ssg[cmd^0xff](work, pmd, part); +} + +// 184d +static void pmd_part_cmd_fm( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part, + uint8_t cmd +) { + if (cmd < 0xb1) { + part->ptr = 0; + return; + } + pmd_cmd_table_fm[cmd^0xff](work, pmd, part); +} + +// 1852 +static void pmd_part_cmd_rhythm( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part, + uint8_t cmd +) { + if (cmd < 0xb1) { + part->ptr = 0; + return; + } + pmd_cmd_table_rhythm[cmd^0xff](work, pmd, part); +} + +// 20e8 +static void pmd_portamento_tick( + struct pmd_part *part +) { + part->portamento_diff = u16s16(((uint16_t)part->portamento_diff) + ((uint16_t)part->portamento_add)); + if (part->portamento_rem > 0) { + part->portamento_rem--; + part->portamento_diff = u16s16(((uint16_t)part->portamento_diff) + 1); + } else if (part->portamento_rem < 0) { + part->portamento_rem++; + part->portamento_diff = u16s16(((uint16_t)part->portamento_diff) - 1); + } +} + +// 3161 +static void pmd_ssg_env_tick_old( + struct pmd_part *part +) { + switch (part->ssg_env_state_old) { + case SSG_ENV_STATE_OLD_AL: + // 3167 + if (--part->ssg_env_param_set[SSG_ENV_PARAM_OLD_AL]) return; + part->ssg_env_state_old = SSG_ENV_STATE_OLD_SR; + part->ssg_env_vol = u8s8(part->ssg_env_param_set[SSG_ENV_PARAM_OLD_AD]); + return; + case SSG_ENV_STATE_OLD_SR: + // 317c + if (!part->ssg_env_param_set[SSG_ENV_PARAM_OLD_SR]) return; + if (--part->ssg_env_param_set[SSG_ENV_PARAM_OLD_SR]) return; + part->ssg_env_param_set[SSG_ENV_PARAM_OLD_SR] = part->ssg_env_param[SSG_ENV_PARAM_OLD_SR]; + part->ssg_env_vol = u8s8(((uint8_t)part->ssg_env_vol) - 1); + if ((-15 <= part->ssg_env_vol) && (part->ssg_env_vol < 15)) return; + part->ssg_env_vol = -15; + return; + case SSG_ENV_STATE_OLD_RR: + // 31a3 + if (!part->ssg_env_param_set[SSG_ENV_PARAM_OLD_RR]) { + part->ssg_env_vol = -15; + return; + } + if (--part->ssg_env_param_set[SSG_ENV_PARAM_OLD_RR]) return; + part->ssg_env_param_set[SSG_ENV_PARAM_OLD_RR] = part->ssg_env_param[SSG_ENV_PARAM_OLD_RR]; + part->ssg_env_vol = u8s8(((uint8_t)part->ssg_env_vol) - 1); + if ((-15 <= part->ssg_env_vol) && (part->ssg_env_vol < 15)) return; + part->ssg_env_vol = -15; + return; + } +} + +// 314e +// returns true if volume update needed +static bool pmd_ssg_env_tick_check( + struct pmd_part *part +) { + if (part->ssg_env_state_old == SSG_ENV_STATE_OLD_NEW) { + return pmd_ssg_env_tick_new_check(part); + } + int8_t old_env_vol = part->ssg_env_vol; + pmd_ssg_env_tick_old(part); + return old_env_vol != part->ssg_env_vol; +} + +// 312e +// returns true if volume update needed +static bool pmd_ssg_env_proc( + struct driver_pmd *pmd, + struct pmd_part *part +) { + if (part->flagext.env) { + // 3134 + uint8_t timera_lapsed = pmd->timera_cnt - pmd->timera_cnt_b; + bool update_needed = false; + for (int i = 0; i < timera_lapsed; i++) { + update_needed |= pmd_ssg_env_tick_check(part); + } + return update_needed; + } else { + return pmd_ssg_env_tick_check(part); + } +} + +// 1617 +static void pmd_part_proc_ssg_lfoenv( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { + static const struct pmd_part_lfo_flags lfof_z; + pmd->lfoprocf = lfof_z; + pmd->lfoprocf_b = lfof_z; + pmd->lfoprocf.portamento = part->lfof.portamento; + if (part->lfof.freq || part->lfof.vol || part->lfof.sync || part->lfof.portamento || + part->lfof_b.freq || part->lfof_b.vol || part->lfof_b.sync || part->lfof_b.portamento) { + // 1625 + if (part->lfof.freq || part->lfof.vol) { + if (pmd_lfo_tick(pmd, part)) { + pmd->lfoprocf.freq = part->lfof.freq; + pmd->lfoprocf.vol = part->lfof.vol; + } + } + // 1637 + if (part->lfof_b.freq || part->lfof_b.vol) { + pmd_part_lfo_flip(part); + if (pmd_lfo_tick(pmd, part)) { + pmd->lfoprocf_b.freq = part->lfof_b.freq; + pmd->lfoprocf_b.vol = part->lfof_b.vol; + } + pmd_part_lfo_flip(part); + } + // 1659 + if (pmd->lfoprocf.freq || pmd->lfoprocf.portamento || pmd->lfoprocf_b.freq) { + if (pmd->lfoprocf.portamento) { + pmd_portamento_tick(part); + } + pmd_ssg_freq_out(work, pmd, part); + } + } + // 166d + if (pmd_ssg_env_proc(pmd, part) || pmd->lfoprocf.vol || pmd->lfoprocf_b.vol || pmd->fadeout_speed) { + pmd_ssg_vol_out(work, pmd, part); + } + pmd_part_loop_check(pmd, part); +} + +// 16d9 +static bool pmd_part_ssg_next_masked( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part, + uint8_t note +) { + if (part->mask.ext) return true; + if (!part->mask.effect) return true; + if (pmd->ssgeff_priority >= 2) return true; + if ((note & 0xf) == 0xf) return true; + if (pmd->ssgeff_priority == 1) { + pmd_ssgeff_stop(work, pmd); + } + part->mask.effect = false; + return pmd_part_masked(part); +} + +// 1561 +static void pmd_part_loop_check_masked( + struct driver_pmd *pmd, + struct pmd_part *part +) { + pmd->no_keyoff = false; + pmd->volume_saved = false; + pmd_part_loop_check(pmd, part); +} + +// 1541 +static void pmd_part_proc_note_masked( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { + part->actual_freq = 0; + part->actual_note = 0xff; + part->curr_note = 0xff; + part->len = part->len_cnt = pmd_part_cmdload(pmd, part); + part->note_proc++; + + if (!pmd->volume_saved) { + part->volume_save = 0; + } + pmd->no_keyoff = false; + pmd->volume_saved = false; + pmd_part_loop_check(pmd, part); +} + +// 2cb5 +static void pmd_part_off_fm( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { + if (part->keystatus.off && part->keystatus.off_mask) return; + pmd_part_do_keyoff_fm(work, pmd, part); +} + +// 13f8 +static void pmd_part_proc_fm_lfo( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { + if (part->hlfo_delay) { + if (!--part->hlfo_delay) { + pmd_reg_write(work, pmd, 0xb3+pmd->proc_ch, part->fm_pan_ams_pms); + } + } + // 1410 + if (part->slot_delay_cnt) { + if (!--part->slot_delay_cnt) { + if (!part->keystatus.off) { + pmd_part_fm_keyon(work, pmd, part); + } + } + } + static const struct pmd_part_lfo_flags lfof_z; + pmd->lfoprocf = lfof_z; + pmd->lfoprocf_b = lfof_z; + pmd->lfoprocf.portamento = part->lfof.portamento; + // 1424 + if (part->lfof.freq || part->lfof.vol || part->lfof.sync || part->lfof.portamento || + part->lfof_b.freq || part->lfof_b.vol || part->lfof_b.sync || part->lfof_b.portamento) { + if (part->lfof.freq || part->lfof.vol) { + if (pmd_lfo_tick(pmd, part)) { + pmd->lfoprocf.freq = part->lfof.freq; + pmd->lfoprocf.vol = part->lfof.vol; + } + } + if (part->lfof_b.freq || part->lfof_b.vol) { + pmd_part_lfo_flip(part); + if (pmd_lfo_tick(pmd, part)) { + pmd->lfoprocf_b.freq = part->lfof.freq; + pmd->lfoprocf_b.vol = part->lfof.vol; + } + pmd_part_lfo_flip(part); + } + // 1466 + if (pmd->lfoprocf.freq || pmd->lfoprocf.portamento || pmd->lfoprocf_b.freq) { + if (pmd->lfoprocf.portamento) { + pmd_portamento_tick(part); + } + pmd_fm_freq_out(work, pmd, part); + } + // 147a + } + // 1481 + if (pmd->lfoprocf.vol || pmd->lfoprocf_b.vol || pmd->fadeout_speed) { + pmd_fm_vol_out(work, pmd, part); + } + pmd_part_loop_check(pmd, part); +} + +// 1350 / 14fc +static void pmd_part_proc_fm( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { + if (!part->ptr) return; + part->proc_masked = pmd_part_masked(part); + part->len_cnt--; + if (part->proc_masked) { + part->keystatus.off = true; + part->keystatus.off_mask = true; + } else if (!part->keystatus.off && !part->keystatus.off_mask) { + if (part->len_cnt <= part->gate) { + pmd_part_off_fm(work, pmd, part); + part->keystatus.off = true; + part->keystatus.off_mask = true; + } + } + // 1377 + if (part->len_cnt) { + if (part->proc_masked) { + pmd_part_loop_check(pmd, part); + } else { + pmd_part_proc_fm_lfo(work, pmd, part); + } + return; + } + if (part->proc_masked) { + // 1505 + if (part->mask.effect && !pmd->fmeff_playing) { + part->mask.effect = false; + part->proc_masked = pmd_part_masked(part); + } + } + // 137b + if (!part->proc_masked) { + part->lfof.portamento = false; + } + for (;;) { + // 137f / 151b + uint8_t cmd = pmd_part_cmdload(pmd, part); + if (cmd & 0x80) { + if (cmd != 0x80) { + // 1386 / 1522 + pmd_part_cmd_fm(work, pmd, part, cmd); + if (cmd == 0xda && !pmd_part_masked(part)) return; + } else { + // 138b / 1527 + part->ptr = 0; + part->loop.looped = true; + part->loop.ended = true; + part->actual_note = 0xff; + if (!part->loop_ptr) { + if (part->proc_masked) { + pmd_part_proc_fm_lfo(work, pmd, part); + } else { + pmd_part_loop_check_masked(pmd, part); + } + return; + } + part->ptr = part->loop_ptr; + part->loop.ended = false; + } + } else { + // 13a5 / 1541 + if (part->proc_masked) { + pmd_part_proc_note_masked(work, pmd, part); + return; + } else { + pmd_part_lfo_init_fm(work, pmd, part, cmd); + cmd = pmd_part_note_transpose(part, cmd); + pmd_note_freq_fm(part, cmd); + part->len = part->len_cnt = pmd_part_cmdload(pmd, part); + pmd_part_calc_gate(pmd, part); + // 13b5 + pmd_part_fm_out(work, pmd, part); + return; + } + } + } +} + +// 156f / 1689 +static void pmd_part_proc_ssg( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { + if (!part->ptr) return; + part->proc_masked = pmd_part_masked(part); + + part->len_cnt--; + if (part->proc_masked) { + part->keystatus.off = true; + part->keystatus.off_mask = true; + } else if (!part->keystatus.off && !part->keystatus.off_mask) { + if (part->len_cnt <= part->gate) { + pmd_part_off_ssg(part); + part->keystatus.off = true; + part->keystatus.off_mask = true; + } + } + // 1596 + if (part->len_cnt) { + if (part->proc_masked) { + pmd_part_loop_check(pmd, part); + } else { + pmd_part_proc_ssg_lfoenv(work, pmd, part); + } + return; + } + part->lfof.portamento = false; + for (;;) { + // 159e / 1699 + uint8_t cmd = pmd_part_cmdload(pmd, part); + if (cmd & 0x80) { + if (cmd != 0x80) { + if (part->proc_masked && (cmd == 0xda)) { + // 16a0 + part->proc_masked = pmd_part_ssg_next_masked(work, pmd, part, cmd); + } + // 15a5 + pmd_part_cmd_ssg(work, pmd, part, cmd); + if (cmd == 0xda && !pmd_part_masked(part)) return; + } else { + // 15aa + part->ptr = 0; + part->loop.looped = true; + part->loop.ended = true; + part->actual_note = 0xff; + if (!part->loop_ptr) { + if (part->proc_masked) { + pmd_part_proc_ssg_lfoenv(work, pmd, part); + } else { + pmd_part_loop_check_masked(pmd, part); + } + return; + } + part->ptr = part->loop_ptr; + part->loop.ended = false; + } + } else { + if (part->proc_masked && pmd_part_ssg_next_masked(work, pmd, part, cmd)) { + // 16ce + pmd_part_proc_note_masked(work, pmd, part); + return; + } else { + // 15c4 + pmd_part_lfo_init_ssg(work, pmd, part, cmd); + cmd = pmd_part_note_transpose(part, cmd); + pmd_note_freq_ssg(part, cmd); + part->len = part->len_cnt = pmd_part_cmdload(pmd, part); + pmd_part_calc_gate(pmd, part); + // 15d4 + if (part->volume_save && (part->actual_note != 0xff)) { + if (!pmd->volume_saved) { + part->volume_save = 0; + } + pmd->volume_saved = false; + } + // 15ef + pmd_ssg_vol_out(work, pmd, part); + pmd_ssg_freq_out(work, pmd, part); + pmd_ssg_note_noise_out(work, pmd, part); + part->note_proc++; + pmd->no_keyoff = false; + pmd->volume_saved = false; + part->keystatus.off = false; + part->keystatus.off_mask = false; + // fb + if (pmd->datalen > (part->ptr + 1)) { + if (pmd->data[part->ptr] == 0xfb) { + part->keystatus.off_mask = true; + } + } + pmd_part_loop_check(pmd, part); + return; + } + } + } + //pmd_part_proc_ssg_lfoenv(work, pmd, part); +} + +// 42d6 +static const struct pmd_ssgrhythm_opna_table_entry { + uint8_t reg; + uint8_t data; + uint8_t kon; +} pmd_ssgrhythm_opna_table[11] = { + {0x18, 0xdf, 0x01}, + {0x19, 0xdf, 0x02}, + {0x1c, 0x5f, 0x10}, + {0x1c, 0xdf, 0x10}, + {0x1c, 0x9f, 0x10}, + {0x1d, 0xd3, 0x20}, + {0x19, 0xdf, 0x02}, + {0x1b, 0x9c, 0x88}, + {0x1a, 0x9d, 0x04}, + {0x1a, 0xdf, 0x04}, + {0x1a, 0x5e, 0x04}, +}; + +// 1813 +static void pmd_ssgrhythm_opna_out( + struct fmdriver_work *work, + struct driver_pmd *pmd, + const struct pmd_ssgrhythm_opna_table_entry *r +) { + work->opna_writereg(work, r->reg, r->data); + uint8_t kon = r->kon & pmd->opnarhythm_mask; + if (!kon) return; + if (kon & 0x80) { + // 1828 + work->opna_writereg(work, 0x10, 0x84); + kon = 0x08 & pmd->opnarhythm_mask; + if (!kon) return; + } + work->opna_writereg(work, 0x10, kon); +} + +// 170d +static void pmd_part_proc_opnarhythm( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { + if (!part->ptr) return; + + if (--part->len_cnt) { + pmd_part_loop_check(pmd, part); + return; + } + // 171b + for (;;) { + while (pmd->r_ptr && (pmd->datalen >= (pmd->r_ptr+1)) && (pmd->data[pmd->r_ptr] != 0xff)) { + // 1726 + uint8_t rcmd = pmd->data[pmd->r_ptr++]; + if (rcmd & 0x80) { + // 1785 + if (rcmd & 0x40) { + uint16_t tmp = part->ptr; + part->ptr = pmd->r_ptr; + pmd->r_ptr = tmp; + pmd_part_cmd_rhythm(work, pmd, part, rcmd); + tmp = part->ptr; + part->ptr = pmd->r_ptr; + pmd->r_ptr = tmp; + continue; + } + // 1794 + if (pmd_part_masked(part)) { + pmd->ssgrhythm = 0; + pmd->r_ptr++; + part->len = part->len_cnt = pmd->data[pmd->r_ptr++]; + pmd_part_loop_check_masked(pmd, part); + part->note_proc++; + return; + } + pmd->ssgrhythm = ((rcmd << 8) | pmd->data[pmd->r_ptr++]) & 0x3fff; + if (pmd->ssgrhythm) { + // 17b0 + if (pmd->ssgrhythm_opna) { + for (int i = 0; i < 11; i++) { + if (pmd->ssgrhythm & (1<<i)) { + pmd_ssgrhythm_opna_out(work, pmd, &pmd_ssgrhythm_opna_table[i]); + } + } + } + // 17cc + if (pmd->fadeout_vol) { + if (pmd->ssgrhythm_opna) { + pmd_opnarhythm_tl_write(work, pmd, pmd->opnarhythm_tl); + } + } + // 17ea + if (!pmd->fadeout_vol || pmd->ppsdrv_enabled) { + // TODO: PPSDRV + } + // 180c + uint8_t eff; + for (eff = 0;; eff++) { + if (pmd->ssgrhythm & (1<<eff)) break; + } + pmd_ssg_effect(work, pmd, eff); + } + } else { + pmd->ssgrhythm = 0; + } + part->len = part->len_cnt = pmd->data[pmd->r_ptr++]; + pmd_part_loop_check_masked(pmd, part); + part->note_proc++; + return; + } + // 1740 + for (;;) { + uint8_t cmd = pmd_part_cmdload(pmd, part); + if (cmd & 0x80) { + if (cmd != 0x80) { + pmd_part_cmd_rhythm(work, pmd, part, cmd); + } else { + // 1765 + part->ptr = 0; + part->loop.looped = true; + part->loop.ended = true; + if (!part->loop_ptr) { + part->ptr = 0; + pmd_part_loop_check_masked(pmd, part); + return; + } + part->ptr = part->loop_ptr; + part->loop.ended = false; + } + } else { + // 174c + uint16_t ptr = pmd->r_offset + cmd*2; + if (pmd->datalen < (ptr + 2)) { + part->ptr = 0; + return; + } + pmd->r_ptr = pmd->data[ptr] | (((uint16_t)pmd->data[ptr+1]) << 8); + break; + } + } + } +} + +// 0149 +static void pmd_part_proc_adpcm( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { +} + +// 079b +static void pmd_part_proc_ppz8( + struct fmdriver_work *work, + struct driver_pmd *pmd, + struct pmd_part *part +) { +} + +// 11fd +static void pmd_proc_parts( + struct fmdriver_work *work, + struct driver_pmd *pmd +) { + if (!pmd->opm_flag) { + for (int c = 0; c < 3; c++) { + pmd->proc_ch = c+1; + struct pmd_part *part = &pmd->parts[PMD_PART_SSG_1+c]; + pmd_part_proc_ssg(work, pmd, part); + } + } + // 122a + pmd_opna_a1_on(pmd); + for (int c = 0; c < 3; c++) { + pmd->proc_ch = c+1; + struct pmd_part *part = &pmd->parts[PMD_PART_FM_4+c]; + pmd_part_proc_fm(work, pmd, part); + } + pmd_opna_a1_off(pmd); + for (int c = 0; c < 3; c++) { + pmd->proc_ch = c+1; + struct pmd_part *part = &pmd->parts[PMD_PART_FM_1+c]; + pmd_part_proc_fm(work, pmd, part); + } + // 1272 + for (int c = 0; c < 3; c++) { + struct pmd_part *part = &pmd->parts[PMD_PART_FM_3B+c]; + pmd_part_proc_fm(work, pmd, part); + } + // 1284 + if (!pmd->opm_flag) { + pmd_part_proc_opnarhythm(work, pmd, &pmd->parts[PMD_PART_RHYTHM]); + pmd_part_proc_adpcm(work, pmd, &pmd->parts[PMD_PART_ADPCM]); + for (int c = 0; c < 8; c++) { + pmd->proc_ch = c; + struct pmd_part *part = &pmd->parts[PMD_PART_PPZ_1+c]; + pmd_part_proc_ppz8(work, pmd, part); + } + } + // 12ef + if (!pmd->loop.looped && !pmd->loop.ended && !pmd->loop.env) return; + // 12f7 + for (int i = 0; i < 12; i++) { + struct pmd_part *part = &pmd->parts[PMD_PART_FM_1+i]; + if (!part->loop.looped || !part->loop.ended || part->loop.env) { + part->loop.looped = false; + part->loop.ended = false; + part->loop.env = false; + } + } + // 130d + if (!pmd->loop.looped || !pmd->loop.ended || pmd->loop.env) { + if (++pmd->status2 == 0xff) pmd->status2 = 1; + } else { + pmd->status2 = 0xff; + } +} + +// 3e2e +static void pmd_update_note_meas( + struct driver_pmd *pmd +) { + uint8_t tick = ++pmd->tick_cnt; + if (tick == pmd->meas_len) { + pmd->tick_cnt = 0; + pmd->meas_cnt++; + } +} + +// 3d68 +static void pmd_timerb( + struct fmdriver_work *work, + struct driver_pmd *pmd +) { + if (pmd->playing) { + // 3d8f + pmd_proc_parts(work, pmd); + pmd_timerb_write(work, pmd); + pmd_update_note_meas(pmd); + pmd->timera_cnt_b = pmd->timera_cnt; + } + // 3d9e + // user interrupt +} + +// 329e +static void pmd_fadeout_tick( + struct fmdriver_work *work, + struct driver_pmd *pmd +) { + if (pmd->paused) return; + if (!pmd->fadeout_speed) return; + int newvol = pmd->fadeout_vol + u8s8(pmd->fadeout_speed); + if (newvol < 0) { + newvol = 0; + pmd->fadeout_vol = 0; + pmd->fadeout_speed = 0; + pmd_opnarhythm_tl_write(work, pmd, pmd->opnarhythm_tl); + } else if (newvol > 0xff) { + newvol = 0xff; + pmd->fadeout_speed = 0; + //if (pmd_fadeout_mstop) pmd-> + } +} + +// 3daf +static void pmd_timera( + struct fmdriver_work *work, + struct driver_pmd *pmd +) { + if (!(++pmd->timera_cnt & 7)) { + // 3dbf + pmd_fadeout_tick(work, pmd); + // 3e66: fast-forward + } + if (pmd->ssgeff_priority) { + // TODO: PPSDRV + if (!pmd->ppsdrv_enabled || (!(pmd->ssgeff_num & 0x80))) { + pmd_ssgeff_tick(work, pmd); + } + } + // 3ddd + if (pmd->fmeff_playing) { + // TODO: FMEFF + // call 0x0f03 + } + // esc/grph key check?? +} + +// 3d1b +static void pmd_timer( + struct fmdriver_work *work, + struct driver_pmd *pmd +) { + uint8_t status = work->opna_status(work, 0); + work->opna_writereg(work, 0x27, pmd->fm3ex_mode); + if (status & 1) { + pmd_timera(work, pmd); + } + if (status & 2) { + pmd_timerb(work, pmd); + } +} + +enum pmd_part_type { + PART_TYPE_FM, + PART_TYPE_SSG, + PART_TYPE_ADPCM, +}; + +static const struct { + uint8_t ind; + enum pmd_part_type type; + bool fm3ex; +} pmd_track_map[FMDRIVER_TRACK_NUM] = { + {PMD_PART_FM_1, PART_TYPE_FM, false}, + {PMD_PART_FM_2, PART_TYPE_FM, false}, + {PMD_PART_FM_3, PART_TYPE_FM, true}, + {PMD_PART_FM_3B, PART_TYPE_FM, true}, + {PMD_PART_FM_3C, PART_TYPE_FM, true}, + {PMD_PART_FM_3D, PART_TYPE_FM, true}, + {PMD_PART_FM_4, PART_TYPE_FM, false}, + {PMD_PART_FM_5, PART_TYPE_FM, false}, + {PMD_PART_FM_6, PART_TYPE_FM, false}, + {PMD_PART_SSG_1, PART_TYPE_SSG, false}, + {PMD_PART_SSG_2, PART_TYPE_SSG, false}, + {PMD_PART_SSG_3, PART_TYPE_SSG, false}, + {PMD_PART_ADPCM, PART_TYPE_ADPCM, false}, +}; + +static void pmd_work_status_update( + struct fmdriver_work *work, + const struct driver_pmd *pmd +) { + for (int t = 0; t < FMDRIVER_TRACK_NUM; t++) { + struct fmdriver_track_status *track = &work->track_status[t]; + const struct pmd_part *part = &pmd->parts[pmd_track_map[t].ind]; + track->playing = !part->loop.ended; + track->masked = pmd_part_masked(part); + track->info = FMDRIVER_TRACK_INFO_NORMAL; + track->ticks = part->len; + track->ticks_left = part->len_cnt; + track->key = part->actual_note; + track->fmslotmask[0] = !(part->fm_slotmask & (1<<4)); + track->fmslotmask[1] = !(part->fm_slotmask & (1<<5)); + track->fmslotmask[2] = !(part->fm_slotmask & (1<<6)); + track->fmslotmask[3] = !(part->fm_slotmask & (1<<7)); + track->tonenum = part->tonenum; + track->volume = part->vol; + int detune = part->detune; + if (detune > INT8_MAX) detune = INT8_MAX; + if (detune < INT8_MIN) detune = INT8_MIN; + track->detune = detune; + track->status[0] = part->lfof.freq ? 'P' : '-'; + track->status[1] = part->lfof.vol ? 'A' : '-'; + track->status[2] = part->lfof.sync ? 'S' : '-'; + track->status[3] = part->lfof_b.freq ? 'P' : '-'; + track->status[4] = part->lfof_b.vol ? 'A' : '-'; + track->status[5] = part->lfof_b.sync ? 'S' : '-'; + track->status[6] = '-'; + track->status[7] = part->lfof.portamento ? 'P' : '-'; + switch (pmd_track_map[t].type) { + case PART_TYPE_FM: + track->actual_key = ((track->key & 0xf) == 0xf) ? + 0xff : fmdriver_fm_freq2key(part->output_freq); + if (pmd_track_map[t].fm3ex) { + if (part->fm_slotmask != 0xf0) track->info = FMDRIVER_TRACK_INFO_FM3EX; + } + break; + case PART_TYPE_SSG: + track->info = FMDRIVER_TRACK_INFO_SSG; + track->actual_key = ((track->key & 0xf) == 0xf) ? + 0xff : fmdriver_ssg_freq2key(part->output_freq); + track->ssg_tone = part->ssg_mix & (1<<0); + track->ssg_noise = part->ssg_mix & (1<<3); + if (part == &pmd->parts[PMD_PART_SSG_3]) { + if (pmd->ssgeff_on) { + track->info = FMDRIVER_TRACK_INFO_SSGEFF; + track->tonenum = pmd->ssgeff_num; + track->ssg_tone = pmd->ssgeff_tone_mix; + track->ssg_noise = pmd->ssgeff_noise_mix; + track->actual_key = pmd->ssgeff_tone_mix ? + fmdriver_ssg_freq2key(pmd->ssgeff_tonefreq) : 0xff; + } + } + break; + case PART_TYPE_ADPCM: + track->playing = false; + } + } + work->ssg_noise_freq = pmd->ssg_noise_freq_wrote; +} + +// 3c76 +static void pmd_opna_interrupt(struct fmdriver_work *work) { + struct driver_pmd *pmd = (struct driver_pmd *)work->driver; + // 3d1b + for (;;) { + uint8_t status = work->opna_status(work, 0); + if (status & 3) { + pmd_timer(work, pmd); + } else { + break; + } + } + // 3cc0 + pmd_work_status_update(work, pmd); +} + +// 0f4d +static void pmd_mstart( + struct fmdriver_work *work, + struct driver_pmd *pmd +) { + pmd_mstop(work, pmd); + pmd_reset_state(pmd); + pmd_data_init(pmd); + pmd->fadeout_vol = 0; + if (pmd->adpcm_disabled) { + pmd->parts[PMD_PART_ADPCM].mask.disabled = true; + } + // reset PPZ8 + + // 0f99 + pmd_reset_opna(work, pmd); + pmd_reset_timer(work, pmd); + pmd->playing = true; + // TODO + // 4375?? +} + +bool pmd_load(struct driver_pmd *pmd, + uint8_t *data, uint16_t datalen) { + if (!datalen) return false; + pmd->data = data + 1; + pmd->datalen = datalen - 1; + pmd_reset_state(pmd); + pmd->ssgeff_num = 0xff; + if (!pmd_data_init(pmd)) return false; + pmd->fadeout_vol = 0; + if (pmd->adpcm_disabled) { + pmd->parts[PMD_PART_ADPCM].mask.disabled = true; + } + pmd->opnarhythm_mask = 0xff; + pmd->ssgrhythm_opna = true; + return true; +} + +// check if null-terminated string is valid +static const char *pmd_check_str( + const struct driver_pmd *pmd, + uint16_t ptr +) { + uint16_t c = ptr; + while (pmd->datalen >= (c+1)) { + if (!pmd->data[c++]) return &pmd->data[ptr]; + } + return 0; +} + +// 383e +const char *pmd_get_memo( + const struct driver_pmd *pmd, + int index +) { + if (index < -2) return 0; + if (pmd->datalen < 2) return 0; + if (read16le(&pmd->data[0]) == 0x18) return 0; + if (pmd->datalen < (0x18+2)) return 0; + uint16_t toneptr = read16le(&pmd->data[0x18]); + if (toneptr < 4) return 0; + if (pmd->datalen < toneptr) return 0; + uint8_t flaglow = pmd->data[toneptr-2]; + uint8_t flaghigh = pmd->data[toneptr-1]; + if (flaglow != 0x40) { + if (flaghigh != 0xfe) return 0; + if (flaglow < 0x41) return 0; + } + if (flaglow >= 0x42) index++; + if (flaglow >= 0x48) index++; + if (index < 0) return 0; + // 3873 + uint16_t memoptr = read16le(&pmd->data[toneptr-4]); + while ((pmd->datalen >= (memoptr+2)) && read16le(&pmd->data[memoptr])) { + if (index == 0) { + if (pmd->datalen < (memoptr+2)) return 0; + return pmd_check_str(pmd, read16le(&pmd->data[memoptr])); + } + memoptr += 2; + index--; + } + return 0; +} + +void pmd_filenamecopy(char *dest, const char *src) { + int i; + for (i = 0; i < (PMD_FILENAMELEN+1); i++) { + dest[i] = src[i]; + if (!src[i]) return; + } + dest[0] = 0; +} + +void pmd_init(struct fmdriver_work *work, + struct driver_pmd *pmd) { + // TODO: reset ppz8 + + // 0f99 + work->driver = pmd; + pmd_reset_opna(work, pmd); + pmd_reset_timer(work, pmd); + pmd->playing = true; + work->driver_opna_interrupt = pmd_opna_interrupt; + static const int memotable[3] = {1, 4, 5}; + for (int i = 0; i < 3; i++) { + const char *title = pmd_get_memo(pmd, memotable[i]); + int c = 0; + if (title) { + while (title[c] && (c < (FMDRIVER_TITLE_BUFLEN-1))) { + work->comment[i][c] = title[c]; + c++; + } + } + work->comment[i][c] = 0; + } + const char *pcmfile = pmd_get_memo(pmd, -2); + if (pcmfile) { + pmd_filenamecopy(&pmd->ppzfile, pcmfile); + } + pcmfile = pmd_get_memo(pmd, -1); + if (pcmfile) { + pmd_filenamecopy(&pmd->ppsfile, pcmfile); + } + pcmfile = pmd_get_memo(pmd, 0); + if (pcmfile) { + pmd_filenamecopy(&pmd->ppcfile, pcmfile); + } +} + +enum { + PPC_HEADER_SIZE = 30+2+4*256 +}; + +bool pmd_ppc_load( + struct fmdriver_work *work, + uint8_t *data, size_t datalen +) { + if (datalen < PPC_HEADER_SIZE) return false; + const char *header = "ADPCM DATA for PMD ver.4.4- "; + for (int i = 0; i < 30; i++) { + if (data[i] != (uint8_t)header[i]) return false; + } + +} |