modeng.c

这个是延伸mame的在wince平台下的游戏模拟器的代码

}

static VOID OnToneAndSlide(LPTRACK lpTrack)
{
    if (!Player.nFrame) {
        OnVolumeSlide(lpTrack);
        lpTrack->bControl &= ~(AUDIO_CTRL_PITCH | AUDIO_CTRL_KEYON);
    }
    else {
        OnTonePorta(lpTrack);
        OnVolumeSlide(lpTrack);
    }
}

static VOID OnVibratoAndSlide(LPTRACK lpTrack)
{
    if (!Player.nFrame) {
        OnVolumeSlide(lpTrack);
    }
    else {
        OnVibrato(lpTrack);
        OnVolumeSlide(lpTrack);
    }
}

static VOID OnTremolo(LPTRACK lpTrack)
{
    int nDelta, nFrame;

    if (!Player.nFrame) {
        if (LOPARAM(lpTrack->bParams)) {
            lpTrack->nTremoloDepth = LOPARAM(lpTrack->bParams);
        }
        if (HIPARAM(lpTrack->bParams)) {
            lpTrack->nTremoloRate = HIPARAM(lpTrack->bParams) << 2;
        }
    }
    else {
        nFrame = (lpTrack->nTremoloFrame >> 2) & 0x1F;
        switch (lpTrack->bWaveCtrl & 0x30) {
        case 0x00:
            nDelta = aSineTable[nFrame];
            break;
        case 0x10:
            nDelta = nFrame << 3;
            if (lpTrack->nTremoloFrame & 0x80)
                nDelta ^= 0xFF;
            break;
        case 0x20:
            nDelta = 0xFF;
            break;
        default:
            /* TODO: random waveform not implemented */
            nDelta = 0x00;
            break;
        }
        nDelta = (nDelta * lpTrack->nTremoloDepth) >> 6;
        lpTrack->nOutVolume = lpTrack->nVolume;
        if (lpTrack->nTremoloFrame & 0x80) {
            lpTrack->nOutVolume -= nDelta;
            if (lpTrack->nOutVolume < AUDIO_MIN_VOLUME)
                lpTrack->nOutVolume = AUDIO_MIN_VOLUME;
        }
        else {
            lpTrack->nOutVolume += nDelta;
            if (lpTrack->nOutVolume > AUDIO_MAX_VOLUME)
                lpTrack->nOutVolume = AUDIO_MAX_VOLUME;
        }
        lpTrack->bControl |= AUDIO_CTRL_VOLUME;
        lpTrack->nTremoloFrame += lpTrack->nTremoloRate;
    }
}

static VOID OnSetPanning(LPTRACK lpTrack)
{
    if (!Player.nFrame) {
        lpTrack->nPanning = lpTrack->bParams;
        lpTrack->bControl |= AUDIO_CTRL_PANNING;
    }
}

static VOID OnSampleOffset(LPTRACK lpTrack)
{
    if (!Player.nFrame) {
        lpTrack->dwSampleOffset = (LONG) lpTrack->bParams << 8;
        lpTrack->bControl |= AUDIO_CTRL_KEYON | AUDIO_CTRL_TOUCH;
    }
}

static VOID OnJumpPosition(LPTRACK lpTrack)
{
    if (!Player.nFrame) {
        if (lpTrack->bParams < Player.lpModule->nOrders) {
            Player.nJumpOrder = lpTrack->bParams;
            Player.wControl |= AUDIO_PLAYER_JUMP;
        }
    }
}

static VOID OnSetVolume(LPTRACK lpTrack)
{
    if (!Player.nFrame) {
        if ((lpTrack->nVolume = lpTrack->bParams) > AUDIO_MAX_VOLUME)
            lpTrack->nVolume = AUDIO_MAX_VOLUME;
        lpTrack->nOutVolume = lpTrack->nVolume;
        lpTrack->bControl |= AUDIO_CTRL_VOLUME;
    }
}

static VOID OnPatternBreak(LPTRACK lpTrack)
{
    if (!Player.nFrame) {
        Player.nJumpRow = 10 * HIPARAM(lpTrack->bParams) +
            LOPARAM(lpTrack->bParams);
        Player.wControl |= AUDIO_PLAYER_BREAK;
    }
}

static VOID OnExtraCommand(LPTRACK lpTrack)
{
    switch (HIPARAM(lpTrack->bParams)) {
    case 0x0:
        /* TODO: filter control not implemented */
        break;
    case 0x1:
        /* fine portamento up */
        if (!Player.nFrame) {
            if (LOPARAM(lpTrack->bParams))
                lpTrack->nFinePortaUp = LOPARAM(lpTrack->bParams) << 2;
            lpTrack->nPeriod -= lpTrack->nFinePortaUp;
            if (lpTrack->nPeriod < AUDIO_MIN_PERIOD)
                lpTrack->nPeriod = AUDIO_MIN_PERIOD;
            lpTrack->nOutPeriod = lpTrack->nPeriod;
            lpTrack->bControl |= AUDIO_CTRL_PITCH;
        }
        break;
    case 0x2:
        /* fine portamento down */
        if (!Player.nFrame) {
            if (LOPARAM(lpTrack->bParams))
                lpTrack->nFinePortaDown = LOPARAM(lpTrack->bParams) << 2;
            lpTrack->nPeriod += lpTrack->nFinePortaDown;
            if (lpTrack->nPeriod > AUDIO_MAX_PERIOD)
                lpTrack->nPeriod = AUDIO_MAX_PERIOD;
            lpTrack->nOutPeriod = lpTrack->nPeriod;
            lpTrack->bControl |= AUDIO_CTRL_PITCH;
        }
        break;
    case 0x3:
        /* set glissando control */
        if (!Player.nFrame) {
            lpTrack->bGlissCtrl = LOPARAM(lpTrack->bParams);
        }
        break;
    case 0x4:
        /* set vibrato wave control */
        if (!Player.nFrame) {
            lpTrack->bWaveCtrl &= 0xF0;
            lpTrack->bWaveCtrl |= LOPARAM(lpTrack->bParams);
        }
        break;
    case 0x5:
        /* set finetune */
        if (!Player.nFrame) {
            lpTrack->nFinetune = ((int) LOPARAM(lpTrack->bParams) << 4) - 0x80;
            lpTrack->nOutPeriod = GetPeriodValue(lpTrack->nNote,
						 lpTrack->nRelativeNote, lpTrack->nFinetune);
            lpTrack->bControl |= AUDIO_CTRL_PITCH;
        }
        break;
    case 0x6:
        /* set/start pattern loop */
        if (!Player.nFrame) {
            if (LOPARAM(lpTrack->bParams)) {
                if (lpTrack->nPatternLoop)
                    lpTrack->nPatternLoop--;
                else
                    lpTrack->nPatternLoop = LOPARAM(lpTrack->bParams);
                if (lpTrack->nPatternLoop) {
                    Player.nJumpRow = lpTrack->nPatternRow;
                    Player.nJumpOrder = Player.nOrder;
                    Player.wControl |= AUDIO_PLAYER_JUMP;
                }
            }
            else {
                lpTrack->nPatternRow = Player.nRow;
            }
        }
        break;
    case 0x7:
        /* set tremolo wave control */
        if (!Player.nFrame) {
            lpTrack->bWaveCtrl &= 0x0F;
            lpTrack->bWaveCtrl |= LOPARAM(lpTrack->bParams) << 4;
        }
        break;
    case 0x8:
        /* set stereo panning control */
        if (!Player.nFrame) {
            lpTrack->nPanning = LOPARAM(lpTrack->bParams) << 4;
            lpTrack->bControl |= AUDIO_CTRL_PANNING;
        }
        break;
    case 0x9:
        /* retrig note */
        if (!Player.nFrame) {
            RetrigNote(lpTrack);
        }
        else if (LOPARAM(lpTrack->bParams)) {
            if (!(Player.nFrame % LOPARAM(lpTrack->bParams))) {
                RetrigNote(lpTrack);
            }
        }
        break;
    case 0xA:
        /* fine volume slide up */
        if (!Player.nFrame) {
            lpTrack->nVolume += LOPARAM(lpTrack->bParams);
            if (lpTrack->nVolume > AUDIO_MAX_VOLUME)
                lpTrack->nVolume = AUDIO_MAX_VOLUME;
            lpTrack->nOutVolume = lpTrack->nVolume;
            lpTrack->bControl |= AUDIO_CTRL_VOLUME;
        }
        break;
    case 0xB:
        /* fine volume slide down */
        if (!Player.nFrame) {
            lpTrack->nVolume -= LOPARAM(lpTrack->bParams);
            if (lpTrack->nVolume < AUDIO_MIN_VOLUME)
                lpTrack->nVolume = AUDIO_MIN_VOLUME;
            lpTrack->nOutVolume = lpTrack->nVolume;
            lpTrack->bControl |= AUDIO_CTRL_VOLUME;
        }
        break;
    case 0xC:
        /* note cut */
        if (Player.nFrame == LOPARAM(lpTrack->bParams)) {
            lpTrack->nVolume = lpTrack->nOutVolume = 0;
            lpTrack->bControl |= AUDIO_CTRL_VOLUME;
        }
        break;
    case 0xD:
        /* note delay */
        lpTrack->bControl &= AUDIO_CTRL_KEYOFF;
        if (Player.nFrame == LOPARAM(lpTrack->bParams)) {
            RetrigNote(lpTrack);
            lpTrack->bControl |= (AUDIO_CTRL_VOLUME | AUDIO_CTRL_PANNING);
        }
        break;
    case 0xE:
        /* pattern delay */
        if (!Player.nFrame) {
            if (!(Player.wControl & AUDIO_PLAYER_DELAY)) {
                Player.nPatternDelay = LOPARAM(lpTrack->bParams) + 1;
                Player.wControl |= AUDIO_PLAYER_DELAY;
            }
        }
        break;
    case 0xF:
        /* TODO: funk it! not implemented */
        break;
    }
}

static VOID OnSetSpeed(LPTRACK lpTrack)
{
    if (!Player.nFrame) {
        if (lpTrack->bParams >= 0x20) {
            Player.nBPM = lpTrack->bParams;
            Player.wControl |= AUDIO_PLAYER_BPM;
        }
        else if (lpTrack->bParams >= 0x01) {
            Player.nTempo = lpTrack->bParams;
        }
    }
}

static VOID OnSetGlobalVolume(LPTRACK lpTrack)
{
    if (!Player.nFrame) {
        if ((Player.nVolume = lpTrack->bParams) > AUDIO_MAX_VOLUME)
            Player.nVolume = AUDIO_MAX_VOLUME;
        Player.wControl |= AUDIO_PLAYER_VOLUME;
    }
}

static VOID OnGlobalVolumeSlide(LPTRACK lpTrack)
{
    if (!Player.nFrame) {
        if (lpTrack->bParams != 0x00) {
            Player.nVolumeRate = lpTrack->bParams;
        }
    }
    else {
        if (HIPARAM(Player.nVolumeRate)) {
            Player.nVolume += HIPARAM(Player.nVolumeRate);
            if (Player.nVolume > AUDIO_MAX_VOLUME)
                Player.nVolume = AUDIO_MAX_VOLUME;
        }
        else {
            Player.nVolume -= LOPARAM(Player.nVolumeRate);
            if (Player.nVolume < AUDIO_MIN_VOLUME)
                Player.nVolume = AUDIO_MIN_VOLUME;
        }
        Player.wControl |= AUDIO_PLAYER_VOLUME;
    }
}

static VOID OnKeyOff(LPTRACK lpTrack)
{
    if (Player.nFrame == lpTrack->bParams) {
        StopNote(lpTrack);
    }
}

static VOID OnSetEnvelope(LPTRACK lpTrack)
{
    /* TODO: set envelope position not implemented */
    if (lpTrack != NULL) {
    }
}

static VOID OnPanningSlide(LPTRACK lpTrack)
{
    if (!Player.nFrame) {
        if (lpTrack->bParams != 0x00) {
            lpTrack->bPanningSlide = lpTrack->bParams;
        }
    }
    else {
        if (HIPARAM(lpTrack->bPanningSlide)) {
            lpTrack->nPanning += HIPARAM(lpTrack->bPanningSlide);
            if (lpTrack->nPanning > AUDIO_MAX_PANNING)
                lpTrack->nPanning = AUDIO_MAX_PANNING;
        }
        else {
            lpTrack->nPanning -= LOPARAM(lpTrack->bPanningSlide);
            if (lpTrack->nPanning < AUDIO_MIN_PANNING)
                lpTrack->nPanning = AUDIO_MIN_PANNING;
        }
        lpTrack->bControl |= AUDIO_CTRL_PANNING;
    }
}

static VOID OnMultiRetrig(LPTRACK lpTrack)
{
    if (!Player.nFrame) {
        if (HIPARAM(lpTrack->bParams))
            lpTrack->nRetrigType = HIPARAM(lpTrack->bParams);
        if (LOPARAM(lpTrack->bParams))
            lpTrack->nRetrigInterval = LOPARAM(lpTrack->bParams);
    }
    else if (++lpTrack->nRetrigFrame >= lpTrack->nRetrigInterval) {
        lpTrack->nRetrigFrame = 0;
        lpTrack->nVolume += aRetrigTable[lpTrack->nRetrigType];
        lpTrack->nVolume *= aRetrigTable[lpTrack->nRetrigType + 16];
        lpTrack->nVolume >>= 4;
        lpTrack->nVolume = CLIP(lpTrack->nVolume,
				AUDIO_MIN_VOLUME, AUDIO_MAX_VOLUME);
        if (lpTrack->nVolumeCmd >= 0x10 && lpTrack->nVolumeCmd <= 0x50) {
            lpTrack->nVolume = lpTrack->nVolumeCmd - 0x10;
            lpTrack->bControl |= AUDIO_CTRL_VOLUME;
        }
        if (lpTrack->nVolumeCmd >= 0xC0 && lpTrack->nVolumeCmd <= 0xCF) {
            lpTrack->nPanning = LOPARAM(lpTrack->nVolumeCmd) << 4;
            lpTrack->bControl |= AUDIO_CTRL_PANNING;
        }
        lpTrack->nOutVolume = lpTrack->nVolume;
        lpTrack->bControl |= AUDIO_CTRL_VOLUME;
        PlayNote(lpTrack);
    }
}

static VOID OnTremor(LPTRACK lpTrack)
{
    if (!Player.nFrame) {
        if (lpTrack->bParams) {
            lpTrack->bTremorParms = lpTrack->bParams;
        }
    }
    if (!lpTrack->nTremorFrame--) {
        lpTrack->nTremorFrame = lpTrack->bTremorOnOff ?
            LOPARAM(lpTrack->bTremorParms) :
            HIPARAM(lpTrack->bTremorParms);
        lpTrack->bTremorOnOff = !lpTrack->bTremorOnOff;
    }
    lpTrack->nOutVolume = lpTrack->bTremorOnOff ? lpTrack->nVolume : 0x00;
    lpTrack->bControl |= AUDIO_CTRL_VOLUME;
}

static VOID OnExtraFinePorta(LPTRACK lpTrack)
{
    if (!Player.nFrame) {
        if (HIPARAM(lpTrack->bParams) == 0x1) {
            if (LOPARAM(lpTrack->bParams))
                lpTrack->nExtraPortaUp = LOPARAM(lpTrack->bParams);
            lpTrack->nPeriod -= lpTrack->nExtraPortaUp;
            if (lpTrack->nPeriod < AUDIO_MIN_PERIOD)
                lpTrack->nPeriod = AUDIO_MIN_PERIOD;
            lpTrack->nOutPeriod = lpTrack->nPeriod;
            lpTrack->bControl |= AUDIO_CTRL_PITCH;
        }
        else if (HIPARAM(lpTrack->bParams) == 0x2) {
            if (LOPARAM(lpTrack->bParams))
                lpTrack->nExtraPortaDown = LOPARAM(lpTrack->bParams);
            lpTrack->nPeriod += lpTrack->nExtraPortaDown;
            if (lpTrack->nPeriod > AUDIO_MAX_PERIOD)
                lpTrack->nPeriod = AUDIO_MAX_PERIOD;
            lpTrack->nOutPeriod = lpTrack->nPeriod;
            lpTrack->bControl |= AUDIO_CTRL_PITCH;
        }
    }
}