ym2413.c

DC的SEGA_GG模拟器源代码

                    case 0x0E: /* Rhythm enable and key-on bits */
                        if((data & 0x20) && (opll->rhythm == 0))
                        {
                            opll->rhythm = 1;
                            rhythm_mode_init(chip);
                        }
                        else
                        {
                            opll->rhythm = 0;
                        }
                        OPL_WRITE(chip, 0xBD, (data & 0x3F));
                        break;
                }
    
                /* If the user instrument registers were accessed, then
                   go through each channel and update the ones that were
                   currently using the user instrument. We can skip the
                   last three channels in rhythm mode since they can
                   only use percussion sounds anyways. */
                if(opll->latch <= 0x07)
                {
                    int x;
                    for(x = 0; x < ((opll->reg[0x0E] & 0x20) ? 6 : 9); x += 1)
                        if(opll->channel[x].instrument == 0x00)
                            load_instrument(chip, x, 0x00, opll->channel[x].volume);
                }
                break;
    
            case 0x10: /* Channel Frequency (LSB) */
            case 0x20: /* Channel Frequency (MSB) + key-on and sustain control */
                {
                    int block;
                    int frequency;
                    int ch = (opll->latch & 0x0F);

                    /* Ensure proper channel range */
                    if(ch > 0x08) break;
    
                    /* Get YM2413 channel frequency */
                    frequency = ((opll->reg[0x10 + ch] & 0xFF) | ((opll->reg[0x20 + ch] & 0x01) << 8));
    
                    /* Scale 9 bit frequency to 10 bits */
                    frequency = (frequency << 1) & 0x1FFF;
    
                    /* Get YM2413 block */
                    block = (opll->reg[0x20 + ch] >> 1) & 7;
    
                    /* Add in block */
                    frequency |= (block << 10);
    
                    /* Add key-on flag */
                    if(opll->reg[0x20 + ch] & 0x10) frequency |= 0x2000;
    
                    /* Save current frequency/block/key-on setting */
                    opll->channel[ch].frequency = (frequency & 0x3FFF);
    
                    /* TODO: Handle sustain flag (bit 5) before key-on */
    
                    /* Write changes to YM3812 */
                    OPL_WRITE(chip, 0xA0 + ch, (opll->channel[ch].frequency >> 0) & 0xFF);
                    OPL_WRITE(chip, 0xB0 + ch, (opll->channel[ch].frequency >> 8) & 0xFF);
                }
                break;
    
            case 0x30: /* Channel Volume Level and Instrument Select */

                /* Ensure proper channel range */
                if(opll->latch > 0x38) break;
    
                /* If we're accessing registers 36, 37, or 38, and we're
                   in rhythm mode, then update the individual volume
                   settings. */
                if((opll->latch >= 0x36) && (opll->reg[0x0E] & 0x20))
                {
                    switch(opll->latch & 0x0F)
                    {
                        case 0x06: /* Bass drum */
                          OPL_WRITE(chip, 0x53, ((data >> 0) & 0x0F) << 2);
                          break;
        
                        case 0x07: /* High hat and snare drum */
                          OPL_WRITE(chip, 0x51, ((data >> 4) & 0x0F) << 2);
                          OPL_WRITE(chip, 0x54, ((data >> 0) & 0x0F) << 2);
                          break;
        
                        case 0x08: /* Tom-top and top cymbal */
                          OPL_WRITE(chip, 0x52, ((data >> 4) & 0x0F) << 2);
                          OPL_WRITE(chip, 0x55, ((data >> 0) & 0x0F) << 2);
                          break;
                    }
                }
                else /* Set the new instrument and volume for this channel */
                {
                    int ch = (opll->latch & 0x0F);
                    int inst = (data >> 4) & 0x0F;
                    int vol = (data & 0x0F) << 2;
    
                    load_instrument(chip, ch, inst, vol);
                }
                break;
        }
    }
    else /* Register latch */
    {
        opll->latch = (data & 0x3F);
    }
}


void rhythm_mode_init(int chip)
{
    /* Point to current YM2413 context */
    t_ym2413 *opll = &ym2413[chip];

    /* Load instrument settings for channel seven. (Bass drum) */
    OPL_WRITE(chip, 0x30, 0x13);
    OPL_WRITE(chip, 0x33, 0x11);
    OPL_WRITE(chip, 0x50, 0x25);
    OPL_WRITE(chip, 0x53, ((opll->reg[0x36] >> 0) & 0x0F) << 2);
    OPL_WRITE(chip, 0x70, 0xD7);
    OPL_WRITE(chip, 0x73, 0xB7);
    OPL_WRITE(chip, 0x90, 0xF4);
    OPL_WRITE(chip, 0x93, 0xF4);
    OPL_WRITE(chip, 0xF0, 0x00);
    OPL_WRITE(chip, 0xF3, 0x00);
    OPL_WRITE(chip, 0xC6, 0x00);
    /* Use old frequency, but strip key-on bit */
    OPL_WRITE(chip, 0xA6, (opll->channel[6].frequency >> 0) & 0xFF);
    OPL_WRITE(chip, 0xB6, (opll->channel[6].frequency >> 8) & 0x1F);

    /* Load instrument settings for channel eight. (High hat and snare drum) */
    OPL_WRITE(chip, 0x31, 0x13);
    OPL_WRITE(chip, 0x34, 0x11);
    OPL_WRITE(chip, 0x51, ((opll->reg[0x37] >> 4) & 0x0f) << 2);
    OPL_WRITE(chip, 0x54, ((opll->reg[0x37] >> 0) & 0x0f) << 2);
    OPL_WRITE(chip, 0x71, 0xD7);
    OPL_WRITE(chip, 0x74, 0xB7);
    OPL_WRITE(chip, 0x91, 0xF4);
    OPL_WRITE(chip, 0x94, 0xF4);
    OPL_WRITE(chip, 0xF1, 0x00);
    OPL_WRITE(chip, 0xF4, 0x00);
    OPL_WRITE(chip, 0xC7, 0x00);
    /* Use old frequency, but strip key-on bit */
    OPL_WRITE(chip, 0xA7, (opll->channel[7].frequency >> 0) & 0xFF);
    OPL_WRITE(chip, 0xB7, (opll->channel[7].frequency >> 8) & 0x1F);

    /* Load instrument settings for channel nine. (Tom-tom and top cymbal) */
    OPL_WRITE(chip, 0x32, 0x13);
    OPL_WRITE(chip, 0x35, 0x11);
    OPL_WRITE(chip, 0x52, ((opll->reg[0x38] >> 4) & 0x0F) << 2);
    OPL_WRITE(chip, 0x55, ((opll->reg[0x38] >> 0) & 0x0F) << 2);
    OPL_WRITE(chip, 0x72, 0xD7);
    OPL_WRITE(chip, 0x75, 0xB7);
    OPL_WRITE(chip, 0x92, 0xF4);
    OPL_WRITE(chip, 0x95, 0xF4);
    OPL_WRITE(chip, 0xF2, 0x00);
    OPL_WRITE(chip, 0xF5, 0x00);
    OPL_WRITE(chip, 0xC8, 0x00);
    /* Use old frequency, but strip key-on bit */
    OPL_WRITE(chip, 0xA8, (opll->channel[8].frequency >> 0) & 0xFF);
    OPL_WRITE(chip, 0xB8, (opll->channel[8].frequency >> 8) & 0x1F);
}


/* channel (0-9), instrument (0-F), volume (0-3F, YM3812 format) */
void load_instrument(int chip, int ch, int inst, int vol)
{
    /* Point to current YM2413 context */
    t_ym2413 *opll = &ym2413[chip];

    /* Point to fixed instrument or user table */
    unsigned char *param = (inst == 0) ? &opll->user[0] : &table[inst][0];

    /* Maps channels to operator registers */
    unsigned char ch2op[] = {0, 1, 2, 8, 9, 10, 16, 17, 18};

    /* Make operator offset from requested channel */
    int op = ch2op[ch];

    /* Store volume level */
    opll->channel[ch].volume = (vol & 0x3F);

    /* Store instrument number */
    opll->channel[ch].instrument = (inst & 0x0F);

    /* Update instrument settings, except frequency registers */
    OPL_WRITE(chip, 0x20 + op,  param[0]);
    OPL_WRITE(chip, 0x23 + op,  param[1]);
    OPL_WRITE(chip, 0x40 + op,  param[2]);
    OPL_WRITE(chip, 0x43 + op, (param[3] & 0xC0) | opll->channel[ch].volume);
    OPL_WRITE(chip, 0x60 + op,  param[4]);
    OPL_WRITE(chip, 0x63 + op,  param[5]);
    OPL_WRITE(chip, 0x80 + op,  param[6]);
    OPL_WRITE(chip, 0x83 + op,  param[7]);
    OPL_WRITE(chip, 0xE0 + op,  param[8]);
    OPL_WRITE(chip, 0xE3 + op,  param[9]);
    OPL_WRITE(chip, 0xC0 + ch,  param[10]);
}