DOOM64-RE

Doom 64 Reverse Engineering
Log | Files | Refs | README | LICENSE

commit 52e10a1761bd0a29edea87e8a33118f507af0150
parent 810e31341a27350a9b63a03934797398875b0180
Author: Erick Vásquez García <41172072+Erick194@users.noreply.github.com>
Date:   Wed, 18 Nov 2020 00:20:50 -0600

Add files via upload
Diffstat:
ADoom 64/wesshand.c | 1003+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
ADoom 64/wessseq.c | 900+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
ADoom 64/wessshell.c | 27+++++++++++++++++++++++++++
ADoom 64/wesstrak.c | 312+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
ADoom 64/wesstwek.c | 88+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
ADoom 64/z_zone.c | 574+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
6 files changed, 2904 insertions(+), 0 deletions(-)

diff --git a/Doom 64/wesshand.c b/Doom 64/wesshand.c @@ -0,0 +1,1003 @@ + +/* ULTRA64 LIBRARIES */ +#include <ultra64.h> +#include "ultratypes.h" +#include <libaudio.h> + +/* WESS API INCLUDES */ +#include "wessapi.h" // audio stuff... +#include "seqload.h" +#include "soundhw.h" +#include "wessarc.h" +#include "wessseq.h" + +#include "funqueue.h" + +#include "wessedit.h" +#include "wesstrak.h" +#include "wesshand.h" + +#ifndef NOUSEWESSCODE +extern pmasterstat *pm_stat; //0x800B41CC +extern unsigned char CmdLength[36]; +extern unsigned char CmdSort[44]; +extern void(*DrvFunctions[36])(track_status *); + +/* used by wess trigger functions */ +enum HandleFlag { NoHandle, YesHandle }; + +enum HandleStatus { HANDLE_INVALID, HANDLE_STOPPED, HANDLE_PLAYING }; + + +char scratch_area[32];//800B41E0 + +void tracksetspecial(track_status *ptmp, TriggerPlayAttr *attr); // 8003429C +void trackgetspecial(track_status *ptmp, TriggerPlayAttr *attr); // 80034508 + +sequence_status *gethandleseq(int handle) // 80032E80 +{ + char hindx; + sequence_status *psq; + + if ((handle > 0) && (handle <= wess_driver_sequences)) + { + hindx = handle - 1; + if ((psq = (pm_stat->pseqstattbl + hindx))->flags & SEQ_HANDLE) + { + return(psq); + } + } + return(NULL); +} + +track_status *gethandletrk(int handle, int track) // 80032EE0 +{ + char hindx; + sequence_status *psq; + track_status *ptrk; + + if (handle > 0 && handle <= wess_driver_sequences) + { + hindx = handle - 1; + if ((psq = (pm_stat->pseqstattbl + hindx))->flags & SEQ_HANDLE) + { + if (*(psq->ptrk_indxs + track) != 0xFF) + { + if ((ptrk = pm_stat->ptrkstattbl + *(psq->ptrk_indxs + track))->flags & TRK_HANDLED) + { + return(ptrk); + } + } + } + } + return(NULL); +} + +int wess_handle_get(int seq_num) // 80032F80 +{ + sequence_data *psq_info; + + if (!Is_Seq_Num_Valid(seq_num)) + return(NULL); + + psq_info = (pm_stat->pmod_info->pseq_info + seq_num); + return wess_seq_structrig(psq_info, seq_num, 0, YesHandle, NULL); +} + +int wess_handle_status(int handle) // 80032FD8 +{ + sequence_status *psq_stat; + int status; + + if(!Is_Module_Loaded()) + return HANDLE_INVALID; + + psq_stat = gethandleseq(handle); + + status = HANDLE_INVALID; + if (psq_stat) + { + if (psq_stat->playmode) + { + if (psq_stat->playmode == SEQ_STATE_STOPPED) + status = HANDLE_STOPPED; + else if (psq_stat->playmode == SEQ_STATE_PLAYING) + status = HANDLE_PLAYING; + } + } + + return status; +} + +void wess_handle_return(int handle) // 80033048 +{ + sequence_status *psq_stat; + track_status *ptmp; + + int li, lj; + char *lpdest; + + int _handle; + + _handle = handle; + + if (!Is_Module_Loaded()) + return; + + wess_disable(); + + psq_stat = gethandleseq(_handle); + + if (psq_stat) + { + li = psq_stat->tracks_active; + lj = pm_stat->max_trks_perseq; + + /* *lpdest refers to an active track if not 0xFF */ + lpdest = psq_stat->ptrk_indxs; + while (lj--) + { + if (*lpdest != 0xFF) + { + ptmp = (pm_stat->ptrkstattbl + (*lpdest)); + ptmp->flags &= ~TRK_HANDLED; + CmdFuncArr[ptmp->patchtype][TrkOff](ptmp); + if (!--li) break; + } + lpdest++; + } + + psq_stat->flags &= ~SEQ_HANDLE; + } + + wess_enable(); + + return; +} + +void wess_handle_play_special(int handle, TriggerPlayAttr *attr) // 80033180 +{ + sequence_status *psq_stat; + track_status *ptmp; + + int li, lj; + char *lpdest; + + int _handle; + TriggerPlayAttr *_attr; + + _handle = handle; + _attr = attr; + + if (!Is_Module_Loaded()) + return; + + wess_disable(); + + psq_stat = gethandleseq(_handle); + + if (psq_stat) + { + li = psq_stat->tracks_active; + lj = pm_stat->max_trks_perseq; + + /* *lpdest refers to an active track if not 0xFF */ + lpdest = psq_stat->ptrk_indxs; + while (lj--) + { + if (*lpdest != 0xFF) + { + ptmp = (pm_stat->ptrkstattbl + (*lpdest)); + trackstart(ptmp, psq_stat); + tracksetspecial(ptmp, _attr); + if (!--li) break; + } + lpdest++; + } + + psq_stat->playmode = SEQ_STATE_PLAYING; + } + + wess_enable(); + + return; +} + +void wess_handle_play(int handle) // 80033298() +{ + wess_handle_play_special(handle, 0); +} + +void wess_handle_play_track_special(int handle, int track, TriggerPlayAttr *attr) // 800332B8 +{ + sequence_status *psq_stat; + track_status *ptmp; + + int _handle; + int _track; + TriggerPlayAttr *_attr; + + _handle = handle; + _track = track; + _attr = attr; + + if (!Is_Module_Loaded()) + return; + + wess_disable(); + + psq_stat = gethandleseq(_handle); + + if (psq_stat) + { + ptmp = gethandletrk(_handle, _track); + + if (ptmp) + { + trackstart(ptmp, psq_stat); + tracksetspecial(ptmp, _attr); + } + } + + wess_enable(); + + return; +} + +void wess_handle_play_track(int handle, int track) // 80033344 +{ + wess_handle_play_track_special(handle, track, 0); + return; +} + +void wess_handle_get_special(int handle, TriggerPlayAttr *attr) // 80033364 +{ + sequence_status *psq_stat; + track_status *ptmp; + + int li, lj; + char *lpdest; + + int _handle; + TriggerPlayAttr *_attr; + + _handle = handle; + _attr = attr; + + if (!Is_Module_Loaded()) + return; + + wess_disable(); + + psq_stat = gethandleseq(_handle); + + if (psq_stat) + { + li = psq_stat->tracks_active; + lj = pm_stat->max_trks_perseq; + + /* *lpdest refers to an active track if not 0xFF */ + lpdest = psq_stat->ptrk_indxs; + while (lj--) + { + if (*lpdest != 0xFF) + { + ptmp = (pm_stat->ptrkstattbl + (*lpdest)); + trackgetspecial(ptmp, _attr); + if (!--li) break; + } + lpdest++; + } + } + + wess_enable(); + + return; +} + +void wess_handle_set_special(int handle, TriggerPlayAttr *attr) // 80033454 +{ + sequence_status *psq_stat; + track_status *ptmp; + + int li, lj; + char *lpdest; + + int _handle; + TriggerPlayAttr *_attr; + + _handle = handle; + _attr = attr; + + if (!Is_Module_Loaded()) + return; + + wess_disable(); + + psq_stat = gethandleseq(_handle); + + if (psq_stat) + { + li = psq_stat->tracks_active; + lj = pm_stat->max_trks_perseq; + + /* *lpdest refers to an active track if not 0xFF */ + lpdest = psq_stat->ptrk_indxs; + while (lj--) + { + if (*lpdest != 0xFF) + { + ptmp = (pm_stat->ptrkstattbl + (*lpdest)); + tracksetspecial(ptmp, _attr); + if (!--li) break; + } + lpdest++; + } + } + + wess_enable(); + + return; +} + +void wess_handle_stop(int handle) // 80033544 +{ + sequence_status *psq_stat; + track_status *ptmp; + + int li, lj; + char *lpdest; + + int _handle; + + _handle = handle; + + if (!Is_Module_Loaded()) + return; + + wess_disable(); + + psq_stat = gethandleseq(_handle); + + if (psq_stat) + { + li = psq_stat->tracks_active; + lj = pm_stat->max_trks_perseq; + + /* *lpdest refers to an active track if not 0xFF */ + lpdest = psq_stat->ptrk_indxs; + while (lj--) + { + if (*lpdest != 0xFF) + { + ptmp = (pm_stat->ptrkstattbl + (*lpdest)); + CmdFuncArr[ptmp->patchtype][TrkOff](ptmp); + if (!--li) break; + } + lpdest++; + } + } + + wess_enable(); + + return; +} + +void wess_handle_fastsettempo(int handle, short tempo) // 80033658 +{ + sequence_status *psq_stat; + track_status *ptmp; + + int li, lj; + char *lpdest; + unsigned long ppi; + + int _handle; + short _tempo; + + _handle = handle; + _tempo = tempo; + + if (!Is_Module_Loaded()) + return; + + wess_disable(); + + psq_stat = gethandleseq(_handle); + ppi = 0; + + if (psq_stat) + { + li = psq_stat->tracks_active; + lj = pm_stat->max_trks_perseq; + + /* *lpdest refers to an active track if not 0xFF */ + lpdest = psq_stat->ptrk_indxs; + while (lj--) + { + if (*lpdest != 0xFF) + { + ptmp = (pm_stat->ptrkstattbl + (*lpdest)); + ptmp->qpm = _tempo; + if (ppi == 0) + ppi = CalcPartsPerInt(GetIntsPerSec(), ptmp->ppq, ptmp->qpm); + ptmp->ppi = ppi; + + if (!--li) break; + } + lpdest++; + } + } + + wess_enable(); + + return; +} + +int wess_handle_fade(void) // 80033788 +{ + return Is_Module_Loaded(); +} + +void wess_handle_resetposition(int handle) // 800337B0 +{ + sequence_status *psq_stat; + track_status *ptmp; + + int li, lj; + char *lpdest; + + int _handle; + + _handle = handle; + + if (!Is_Module_Loaded()) + return; + + wess_disable(); + + psq_stat = gethandleseq(_handle); + + if (psq_stat) + { + li = psq_stat->tracks_active; + lj = pm_stat->max_trks_perseq; + + /* *lpdest refers to an active track if not 0xFF */ + lpdest = psq_stat->ptrk_indxs; + while (lj--) + { + if (*lpdest != 0xFF) + { + ptmp = (pm_stat->ptrkstattbl + (*lpdest)); + CmdFuncArr[ptmp->patchtype][TrkMute](ptmp); + + ptmp->starppi = 0; + ptmp->totppi = 0; + ptmp->ppos = Read_Vlq(ptmp->pstart, &ptmp->deltatime); + + if (!--li) break; + } + lpdest++; + } + } + + wess_enable(); + return; +} + +int wess_track_gotoposition(track_status *ptmp, int position, char *ppos) // 800338F0 +{ + int deltatime; + int status; + int accppi; + + + deltatime = ptmp->deltatime; + accppi = ptmp->totppi + (ptmp->starppi >> 16); + + while (1) + { + accppi += deltatime; + + if (position <= accppi) + { + status = 1; + break; + } + + if (*ptmp->ppos == TrkEnd) + { + status = 0; + break; + } + + if (*ptmp->ppos == NoteOn || *ptmp->ppos == NoteOff) + { + ptmp->ppos += CmdLength[*ptmp->ppos]; + ptmp->ppos = Read_Vlq(ptmp->ppos, &deltatime); + continue; + } + else + { + if ((*ptmp->ppos < PatchChg) || (*ptmp->ppos > NoteOff)) + { + if ((*ptmp->ppos < StatusMark) || (*ptmp->ppos > NullEvent)) + { + Eng_SeqEnd(ptmp); + } + else + { + DrvFunctions[*ptmp->ppos](ptmp); + + if (ptmp->flags & TRK_SKIP) + { + ptmp->flags &= ~TRK_SKIP; + } + else + { + ptmp->ppos += CmdLength[*ptmp->ppos]; + ptmp->ppos = Read_Vlq(ptmp->ppos, &deltatime); + } + } + } + else + { + CmdFuncArr[ptmp->patchtype][*ptmp->ppos](ptmp); + ptmp->ppos += CmdLength[*ptmp->ppos]; + ptmp->ppos = Read_Vlq(ptmp->ppos, &deltatime); + } + } + } + + if (status) + { + ptmp->deltatime = accppi - position; + ptmp->starppi = 0; + ptmp->totppi = position; + } + else + { + ptmp->deltatime = 0; + ptmp->starppi = 0; + ptmp->totppi = accppi; + } + + ppos = ptmp->ppos; + + return ptmp->totppi; +} + +int wess_track_setposition(track_status *ptmp, int position, char *ppos) // 80033B24 +{ + int deltatime; + int val; + int accppi; + int status; + + deltatime = 0; + accppi = 0; + ptmp->ppos = ptmp->pstart; + ptmp->ppos = Read_Vlq(ptmp->ppos, &deltatime); + + while (1) + { + accppi += deltatime; + + if (position <= accppi) + { + status = 1; + break; + } + + if (*ptmp->ppos == TrkEnd) + { + status = 0; + break; + } + + if (*ptmp->ppos == NoteOn || *ptmp->ppos == NoteOff) + { + ptmp->ppos += CmdLength[*ptmp->ppos]; + ptmp->ppos = Read_Vlq(ptmp->ppos, &deltatime); + continue; + } + else + { + if ((*ptmp->ppos < PatchChg) || (*ptmp->ppos > NoteOff)) + { + if ((*ptmp->ppos < StatusMark) || (*ptmp->ppos > NullEvent)) + { + Eng_SeqEnd(ptmp); + } + else + { + DrvFunctions[*ptmp->ppos](ptmp); + + if (ptmp->flags & TRK_SKIP) + { + ptmp->flags &= ~TRK_SKIP; + } + else + { + ptmp->ppos += CmdLength[*ptmp->ppos]; + ptmp->ppos = Read_Vlq(ptmp->ppos, &deltatime); + } + } + } + else + { + CmdFuncArr[ptmp->patchtype][*ptmp->ppos](ptmp); + ptmp->ppos += CmdLength[*ptmp->ppos]; + ptmp->ppos = Read_Vlq(ptmp->ppos, &deltatime); + } + } + } + + if (status) + { + ptmp->deltatime = (accppi - position); + ptmp->starppi = 0; + ptmp->totppi = position; + } + else + { + ptmp->deltatime = 0; + ptmp->starppi = 0; + ptmp->totppi = accppi; + } + + ppos = ptmp->ppos; + + return ptmp->totppi; +} + +int wess_handle_advposition(int handle, int position) // 80033D58 +{ + sequence_status *psq_stat; + track_status *ptmp; + char ppos[12]; + + int li, lj; + char *lpdest; + + int _handle, _position; + + _handle = handle; + _position = position; + + if (!Is_Module_Loaded()) + return 0; + + wess_disable(); + + psq_stat = gethandleseq(_handle); + + if (psq_stat) + { + li = psq_stat->tracks_active; + lj = pm_stat->max_trks_perseq; + + /* *lpdest refers to an active track if not 0xFF */ + lpdest = psq_stat->ptrk_indxs; + while (lj--) + { + if (*lpdest != 0xFF) + { + ptmp = (pm_stat->ptrkstattbl + (*lpdest)); + CmdFuncArr[ptmp->patchtype][TrkMute](ptmp); + wess_track_gotoposition(ptmp, ptmp->totppi + _position, ppos); + if (!--li) break; + } + lpdest++; + } + } + + wess_enable(); + return wess_handle_getposition(_handle); +} + +int wess_handle_setposition(int handle, int position) // 80033EB8 +{ + sequence_status *psq_stat; + track_status *ptmp; + char ppos[12]; + + int li, lj; + char *lpdest; + + int _handle, _position; + + _handle = handle; + _position = position; + + if (!Is_Module_Loaded()) + return 0; + + wess_disable(); + + psq_stat = gethandleseq(_handle); + + if (psq_stat) + { + li = psq_stat->tracks_active; + lj = pm_stat->max_trks_perseq; + + /* *lpdest refers to an active track if not 0xFF */ + lpdest = psq_stat->ptrk_indxs; + while (lj--) + { + if (*lpdest != 0xFF) + { + ptmp = (pm_stat->ptrkstattbl + (*lpdest)); + CmdFuncArr[ptmp->patchtype][TrkMute](ptmp); + wess_track_setposition(ptmp, _position, ppos); + if (!--li) break; + } + lpdest++; + } + } + + wess_enable(); + return wess_handle_getposition(_handle); +} + +int wess_handle_getposition(int handle) // 80034010 +{ + sequence_status *psq_stat; + track_status *ptmp; + + int li, lj; + char *lpdest; + int position; + + int _handle; + + _handle = handle; + + position = 0; + + if (!Is_Module_Loaded()) + return 0; + + wess_disable(); + + psq_stat = gethandleseq(_handle); + + if (psq_stat) + { + li = psq_stat->tracks_active; + lj = pm_stat->max_trks_perseq; + + /* *lpdest refers to an active track if not 0xFF */ + lpdest = psq_stat->ptrk_indxs; + while (lj--) + { + if (*lpdest != 0xFF) + { + ptmp = (pm_stat->ptrkstattbl + (*lpdest)); + if(position < ptmp->totppi) + position = ptmp->totppi; + + if (!--li) break; + } + lpdest++; + } + } + + wess_enable(); + + return position; +} + +void patch_chg_action(track_status *ptmp, int patch_num) // 800340E0 +{ + ptmp->ppos[0] = PatchChg; + ptmp->ppos[1] = patch_num; + ptmp->ppos[2] = patch_num >> 8; + CmdFuncArr[ptmp->patchtype][PatchChg](ptmp); +} + +void pitch_mod_action(track_status *ptmp, int pitch_cntr) // 80034144 +{ + ptmp->ppos[0] = PitchMod; + ptmp->ppos[1] = pitch_cntr; + ptmp->ppos[2] = pitch_cntr >> 8; + CmdFuncArr[ptmp->patchtype][PitchMod](ptmp); +} + +void volume_mod_action(track_status *ptmp, int volume_cntr) // 800341A8 +{ + ptmp->ppos[0] = VolumeMod; + ptmp->ppos[1] = volume_cntr; + CmdFuncArr[ptmp->patchtype][VolumeMod](ptmp); +} + +void pan_mod_action(track_status *ptmp, int pan_cntr) // 80034200 +{ + ptmp->ppos[0] = PanMod; + ptmp->ppos[1] = pan_cntr; + CmdFuncArr[ptmp->patchtype][PanMod](ptmp); +} + +void wess_track_parm_mod(track_status *ptmp, int value, WessAction funcion) // 80034258 +{ + char *ppos; + + //save + ppos = ptmp->ppos; + ptmp->ppos = scratch_area; + funcion(ptmp, value); + //restore + ptmp->ppos = ppos; +} + +void tracksetspecial(track_status *ptmp, TriggerPlayAttr *attr) // 8003429C +{ + int mask; + + ptmp->flags &= ~(TRK_TIMED | TRK_LOOPED); + + if (attr != NULL) + { + mask = attr->mask; + if (mask) + { + if (mask & TRIGGER_VOLUME) + { + ptmp->volume_cntrl = attr->volume; + wess_track_parm_mod(ptmp, attr->volume, volume_mod_action); + + mask &= ~TRIGGER_VOLUME; + if (!(mask)) + return; + } + + if (mask & TRIGGER_PAN) + { + ptmp->pan_cntrl = attr->pan; + wess_track_parm_mod(ptmp, attr->pan, pan_mod_action); + + mask &= ~TRIGGER_PAN; + if (!(mask)) + return; + } + + if (mask & TRIGGER_PATCH) + { + ptmp->patchnum = attr->patch; + wess_track_parm_mod(ptmp, attr->patch, patch_chg_action); + + mask &= ~TRIGGER_PATCH; + if (!(mask)) + return; + } + + if (mask & TRIGGER_PITCH) + { + ptmp->pitch_cntrl = attr->pitch; + wess_track_parm_mod(ptmp, attr->pitch, pitch_mod_action); + + mask &= ~TRIGGER_PITCH; + if (!(mask)) + return; + } + + if (mask & TRIGGER_MUTEMODE) + { + if (ptmp->mutemask & (1 << attr->mutemode)) + { + ptmp->flags |= TRK_MUTE; + CmdFuncArr[ptmp->patchtype][TrkMute](ptmp); + } + ptmp->flags &= ~TRK_MUTE; + + mask &= ~TRIGGER_MUTEMODE; + if (!(mask)) + return; + } + + if (mask & TRIGGER_TEMPO) + { + ptmp->qpm = attr->tempo; + ptmp->ppi = CalcPartsPerInt(GetIntsPerSec(), ptmp->ppq, ptmp->qpm); + + mask &= ~TRIGGER_TEMPO; + if (!(mask)) + return; + } + + if (mask & TRIGGER_TIMED) + { + ptmp->endppi = ptmp->totppi + attr->timeppq; + ptmp->flags |= TRK_TIMED; + + mask &= ~TRIGGER_TIMED; + if (!(mask)) + return; + } + + if (mask & TRIGGER_LOOPED) + { + ptmp->flags |= TRK_LOOPED; + } + } + } +} + +void trackgetspecial(track_status *ptmp, TriggerPlayAttr *attr) // 80034508 +{ + int mask; + + mask = attr->mask; + + if (mask) + { + if (mask & TRIGGER_VOLUME) + { + attr->volume = ptmp->volume_cntrl; + mask &= ~TRIGGER_VOLUME; + if (!(mask)) + return; + } + + if (mask & TRIGGER_PAN) + { + attr->pan = ptmp->pan_cntrl; + mask &= ~TRIGGER_PAN; + if (!(mask)) + return; + } + + if (mask & TRIGGER_PATCH) + { + attr->patch = ptmp->patchnum; + mask &= ~TRIGGER_PATCH; + if (!(mask)) + return; + } + + if (mask & TRIGGER_PITCH) + { + attr->pitch = ptmp->pitch_cntrl; + mask &= ~TRIGGER_PITCH; + if (!(mask)) + return; + } + + if (mask & TRIGGER_MUTEMODE) + { + attr->mutemode = ptmp->mutemask; + mask &= ~TRIGGER_MUTEMODE; + if (!(mask)) + return; + } + + if (mask & TRIGGER_TEMPO) + { + attr->tempo = ptmp->qpm; + mask &= ~TRIGGER_TEMPO; + if (!(mask)) + return; + } + + if (mask & TRIGGER_TIMED) + { + if (!(ptmp->flags & TRK_TIMED)) + attr->mask &= ~TRIGGER_TIMED; + else + attr->timeppq = ptmp->endppi - ptmp->totppi; + + mask &= ~TRIGGER_TIMED; + if (!(mask)) + return; + } + + if (mask & TRIGGER_LOOPED) + { + if (!(ptmp->flags & TRK_LOOPED)) + attr->mask &= ~TRIGGER_LOOPED; + } + } +} +#endif // 0 diff --git a/Doom 64/wessseq.c b/Doom 64/wessseq.c @@ -0,0 +1,900 @@ +// Reconstruido por Erick Vasquez Garcia 16/05/2019 [GEC] +// Update_1 20/10/2019 [GEC] +// Update_2 31/01/2020 [GEC] + +#include "wessseq.h" + +#include "graph.h" +#ifndef NOUSEWESSCODE +extern void (**CmdFuncArr[10])(track_status *); +extern void(*DrvFunctions[36])(track_status *); + +char *Read_Vlq(char *pstart, void *deltatime); +char *Write_Vlq(char *dest, unsigned int value); +int Len_Vlq(unsigned int value); + +void Eng_DriverInit (track_status *ptk_stat);//(master_status_structure *pm_stat); +void Eng_DriverExit (track_status *ptk_stat); +void Eng_DriverEntry1 (track_status *ptk_stat); +void Eng_DriverEntry2 (track_status *ptk_stat); +void Eng_DriverEntry3 (track_status *ptk_stat); +void Eng_TrkOff (track_status *ptk_stat); +void Eng_TrkMute (track_status *ptk_stat); +void Eng_PatchChg (track_status *ptk_stat); +void Eng_PatchMod (track_status *ptk_stat); +void Eng_PitchMod (track_status *ptk_stat); +void Eng_ZeroMod (track_status *ptk_stat); +void Eng_ModuMod (track_status *ptk_stat); +void Eng_VolumeMod (track_status *ptk_stat); +void Eng_PanMod (track_status *ptk_stat); +void Eng_PedalMod (track_status *ptk_stat); +void Eng_ReverbMod (track_status *ptk_stat); +void Eng_ChorusMod (track_status *ptk_stat); +void Eng_NoteOn (track_status *ptk_stat); +void Eng_NoteOff (track_status *ptk_stat); +void Eng_StatusMark (track_status *ptk_stat); +void Eng_GateJump (track_status *ptk_stat); +void Eng_IterJump (track_status *ptk_stat); +void Eng_ResetGates (track_status *ptk_stat); +void Eng_ResetIters (track_status *ptk_stat); +void Eng_WriteIterBox (track_status *ptk_stat); +void Eng_SeqTempo (track_status *ptk_stat); +void Eng_SeqGosub (track_status *ptk_stat); +void Eng_SeqJump (track_status *ptk_stat); +void Eng_SeqRet (track_status *ptk_stat); +void Eng_SeqEnd (track_status *ptk_stat); +void Eng_TrkTempo (track_status *ptk_stat); +void Eng_TrkGosub (track_status *ptk_stat); +void Eng_TrkJump (track_status *ptk_stat); +void Eng_TrkRet (track_status *ptk_stat); +void Eng_TrkEnd (track_status *ptk_stat); +void Eng_NullEvent (track_status *ptk_stat); + +void(*DrvFunctions[36])(track_status *) = +{ + Eng_DriverInit, + Eng_DriverExit, + Eng_DriverEntry1, + Eng_DriverEntry2, + Eng_DriverEntry3, + Eng_TrkOff, + Eng_TrkMute, + Eng_PatchChg, + Eng_PatchMod, + Eng_PitchMod, + Eng_ZeroMod, + Eng_ModuMod, + Eng_VolumeMod, + Eng_PanMod, + Eng_PedalMod, + Eng_ReverbMod, + Eng_ChorusMod, + Eng_NoteOn, + Eng_NoteOff, + Eng_StatusMark, //0x13 + Eng_GateJump, //0x14 + Eng_IterJump, //0x15 + Eng_ResetGates, //0x16 + Eng_ResetIters, //0x17 + Eng_WriteIterBox, //0x18 + Eng_SeqTempo, //0x19 + Eng_SeqGosub, //0x1A + Eng_SeqJump, //0x1B + Eng_SeqRet, //0x1C + //SeqFunctions ?? + Eng_SeqEnd, //0x1D + Eng_TrkTempo, //0x1E + Eng_TrkGosub, //0x1F + Eng_TrkJump, //0x20 + Eng_TrkRet, //0x21 + Eng_TrkEnd, //0x22 + Eng_NullEvent //0x23 +}; + +unsigned char CmdLength[36] = { // 8005D9F0 +0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, +0x02, 0x03, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, +0x02, 0x03, 0x02, 0x04, 0x05, 0x05, 0x02, 0x02, +0x03, 0x03, 0x03, 0x03, 0x01, 0x01, 0x03, 0x03, +0x03, 0x01, 0x01, 0x01 +}; + +unsigned char CmdSort[44] = { // 8005DA14 +0x00, 0x01, 0x02, 0x03, 0x04, 0x07, 0x06, 0x16, +0x17, 0x18, 0x15, 0x1A, 0x1E, 0x19, 0x1B, 0x1D, +0x1C, 0x1F, 0x05, 0x0F, 0x08, 0x09, 0x12, 0x11, +0x10, 0x14, 0x0D, 0x0B, 0x22, 0x23, 0x13, 0x0C, +0x0A, 0x20, 0x21, 0x0E, 0x00, 0x00, 0x00, 0x00, +0x00, 0x00, 0x00, 0x00 +}; + +//----------------------------------------------------------- +// Vlq System +//----------------------------------------------------------- + +//extern unsigned int data01; //L8007F024 +//extern unsigned char data02; //L8007F028 + +char *Read_Vlq(char *pstart, void *deltatime)//L80035F80() +{ + static int v;//800B6630 + static char c;//800B6634 + + v = *pstart++; + if (v & 0x80) + { + v &= 0x7f; + do + { + c = *pstart++; + v = (c & 0x7f) + (v << 7); + } while (c & 0x80); + } + *(int*)deltatime = v; + + return pstart; +} + +char *Write_Vlq(char *dest, unsigned int value)//L8004744C() +{ + char data[10]; + char *ptr; + + data[0] = (value & 0x7f); + ptr = (char*)&data + 1; + + value >>= 7; + if (value) + { + do + { + *ptr++ = ((value & 0x7f) | 0x80); + value >>= 7; + } while (value); + } + + do + { + ptr--; + *dest++ = *ptr; + } while (*ptr & 0x80); + + return dest; +} + +int Len_Vlq(unsigned int value)//L800474AC() +{ + char buff[16]; + char data[10]; + char *ptr; + char *dest, *start; + + dest = start = (char*)&buff; + + data[0] = (value & 0x7f); + ptr = (char*)&data + 1; + + value >>= 7; + if (value) + { + do + { + *ptr++ = ((value & 0x7f) | 0x80); + value >>= 7; + } while (value); + } + + do + { + ptr--; + *dest++ = *ptr; + } while (*ptr & 0x80); + + return (int)(dest - start); +} +//----------------------------------------------------------- +// Engine System +//----------------------------------------------------------- + +static unsigned char ntwa = 0; //8005DAD4 +static track_status *ptsbase = 0; //8005DAD8 +static sequence_status *pssbase = 0; //8005DADC +static master_status_structure *pmsbase = 0; //8005DAE0 + +void Eng_DriverInit (track_status *ptk_stat) // 800360C4 +{ + master_status_structure *pm_stat; + + pm_stat = (master_status_structure*)ptk_stat; + + //PRINTF_D2(WHITE,0,10,"Eng_DriverInit"); + ntwa = wess_driver_tracks; + ptsbase = pm_stat->ptrkstattbl; + pssbase = pm_stat->pseqstattbl; + pmsbase = pm_stat; + + //PRINTF_D(WHITE,"ntwa %d\n", ntwa); + //PRINTF_D(WHITE,"ptsbase %x\n", (int)&ptsbase); + //PRINTF_D(WHITE,"pssbase %x\n", (int)&pssbase); + //PRINTF_D(WHITE,"pmsbase %x\n", (int)&pmsbase); +} + +void Eng_DriverExit (track_status *ptk_stat) // 800360FC +{ + //PRINTF_D2(WHITE,0,10,"Eng_DriverExit"); +} + +void Eng_DriverEntry1 (track_status *ptk_stat) // 80036104 +{ + //PRINTF_D2(WHITE,0,10,"Eng_DriverEntry1"); +} + +void Eng_DriverEntry2 (track_status *ptk_stat) // 8003610C +{ + //PRINTF_D2(WHITE,0,10,"Eng_DriverEntry2"); +} + +void Eng_DriverEntry3 (track_status *ptk_stat) // 80036114 +{ + //PRINTF_D2(WHITE,0,10,"Eng_DriverEntry3"); +} + +void Eng_TrkOff (track_status *ptk_stat) // 8003611C +{ + static sequence_status *lpseq; //800B6638 + static char *lpdest;//800B663C + static unsigned long lj; //800B6640 + + //PRINTF_D2(WHITE,0,10,"Eng_TrkOff"); + + lpseq = (pmsbase->pseqstattbl + ptk_stat->seq_owner); + + if (!(ptk_stat->flags & TRK_STOPPED)) + { + ptk_stat->flags |= TRK_STOPPED; + + if (!--lpseq->tracks_playing) + { + lpseq->playmode = SEQ_STATE_STOPPED; + } + } + + if (!(ptk_stat->flags & TRK_HANDLED)) + { + lj = pmsbase->max_trks_perseq; + lpdest = lpseq->ptrk_indxs; + + while (lj--) + { + if (ptk_stat->refindx == *lpdest) + { + *lpdest++ = 0xff; + break; + } + lpdest++; + } + + ptk_stat->flags &= ~TRK_ACTIVE; + pmsbase->trks_active--; + + if (!--lpseq->tracks_active) + { + lpseq->flags &= ~SEQ_ACTIVE; + pmsbase->seqs_active--; + } + } + + ptk_stat->flags &= ~TRK_TIMED; +} + +void Eng_TrkMute (track_status *ptk_stat) // 80036298 +{ + //PRINTF_D2(WHITE,0,10,"Eng_TrkMute"); +} + +void Eng_PatchChg (track_status *ptk_stat) // 800362A0 +{ + static unsigned char thepatch;//800B6644 + + //PRINTF_D2(WHITE,0,10,"Eng_PatchChg"); + + thepatch = (*(ptk_stat->ppos + 1) | (*(ptk_stat->ppos + 2) << 8)); + ptk_stat->patchnum = (unsigned short)thepatch; +} + + +void Eng_PatchMod (track_status *ptk_stat) // 800362C8 +{ + //PRINTF_D2(WHITE,0,10,"Eng_PatchMod"); +} + +void Eng_PitchMod (track_status *ptk_stat) // 800362D0 +{ + static short thepitchmod;//800B6646 + + //PRINTF_D2(WHITE,0,10,"Eng_PitchMod"); + + thepitchmod = (*(ptk_stat->ppos + 1) | (*(ptk_stat->ppos + 2) << 8)); + ptk_stat->pitch_cntrl = thepitchmod; +} + +void Eng_ZeroMod (track_status *ptk_stat) // 800362F4 +{ + //PRINTF_D2(WHITE,0,10,"Eng_ZeroMod"); +} + +void Eng_ModuMod (track_status *ptk_stat) // 800362FC +{ + //PRINTF_D2(WHITE,0,10,"Eng_ModuMod"); +} + +void Eng_VolumeMod (track_status *ptk_stat) // 80036304 +{ + static unsigned char thevolume; //800B6648 + + //PRINTF_D2(WHITE,0,10,"Eng_VolumeMod"); + + thevolume = *(ptk_stat->ppos + 1); + ptk_stat->volume_cntrl = thevolume; +} + +void Eng_PanMod (track_status *ptk_stat) // 80036320 +{ + static unsigned char thepan; //0x800B6649 + + //PRINTF_D2(WHITE,0,10,"Eng_PanMod"); + thepan = *(ptk_stat->ppos + 1); + ptk_stat->pan_cntrl = thepan; +} + +void Eng_PedalMod (track_status *ptk_stat) // 8003633C +{ + //PRINTF_D2(WHITE,0,10,"Eng_PedalMod"); +} + +void Eng_ReverbMod (track_status *ptk_stat) // 80036344 +{ + //PRINTF_D2(WHITE,0,10,"Eng_ReverbMod"); +} + +void Eng_ChorusMod (track_status *ptk_stat) // 8003634C +{ + //PRINTF_D2(WHITE,0,10,"Eng_ChorusMod"); +} + +void Eng_NoteOn (track_status *ptk_stat) // 80036354 +{ + //PRINTF_D2(WHITE,0,10,"Eng_NoteOn"); +} + +void Eng_NoteOff (track_status *ptk_stat) // 8003635C +{ + //PRINTF_D2(WHITE,0,10,"Eng_NoteOff"); +} + +void Eng_StatusMark (track_status *ptk_stat) // 80036364 +{ + static char si, sn; //800B664A, 800B664B + static callback_status *cbs; //800B664C + + //PRINTF_D2(WHITE,0,10,"Eng_StatusMark"); + + sn = pmsbase->callbacks_active; + if (sn) + { + cbs = pmsbase->pcalltable; + si = wess_driver_callbacks; + if(wess_driver_callbacks) + { + while (si--) + { + if (cbs->active) + { + if (cbs->type == *(ptk_stat->ppos + 1)) + { + cbs->curval = (*(ptk_stat->ppos + 2) | (*(ptk_stat->ppos + 3) << 8)); + cbs->callfunc(cbs->type, cbs->curval); + break; + } + + if (!--sn) break; + } + + cbs++; + } + } + } +} + +void Eng_GateJump (track_status *ptk_stat) // 80036488 +{ + static short lindex; //800B6650 + static char *laboff; //800B6654 + static char *pgate; //800B6658 + + //PRINTF_D2(WHITE,0,10,"Eng_GateJump"); + pgate = (pssbase + ptk_stat->seq_owner)->pgates + *(ptk_stat->ppos + 1); + + if (*pgate != 0) + { + if (*pgate == 0xff) + { + *pgate = *(ptk_stat->ppos + 2); + } + + lindex = (*(ptk_stat->ppos + 3) | (*(ptk_stat->ppos + 4) << 8)); + + if (lindex >= 0) + { + if (lindex < ptk_stat->labellist_count) + { + laboff = ptk_stat->pstart + *(ptk_stat->plabellist + lindex); + ptk_stat->ppos = laboff; + ptk_stat->deltatime = 0; + ptk_stat->flags |= TRK_SKIP; + } + } + } +} + +void Eng_IterJump (track_status *ptk_stat) // 80036568 +{ + static short lindex; //800B665C + static char *laboff; //800B6660 + static char *piter; //800B6664 + + //PRINTF_D2(WHITE,0,10,"Eng_IterJump"); + piter = (pssbase + ptk_stat->seq_owner)->piters + *(ptk_stat->ppos + 1); + + if (*piter != 0) + { + if (*piter == 0xFF) + { + *piter = *(ptk_stat->ppos + 2); + } + else + { + *piter = *piter + 0xFF; + } + + lindex = (*(ptk_stat->ppos + 3) | (*(ptk_stat->ppos + 4) << 8)); + + if (lindex >= 0) + { + if (lindex < ptk_stat->labellist_count) + { + laboff = ptk_stat->pstart + *(ptk_stat->plabellist + lindex); + ptk_stat->ppos = laboff; + ptk_stat->deltatime = 0; + ptk_stat->flags |= TRK_SKIP; + } + } + } +} + +void Eng_ResetGates (track_status *ptk_stat) // 80036654 +{ + static unsigned char gi; //800B6668 + static char *pgate; //800B666C + + //PRINTF_D2(WHITE,0,10,"Eng_ResetGates"); + if (*(ptk_stat->ppos + 1) == 0xff) + { + gi = wess_driver_gates; + pgate = (pssbase + ptk_stat->seq_owner)->pgates; + + while (gi--) + { + *pgate++ = 0xFF; + } + } + else + { + pgate = (pssbase + ptk_stat->seq_owner)->pgates + *(ptk_stat->ppos + 1); + *pgate = 0xff; + } +} + +void Eng_ResetIters (track_status *ptk_stat) // 80036720 +{ + static unsigned char ii; //800B6670 + static char *piter; //800B6674 + + //PRINTF_D2(WHITE,0,10,"Eng_ResetIters"); + if (*(ptk_stat->ppos + 1) == 0xff) + { + ii = wess_driver_iters; + piter = (pssbase + ptk_stat->seq_owner)->piters; + + while (ii--) + { + *piter++ = 0xFF; + } + } + else + { + piter = (pssbase + ptk_stat->seq_owner)->piters + *(ptk_stat->ppos + 1); + *piter = 0xff; + } +} + +void Eng_WriteIterBox (track_status *ptk_stat) // 800367EC +{ + static char *piter;//800B6678 + + //PRINTF_D2(WHITE,0,10,"Eng_WriteIterBox"); + piter = (pssbase + ptk_stat->seq_owner)->piters + *(ptk_stat->ppos + 1); + *piter = *(ptk_stat->ppos + 2); +} + +void Eng_SeqTempo (track_status *ptk_stat) // 8003682C +{ + static unsigned short ntracks; //800B667C + static unsigned char nactive; //800B667E + static unsigned char *ptindxs; //800B6680 + static track_status *ptstemp; //800B6684 + static sequence_status *psstemp; //800B6688 + + //PRINTF_D2(WHITE,0,10,"Eng_SeqTempo"); + + psstemp = (pssbase + ptk_stat->seq_owner); + ptindxs = (unsigned char *)psstemp->ptrk_indxs; + nactive = psstemp->tracks_active; + ntracks = (pmsbase->pmod_info->pseq_info + psstemp->seq_num)->seq_hdr.tracks; + + while (ntracks--) + { + if (*ptindxs != 0xff) + { + ptstemp = (ptsbase + (*ptindxs)); + ptstemp->qpm = (unsigned short)(*(ptk_stat->ppos + 1) | (*(ptk_stat->ppos + 2) << 8)); + ptstemp->ppi = CalcPartsPerInt(GetIntsPerSec(), ptstemp->ppq, ptstemp->qpm); + + if (!--nactive) break; + } + ptindxs++; + } +} + +void Eng_SeqGosub (track_status *ptk_stat) // 800369C8 +{ + static short lindex; //800B668C + static unsigned short ntracks; //800B668E + static char *laboff; //800B6690 + static unsigned char nactive; //800B6694 + static unsigned char *ptindxs; //800B6698 + static track_status *ptstemp; //800B669C + static sequence_status *psstemp; //800B66A0 + + //PRINTF_D2(WHITE,0,10,"Eng_SeqGosub"); + + lindex = (*(ptk_stat->ppos + 1) | (*(ptk_stat->ppos + 2) << 8)); + + if ((lindex >= 0) && (lindex < ptk_stat->labellist_count)) + { + psstemp = (pssbase + ptk_stat->seq_owner); + ptindxs = (unsigned char *)psstemp->ptrk_indxs; + nactive = psstemp->tracks_active; + ntracks = (pmsbase->pmod_info->pseq_info + psstemp->seq_num)->seq_hdr.tracks; + + while (ntracks--) + { + if (*ptindxs != 0xFF) + { + ptstemp = (ptsbase + (*ptindxs)); + + ptstemp->psp = (unsigned char*)ptstemp->ppos + CmdLength[26]; + ptstemp->psp++; + laboff = ptstemp->pstart + *(ptstemp->plabellist + lindex); + ptstemp->ppos = laboff; + ptstemp->deltatime = 0; + ptstemp->flags |= TRK_SKIP; + + if (!--nactive) break; + } + ptindxs++; + } + } +} + +void Eng_SeqJump (track_status *ptk_stat) // 80036B80 +{ + static short lindex; //800B66A4 + static unsigned short ntracks; //800B66A6 + static char *laboff; //800B66A8 + static unsigned char nactive; //800B66AC + static unsigned char *ptindxs; //800B66B0 + static track_status *ptstemp; //800B66B4 + static sequence_status *psstemp; //800B66B8 + + //PRINTF_D2(WHITE,0,10,"Eng_SeqJump"); + + lindex = (*(ptk_stat->ppos + 1) | (*(ptk_stat->ppos + 2) << 8)); + + if ((lindex >= 0) && (lindex < ptk_stat->labellist_count)) + { + psstemp = (pssbase + ptk_stat->seq_owner); + ptindxs = (unsigned char *)psstemp->ptrk_indxs; + nactive = psstemp->tracks_active; + ntracks = (pmsbase->pmod_info->pseq_info + psstemp->seq_num)->seq_hdr.tracks; + + while (ntracks--) + { + if (*ptindxs != 0xFF) + { + ptstemp = (ptsbase + (*ptindxs)); + laboff = ptstemp->pstart + *(ptstemp->plabellist + lindex); + ptstemp->ppos = laboff; + ptstemp->deltatime = 0; + ptstemp->flags |= TRK_SKIP; + + if (!--nactive) break; + } + ptindxs++; + } + } +} + +void Eng_SeqRet (track_status *ptk_stat) // 80036D10 +{ + static unsigned short ntracks; //800B66BC + static unsigned char nactive; //800B66BE + static unsigned char *ptindxs; //800B66C0 + static track_status *ptstemp; //800B66C4 + static sequence_status *psstemp; //800B66C8 + + //PRINTF_D2(WHITE,0,10,"Eng_SeqRet"); + + psstemp = (pssbase + ptk_stat->seq_owner); + ptindxs = (unsigned char *)psstemp->ptrk_indxs; + nactive = psstemp->tracks_active; + ntracks = (pmsbase->pmod_info->pseq_info + psstemp->seq_num)->seq_hdr.tracks; + + while (ntracks--) + { + if (*ptindxs != 0xFF) + { + ptstemp = (ptsbase + (*ptindxs)); + ptstemp->psp--; + ptstemp->deltatime = 0; + ptstemp->flags |= TRK_SKIP; + ptstemp->ppos = (unsigned char*)ptstemp->psp; + + if (!--nactive) break; + } + ptindxs++; + } +} + +void Eng_SeqEnd (track_status *ptk_stat) // 80036E48 +{ + static sequence_status *lpseq; //800B66CC + static track_status *ptmp; //800B66D0 + static unsigned char *lpdest; //800B66D4 + static unsigned char li; //800B66D8 + static unsigned long lj; //800B66DC + + //PRINTF_D2(WHITE,0,10,"Eng_SeqEnd"); + + if (ptk_stat->flags & TRK_HANDLED) + { + lpseq = (pmsbase->pseqstattbl + ptk_stat->seq_owner); + lpdest = (unsigned char *)lpseq->ptrk_indxs; + li = lpseq->tracks_active; + lj = pmsbase->max_trks_perseq; + + while (lj--) + { + if (*lpdest != 0xFF) + { + ptmp = (ptsbase + *lpdest); + CmdFuncArr[ptmp->patchtype][TrkOff]((track_status *)ptmp); + + if (!--li) break; + } + + lpdest++; + } + + ptk_stat->flags |= TRK_SKIP; + } + else + { + lpseq = (pmsbase->pseqstattbl + ptk_stat->seq_owner); + lpdest = (unsigned char *)lpseq->ptrk_indxs; + li = lpseq->tracks_active; + lj = pmsbase->max_trks_perseq; + + while (lj--) + { + if (*lpdest != 0xFF) + { + ptmp = (ptsbase + *lpdest); + CmdFuncArr[ptmp->patchtype][TrkOff]((track_status *)ptmp); + + if (!--li) break; + } + + lpdest++; + } + } +} + +void Eng_TrkTempo (track_status *ptk_stat) // 800370D8 +{ + //PRINTF_D2(WHITE,0,10,"Eng_TrkTempo"); + ptk_stat->qpm = *(ptk_stat->ppos + 1) | (*(ptk_stat->ppos + 2) << 8); + ptk_stat->ppi = CalcPartsPerInt(GetIntsPerSec(), ptk_stat->ppq, ptk_stat->qpm); +} + +void Eng_TrkGosub (track_status *ptk_stat) // 8003713C +{ + unsigned int position; + + //PRINTF_D2(WHITE,0,10,"Eng_TrkGosub"); + + position = (unsigned int)(*(ptk_stat->ppos + 1) | (*(ptk_stat->ppos + 2) << 8)); + if ((position >= 0) && (position < ptk_stat->labellist_count)) + { + ptk_stat->psp = (unsigned char*)ptk_stat->ppos + CmdLength[26]; + ptk_stat->psp++; + ptk_stat->ppos = ptk_stat->pstart + *(ptk_stat->plabellist + position); + ptk_stat->deltatime = 0; + ptk_stat->flags |= TRK_SKIP; + } +} + +void Eng_TrkJump (track_status *ptk_stat) // 800371C4 +{ + unsigned int position; + + //PRINTF_D2(WHITE,0,10,"Eng_TrkJump"); + + position = (unsigned int)(*(ptk_stat->ppos + 1) | (*(ptk_stat->ppos + 2) << 8)); + if ((position >= 0) && (position < ptk_stat->labellist_count)) + { + ptk_stat->ppos = ptk_stat->pstart + *(ptk_stat->plabellist + position); + ptk_stat->deltatime = 0; + ptk_stat->flags |= TRK_SKIP; + } +} + +void Eng_TrkRet (track_status *ptk_stat) // 80037230 +{ + //PRINTF_D2(WHITE,0,10,"Eng_TrkRet"); + ptk_stat->psp--; + ptk_stat->ppos = (unsigned char*)ptk_stat->psp; + ptk_stat->ppos = Read_Vlq(ptk_stat->ppos, &ptk_stat->deltatime); + ptk_stat->deltatime = 0; + ptk_stat->flags |= TRK_SKIP; +} + +void Eng_TrkEnd (track_status *ptk_stat) // 8003728C +{ + //PRINTF_D2(WHITE,0,10,"Eng_TrkEnd"); + + if (ptk_stat->flags & TRK_HANDLED) + { + if ((ptk_stat->flags & TRK_LOOPED) && (ptk_stat->totppi > 15)) + { + ptk_stat->flags |= TRK_SKIP; + ptk_stat->ppos = ptk_stat->pstart; + ptk_stat->ppos = Read_Vlq(ptk_stat->pstart, &ptk_stat->deltatime); + } + else + { + CmdFuncArr[ptk_stat->patchtype][TrkOff](ptk_stat); + ptk_stat->flags |= TRK_SKIP; + } + } + else + { + if ((ptk_stat->flags & TRK_LOOPED) && (ptk_stat->totppi > 15)) + { + ptk_stat->flags |= TRK_SKIP; + ptk_stat->ppos = ptk_stat->pstart; + ptk_stat->ppos = Read_Vlq(ptk_stat->pstart, &ptk_stat->deltatime); + } + else + { + CmdFuncArr[ptk_stat->patchtype][TrkOff](ptk_stat); + } + } +} + +void Eng_NullEvent (track_status *ptk_stat) // 800373A4 +{ + //PRINTF_D2(WHITE,0,10,"Eng_NullEvent"); +} + +void SeqEngine(void) // 800373AC +{ + static track_status *pts; //800B66E0 + static unsigned char na; //800B66E4 + static unsigned int ni; //800B66E8 + static char *nn; //800B66EC + + track_status *ptrkstattbl; + //PRINTF_D2(WHITE,0,9,"SeqEngine %d\n",SeqOn); + + na = pmsbase->trks_active; + //PRINTF_D2(WHITE,0,4,"trks_active %d",na); + //PRINTF_D2(WHITE,0,5,"ptsbase->patchtype %d",ptsbase->patchtype); + + if (na) + { + //printf("trks_active %d\n",na); + pts = ptsbase; + ni = ntwa; + + while (ni--) + { + if ((pts->flags & TRK_ACTIVE)) + { + if (!(pts->flags & TRK_STOPPED)) + { + pts->starppi += pts->ppi; + pts->totppi += (pts->starppi >> 16); + pts->accppi += (pts->starppi >> 16); + pts->starppi &= 65535; + //printf("totppi %d\n",pts->totppi); + //printf("accppi %d\n",pts->accppi); + //printf("starppi %d\n",pts->starppi); + + if (!(pts->flags & TRK_TIMED) || (pts->totppi < pts->endppi)) + { + /*printf("totppi %d\n",pts->totppi); + printf("accppi %d\n",pts->accppi); + printf("starppi %d\n",pts->starppi); + printf("deltatime %d\n",pts->deltatime);*/ + + while (pts->deltatime <= pts->accppi && + ((pts->flags & (TRK_STOPPED | TRK_ACTIVE)) == TRK_ACTIVE)) + { + pts->accppi -= pts->deltatime; + nn = (pts->ppos); + + if (!(*nn < 7) && (*nn < 19)) + { + CmdFuncArr[pts->patchtype][*nn]((track_status *)pts); + + pts->ppos += CmdLength[*nn]; + pts->ppos = Read_Vlq(pts->ppos, &pts->deltatime); + } + else if (!(*nn < 19) && (*nn < 36)) + { + DrvFunctions[*nn]((track_status *)pts); + + if ((pts->flags & (TRK_ACTIVE | TRK_SKIP)) == TRK_ACTIVE) + { + pts->ppos += CmdLength[*nn]; + pts->ppos = Read_Vlq(pts->ppos, &pts->deltatime); + } + else + { + pts->flags &= ~TRK_SKIP; + } + } + else + { + Eng_SeqEnd((track_status *)pts); + } + } + } + else + { + CmdFuncArr[pts->patchtype][TrkOff]((track_status *)pts); + } + } + + if (!--na) break; + } + + pts++; + } + } + + CmdFuncArr[ptsbase->patchtype][2](ptsbase); +} + +#endif diff --git a/Doom 64/wessshell.c b/Doom 64/wessshell.c @@ -0,0 +1,27 @@ +/* ULTRA64 LIBRARIES */ +#include <ultra64.h> +#include "ultratypes.h" +#include <libaudio.h> + +#include "wessarc.h" +#include "wessshell.h" +#ifndef NOUSEWESSCODE +ALPlayer wessnode; //800B4140 +ALPlayer *wessstate;//800B4154 + +void SSP_SeqpNew(void) // 8002F100 +{ + wessnode.next = NULL; + wessnode.handler = __wessVoiceHandler; + wessnode.callTime = 0; + wessnode.samplesLeft = 0; + wessnode.clientData = wessstate; + alSynAddPlayer(&alGlobals->drvr, &wessnode); +} + +ALMicroTime __wessVoiceHandler(void *node) // 8002F154 +{ + WessInterruptHandler(); + return 8333; /* call back in 8.333 millisecond */ +} +#endif // 0 diff --git a/Doom 64/wesstrak.c b/Doom 64/wesstrak.c @@ -0,0 +1,312 @@ + +/* ULTRA64 LIBRARIES */ +#include <ultra64.h> +#include "ultratypes.h" +#include <libaudio.h> + +/* WESS API INCLUDES */ +#include "wessapi.h" // audio stuff... +#include "seqload.h" +#include "soundhw.h" +#include "wessarc.h" +#include "wessseq.h" + +#include "funqueue.h" + +#include "wessedit.h" +#include "wesstrak.h" +#include "wesshand.h" + +#ifndef NOUSEWESSCODE + +/* +PatchChg 7 +{ + Tuning Program Change +} + +PitchMod 9 +{ + Pitch Bend Sensitivity +} + +ZeroMod 11 +{ + MIDI_Controller = 0 (Bank Select) +} + +ModuMod 11 +{ + MIDI_Controller = 1 (Modulation Wheel or Lever) +} + +VolumeMod 12 +{ + MIDI_Controller = 7 (Channel Volume(formerly Main Volume)) +} + +PanMod 13 +{ + MIDI_Controller = 10 (Pan) +} + +PedalMod 14 +{ + MIDI_Controller = 64 (Damper Pedal on / off(Sustain)) +} + +ReverbMod 15 +{ + MIDI_Controller = 91 (Effects 1 Depth->Reverb Send Level) +} + +ChorusMod 16 +{ + MIDI_Controller = 93 (Effects 3 Depth->Chorus Send Level) +} +*/ + +extern char scratch_area[32];//800B41E0 + +extern void patch_chg_action(track_status *ptmp, int patch_num); // 800340E0 +extern void pitch_mod_action(track_status *ptmp, int pitch_cntr); // 80034144 +extern void volume_mod_action(track_status *ptmp, int volume_cntr); // 800341A8 +extern void pan_mod_action(track_status *ptmp, int pan_cntr); // 80034200 +extern track_status *gethandletrk(int handle, int track); // 80032EE0 + +void queue_wess_handle_noteon(int handle, int track, char keynum, char velnum); +void wess_handle_parm_mod(int handle, int track, int value, WessAction function); +void queue_wess_handle_parm_mod(int handle, int track, int value, WessAction function); + +void wess_handle_patchchg(int handle, int track, short patchnum) // 80034664 +{ + wess_handle_parm_mod(handle, track, patchnum, patch_chg_action); +} + +void wess_handle_noteon(int handle, int track, char keynum, char velnum) // 8003469C +{ + int _handle; + int _track; + char _keynum; + char _velnum; + + _handle = handle; + _track = track; + _keynum = keynum; + _velnum = velnum; + + wess_disable(); + queue_the_function(QUEUE_HANDLE_NOTEON); + queue_the_data(&_handle, sizeof(int)); + queue_the_data(&_track, sizeof(int)); + queue_the_data(&_keynum, sizeof(char)); + queue_the_data(&_velnum, sizeof(char)); + wess_enable(); +} + +void run_queue_wess_handle_noteon(void) // 80034708 +{ + int handle; + int track; + char keynum; + char velnum; + + unqueue_the_data(&handle, sizeof(int)); + unqueue_the_data(&track, sizeof(int)); + unqueue_the_data(&keynum, sizeof(char)); + unqueue_the_data(&velnum, sizeof(char)); + queue_wess_handle_noteon(handle, track, keynum, velnum); +} + +void queue_wess_handle_noteon(int handle, int track, char keynum, char velnum) // 80034768 +{ + track_status *ptmp; + char *ppos; + + int _handle; + int _track; + char _keynum; + char _velnum; + + _handle = handle; + _track = track; + _keynum = keynum; + _velnum = velnum; + + if (Is_Module_Loaded()) + { + wess_disable(); + ptmp = gethandletrk(_handle, _track); + + if (ptmp) + { + //save + ppos = ptmp->ppos; + + // set tmp buffer ppos + ptmp->ppos = scratch_area; + ptmp->ppos[0] = NoteOn; + ptmp->ppos[1] = _keynum; + ptmp->ppos[2] = _velnum; + + CmdFuncArr[ptmp->patchtype][NoteOn](ptmp); + + //restore + ptmp->ppos = ppos; + } + + wess_enable(); + } +} + +void noteoff_action(track_status *ptmp, int keynum) // 8003483C +{ + ptmp->ppos[0]= NoteOff; + ptmp->ppos[1]= keynum; + CmdFuncArr[ptmp->patchtype][NoteOff](ptmp); +} + +void wess_handle_noteoff(int handle, int track, char keynum) // 80034894 +{ + wess_handle_parm_mod(handle, track, keynum, noteoff_action); +} + +void wess_handle_pitchmod(int handle, int track, short pitch_cntrl) // 800348C0 +{ + wess_handle_parm_mod(handle, track, pitch_cntrl, pitch_mod_action); +} + +void zero_mod_action(track_status *ptmp, int value) // 800348F0 +{ + ptmp->ppos[0] = ZeroMod; + ptmp->ppos[1] = value; + CmdFuncArr[ptmp->patchtype][ZeroMod](ptmp); +} + +void wess_handle_zeromod(int handle, int track, char value) // 80034948 +{ + wess_handle_parm_mod(handle, track, value, zero_mod_action); +} + +void modu_mod_action(track_status *ptmp, int value) // 80034974 +{ + ptmp->ppos[0]= ModuMod; + ptmp->ppos[1] = value; + CmdFuncArr[ptmp->patchtype][ModuMod](ptmp); +} + +void wess_handle_modumod(int handle, int track, char value) // 800349CC +{ + wess_handle_parm_mod(handle, track, value, modu_mod_action); +} + +void wess_handle_volumemod(int handle, int track, char volume_cntrl) // 800349F8 +{ + wess_handle_parm_mod(handle, track, volume_cntrl, volume_mod_action); +} + +void wess_handle_panmod(int handle, int track, char pan_cntr) // 80034A24 +{ + wess_handle_parm_mod(handle, track, pan_cntr, pan_mod_action); +} + +void pedal_mod_action(track_status *ptmp, int value) // 80034A50 +{ + ptmp->ppos[0] = PedalMod; + ptmp->ppos[1] = value; + CmdFuncArr[ptmp->patchtype][PedalMod](ptmp); +} + +void wess_handle_pedalmod(int handle, int track, char value) // 80034AA8 +{ + wess_handle_parm_mod(handle, track, value, pedal_mod_action); +} + +void reverb_mod_action(track_status *ptmp, int reverb) // 80034AD4 +{ + ptmp->ppos[0] = ReverbMod; + ptmp->ppos[1] = reverb; + CmdFuncArr[ptmp->patchtype][ReverbMod](ptmp); +} + +void wess_handle_reverbmod(int handle, int track, char reverb) // 80034B2C +{ + wess_handle_parm_mod(handle, track, reverb, reverb_mod_action); +} + +void chorus_mod_action(track_status *ptmp, int chorus) // 80034B58 +{ + ptmp->ppos[0] = ChorusMod; + ptmp->ppos[1] = chorus; + CmdFuncArr[ptmp->patchtype][ChorusMod](ptmp); +} + +void wess_handle_chorusmod(int handle, int track, char chorus) // 80034BB0 +{ + wess_handle_parm_mod(handle, track, chorus, chorus_mod_action); +} + +void wess_handle_parm_mod(int handle, int track, int value, WessAction function) // 80034BDC +{ + int _handle; + int _track; + int _value; + WessAction _function; + + _handle = handle; + _track = track; + _value = value; + _function = function; + + wess_disable(); + queue_the_function(QUEUE_HANDLE_PARM_MOD); + queue_the_data(&_handle, sizeof(int)); + queue_the_data(&_track, sizeof(int)); + queue_the_data(&_value, sizeof(int)); + queue_the_data(&_function, sizeof(WessAction)); + wess_enable(); +} + +void run_queue_wess_handle_parm_mod(void) // 80034C48 +{ + int handle; + int track; + int value; + WessAction function; + + unqueue_the_data(&handle, sizeof(int)); + unqueue_the_data(&track, sizeof(int)); + unqueue_the_data(&value, sizeof(int)); + unqueue_the_data(&function, sizeof(WessAction)); + queue_wess_handle_parm_mod(handle, track, value, function); +} + +void queue_wess_handle_parm_mod(int handle, int track, int value, WessAction function) // 80034CA8 +{ + track_status *ptmp; + char *ppos; + + int _handle; + int _track; + int _value; + WessAction _function; + + _handle = handle; + _track = track; + _value = value; + _function = function; + + if (Is_Module_Loaded()) + { + wess_disable(); + ptmp = gethandletrk(_handle, _track); + + if (ptmp) + { + wess_track_parm_mod(ptmp, _value, _function); + } + + wess_enable(); + } +} +#endif // 0 diff --git a/Doom 64/wesstwek.c b/Doom 64/wesstwek.c @@ -0,0 +1,88 @@ + +/* ULTRA64 LIBRARIES */ +#include <ultra64.h> +#include "ultratypes.h" +#include <libaudio.h> + +/* WESS API INCLUDES */ +#include "wessapi.h" // audio stuff... +#include "seqload.h" +#include "soundhw.h" +#include "wessarc.h" +#include "wessseq.h" + +#include "funqueue.h" + +#include "wessedit.h" +#include "wesstrak.h" +#include "wesshand.h" + + +#include "graph.h" + +#ifndef NOUSEWESSCODE + +void wess_set_tweaks(WessTweakAttr *attr) // 8002F180 +{ + if (attr->mask & TWEAK_DMA_BUFFERS) + wess_driver_num_dma_buffers = attr->dma_buffers; + + if (attr->mask & TWEAK_DMA_MESSAGES) + wess_driver_num_dma_messages = attr->dma_messages; + + if (attr->mask & TWEAK_DMA_BUFFER_LENGTH) + wess_driver_dma_buffer_length = attr->dma_buffer_length; + + if (attr->mask & TWEAK_EXTRA_SAMPLES) + wess_driver_extra_samples = attr->extra_samples; + + if (attr->mask & TWEAK_FRAME_LAG) + wess_driver_frame_lag = attr->frame_lag; + + if (attr->mask & TWEAK_VOICES) + wess_driver_voices = attr->voices; + + if (attr->mask & TWEAK_UPDATES) + wess_driver_updates = attr->updates; + + if (attr->mask & TWEAK_SEQUENCES) + wess_driver_sequences = attr->sequences; + + if (attr->mask & TWEAK_TRACKS) + wess_driver_tracks = attr->tracks; + + if (attr->mask & TWEAK_GATES) + wess_driver_gates = attr->gates; + + if (attr->mask & TWEAK_ITERS) + wess_driver_iters = attr->iters; + + if (attr->mask & TWEAK_CALLBACKS) + wess_driver_callbacks = attr->callbacks; + + if (attr->mask & TWEAK_MAX_TRKS_PER_SEQ) + wess_driver_max_trks_per_seq = attr->max_trks_per_seq; + + if (attr->mask & TWEAK_MAX_SUBS_PER_TRK) + wess_driver_max_subs_per_trk = attr->max_subs_per_trk; +} + +void wess_get_tweaks(WessTweakAttr *attr) // 8002F348 +{ + attr->mask = 0; + attr->dma_buffers = wess_driver_num_dma_buffers; + attr->dma_messages = wess_driver_num_dma_messages; + attr->dma_buffer_length = wess_driver_dma_buffer_length; + attr->extra_samples = wess_driver_extra_samples; + attr->frame_lag = wess_driver_frame_lag; + attr->voices = wess_driver_voices; + attr->updates = wess_driver_updates; + attr->sequences = wess_driver_sequences; + attr->tracks = wess_driver_tracks; + attr->gates = wess_driver_gates; + attr->iters = wess_driver_iters; + attr->callbacks = wess_driver_callbacks; + attr->max_trks_per_seq = wess_driver_max_trks_per_seq; + attr->max_subs_per_trk = wess_driver_max_subs_per_trk; +} +#endif diff --git a/Doom 64/z_zone.c b/Doom 64/z_zone.c @@ -0,0 +1,574 @@ +/* Z_zone.c */ + +#include "doomdef.h" + +/* +============================================================================== + + ZONE MEMORY ALLOCATION + +There is never any space between memblocks, and there will never be two +contiguous free memblocks. + +The rover can be left pointing at a non-empty block + +It is of no value to free a cachable block, because it will get overwritten +automatically if needed + +============================================================================== +*/ + +#define DEBUG_ 0 + +extern u32 NextFrameIdx; + +memzone_t *mainzone; + +#define MEM_HEAP_SIZE (0x26B510) // 2.41 MB +extern u64 mem_heap[MEM_HEAP_SIZE / sizeof(u64)]; // 800BA2F0 + +/* +======================== += += Z_Init += +======================== +*/ + +#include "graph.h" + +void Z_Init (void) // 8002C8F0 +{ + byte *mem; + int size; + + mem = (byte *)(u32)(((u32)mem_heap + 15) & ~15); + size = (u32)(mem_heap+(MEM_HEAP_SIZE / sizeof(u64))) - (u32)mem; + + /* mars doesn't have a refzone */ + mainzone = Z_InitZone(mem, size); + + //PRINTF_D2(WHITE, 0, 25, "%d", (u32)size); + //while(1){} +} + +/* +======================== += += Z_InitZone += +======================== +*/ + +memzone_t *Z_InitZone(byte *base, int size) // 8002C934 +{ + memzone_t *zone; + + zone = (memzone_t *)base; + zone->size = size; + zone->rover = &zone->blocklist; + zone->rover2 = &zone->blocklist; + zone->rover3 = &zone->blocklist; + zone->blocklist.size = size - (int)((byte *)&zone->blocklist - (byte *)zone); + zone->blocklist.user = NULL; + zone->blocklist.tag = 0; + zone->blocklist.id = ZONEID; + zone->blocklist.next = NULL; + zone->blocklist.prev = NULL; + //zone->blocklist.lockframe = -1; + + return zone; +} + +/* +======================== += += Z_SetAllocBase += Exclusive Doom64 += +======================== +*/ + +void Z_SetAllocBase(memzone_t *mainzone) // 8002C970 +{ + mainzone->rover2 = mainzone->rover; +} + +/* +======================== += += Z_Malloc2 += += You can pass a NULL user if the tag is < PU_PURGELEVEL +======================== +*/ + +#define MINFRAGMENT 64 + +void *Z_Malloc2 (memzone_t *mainzone, int size, int tag, void *user) // 8002C97C +{ + int extra; + memblock_t *start, *rover, *newblock, *base; + + #if DEBUG_ + Z_CheckZone (mainzone); /* DEBUG */ + #endif + + /* */ + /* scan through the block list looking for the first free block */ + /* of sufficient size, throwing out any purgable blocks along the way */ + /* */ + + size += sizeof(memblock_t); /* account for size of block header */ + size = (size+15) & ~15; /* phrase align everything */ + + start = base = mainzone->rover; + + while (base->user || base->size < size) + { + if (base->user) + rover = base; + else + rover = base->next; + + if (!rover) + goto backtostart; + + if (rover->user) + { + if (!(rover->tag & PU_PURGELEVEL)) + { + if (!(rover->tag & PU_CACHE) || (u32)rover->lockframe >= (NextFrameIdx - 1)) + { + /* hit an in use block, so move base past it */ + base = rover->next; + if (!base) + { + backtostart: + base = mainzone->rover2; + } + + if (base == start) /* scaned all the way around the list */ + { + Z_DumpHeap(mainzone); + I_Error("Z_Malloc2: failed allocation on %i", size); + } + continue; + } + } + + /* */ + /* free the rover block (adding the size to base) */ + /* */ + Z_Free((byte *)rover + sizeof(memblock_t)); /* mark as free */ + } + + if (base != rover) + { /* merge with base */ + base->size += rover->size; + base->next = rover->next; + if (rover->next) + rover->next->prev = base; + else + mainzone->rover3 = base; + } + } + + /* */ + /* found a block big enough */ + /* */ + extra = base->size - size; + if (extra > MINFRAGMENT) + { /* there will be a free fragment after the allocated block */ + newblock = (memblock_t *) ((byte *)base + size ); + newblock->prev = base; + newblock->next = base->next; + if (newblock->next) + newblock->next->prev = newblock; + else + mainzone->rover3 = newblock; + + base->next = newblock; + base->size = size; + + newblock->size = extra; + newblock->user = NULL; /* free block */ + newblock->tag = 0; + newblock->id = ZONEID; + } + + if (user) + { + base->user = user; /* mark as an in use block */ + *(void **)user = (void *)((byte *)base + sizeof(memblock_t)); + } + else + { + if (tag >= PU_PURGELEVEL) + I_Error ("Z_Malloc: an owner is required for purgable blocks"); + base->user = (void *)1; /* mark as in use, but unowned */ + } + + base->tag = tag; + base->id = ZONEID; + base->lockframe = NextFrameIdx; + + mainzone->rover = base->next; /* next allocation will start looking here */ + if (!mainzone->rover) + { + mainzone->rover3 = base; + mainzone->rover = mainzone->rover2;//mainzone->rover = &mainzone->blocklist; + } + + #if DEBUG_ + Z_CheckZone (mainzone); /* DEBUG */ + #endif + + return (void *) ((byte *)base + sizeof(memblock_t)); +} + + +/* +======================== += += Z_Alloc2 += += You can pass a NULL user if the tag is < PU_PURGELEVEL += Exclusive Psx Doom +======================== +*/ + +void *Z_Alloc2(memzone_t *mainzone, int size, int tag, void *user) // 8002CBE0 +{ + int extra; + memblock_t *rover, *base, *block, *newblock; + + #if DEBUG_ + Z_CheckZone (mainzone); /* DEBUG */ + #endif + + /* */ + /* scan through the block list looking for the first free block */ + /* of sufficient size, throwing out any purgable blocks along the way */ + /* */ + + size += sizeof(memblock_t); /* account for size of block header */ + size = (size+15) & ~15; /* phrase align everything */ + + base = mainzone->rover3; + + while (base->user || base->size < size) + { + if (base->user) + rover = base; + else + { + /* hit an in use block, so move base past it */ + rover = base->prev; + if (!rover) + { + Z_DumpHeap(mainzone); + I_Error("Z_Alloc: failed allocation on %i", size); + } + } + + if (rover->user) + { + if (!(rover->tag & PU_PURGELEVEL)) + { + if (!(rover->tag & PU_CACHE) || (u32)rover->lockframe >= (NextFrameIdx - 1)) + { + /* hit an in use block, so move base past it */ + base = rover->prev; + if (!base) + { + Z_DumpHeap(mainzone); + I_Error("Z_Alloc: failed allocation on %i", size); + } + continue; + } + } + + /* */ + /* free the rover block (adding the size to base) */ + /* */ + Z_Free((byte *)rover + sizeof(memblock_t)); /* mark as free */ + } + + if (base != rover) + { + /* merge with base */ + rover->size += base->size; + rover->next = base->next; + + if (base->next) + base->next->prev = rover; + else + mainzone->rover3 = rover; + + base = rover; + } + } + + /* */ + /* found a block big enough */ + /* */ + extra = (base->size - size); + + newblock = base; + block = base; + + if (extra > MINFRAGMENT) + { + block = (memblock_t *)((byte *)base + extra); + block->prev = newblock; + block->next = (void *) newblock->next; + + if (newblock->next) + newblock->next->prev = block; + + newblock->next = block; + block->size = size; + newblock->size = extra; + newblock->user = 0; + newblock->tag = 0; + newblock->id = ZONEID; + } + + if (block->next == 0) + mainzone->rover3 = block; + + if (user) + { + block->user = user; /* mark as an in use block */ + *(void **)user = (void *)((byte *)block + sizeof(memblock_t)); + } + else + { + if (tag >= PU_PURGELEVEL) + I_Error("Z_Alloc: an owner is required for purgable blocks"); + block->user = (void *)1; /* mark as in use, but unowned */ + } + + block->id = ZONEID; + block->tag = tag; + block->lockframe = NextFrameIdx; + + #if DEBUG_ + Z_CheckZone (mainzone); /* DEBUG */ + #endif + + return (void *) ((byte *)block + sizeof(memblock_t)); +} + +/* +======================== += += Z_Free2 += +======================== +*/ + +void Z_Free2(memzone_t *mainzone, void *ptr) // 8002CE28 +{ + memblock_t *block; + + block = (memblock_t *)((byte *)ptr - sizeof(memblock_t)); + if (block->id != ZONEID) + I_Error("Z_Free: freed a pointer without ZONEID"); + + if (block->user > (void **)0x100) /* smaller values are not pointers */ + *block->user = 0; /* clear the user's mark */ + block->user = NULL; /* mark as free */ + block->tag = 0; +} + +/* +======================== += += Z_FreeTags += +======================== +*/ + +void Z_FreeTags (memzone_t *mainzone, int tag) // 8002CE8C +{ + memblock_t *block, *next; + + for (block = &mainzone->blocklist; block ; block = next) + { + /* get link before freeing */ + next = block->next; + + /* free block */ + if (block->user) + { + if(block->tag & tag) + { + Z_Free((byte *)block + sizeof(memblock_t)); + } + } + } + + for (block = &mainzone->blocklist; block; block = next) + { + /* get link before freeing */ + next = block->next; + + if (!block->user && next && !next->user) + { + block->size += next->size; + block->next = next->next; + if (next->next) + next->next->prev = block; + next = block; + } + } + + mainzone->rover = &mainzone->blocklist; + mainzone->rover2 = &mainzone->blocklist; + mainzone->rover3 = &mainzone->blocklist; + + block = mainzone->blocklist.next; + while (block) + { + mainzone->rover3 = block; + block = block->next; + } +} + +/* +======================== += += Z_Touch += Exclusive Doom64 += +======================== +*/ + +void Z_Touch(void *ptr) // 8002CF9C +{ + memblock_t *block; + + block = (memblock_t *)((byte *)ptr - sizeof(memblock_t)); + if (block->id != ZONEID) + I_Error("Z_Touch: touched a pointer without ZONEID"); + + block->lockframe = NextFrameIdx; +} + + +/* +======================== += += Z_CheckZone += +======================== +*/ + +void Z_CheckZone (memzone_t *mainzone) // 8002CFEC +{ + memblock_t *checkblock; + int size; + + for (checkblock = &mainzone->blocklist ; checkblock; checkblock = checkblock->next) + { + if(checkblock->id != ZONEID) + I_Error("Z_CheckZone: block missing ZONEID"); + + if (!checkblock->next) + { + size = (byte *)checkblock + checkblock->size - (byte *)mainzone; + if (size != mainzone->size) + I_Error ("Z_CheckZone: zone size changed from %d to %d\n", mainzone->size, size); + break; + } + + if ( (byte *)checkblock + checkblock->size != (byte *)checkblock->next) + I_Error ("Z_CheckZone: block size does not touch the next block\n"); + if ( checkblock->next->prev != checkblock) + I_Error ("Z_CheckZone: next block doesn't have proper back link\n"); + } + + #if DEBUG_ + Z_DumpHeap(mainzone); + #endif +} + + +/* +======================== += += Z_ChangeTag += +======================== +*/ + +void Z_ChangeTag (void *ptr, int tag) // 8002D0F0 +{ + memblock_t *block; + + block = (memblock_t *) ( (byte *)ptr - sizeof(memblock_t)); + if (block->id != ZONEID) + I_Error ("Z_ChangeTag: freed a pointer without ZONEID"); + if (tag >= PU_PURGELEVEL && (int)block->user < 0x100) + I_Error ("Z_ChangeTag: an owner is required for purgable blocks"); + block->tag = tag; + block->lockframe = NextFrameIdx; +} + + +/* +======================== += += Z_FreeMemory += +======================== +*/ + +int Z_FreeMemory (memzone_t *mainzone) // 8002D188 +{ + memblock_t *block; + int free; + + free = 0; + for (block = &mainzone->blocklist ; block ; block = block->next) + { + if (!block->user) + free += block->size; + } + + return free; +} + +/* +======================== += += Z_DumpHeap += +======================== +*/ + +void Z_DumpHeap(memzone_t *mainzone) // 8002D1C8 +{ +#if DEBUG_ + memblock_t *block; + + printf("zone size: %i location: %p\n", mainzone->size, mainzone); + + for (block = &mainzone->blocklist; block; block = block->next) + { + printf("block:%p size:%7i user:%p tag:%3i frame:%i\n", + block, block->size, block->user, block->tag, block->lockframe); + + if (!block->next) + continue; + + if ((byte *)block + block->size != (byte *)block->next) + printf("ERROR: block size does not touch the next block\n"); + if (block->next->prev != block) + printf("ERROR: next block doesn't have proper back link\n"); + } +#endif +} +