a_dinosaur/ZSNES
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
102cef14dec8657cefee4b8de5ce0f6529da8147
ZSNES/zsnes/src/zstate.c
n-a-c-h 102cef14de Fixed loading old ZSTs.
2005-03-28 13:24:49 +00:00

1103 lines
26 KiB
C
Executable File
Raw Blame History

/*
Copyright (C) 1997-2005 ZSNES Team ( zsKnight, _Demo_, pagefault, Nach )
http://www.zsnes.com
http://sourceforge.net/projects/zsnes
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later
version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
#ifdef __LINUX__
#include "gblhdr.h"
#define DIR_SLASH "/"
#else
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#define DIR_SLASH "\\"
#endif
#include "gblvars.h"
#include "asm_call.h"
#ifdef __MSDOS__
#define clim() __asm__ __volatile__ ("cli");
#define stim() __asm__ __volatile__ ("sti");
#else
#define clim()
#define stim()
#endif
static void copy_snes_data(unsigned char **buffer, void (*copy_func)(unsigned char **, void *, size_t))
{
//65816 status, etc.
copy_func(buffer, &curcyc, PH65816regsize);
//SPC Timers
copy_func(buffer, &cycpbl, 2*4);
//SNES PPU Register status
copy_func(buffer, &sndrot, 3019);
}
static void copy_spc_data(unsigned char **buffer, void (*copy_func)(unsigned char **, void *, size_t))
{
//SPC stuff, DSP stuff
copy_func(buffer, spcRam, PHspcsave);
copy_func(buffer, &BRRBuffer, PHdspsave);
copy_func(buffer, &DSPMem, sizeof(DSPMem));
}
static void copy_extra_data(unsigned char **buffer, void (*copy_func)(unsigned char **, void *, size_t))
{
copy_func(buffer, &soundcycleft, 33);
copy_func(buffer, &spc700read, 10*4);
copy_func(buffer, &timer2upd, 1*4);
copy_func(buffer, &xa, 14*4);
copy_func(buffer, &spcnumread, 4);
copy_func(buffer, &spchalted, 4);
copy_func(buffer, &opcd, 6*4);
copy_func(buffer, &HIRQCycNext, 5);
copy_func(buffer, &oamaddr, 14*4);
copy_func(buffer, &prevoamptr, 1);
}
static size_t load_save_size;
static unsigned int zst_version;
//For compatibility with old save states (pre v1.43)
#define loading_old_state (!buffer && read && (zst_version < 143))
#define loading_state_no_sram (!buffer && read && !SRAMState)
static void copy_state_data(unsigned char *buffer, void (*copy_func)(unsigned char **, void *, size_t), bool read)
{
copy_snes_data(&buffer, copy_func);
//WRAM (128k), VRAM (64k)
copy_func(&buffer, wramdata, 8192*16);
copy_func(&buffer, vram, 4096*16);
if (spcon)
{
copy_spc_data(&buffer, copy_func);
if (buffer) //Rewind stuff
{
copy_func(&buffer, &echoon0, PHdspsave2);
}
}
if (C4Enable)
{
copy_func(&buffer, C4Ram, 2048*4);
}
if (SFXEnable)
{
copy_func(&buffer, sfxramdata, 8192*16);
copy_func(&buffer, &SfxR0, PHnum2writesfxreg);
}
if (SA1Enable)
{
copy_func(&buffer, &SA1Mode, PHnum2writesa1reg);
copy_func(&buffer, SA1RAMArea, 8192*16);
if (!loading_old_state)
{
copy_func(&buffer, &SA1Status, 3);
copy_func(&buffer, &SA1xpc, 1*4);
copy_func(&buffer, &sa1dmaptr, 2*4);
}
}
if (DSP1Type && !loading_old_state)
{
copy_func(&buffer, &DSP1COp, 70+128);
copy_func(&buffer, &Op00Multiplicand, 3*4+128);
copy_func(&buffer, &Op10Coefficient, 4*4+128);
copy_func(&buffer, &Op04Angle, 4*4+128);
copy_func(&buffer, &Op08X, 5*4+128);
copy_func(&buffer, &Op18X, 5*4+128);
copy_func(&buffer, &Op28X, 4*4+128);
copy_func(&buffer, &Op0CA, 5*4+128);
copy_func(&buffer, &Op02FX, 11*4+3*4+28*8+128);
copy_func(&buffer, &Op0AVS, 5*4+14*8+128);
copy_func(&buffer, &Op06X, 6*4+10*8+4+128);
copy_func(&buffer, &Op01m, 4*4+128);
copy_func(&buffer, &Op0DX, 6*4+128);
copy_func(&buffer, &Op03F, 6*4+128);
copy_func(&buffer, &Op14Zr, 9*4+128);
copy_func(&buffer, &Op0EH, 4*4+128);
}
if (SETAEnable)
{
copy_func(&buffer, setaramdata, 256*16);
//Todo: copy the SetaCmdEnable? For completeness we should do it
//but currently we ignore it anyway.
}
if (SPC7110Enable)
{
copy_func(&buffer, romdata+0x510000, 65536);
copy_func(&buffer, &SPCMultA, PHnum2writespc7110reg);
}
if (!loading_old_state)
{
copy_extra_data(&buffer, copy_func);
if (!loading_state_no_sram)
{
copy_func(&buffer, sram, ramsize);
}
if (buffer) //Not to a file, i.e. rewind
{
copy_func(&buffer, &tempesi, 4);
copy_func(&buffer, &tempedi, 4);
copy_func(&buffer, &tempedx, 4);
copy_func(&buffer, &tempebp, 4);
}
}
else
{
spcnumread = 0;
spchalted = 0xFFFFFFFF;
}
}
static void memcpyinc(unsigned char **dest, void *src, size_t len)
{
memcpy(*dest, src, len);
*dest += len;
}
static void memcpyrinc(unsigned char **src, void *dest, size_t len)
{
memcpy(dest, *src, len);
*src += len;
}
extern unsigned int RewindTimer;
extern unsigned char RewindStates;
unsigned char *StateBackup = 0;
size_t rewind_state_size, cur_zst_size, old_zst_size;
/* A nice idea, but needs more ported from the assembly first.
size_t RewindPos, RewindEarliestPos;
void BackupCVFrame()
{
unsigned char *RewindBufferPos = StateBackup + RewindPos*rewind_state_size;
printf("Backing up rewind in slot #%u\n", RewindPos);
copy_state_data(RewindBufferPos, memcpyinc, false);
RewindPos++;
if (RewindPos == RewindStates)
{
RewindPos = 0;
}
if (RewindPos == RewindEarliestPos)
{
RewindEarliestPos++;
if (RewindEarliestPos == RewindStates)
{
RewindEarliestPos = 0;
}
}
RewindTimer = 60*3;
}
void RestoreCVFrame()
{
if (RewindPos != RewindEarliestPos)
{
unsigned char *RewindBufferPos;
if (!RewindPos)
{
RewindPos = RewindStates;
}
RewindPos--;
RewindBufferPos = StateBackup + RewindPos*rewind_state_size;
printf("Restoring rewind in slot #%u\n", RewindPos);
copy_state_data(RewindBufferPos, memcpyrinc, true);
//Clear Cache Check
memset(vidmemch2, 1, sizeof(vidmemch2));
memset(vidmemch4, 1, sizeof(vidmemch4));
memset(vidmemch8, 1, sizeof(vidmemch8));
RewindTimer = 60*3;
}
}
void MultipleFrameBack(unsigned int i)
{
while (i--)
{
if (RewindPos != RewindEarliestPos)
{
if (!RewindPos)
{
RewindPos = RewindStates;
}
RewindPos--;
}
else
{
break;
}
}
}
void SetupRewindBuffer()
{
if (StateBackup){ free(StateBackup); }
for (; RewindStates; RewindStates--)
{
StateBackup = 0;
StateBackup = (unsigned char *)malloc(rewind_state_size*RewindStates);
if (StateBackup) { break; }
}
}
*/
extern unsigned int CBackupPos, PBackupPos, RewindPos, RewindOldPos;
extern unsigned char RewindFrames, romispal;
extern unsigned char MovieProcessing;
void zmv_rewind_save(size_t, bool);
void zmv_rewind_load(size_t, bool);
#define ActualRewindFrames (RewindFrames * (romispal ? 25 : 30))
void BackupCVFrame()
{
unsigned char *RewindBufferPos = StateBackup + CBackupPos*rewind_state_size;
//printf("Backing up rewind in slot #%u\n", CBackupPos);
copy_state_data(RewindBufferPos, memcpyinc, false);
if (MovieProcessing == 1) { zmv_rewind_save(CBackupPos, true); }
else if (MovieProcessing == 1) { zmv_rewind_save(CBackupPos, false); }
RewindTimer = ActualRewindFrames;
}
void RestoreCVFrame()
{
unsigned char *RewindBufferPos = StateBackup + PBackupPos*rewind_state_size;
//printf("Restoring rewind in slot #%u\n", PBackupPos);
copy_state_data(RewindBufferPos, memcpyrinc, true);
if (MovieProcessing == 1) { zmv_rewind_save(CBackupPos, true); }
else if (MovieProcessing == 1) { zmv_rewind_save(CBackupPos, false); }
RewindTimer = ActualRewindFrames;
}
void outofmemory();
void SetupRewindBuffer()
{
if (StateBackup){ free(StateBackup); }
RewindStates = 16;
StateBackup = 0;
StateBackup = (unsigned char *)malloc(rewind_state_size*RewindStates);
if (!StateBackup)
{
asm_call(outofmemory);
}
}
static size_t state_size;
static void state_size_tally(unsigned char **dest, void *src, size_t len)
{
state_size += len;
}
void InitRewindVars()
{
#ifndef __MSDOS__ //When all the code is ported to C, we can make this work with DOS too
unsigned char almost_useless_array[1]; //An array is needed for copy_state_data to give the correct size
state_size = 0;
copy_state_data(almost_useless_array, state_size_tally, false);
rewind_state_size = state_size;
SetupRewindBuffer();
RewindPos = 0;
RewindOldPos = 0;
//RewindEarliestPos = 0;
RewindTimer = ActualRewindFrames;
#endif
}
//This is used to preserve system load state between loads
static unsigned char BackupSystemBuffer[0x800000]; //Half a megabyte, should be enough for a while
void BackupSystemVars()
{
unsigned char *buffer = BackupSystemBuffer;
copy_snes_data(&buffer, memcpyinc);
copy_spc_data(&buffer, memcpyinc);
copy_extra_data(&buffer, memcpyinc);
}
void RestoreSystemVars()
{
unsigned char *buffer = BackupSystemBuffer;
InitRewindVars();
copy_snes_data(&buffer, memcpyrinc);
copy_spc_data(&buffer, memcpyrinc);
copy_extra_data(&buffer, memcpyrinc);
}
extern unsigned int Bank0datr8[256], Bank0datr16[256], Bank0datw8[256];
extern unsigned int Bank0datw16[256], xd, DPageR8, DPageR16, DPageW8;
extern unsigned int DPageW16;
void UpdateDPageC()
{
DPageR8 = Bank0datr8[(xd >> 8) & 0xFF];
DPageR16 = Bank0datr16[(xd >> 8) & 0xFF];
DPageW8 = Bank0datw8[(xd >> 8) & 0xFF];
DPageW16 = Bank0datw16[(xd >> 8) & 0xFF];
}
extern unsigned int SA1xd, SA1DPageR8, SA1DPageR16, SA1DPageW8, SA1DPageW16;
void SA1UpdateDPageC()
{
SA1DPageR8 = Bank0datr8[(SA1xd >> 8) & 0xFF];
SA1DPageR16 = Bank0datr16[(SA1xd >> 8) & 0xFF];
SA1DPageW8 = Bank0datw8[(SA1xd >> 8) & 0xFF];
SA1DPageW16 = Bank0datw16[(SA1xd >> 8) & 0xFF];
}
extern unsigned int xdb, xpb, xs, xx, xy;
extern unsigned short oamaddrt, xat, xst, xdt, xxt, xyt;
extern unsigned char xdbt, xpbt;
void unpackfunct()
{
oamaddrt = (oamaddr & 0xFFFF);
xat = (xa & 0xFFFF);
xdbt = (xdb & 0xFF);
xpbt = (xpb & 0xFF);
xst = (xs & 0xFFFF);
xdt = (xd & 0xFFFF);
xxt = (xx & 0xFFFF);
xyt = (xy & 0xFFFF);
}
extern unsigned int spcBuffera;
extern unsigned int Voice0BufPtr, Voice1BufPtr, Voice2BufPtr, Voice3BufPtr;
extern unsigned int Voice4BufPtr, Voice5BufPtr, Voice6BufPtr, Voice7BufPtr;
extern unsigned int Curtableaddr, tableA[256], spcPCRam, spcRamDP;
void PrepareSaveState()
{
unsigned int offst = (unsigned int)spcRam;
spcPCRam -= offst;
spcRamDP -= offst;
Voice0BufPtr -= spcBuffera;
Voice1BufPtr -= spcBuffera;
Voice2BufPtr -= spcBuffera;
Voice3BufPtr -= spcBuffera;
Voice4BufPtr -= spcBuffera;
Voice5BufPtr -= spcBuffera;
Voice6BufPtr -= spcBuffera;
Voice7BufPtr -= spcBuffera;
}
#define byteset(byte, checkbit) (byte & (1 << checkbit)) ? 1 : 0
extern unsigned int GlobalVL, GlobalVR, EchoVL, EchoVR, EchoRate[16], MaxEcho;
extern unsigned int EchoFB, NoiseSpeeds[32], dspPAdj, NoiseInc, bg1ptrx;
extern unsigned int bg1ptry, bg2ptrx, bg2ptry, bg3ptrx, bg3ptry, bg4ptrx;
extern unsigned int bg4ptry;
extern signed int FIRTAPVal0, FIRTAPVal1, FIRTAPVal2, FIRTAPVal3, FIRTAPVal4;
extern signed int FIRTAPVal5, FIRTAPVal6, FIRTAPVal7;
extern unsigned short VolumeConvTable[32768], bg1ptr, bg1ptrb, bg1ptrc;
extern unsigned short bg2ptr, bg2ptrb, bg2ptrc, bg3ptr, bg3ptrb, bg3ptrc;
extern unsigned short bg4ptr, bg4ptrb, bg4ptrc;
extern unsigned char VolumeTableb[256], MusicVol, Voice0Status;
extern unsigned char Voice1Status, Voice2Status, Voice3Status, Voice4Status;
extern unsigned char Voice5Status, Voice6Status, Voice7Status, Voice0Noise;
extern unsigned char Voice1Noise, Voice2Noise, Voice3Noise, Voice4Noise;
extern unsigned char Voice5Noise, Voice6Noise, Voice7Noise, bgtilesz;
extern unsigned char BG116x16t, BG216x16t, BG316x16t, BG416x16t, vramincby8on;
extern unsigned char vramincr;
extern void (**regptw)();
void reg2118();
void reg2118inc();
void reg2118inc8();
void reg2118inc8inc();
void reg2119();
void reg2119inc();
void reg2119inc8();
void reg2119inc8inc();
void repackfunct()
{
signed char val;
unsigned char block;
// Global/Echo Volumes
GlobalVL = (VolumeConvTable[(MusicVol << 8) + VolumeTableb[DSPMem[0x0C]]] & 0xFF);
GlobalVR = (VolumeConvTable[(MusicVol << 8) + VolumeTableb[DSPMem[0x1C]]] & 0xFF);
EchoVL = (VolumeConvTable[(MusicVol << 8) + VolumeTableb[DSPMem[0x2C]]] & 0xFF);
EchoVR = (VolumeConvTable[(MusicVol << 8) + VolumeTableb[DSPMem[0x3C]]] & 0xFF);
// Echo Values
MaxEcho = EchoRate[(DSPMem[0x7D] & 0xF)];
EchoFB = VolumeTableb[DSPMem[0x0D]];
// FIR Filter Values
val = DSPMem[0x0F];
FIRTAPVal0 = (signed int)val;
val = DSPMem[0x1F];
FIRTAPVal1 = (signed int)val;
val = DSPMem[0x2F];
FIRTAPVal2 = (signed int)val;
val = DSPMem[0x3F];
FIRTAPVal3 = (signed int)val;
val = DSPMem[0x4F];
FIRTAPVal4 = (signed int)val;
val = DSPMem[0x5F];
FIRTAPVal5 = (signed int)val;
val = DSPMem[0x6F];
FIRTAPVal6 = (signed int)val;
val = DSPMem[0x7F];
FIRTAPVal7 = (signed int)val;
// Noise
block = DSPMem[0x6C];
DSPMem[0x6C] &= 0x7F;
if (block && 0xC0)
{
Voice0Status = Voice1Status = Voice2Status = Voice3Status = 0;
Voice4Status = Voice5Status = Voice6Status = Voice7Status = 0;
}
NoiseInc = (((NoiseSpeeds[(block & 0x1F)] * dspPAdj) >> 17) & 0xFFFFFFFF);
Voice0Noise = byteset (DSPMem[0x3D], 0);
Voice1Noise = byteset (DSPMem[0x3D], 1);
Voice2Noise = byteset (DSPMem[0x3D], 2);
Voice3Noise = byteset (DSPMem[0x3D], 3);
Voice4Noise = byteset (DSPMem[0x3D], 4);
Voice5Noise = byteset (DSPMem[0x3D], 5);
Voice6Noise = byteset (DSPMem[0x3D], 6);
Voice7Noise = byteset (DSPMem[0x3D], 7);
bg1ptrx = bg1ptrb - bg1ptr;
bg1ptry = bg1ptrc - bg1ptr;
bg2ptrx = bg2ptrb - bg2ptr;
bg2ptry = bg2ptrc - bg2ptr;
bg3ptrx = bg3ptrb - bg3ptr;
bg3ptry = bg3ptrc - bg3ptr;
bg4ptrx = bg4ptrb - bg4ptr;
bg4ptry = bg4ptrc - bg4ptr;
// 16x16 tiles
BG116x16t = byteset (bgtilesz, 0);
BG216x16t = byteset (bgtilesz, 1);
BG316x16t = byteset (bgtilesz, 2);
BG416x16t = byteset (bgtilesz, 3);
oamaddr = oamaddrt;
xa = xat;
xdb = xdbt;
xpb = xpbt;
xs = xst;
xd = xdt;
xx = xxt;
xy = xyt;
if (vramincby8on == 1)
{
if (vramincr == 1)
{
regptw[0x2118] = reg2118inc8inc;
regptw[0x2119] = reg2119inc8;
}
else
{
regptw[0x2118] = reg2118inc8;
regptw[0x2119] = reg2119inc8inc;
}
}
else
{
if (vramincr == 1)
{
regptw[0x2118] = reg2118inc;
regptw[0x2119] = reg2119;
}
else
{
regptw[0x2118] = reg2118;
regptw[0x2119] = reg2119inc;
}
}
}
extern unsigned int SA1Stat;
extern unsigned char IRAM[2049], *SA1Ptr, *SA1RegPCS, *CurBWPtr, *SA1BWPtr;
extern unsigned char *SNSBWPtr;
void SaveSA1()
{
unsigned int offst=(unsigned int)SA1RegPCS;
SA1Stat &= 0xFFFFFF00;
SA1Ptr -= offst;
if (SA1RegPCS == IRAM)
{
SA1Stat = (SA1Stat & 0xFFFFFF00) + 1;
}
if (SA1RegPCS == IRAM-0x3000)
{
SA1Stat = (SA1Stat & 0xFFFFFF00) + 2;
}
offst = (unsigned int)romdata;
SA1RegPCS -= offst;
CurBWPtr -= offst;
SA1BWPtr -= offst;
SNSBWPtr -= offst;
}
void RestoreSA1()
{
unsigned int offst=(unsigned int)romdata;
SA1RegPCS += offst;
CurBWPtr += offst;
SA1BWPtr += offst;
SNSBWPtr += offst;
if ((SA1Stat & 0xFF) == 1)
{
SA1RegPCS = IRAM;
}
if ((SA1Stat & 0xFF) == 2)
{
SA1RegPCS = IRAM-0x3000;
}
offst = (unsigned int)SA1RegPCS;
SA1Ptr += offst;
SA1RAMArea = romdata + 4096*1024;
}
#define ResState(Voice_BufPtr) \
Voice_BufPtr += spcBuffera; \
if (Voice_BufPtr >= spcBuffera + 65536*4) \
{ \
Voice_BufPtr = spcBuffera; \
}
void ResetState()
{
unsigned int offst = (unsigned int)spcRam;
spcPCRam += offst;
spcRamDP += offst;
ResState(Voice0BufPtr);
ResState(Voice1BufPtr);
ResState(Voice2BufPtr);
ResState(Voice3BufPtr);
ResState(Voice4BufPtr);
ResState(Voice5BufPtr);
ResState(Voice6BufPtr);
ResState(Voice7BufPtr);
}
extern unsigned int statefileloc, CurrentHandle, SfxRomBuffer;
extern unsigned int SfxCROM, SfxLastRamAdr, SfxRAMMem;
extern unsigned int MsgCount, MessageOn;
extern unsigned char AutoIncSaveSlot, firstsaveinc, fnamest[512];
extern unsigned char cbitmode, NoPictureSave, txtsavemsg[14];
extern unsigned char *Msgptr, txtsavemsgfail[15];
extern unsigned short PrevPicture[64*56];
static FILE *fhandle;
void SRAMChdir();
void CapturePicture();
static void write_save_state_data(unsigned char **dest, void *data, size_t len)
{
fwrite(data, 1, len, fhandle);
}
static const char zst_header_old[] = "ZSNES Save State File V0.6\x1a\x3c";
static const char zst_header_cur[] = "ZSNES Save State File V143\x1a\x8f";
void calculate_state_sizes()
{
state_size = 0;
zst_version = 143;
copy_state_data(0, state_size_tally, false);
cur_zst_size = state_size + sizeof(zst_header_cur)-1;
state_size = 0;
zst_version = 60;
copy_state_data(0, state_size_tally, true);
old_zst_size = state_size + sizeof(zst_header_old)-1;
}
void PrepareOffset()
{
Curtableaddr -= (unsigned int)tableA;
}
void ResetOffset()
{
Curtableaddr += (unsigned int)tableA;
}
void zst_save(FILE *fp, bool Thumbnail)
{
fwrite(zst_header_cur, 1, sizeof(zst_header_cur)-1, fp); //-1 for null
PrepareOffset();
PrepareSaveState();
unpackfunct();
if (SFXEnable)
{
SfxRomBuffer -= SfxCROM;
SfxLastRamAdr -= SfxRAMMem;
}
if (SA1Enable)
{
SaveSA1(); //Convert SA-1 stuff to standard, non displacement format
}
fhandle = fp; //Set global file handle
copy_state_data(0, write_save_state_data, false);
if (SFXEnable)
{
SfxRomBuffer += SfxCROM;
SfxLastRamAdr += SfxRAMMem;
}
if (SA1Enable)
{
RestoreSA1(); //Convert back SA-1 stuff
}
if (Thumbnail)
{
CapturePicture();
fwrite(PrevPicture, 1, 64*56*sizeof(unsigned short), fp);
}
ResetOffset();
ResetState();
}
void statesaver()
{
//Save State code
#ifdef __LINUX__
SRAMChdir();
#endif
if (MovieProcessing == 2)
{
bool mzt_save(char *, bool, bool);
if (mzt_save(fnamest+1, (cbitmode && !NoPictureSave) ? true : false, false))
{
Msgptr = "RR STATE SAVED.";
MessageOn = MsgCount;
}
return;
}
//'Auto increment savestate slot' code
if (AutoIncSaveSlot)
{
if (firstsaveinc)
{
firstsaveinc = 0;
}
else
{
switch (fnamest[statefileloc])
{
case 't':
fnamest[statefileloc] = '1';
break;
case '9':
fnamest[statefileloc] = 't';
break;
default:
fnamest[statefileloc]++;
}
}
}
clim();
if ((fhandle = fopen(fnamest+1,"wb")))
{
zst_save(fhandle, (cbitmode && !NoPictureSave) ? true : false);
fclose(fhandle);
//Display message on the screen, 'STATE X SAVED.'
if (fnamest[statefileloc] == 't')
{
txtsavemsg[6]='0';
}
else
{
txtsavemsg[6]=fnamest[statefileloc];
}
Msgptr = txtsavemsg;
MessageOn = MsgCount;
}
else
{
//Display message on the screen, 'UNABLE TO SAVE.'
Msgptr = txtsavemsgfail;
MessageOn = MsgCount;
}
stim();
}
extern unsigned int snesmmap[256], snesmap2[256];
/*extern unsigned int NumofBanks;
extern unsigned char SA1BankVal[4];
void BankSwitchC (unsigned char bank, unsigned int offset1, unsigned int offset2, unsigned int pointer)
{
unsigned int curbankval=SA1BankVal[bank], membankval, i;
if ((NumofBanks & 0xFF) == 64) { curbankval &= 1 ; }
curbankval &= 7;
curbankval <<= 20;
if (SA1BankVal[bank] & 0x80)
{
membankval = (pointer + (unsigned int)romdata - 0x8000);
}
else
{
membankval = (curbankval + (unsigned int)romdata - 0x8000);
}
for (i=0 ; i<32 ; i++)
{
snesmmap[offset1+i] = membankval;
membankval += 0x8000;
}
membankval = curbankval + (unsigned int)romdata;
for (i=0 ; i<16 ; i++)
{
snesmap2[offset2+i] = membankval;
snesmmap[offset2+i] = membankval;
membankval += 0x10000;
}
}
extern unsigned int SA1BankSw;
void UpdateBanks()
{
if ((SA1BankSw & 0xFF) == 1)
{
BankSwitchC (0, 0x000, 0x0C0, 0x000000) ;
BankSwitchC (1, 0x020, 0x0D0, 0x100000) ;
BankSwitchC (2, 0x080, 0x0E0, 0x200000) ;
BankSwitchC (3, 0x0A0, 0x0F0, 0x300000) ;
}
}*/
void BankSwitchSDD1C (unsigned char bankval, unsigned int offset)
{
unsigned int curbankval = bankval, i;
curbankval &= 7;
curbankval <<= 20;
curbankval += (unsigned int)romdata;
for (i=0; i<16 ; i++)
{
snesmap2[offset+i] = curbankval;
snesmmap[offset+i] = curbankval;
curbankval += 0x10000;
}
}
extern unsigned char SDD1BankA, SDD1BankB, SDD1BankC, SDD1BankD;
void UpdateBanksSDD1()
{
if (SDD1BankA)
{
BankSwitchSDD1C(SDD1BankA, 0x0C0);
BankSwitchSDD1C(SDD1BankB, 0x0D0);
BankSwitchSDD1C(SDD1BankC, 0x0E0);
BankSwitchSDD1C(SDD1BankD, 0x0F0);
}
}
extern unsigned int Voice0Freq, Voice1Freq, Voice2Freq, Voice3Freq;
extern unsigned int Voice4Freq, Voice5Freq, Voice6Freq, Voice7Freq;
extern unsigned short Voice0Pitch, Voice1Pitch, Voice2Pitch, Voice3Pitch;
extern unsigned short Voice4Pitch, Voice5Pitch, Voice6Pitch, Voice7Pitch;
void initpitch()
{
Voice0Pitch = DSPMem[2+0*0x10];
Voice0Freq = ((((Voice0Pitch & 0x3FFF) * dspPAdj) >> 8) & 0xFFFFFFFF);
Voice1Pitch = DSPMem[2+1*0x10];
Voice1Freq = ((((Voice1Pitch & 0x3FFF) * dspPAdj) >> 8) & 0xFFFFFFFF);
Voice2Pitch = DSPMem[2+2*0x10];
Voice2Freq = ((((Voice2Pitch & 0x3FFF) * dspPAdj) >> 8) & 0xFFFFFFFF);
Voice3Pitch = DSPMem[2+3*0x10];
Voice3Freq = ((((Voice3Pitch & 0x3FFF) * dspPAdj) >> 8) & 0xFFFFFFFF);
Voice4Pitch = DSPMem[2+4*0x10];
Voice4Freq = ((((Voice4Pitch & 0x3FFF) * dspPAdj) >> 8) & 0xFFFFFFFF);
Voice5Pitch = DSPMem[2+5*0x10];
Voice5Freq = ((((Voice5Pitch & 0x3FFF) * dspPAdj) >> 8) & 0xFFFFFFFF);
Voice6Pitch = DSPMem[2+6*0x10];
Voice6Freq = ((((Voice6Pitch & 0x3FFF) * dspPAdj) >> 8) & 0xFFFFFFFF);
Voice7Pitch = DSPMem[2+7*0x10];
Voice7Freq = ((((Voice7Pitch & 0x3FFF) * dspPAdj) >> 8) & 0xFFFFFFFF);
}
extern unsigned int KeyLoadState, Totalbyteloaded, SfxMemTable[256], SfxCPB;
extern unsigned int SfxPBR, SfxROMBR, SfxRAMBR;
extern unsigned char pressed[256+128+64], multchange, txtloadmsg[15];
extern unsigned char txtconvmsg[16], txtnfndmsg[23], ioportval, SDD1Enable;
extern unsigned char nexthdma;
void procexecloop();
static void read_save_state_data(unsigned char **dest, void *data, size_t len)
{
load_save_size += fread(data, 1, len, fhandle);
}
bool zst_load(FILE *fp)
{
char zst_header_check[sizeof(zst_header_cur)-1];
zst_version = 0;
Totalbyteloaded += fread(zst_header_check, 1, sizeof(zst_header_check), fp);
if (!memcmp(zst_header_check, zst_header_cur, sizeof(zst_header_check)-2))
{
zst_version = 143; //v1.43+
}
// the -2 means we only check the text - trust me, that's ok
if (!memcmp(zst_header_check, zst_header_old, sizeof(zst_header_check)-2))
{
zst_version = 60; //v0.60 - v1.42
}
if (!zst_version) { return(false); } //Pre v0.60 saves are no longer loaded
load_save_size = 0;
fhandle = fp; //Set global file handle
copy_state_data(0, read_save_state_data, true);
Totalbyteloaded += load_save_size;
if (SFXEnable)
{
SfxCPB = SfxMemTable[(SfxPBR & 0xFF)];
SfxCROM = SfxMemTable[(SfxROMBR & 0xFF)];
SfxRAMMem = (unsigned int)sfxramdata + ((SfxRAMBR & 0xFF) << 16);
SfxRomBuffer += SfxCROM;
SfxLastRamAdr += SfxRAMMem;
}
if (SA1Enable)
{
RestoreSA1(); //Convert back SA-1 stuff
/*
All UpdateBanks() seems to do is break Oshaberi Parodius...
The C port is still present, just commented out
*/
//UpdateBanks();
SA1UpdateDPageC();
}
if (SDD1Enable)
{
UpdateBanksSDD1();
}
//Clear cache check if state loaded
memset(vidmemch2, 1, sizeof(vidmemch2));
memset(vidmemch4, 1, sizeof(vidmemch4));
memset(vidmemch8, 1, sizeof(vidmemch8));
if (zst_version == 60) //Set new vars which old states did not have
{
prevoamptr = 0xFF;
ioportval = 0xFF;
spcnumread = 0;
spchalted = 0xFFFFFFFF;
nexthdma = 0;
}
repackfunct();
initpitch();
ResetOffset();
ResetState();
procexecloop();
return(true);
}
void zst_sram_load(FILE *fp)
{
fseek(fp, sizeof(zst_header_cur)-1 + PH65816regsize + 199635, SEEK_CUR);
if (spcon) { fseek(fp, PHspcsave + PHdspsave + sizeof(DSPMem), SEEK_CUR); }
if (C4Enable) { fseek(fp, 8192, SEEK_CUR); }
if (SFXEnable) { fseek(fp, PHnum2writesfxreg + 131072, SEEK_CUR); }
if (SA1Enable)
{
fseek(fp, PHnum2writesa1reg, SEEK_CUR);
fread(SA1RAMArea, 1, 131072, fp); // SA-1 sram
fseek(fp, 15, SEEK_CUR);
}
if (DSP1Type) { fseek(fp, 2874, SEEK_CUR); }
if (SETAEnable) { fread(setaramdata, 1, 4096, fp); } // SETA sram
if (SPC7110Enable) { fseek(fp, PHnum2writespc7110reg + 65536, SEEK_CUR); }
fseek(fp, 227, SEEK_CUR);
if (ramsize) { fread(sram, 1, ramsize, fp); } // normal sram
}
void stateloader (unsigned char *statename, unsigned char keycheck, unsigned char xfercheck)
{
#ifdef __LINUX__
SRAMChdir();
#endif
if (keycheck)
{
unsigned char statevalue;
pressed[1] = 0;
pressed[KeyLoadState] = 2;
multchange = 1;
//Get the state number
if (fnamest[statefileloc] == 't')
{
statevalue = '0';
}
else
{
statevalue = fnamest[statefileloc];
}
txtloadmsg[6] = statevalue;
txtconvmsg[6] = statevalue;
txtnfndmsg[21] = statevalue;
}
switch (MovieProcessing)
{
bool mzt_load(char *, bool);
case 1:
if (mzt_load(statename, true))
{
Msgptr = "RR STATE LOADED.";
MessageOn = MsgCount;
}
return;
case 2:
if (mzt_load(statename, false))
{
Msgptr = "CHAPTER LOADED.";
MessageOn = MsgCount;
}
return;
}
clim();
//Actual state loading code
if ((fhandle = fopen(statename,"rb")) != NULL)
{
if (xfercheck) { Totalbyteloaded = 0; }
if (zst_load(fhandle))
{
Msgptr = txtloadmsg; // 'STATE X LOADED.'
}
else
{
Msgptr = txtconvmsg; // 'STATE X TOO OLD.'
}
fclose(fhandle);
}
else
{
Msgptr = txtnfndmsg; // 'UNABLE TO LOAD STATE X.'
}
stim();
if (keycheck)
{
MessageOn = MsgCount;
}
}
void debugloadstate()
{
stateloader(fnamest+1, 0, 0);
}
void loadstate()
{
stateloader(fnamest+1, 1, 0);
}
void loadstate2()
{
stateloader(fnamest+1, 0, 1);
}
extern unsigned char Netfname[11];
void loadstate3()
{
stateloader(Netfname, 0, 1);
}
Reference in New Issue View Git Blame Copy Permalink