modeng.c

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

static VOID GetPatternNote(LPNOTE lpNote)
{
    BYTE fPacking;

#define GETBYTE *Player.lpData++

    fPacking = (Player.lpData != NULL) ?
        (Player.lpData[0] & AUDIO_PATTERN_PACKED ? GETBYTE : 0xFF) : 0x00;
    lpNote->nNote = (fPacking & AUDIO_PATTERN_NOTE) ? GETBYTE : 0x00;
    lpNote->nPatch = (fPacking & AUDIO_PATTERN_SAMPLE) ? GETBYTE : 0x00;
    lpNote->nVolume = (fPacking & AUDIO_PATTERN_VOLUME) ? GETBYTE : 0x00;
    lpNote->nCommand = (fPacking & AUDIO_PATTERN_COMMAND) ? GETBYTE : 0x00;
    lpNote->bParams = (fPacking & AUDIO_PATTERN_PARAMS) ? GETBYTE : 0x00;
}

static VOID GetTrackNote(LPTRACK lpTrack)
{
    static NOTE Note;

    /* read next packed note from pattern */
    GetPatternNote(&Note);

    /* reset frequency for vibrato and arpeggio commands */
    if (lpTrack->nCommand == 0x04 || lpTrack->nCommand == 0x06) {
        if (Note.nCommand != 0x04 && Note.nCommand != 0x06) {
            lpTrack->nOutPeriod = lpTrack->nPeriod;
            lpTrack->bControl |= AUDIO_CTRL_PITCH;
        }
    }
    else if (lpTrack->nCommand == 0x00 && lpTrack->bParams != 0x00) {
        lpTrack->nOutPeriod = lpTrack->nPeriod;
        lpTrack->bControl |= AUDIO_CTRL_PITCH;
    }

    /* assign volume and effect commands */
    lpTrack->nVolumeCmd = Note.nVolume;
    lpTrack->nCommand = Note.nCommand;
    lpTrack->bParams = Note.bParams;

    /* change default patch instrument */
    if (Note.nPatch >= 1 && Note.nPatch <= Player.lpModule->nPatches) {
        lpTrack->nPatch = Note.nPatch;
        lpTrack->lpPatch = &Player.lpModule->aPatchTable[lpTrack->nPatch - 1];
    }

    /* new note pressed? */
    if (Note.nNote >= 1 && Note.nNote <= AUDIO_MAX_NOTES) {
        lpTrack->nNote = Note.nNote;
        PlayNote(lpTrack);
        if (Note.nPatch != 0 && lpTrack->lpSample != NULL)
            StartEnvelopes(lpTrack);
    }
    else if (Note.nNote != 0) {
        StopNote(lpTrack);
    }

    /* use default sample's volume and panning? */
    if (Note.nPatch != 0 && lpTrack->lpSample != NULL) {
        lpTrack->nVolume = lpTrack->nOutVolume = lpTrack->lpSample->nVolume;
        lpTrack->bControl |= AUDIO_CTRL_VOLUME;
        if (!(Player.wFlags & AUDIO_MODULE_PANNING)) {
            lpTrack->nPanning = lpTrack->lpSample->nPanning;
            lpTrack->bControl |= AUDIO_CTRL_PANNING;
        }
    }
}

static VOID SendNoteMesg(HAC hVoice, LPTRACK lpTrack)
{
    if (lpTrack->bControl & (AUDIO_CTRL_KEYON | AUDIO_CTRL_TOUCH)) {
        if (lpTrack->lpSample != NULL) {
            APrimeVoice(hVoice, &lpTrack->lpSample->Wave);
            if (lpTrack->bControl & AUDIO_CTRL_TOUCH)
                ASetVoicePosition(hVoice, lpTrack->dwSampleOffset);
        }
    }
    if (lpTrack->bControl & AUDIO_CTRL_KEYOFF) {
        AStopVoice(hVoice);
    }
    if (lpTrack->bControl & AUDIO_CTRL_PITCH) {
        ASetVoiceFrequency(hVoice, GetFrequencyValue(lpTrack->nFinalPeriod));
    }
    if (lpTrack->bControl & AUDIO_CTRL_VOLUME) {
        ASetVoiceVolume(hVoice, (lpTrack->nFinalVolume * Player.nVolume) >> 6);
    }
    if (lpTrack->bControl & AUDIO_CTRL_PANNING) {
        ASetVoicePanning(hVoice, lpTrack->nFinalPanning);
    }
    if (lpTrack->bControl & AUDIO_CTRL_KEYON) {
        AStartVoice(hVoice);
    }
    lpTrack->bControl = 0x00;
}

static VOID GetNextPatternRow(VOID)
{
    static NOTE Note;
    LPAUDIOPATTERN lpPattern;
    int n, m;

    Player.nFrame = 0;
    if (Player.wControl & AUDIO_PLAYER_DELAY)
        return;

    if (++Player.nRow >= Player.nRows) {
        Player.wControl |= AUDIO_PLAYER_BREAK;
    }
    if (Player.wControl & AUDIO_PLAYER_JUMP) {
        Player.nRow = Player.nJumpRow;
        Player.nJumpRow = 0;
        Player.nOrder = Player.nJumpOrder;
    }
    else if (Player.wControl & AUDIO_PLAYER_BREAK) {
        Player.nRow = Player.nJumpRow;
        Player.nJumpRow = 0;
        Player.nOrder++;
    }
    if (Player.wControl & (AUDIO_PLAYER_BREAK | AUDIO_PLAYER_JUMP)) {
        Player.wControl &= ~(AUDIO_PLAYER_BREAK | AUDIO_PLAYER_JUMP);
        if (Player.nOrder >= Player.lpModule->nOrders) {
            Player.nOrder = Player.lpModule->nRestart;
            if (Player.nOrder >= Player.lpModule->nOrders) {
                Player.nOrder = 0x00;
                Player.wControl |= AUDIO_PLAYER_PAUSE;
                return;
            }
        }
        Player.nPattern = Player.lpModule->aOrderTable[Player.nOrder];
        if (Player.nPattern < Player.lpModule->nPatterns) {
            lpPattern = &Player.lpModule->aPatternTable[Player.nPattern];
            Player.nRows = lpPattern->nRows;
            Player.lpData = lpPattern->lpData;
            if (Player.nRow >= Player.nRows) {
                Player.nRow = 0x00;
            }
            for (m = 0; m < Player.nRow; m++) {
                for (n = 0; n < Player.nTracks; n++)
                    GetPatternNote(&Note);
            }
        }
        else {
            Player.nRows = 64;
            Player.lpData = NULL;
        }
    }
    for (n = 0; n < Player.nTracks; n++) {
        GetTrackNote(&Player.aTracks[n]);
    }
}

static VOID AIAPI PlayNextFrame(VOID)
{
    int n;

    if (!(Player.wControl & AUDIO_PLAYER_PAUSE)) {
        if (++Player.nFrame >= Player.nTempo) {
            GetNextPatternRow();
        }

        for (n = 0; n < Player.nTracks; n++) {
            ExecVolumeCmd(&Player.aTracks[n]);
            ExecNoteCmd(&Player.aTracks[n]);
            UpdateEnvelopes(&Player.aTracks[n]);
        }

        if (Player.wControl & AUDIO_PLAYER_DELAY) {
            if (!Player.nFrame && !--Player.nPatternDelay)
                Player.wControl &= ~AUDIO_PLAYER_DELAY;
        }

        if (Player.wControl & AUDIO_PLAYER_VOLUME) {
            Player.wControl &= ~AUDIO_PLAYER_VOLUME;
            for (n = 0; n < Player.nTracks; n++)
                Player.aTracks[n].bControl |= AUDIO_CTRL_VOLUME;
        }

        if (Player.wControl & AUDIO_PLAYER_BPM) {
            Player.wControl &= ~AUDIO_PLAYER_BPM;
            ASetAudioTimerRate(Player.nBPM);
        }

        for (n = 0; n < Player.nTracks; n++) {
            SendNoteMesg(Player.aVoices[n], &Player.aTracks[n]);
        }
    }
}


/*
 * High-level extended module player routines
 */
UINT AIAPI APlayModule(LPAUDIOMODULE lpModule)
{
    int n;

    if (!(Player.wControl & AUDIO_PLAYER_ACTIVE)) {
        if (lpModule != NULL) {
            memset(&Player, 0, sizeof(Player));
            Player.lpModule = lpModule;
            Player.nTracks = lpModule->nTracks;
            Player.wFlags = lpModule->wFlags;
            Player.nTempo = lpModule->nTempo;
            Player.nBPM = lpModule->nBPM;
            Player.nVolume = AUDIO_MAX_VOLUME;
            Player.wControl = AUDIO_PLAYER_ACTIVE | AUDIO_PLAYER_JUMP;
            for (n = 0; n < Player.nTracks; n++) {
                if (ACreateAudioVoice(&Player.aVoices[n]) != AUDIO_ERROR_NONE) {
                    AStopModule();
                    return AUDIO_ERROR_NOMEMORY;
                }
                Player.aTracks[n].nPanning = lpModule->aPanningTable[n];
                ASetVoicePanning(Player.aVoices[n], Player.aTracks[n].nPanning);
            }
            ASetAudioTimerRate(Player.nBPM);
            ASetAudioTimerProc(PlayNextFrame);
            return AUDIO_ERROR_NONE;
        }
        return AUDIO_ERROR_INVALPARAM;
    }
    return AUDIO_ERROR_NOTSUPPORTED;
}

UINT AIAPI AStopModule(VOID)
{
    int n;

    if (Player.wControl & AUDIO_PLAYER_ACTIVE) {
        for (n = 0; n < Player.nTracks; n++) {
            AStopVoice(Player.aVoices[n]);
            ADestroyAudioVoice(Player.aVoices[n]);
        }
        memset(&Player, 0, sizeof(Player));
        ASetAudioTimerProc(NULL);
        ASetAudioTimerRate(125);
        return AUDIO_ERROR_NONE;
    }
    return AUDIO_ERROR_NOTSUPPORTED;
}

UINT AIAPI APauseModule(VOID)
{
    int n;

    if (Player.wControl & AUDIO_PLAYER_ACTIVE) {
        Player.wControl |= AUDIO_PLAYER_PAUSE;
        for (n = 0; n < Player.nTracks; n++)
            ASetVoiceVolume(Player.aVoices[n], 0x00);
        return AUDIO_ERROR_NONE;
    }
    return AUDIO_ERROR_NOTSUPPORTED;
}

UINT AIAPI AResumeModule(VOID)
{
    if (Player.wControl & AUDIO_PLAYER_ACTIVE) {
        Player.wControl &= ~AUDIO_PLAYER_PAUSE;
        Player.wControl |= AUDIO_PLAYER_VOLUME;
        return AUDIO_ERROR_NONE;
    }
    return AUDIO_ERROR_NOTSUPPORTED;
}

UINT AIAPI ASetModuleVolume(UINT nVolume)
{
    if (Player.wControl & AUDIO_PLAYER_ACTIVE) {
        if (nVolume <= AUDIO_MAX_VOLUME) {
            Player.nVolume = nVolume;
            if (!(Player.wControl & AUDIO_PLAYER_PAUSE)) {
                Player.wControl |= AUDIO_PLAYER_VOLUME;
            }
            return AUDIO_ERROR_NONE;
        }
        return AUDIO_ERROR_INVALPARAM;
    }
    return AUDIO_ERROR_NOTSUPPORTED;
}

UINT AIAPI ASetModulePosition(UINT nOrder, UINT nRow)
{
    if (Player.wControl & AUDIO_PLAYER_ACTIVE) {
        Player.nJumpOrder = nOrder;
        Player.nJumpRow = nRow;
        Player.wControl |= AUDIO_PLAYER_JUMP;
        return AUDIO_ERROR_NONE;
    }
    return AUDIO_ERROR_NOTSUPPORTED;
}

UINT AIAPI AGetModuleVolume(LPUINT lpnVolume)
{
    if (Player.wControl & AUDIO_PLAYER_ACTIVE) {
        if (lpnVolume != NULL) {
            *lpnVolume = Player.nVolume;
            return AUDIO_ERROR_NONE;
        }
        return AUDIO_ERROR_INVALPARAM;
    }
    return AUDIO_ERROR_NOTSUPPORTED;
}

UINT AIAPI AGetModulePosition(LPUINT lpnOrder, LPUINT lpnRow)
{
    if (Player.wControl & AUDIO_PLAYER_ACTIVE) {
        if (lpnOrder != NULL && lpnRow != NULL) {
            *lpnOrder = Player.nOrder;
            *lpnRow = Player.nRow;
            return AUDIO_ERROR_NONE;
        }
        return AUDIO_ERROR_INVALPARAM;
    }
    return AUDIO_ERROR_NOTSUPPORTED;
}

UINT AIAPI AGetModuleStatus(LPBOOL lpnStatus)
{
    if (Player.wControl & AUDIO_PLAYER_ACTIVE) {
        if (lpnStatus != NULL) {
            *lpnStatus = ((Player.wControl & AUDIO_PLAYER_PAUSE) != 0);
            return AUDIO_ERROR_NONE;
        }
        return AUDIO_ERROR_INVALPARAM;
    }
    return AUDIO_ERROR_NOTSUPPORTED;
}

UINT AIAPI ASetModuleCallback(LPFNAUDIOCALLBACK lpfnAudioCallback)
{
    if (Player.wControl & AUDIO_PLAYER_ACTIVE) {
        Player.lpfnCallback = lpfnAudioCallback;
        return AUDIO_ERROR_NONE;
    }
    return AUDIO_ERROR_NOTSUPPORTED;
}

UINT AIAPI AFreeModuleFile(LPAUDIOMODULE lpModule)
{
    LPAUDIOPATTERN lpPattern;
    LPAUDIOPATCH lpPatch;
    LPAUDIOSAMPLE lpSample;
    UINT n, m;

    if (lpModule != NULL) {
        if ((lpPattern = lpModule->aPatternTable) != NULL) {
            for (n = 0; n < lpModule->nPatterns; n++, lpPattern++) {
                if (lpPattern->lpData != NULL)
                    free(lpPattern->lpData);
            }
            free(lpModule->aPatternTable);
        }
        if ((lpPatch = lpModule->aPatchTable) != NULL) {
            for (n = 0; n < lpModule->nPatches; n++, lpPatch++) {
                lpSample = lpPatch->aSampleTable;
                for (m = 0; m < lpPatch->nSamples; m++, lpSample++) {
                    ADestroyAudioData(&lpSample->Wave);
                }
                free(lpPatch->aSampleTable);
            }
            free(lpModule->aPatchTable);
        }
        free(lpModule);
        return AUDIO_ERROR_NONE;
    }
    return AUDIO_ERROR_INVALPARAM;
}

UINT AIAPI ALoadModuleFile(LPSTR lpszFileName, 
			   LPAUDIOMODULE *lplpModule, DWORD dwOffset)
{
    extern UINT AIAPI ALoadModuleXM(LPSTR, LPAUDIOMODULE*, DWORD);
    extern UINT AIAPI ALoadModuleS3M(LPSTR, LPAUDIOMODULE*, DWORD);
    extern UINT AIAPI ALoadModuleMOD(LPSTR, LPAUDIOMODULE*, DWORD);
    extern UINT AIAPI ALoadModuleMTM(LPSTR, LPAUDIOMODULE*, DWORD);
    UINT nErrorCode;

    if (lpszFileName != NULL && lplpModule != NULL) {
        *lplpModule = NULL;
        nErrorCode = ALoadModuleXM(lpszFileName, lplpModule, dwOffset);
        if (nErrorCode == AUDIO_ERROR_BADFILEFORMAT)
            nErrorCode = ALoadModuleS3M(lpszFileName, lplpModule, dwOffset);
        if (nErrorCode == AUDIO_ERROR_BADFILEFORMAT)
            nErrorCode = ALoadModuleMOD(lpszFileName, lplpModule, dwOffset);
        if (nErrorCode == AUDIO_ERROR_BADFILEFORMAT)
            nErrorCode = ALoadModuleMTM(lpszFileName, lplpModule, dwOffset);
        return nErrorCode;
    }
    return AUDIO_ERROR_INVALPARAM;
}

/*** NEW: 04/12/98 ***/
UINT AIAPI AGetModuleTrack(UINT nTrack, LPAUDIOTRACK lpTrack)
{
    if (Player.wControl & AUDIO_PLAYER_ACTIVE) {
        if (nTrack < 32 && lpTrack != NULL) {
            lpTrack->nNote = Player.aTracks[nTrack].nNote;
            lpTrack->nPatch = Player.aTracks[nTrack].nPatch;
            lpTrack->nSample = Player.aTracks[nTrack].nSample;
            lpTrack->nCommand = Player.aTracks[nTrack].nCommand;
            lpTrack->nVolumeCmd = Player.aTracks[nTrack].nVolumeCmd;
            lpTrack->bParams = Player.aTracks[nTrack].bParams;
            lpTrack->nVolume = Player.aTracks[nTrack].nFinalVolume;
            lpTrack->nPanning = Player.aTracks[nTrack].nFinalPanning;
            lpTrack->wPeriod = Player.aTracks[nTrack].nFinalPeriod;
            lpTrack->dwFrequency = Player.aTracks[nTrack].dwFrequency;
            return AUDIO_ERROR_NONE;
        }
        return AUDIO_ERROR_INVALPARAM;
    }
    return AUDIO_ERROR_NOTSUPPORTED;
}