Ports/perfect_dark
1
0 Fork 1
mirror of https://github.com/perfect-dark-pc-port/perfect_dark.git synced 2026-10-24 00:02:43 +02:00
Code Issues Packages Projects Releases Wiki Activity

port: 64-bit cleanup: remove dead preprocess code

Browse Source
This commit is contained in:
fgsfds committed 2024-11-10 10:41:15 +01:00
1 parent 8468e69b9f
commit f37abc941e
2 files changed
+2 -134
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

port/src/preprocess/common.c
+2 -2
View File
@@ -1,8 +1,8 @@
#include "common.h"
#include "system.h"
struct ptrmarker m_PtrMarkers[1024*8];
int m_NumPtrMarkers;
static struct ptrmarker m_PtrMarkers[1024*8];
static int m_NumPtrMarkers;
void addMarker(u32 ptr_src, uintptr_t ptr_host)
{
port/src/preprocess/preprocess.c
-132
View File
@@ -4,7 +4,6 @@
#include <assert.h>
#include <PR/ultratypes.h>
#include <PR/gbi.h>
#include <PR/libaudio.h>
#include "platform.h"
#include "data.h"
#include "bss.h"
@@ -16,121 +15,6 @@
#include "system.h"
#include "common.h"
// HACK: to prevent double-swapping stuff, flag swapped offsets in a bitmap
static u8 swapmap[0x40000 >> 3];
static inline u32 alreadySwapped(const intptr_t addr) {
const u32 mask = (1 << (addr & 7));
const u32 old = swapmap[addr >> 3] & mask;
if (!old) {
swapmap[addr >> 3] |= mask;
}
return old;
}
static inline void preprocessALWaveTable(ALWaveTable *tbl, u8 *bankBase)
{
if (alreadySwapped((u8 *)tbl - bankBase)) {
return;
}
PD_SWAP_VAL(tbl->len);
PD_SWAP_PTR(tbl->base);
if (tbl->type == AL_ADPCM_WAVE) {
if (tbl->waveInfo.adpcmWave.loop ) {
PD_SWAP_PTR(tbl->waveInfo.adpcmWave.loop);
ALADPCMloop *loop = PD_PTR_BASE(tbl->waveInfo.adpcmWave.loop, bankBase);
PD_SWAP_VAL(loop->count);
PD_SWAP_VAL(loop->start);
PD_SWAP_VAL(loop->end);
for (s32 i = 0; i < 16; ++i) {
PD_SWAP_VAL(loop->state[i]);
}
}
if (tbl->waveInfo.adpcmWave.book) {
PD_SWAP_PTR(tbl->waveInfo.adpcmWave.book);
ALADPCMBook *book = PD_PTR_BASE(tbl->waveInfo.adpcmWave.book, bankBase);
PD_SWAP_VAL(book->npredictors);
PD_SWAP_VAL(book->order);
const s32 bookSize = book->order * book->npredictors * ADPCMVSIZE;
for (s32 i = 0; i < bookSize && i < 128; ++i) {
PD_SWAP_VAL(book->book[i]);
}
}
} else if (tbl->type == AL_RAW16_WAVE) {
if (tbl->waveInfo.rawWave.loop) {
PD_SWAP_PTR(tbl->waveInfo.rawWave.loop);
ALRawLoop *loop = PD_PTR_BASE(tbl->waveInfo.rawWave.loop, bankBase);
PD_SWAP_VAL(loop->count);
PD_SWAP_VAL(loop->start);
PD_SWAP_VAL(loop->end);
}
}
}
static inline void preprocessALSound(ALSound *snd, u8 *bankBase)
{
if (alreadySwapped((u8 *)snd - bankBase)) {
return;
}
if (snd->envelope) {
PD_SWAP_PTR(snd->envelope);
if (!alreadySwapped((intptr_t)snd->envelope)) {
ALEnvelope *env = PD_PTR_BASE(snd->envelope, bankBase);
PD_SWAP_VAL(env->attackTime);
PD_SWAP_VAL(env->releaseTime);
PD_SWAP_VAL(env->decayTime);
}
}
if (snd->keyMap) {
PD_SWAP_PTR(snd->keyMap);
}
if (snd->wavetable) {
PD_SWAP_PTR(snd->wavetable);
preprocessALWaveTable(PD_PTR_BASE(snd->wavetable, bankBase), bankBase);
}
}
static inline void preprocessALInstrument(ALInstrument *inst, u8 *bankBase)
{
if (alreadySwapped((u8 *)inst - bankBase)) {
return;
}
PD_SWAP_VAL(inst->bendRange);
PD_SWAP_VAL(inst->soundCount);
for (s16 i = 0; i < inst->soundCount; ++i) {
PD_SWAP_PTR(inst->soundArray[i]);
preprocessALSound(PD_PTR_BASE(inst->soundArray[i], bankBase), bankBase);
}
}
static inline void preprocessALBank(ALBank *bank, u8 *bankBase)
{
if (alreadySwapped((u8 *)bank - bankBase)) {
return;
}
PD_SWAP_VAL(bank->sampleRate);
PD_SWAP_VAL(bank->instCount);
if (bank->percussion) {
PD_SWAP_PTR(bank->percussion);
preprocessALInstrument(PD_PTR_BASE(bank->percussion, bankBase), bankBase);
}
for (s16 i = 0; i < bank->instCount; ++i) {
PD_SWAP_PTR(bank->instArray[i]);
preprocessALInstrument(PD_PTR_BASE(bank->instArray[i], bankBase), bankBase);
}
}
u8* preprocessAnimations(u8* data, u32 size, u32* outSize)
{
// set the anim table pointers as well
@@ -198,22 +82,6 @@ u8* preprocessJpnFont(u8* data, u32 size, u32* outSize)
return 0;
}
// to be removed eventually #TODO
u8* preprocessALBankFile_x86(u8* data, u32 size, u32* outSize)
{
memset(swapmap, 0, sizeof(swapmap));
ALBankFile *bankf = (ALBankFile *)data;
PD_SWAP_VAL(bankf->revision);
PD_SWAP_VAL(bankf->bankCount);
for (s16 i = 0; i < bankf->bankCount; ++i) {
PD_SWAP_PTR(bankf->bankArray[i]);
preprocessALBank(PD_PTR_BASE(bankf->bankArray[i], data), data);
}
return 0;
}
void preprocessALCMidiHdr(u8 *data, u32 size)
{
ALCMidiHdr *hdr = (ALCMidiHdr *)data;