modeng.c

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

static VOID OnSyncMark(LPTRACK lpTrack)
{
    if (!Player.nFrame && Player.lpfnCallback)
        Player.lpfnCallback(lpTrack->bParams, Player.nOrder, Player.nRow);
}

static VOID OnNothing(LPTRACK lpTrack)
{
    /* does nothing, just avoid compiler warnings */
    if (lpTrack != NULL) {
    }
}

static VOID ExecNoteCmd(LPTRACK lpTrack)
{
    static VOID (*CommandProcTable[36])(LPTRACK) =
    {
        OnArpeggio,             /* 0xy */
        OnPortaUp,              /* 1xx */
        OnPortaDown,            /* 2xx */
        OnTonePorta,            /* 3xx */
        OnVibrato,              /* 4xy */
        OnToneAndSlide,         /* 5xy */
        OnVibratoAndSlide,      /* 6xy */
        OnTremolo,              /* 7xy */
        OnSetPanning,           /* 8xx */
        OnSampleOffset,         /* 9xx */
        OnVolumeSlide,          /* Axy */
        OnJumpPosition,         /* Bxx */
        OnSetVolume,            /* Cxx */
        OnPatternBreak,         /* Dxx */
        OnExtraCommand,         /* Exy */
        OnSetSpeed,             /* Fxx */
        OnSetGlobalVolume,      /* Gxx */
        OnGlobalVolumeSlide,    /* Hxy */
        OnNothing,              /* Ixx */
        OnNothing,              /* Jxx */
        OnKeyOff,               /* Kxx */
        OnSetEnvelope,          /* Lxx */
        OnNothing,              /* Mxx */
        OnNothing,              /* Nxx */
        OnNothing,              /* Oxx */
        OnPanningSlide,         /* Pxy */
        OnNothing,              /* Qxx */
        OnMultiRetrig,          /* Rxy */
        OnNothing,              /* Sxx */
        OnTremor,               /* Txy */
        OnFineVibrato,          /* Uxy */
        OnNothing,              /* Vxx */
        OnNothing,              /* Wxx */
        OnExtraFinePorta,       /* Xxy */
        OnNothing,              /* Yxx */
        OnSyncMark              /* Zxx */
    };

    if ((lpTrack->nCommand || lpTrack->bParams) && lpTrack->nCommand < 36) {
        (*CommandProcTable[lpTrack->nCommand]) (lpTrack);
    }
}

static VOID ExecVolumeCmd(LPTRACK lpTrack)
{
    UINT nCommand;

    nCommand = lpTrack->nVolumeCmd;
    if (nCommand >= 0x10 && nCommand <= 0x50) {
        /* set volume */
        if (!Player.nFrame) {
            lpTrack->nVolume = nCommand - 0x10;
            lpTrack->nOutVolume = lpTrack->nVolume;
            lpTrack->bControl |= AUDIO_CTRL_VOLUME;
        }
    }
    else if (nCommand >= 0x60 && nCommand <= 0x6F) {
        /* volume slide down */
        if (Player.nFrame) {
            lpTrack->nVolume -= LOPARAM(nCommand);
            if (lpTrack->nVolume < AUDIO_MIN_VOLUME)
                lpTrack->nVolume = AUDIO_MIN_VOLUME;
            lpTrack->nOutVolume = lpTrack->nVolume;
            lpTrack->bControl |= AUDIO_CTRL_VOLUME;
        }
    }
    else if (nCommand >= 0x70 && nCommand <= 0x7F) {
        /* volume slide up */
        if (Player.nFrame) {
            lpTrack->nVolume += LOPARAM(nCommand);
            if (lpTrack->nVolume > AUDIO_MAX_VOLUME)
                lpTrack->nVolume = AUDIO_MAX_VOLUME;
            lpTrack->nOutVolume = lpTrack->nVolume;
            lpTrack->bControl |= AUDIO_CTRL_VOLUME;
        }
    }
    else if (nCommand >= 0x80 && nCommand <= 0x8F) {
        /* fine volume slide down */
        if (!Player.nFrame) {
            lpTrack->nVolume -= LOPARAM(nCommand);
            if (lpTrack->nVolume < AUDIO_MIN_VOLUME)
                lpTrack->nVolume = AUDIO_MIN_VOLUME;
            lpTrack->nOutVolume = lpTrack->nVolume;
            lpTrack->bControl |= AUDIO_CTRL_VOLUME;
        }
    }
    else if (nCommand >= 0x90 && nCommand <= 0x9F) {
        /* fine volume slide up */
        if (!Player.nFrame) {
            lpTrack->nVolume += LOPARAM(nCommand);
            if (lpTrack->nVolume > AUDIO_MAX_VOLUME)
                lpTrack->nVolume = AUDIO_MAX_VOLUME;
            lpTrack->nOutVolume = lpTrack->nVolume;
            lpTrack->bControl |= AUDIO_CTRL_VOLUME;
        }
    }
    else if (nCommand >= 0xA0 && nCommand <= 0xAF) {
        /* set vibrato speed */
        if (!Player.nFrame) {
            if (LOPARAM(nCommand)) {
                lpTrack->nVibratoRate = LOPARAM(nCommand) << 2;
            }
        }
    }
    else if (nCommand >= 0xB0 && nCommand <= 0xBF) {
        /* vibrato */
        if (!Player.nFrame) {
            if (LOPARAM(nCommand)) {
                lpTrack->nVibratoDepth = LOPARAM(nCommand);
            }
        }
        else {
            OnVibrato(lpTrack);
        }
    }
    else if (nCommand >= 0xC0 && nCommand <= 0xCF) {
        /* set coarse panning */
        if (!Player.nFrame) {
            lpTrack->nPanning = LOPARAM(nCommand) << 4;
            lpTrack->bControl |= AUDIO_CTRL_PANNING;
        }
    }
    else if (nCommand >= 0xD0 && nCommand <= 0xDF) {
        /* panning slide left */
        if (Player.nFrame) {
            lpTrack->nPanning -= LOPARAM(nCommand);
            if (lpTrack->nPanning < AUDIO_MIN_PANNING)
                lpTrack->nPanning = AUDIO_MIN_PANNING;
            lpTrack->bControl |= AUDIO_CTRL_PANNING;
        }
    }
    else if (nCommand >= 0xE0 && nCommand <= 0xEF) {
        /* panning slide right */
        if (Player.nFrame) {
            lpTrack->nPanning += LOPARAM(nCommand);
            if (lpTrack->nPanning > AUDIO_MAX_PANNING)
                lpTrack->nPanning = AUDIO_MAX_PANNING;
            lpTrack->bControl |= AUDIO_CTRL_PANNING;
        }
    }
    else if (nCommand >= 0xF0 && nCommand <= 0xFF) {
        /* tone portamento */
        if (Player.nFrame)
            OnTonePorta(lpTrack);
    }
}

static VOID StartEnvelopes(LPTRACK lpTrack)
{
    LPAUDIOPATCH lpPatch;

    /* reset vibrato and tremolo waves */
    if (!(lpTrack->bWaveCtrl & 0x04))
        lpTrack->nVibratoFrame = 0;
    if (!(lpTrack->bWaveCtrl & 0x40))
        lpTrack->nTremoloFrame = 0;

    /* reset retrig and tremor frames */
    lpTrack->nRetrigFrame = 0;
    lpTrack->nTremorFrame = 0;
    lpTrack->bTremorOnOff = 0;

    lpPatch = lpTrack->lpPatch;

    /* start volume envelope */
    if (lpPatch != NULL && (lpPatch->Volume.wFlags & AUDIO_ENVELOPE_ON)) {
        lpTrack->nVolumeFrame = -1;
        lpTrack->nVolumePoint = 0;
    }

    /* start panning envelope */
    if (lpPatch != NULL && (lpPatch->Panning.wFlags & AUDIO_ENVELOPE_ON)) {
        lpTrack->nPanningFrame = -1;
        lpTrack->nPanningPoint = 0;
    }

    /* start volume fadeout */
    if (lpPatch != NULL)
        lpTrack->nVolumeFadeout = lpPatch->nVolumeFadeout;
    lpTrack->nVolumeFade = 0x7FFF;

    /* start automatic vibrato */
    if (lpPatch != NULL && lpPatch->nVibratoDepth) {
        lpTrack->nAutoVibratoFrame = 0;
        if (lpPatch->nVibratoSweep) {
            lpTrack->nAutoVibratoSlope =
                ((int) lpPatch->nVibratoDepth << 8) / lpPatch->nVibratoSweep;
            lpTrack->nAutoVibratoValue = 0;
        }
        else {
            lpTrack->nAutoVibratoSlope = 0;
            lpTrack->nAutoVibratoValue =
                ((int) lpPatch->nVibratoDepth << 8);
        }
    }
}

static VOID UpdateEnvelopes(LPTRACK lpTrack)
{
    LPAUDIOPATCH lpPatch;
    LPAUDIOPOINT lpPts;
    int nFrames, nValue;

    /* get patch structure alias */
    lpPatch = lpTrack->lpPatch;

    /* process volume fadeout */
    if (lpPatch != NULL && !lpTrack->fKeyOn) {
        if ((lpTrack->nVolumeFade -= lpTrack->nVolumeFadeout) < 0) {
            lpTrack->nVolumeFadeout = 0;
            lpTrack->nVolumeFade = 0;
        }
        lpTrack->bControl |= AUDIO_CTRL_VOLUME;
    }

    /* process volume envelope */
    if (lpPatch != NULL && (lpPatch->Volume.wFlags & AUDIO_ENVELOPE_ON)) {
        lpPts = lpPatch->Volume.aEnvelope;
        if (++lpTrack->nVolumeFrame >= lpPts[lpTrack->nVolumePoint].nFrame) {
            if ((lpPatch->Volume.wFlags & AUDIO_ENVELOPE_SUSTAIN) &&
                (lpTrack->nVolumePoint == lpPatch->Volume.nSustain) &&
                lpTrack->fKeyOn) {
                lpTrack->nVolumeFrame = lpPts[lpTrack->nVolumePoint].nFrame;
                lpTrack->nVolumeValue = (int) lpPts[lpTrack->nVolumePoint].nValue << 8;
            }
            else {
                if ((lpPatch->Volume.wFlags & AUDIO_ENVELOPE_LOOP) &&
                    (lpTrack->nVolumePoint == lpPatch->Volume.nLoopEnd)) {
                    lpTrack->nVolumePoint = lpPatch->Volume.nLoopStart;
                }
                lpTrack->nVolumeFrame = lpPts[lpTrack->nVolumePoint].nFrame;
                lpTrack->nVolumeValue = (int) lpPts[lpTrack->nVolumePoint].nValue << 8;
                if (lpTrack->nVolumePoint + 1 >= lpPatch->Volume.nPoints) {
                    lpTrack->nVolumeSlope = 0;
                }
                else {
                    if ((nFrames = lpPts[lpTrack->nVolumePoint + 1].nFrame -
			 lpPts[lpTrack->nVolumePoint].nFrame) <= 0)
                        lpTrack->nVolumeSlope = 0;
                    else {
                        lpTrack->nVolumeSlope =
                            (((int) lpPts[lpTrack->nVolumePoint + 1].nValue -
			      (int) lpPts[lpTrack->nVolumePoint].nValue) << 8) / nFrames;
                    }
                    lpTrack->nVolumePoint++;
                }
            }
        }
        else {
            lpTrack->nVolumeValue += lpTrack->nVolumeSlope;
            lpTrack->nVolumeValue = CLIP(lpTrack->nVolumeValue, 0, 64 * 256);
        }
        lpTrack->nFinalVolume = (((LONG) (lpTrack->nVolumeValue >> 8) *
				  lpTrack->nOutVolume) * lpTrack->nVolumeFade) >> 21;
        lpTrack->bControl |= AUDIO_CTRL_VOLUME;
    }
    else {
        lpTrack->nFinalVolume = lpTrack->nOutVolume;
        if (lpTrack->nVolumeFade != 0x7FFF)
            lpTrack->nFinalVolume = ((LONG) lpTrack->nFinalVolume * 
				     lpTrack->nVolumeFade) >> 15;
    }

    /* process panning envelope */
    if (lpPatch != NULL && (lpPatch->Panning.wFlags & AUDIO_ENVELOPE_ON)) {
        lpPts = lpPatch->Panning.aEnvelope;
        if (++lpTrack->nPanningFrame >= lpPts[lpTrack->nPanningPoint].nFrame) {
            if ((lpPatch->Panning.wFlags & AUDIO_ENVELOPE_SUSTAIN) &&
                (lpTrack->nPanningPoint == lpPatch->Panning.nSustain) &&
                lpTrack->fKeyOn) {
                lpTrack->nPanningFrame = lpPts[lpTrack->nPanningPoint].nFrame;
                lpTrack->nPanningValue = (int) lpPts[lpTrack->nPanningPoint].nValue << 8;
            }
            else {
                if ((lpPatch->Panning.wFlags & AUDIO_ENVELOPE_LOOP) &&
                    (lpTrack->nPanningPoint == lpPatch->Panning.nLoopEnd)) {
                    lpTrack->nPanningPoint = lpPatch->Panning.nLoopStart;
                }
                lpTrack->nPanningFrame = lpPts[lpTrack->nPanningPoint].nFrame;
                lpTrack->nPanningValue = (int) lpPts[lpTrack->nPanningPoint].nValue << 8;
                if (lpTrack->nPanningPoint + 1 >= lpPatch->Panning.nPoints) {
                    lpTrack->nPanningSlope = 0;
                }
                else {
                    if ((nFrames = lpPts[lpTrack->nPanningPoint + 1].nFrame -
			 lpPts[lpTrack->nPanningPoint].nFrame) <= 0)
                        lpTrack->nPanningSlope = 0;
                    else {
                        lpTrack->nPanningSlope =
                            (((int) lpPts[lpTrack->nPanningPoint + 1].nValue -
			      (int) lpPts[lpTrack->nPanningPoint].nValue) << 8) / nFrames;
                    }
                    lpTrack->nPanningPoint++;
                }
            }
        }
        else {
            lpTrack->nPanningValue += lpTrack->nPanningSlope;
            lpTrack->nPanningValue = CLIP(lpTrack->nPanningValue, 0, 64 * 256);
        }
        lpTrack->nFinalPanning = lpTrack->nPanning +
            ((((128L - ABS(lpTrack->nPanning - 128)) << 3) *
	      (lpTrack->nPanningValue - 32 * 256L)) >> 16);
        lpTrack->bControl |= AUDIO_CTRL_PANNING;
    }
    else {
        lpTrack->nFinalPanning = lpTrack->nPanning;
    }

    /* process automatic vibrato */
    if (lpPatch != NULL && lpPatch->nVibratoDepth != 0) {
        if (lpTrack->fKeyOn && lpTrack->nAutoVibratoSlope) {
            lpTrack->nAutoVibratoValue += lpTrack->nAutoVibratoSlope;
            if (lpTrack->nAutoVibratoValue > ((int) lpPatch->nVibratoDepth << 8)) {
                lpTrack->nAutoVibratoValue = (int) lpPatch->nVibratoDepth << 8;
                lpTrack->nAutoVibratoSlope = 0;
            }
        }
        lpTrack->nAutoVibratoFrame += lpPatch->nVibratoRate;
        nFrames = (BYTE) lpTrack->nAutoVibratoFrame;
        switch (lpPatch->nVibratoType) {
        case 0x00:
            nValue = aAutoVibratoTable[nFrames];
            break;
        case 0x01:
            nValue = (nFrames & 0x80) ? +64 : -64;
            break;
        case 0x02:
            nValue = ((64 + (nFrames >> 1)) & 0x7f) - 64;
            break;
        case 0x03:
            nValue = ((64 - (nFrames >> 1)) & 0x7f) - 64;
            break;
        default:
            /* unknown vibrato waveform type */
            nValue = 0;
            break;
        }
        lpTrack->nFinalPeriod = lpTrack->nOutPeriod +
            ((((LONG) nValue << 2) * lpTrack->nAutoVibratoValue) >> 16);
        lpTrack->nFinalPeriod = CLIP(lpTrack->nFinalPeriod,
				     AUDIO_MIN_PERIOD, AUDIO_MAX_PERIOD);
        lpTrack->bControl |= AUDIO_CTRL_PITCH;
    }
    else {
        lpTrack->nFinalPeriod = lpTrack->nOutPeriod;
    }
}

static VOID PlayNote(LPTRACK lpTrack)
{
    LPAUDIOPATCH lpPatch;
    LPAUDIOSAMPLE lpSample;

    lpTrack->fKeyOn = (lpTrack->nNote >= 1 && lpTrack->nNote <= AUDIO_MAX_NOTES);
    if (lpTrack->fKeyOn && (lpPatch = lpTrack->lpPatch) != NULL) {
        lpTrack->nSample = lpPatch->aSampleNumber[lpTrack->nNote - 1];
        if (lpTrack->nSample < lpPatch->nSamples) {
            lpTrack->lpSample = &lpPatch->aSampleTable[lpTrack->nSample];
            lpSample = lpTrack->lpSample;
            lpTrack->nRelativeNote = (signed char) lpSample->nRelativeNote;
            lpTrack->nFinetune = (signed char) lpSample->nFinetune;
            if (lpTrack->nCommand != 0x03 && lpTrack->nCommand != 0x05 &&
                (lpTrack->nVolumeCmd & 0xF0) != 0xF0) {
                lpTrack->nPeriod = lpTrack->nOutPeriod =
                    GetPeriodValue(lpTrack->nNote,
				   lpTrack->nRelativeNote, lpTrack->nFinetune);
                lpTrack->bControl |= (AUDIO_CTRL_PITCH | AUDIO_CTRL_KEYON);
            }
        }
        else {
            lpTrack->lpSample = NULL;
        }
    }
}

static VOID StopNote(LPTRACK lpTrack)
{
    lpTrack->fKeyOn = 0;
    if (lpTrack->lpPatch != NULL) {
        if (!(lpTrack->lpPatch->Volume.wFlags & AUDIO_ENVELOPE_ON)) {
            lpTrack->nVolume = lpTrack->nOutVolume = 0;
            lpTrack->bControl |= (AUDIO_CTRL_VOLUME | AUDIO_CTRL_KEYOFF);
        }
    }
    else {
        lpTrack->bControl |= AUDIO_CTRL_KEYOFF;
    }
}

static VOID RetrigNote(LPTRACK lpTrack)
{
    PlayNote(lpTrack);
    StartEnvelopes(lpTrack);
}