libretro/beetle-psx-libretro
1
0
Fork 0
mirror of https://github.com/libretro/beetle-psx-libretro.git synced 2025-02-12 12:38:55 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

Upgrade to 0.9.36 - enable savestating by default - NOTE: read comment by

Browse Source 
Ryphecha in the code - "Save states will destroy your saved game/memory card data if you're careless, and that will make clobber sad. Poor clobber."
This commit is contained in:
twinaphex 2014-06-19 17:53:44 +02:00
parent b400c0e589
commit 4efa3be0de
19 changed files with 2198 additions and 1639 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

38
libretro.cpp
View File

@ -1721,7 +1721,13 @@ static void SetInput(int port, const char *type, void *ptr)
static int StateAction(StateMem *sm, int load, int data_only)
{
return(0);
#if 0
if(!MDFN_GetSettingB("psx.clobbers_lament"))
{
return(0);
}
#endif
SFORMAT StateRegs[] =
{
SFVAR(CD_TrayOpen),
@ -1742,6 +1748,9 @@ static int StateAction(StateMem *sm, int load, int data_only)
// Call SetDisc() BEFORE we load CDC state, since SetDisc() has emulation side effects. We might want to clean this up in the future.
if(load)
{
if(CD_SelectedDisc >= (int)cdifs->size())
CD_SelectedDisc = -1;
CDC->SetDisc(CD_TrayOpen, (CD_SelectedDisc >= 0 && !CD_TrayOpen) ? (*cdifs)[CD_SelectedDisc] : NULL,
(CD_SelectedDisc >= 0 && !CD_TrayOpen) ? cdifs_scex_ids[CD_SelectedDisc] : NULL);
}
@ -1751,15 +1760,14 @@ static int StateAction(StateMem *sm, int load, int data_only)
ret &= CPU->StateAction(sm, load, data_only);
ret &= DMA_StateAction(sm, load, data_only);
ret &= TIMER_StateAction(sm, load, data_only);
ret &= CDC->StateAction(sm, load, data_only);
ret &= SIO_StateAction(sm, load, data_only);
ret &= CDC->StateAction(sm, load, data_only);
ret &= MDEC_StateAction(sm, load, data_only);
ret &= GPU->StateAction(sm, load, data_only);
ret &= SPU->StateAction(sm, load, data_only);
// These need some work still:
//ret &= MDEC_StateAction(sm, load, data_only);
//ret &= SPU->StateAction(sm, load, data_only);
ret &= FIO->StateAction(sm, load, data_only);
//ret &= SIO_StateAction(sm, load, data_only);
//ret &= GPU->StateAction(sm, load, data_only);
//// End needing work
ret &= IRQ_StateAction(sm, load, data_only); // Do it last.
@ -1913,6 +1921,8 @@ static MDFNSetting PSXSettings[] =
{ "psx.dbg_level", MDFNSF_NOFLAGS, gettext_noop("Debug printf verbosity level."), NULL, MDFNST_UINT, "0", "0", "4" },
#endif
{ "psx.clobbers_lament", MDFNSF_NOFLAGS, gettext_noop("Enable experimental save state functionality."), gettext_noop("Save states will destroy your saved game/memory card data if you're careless, and that will make clobber sad. Poor clobber."), MDFNST_BOOL, "0" },
{ NULL },
};
@ -2021,7 +2031,7 @@ static Deinterlacer deint;
#define MEDNAFEN_CORE_NAME_MODULE "psx"
#define MEDNAFEN_CORE_NAME "Mednafen PSX"
#define MEDNAFEN_CORE_VERSION "v0.9.35.1"
#define MEDNAFEN_CORE_VERSION "v0.9.36"
#define MEDNAFEN_CORE_EXTENSIONS "cue|toc|m3u|ccd"
#define MEDNAFEN_CORE_GEOMETRY_BASE_W 320
#define MEDNAFEN_CORE_GEOMETRY_BASE_H 240
@ -3039,16 +3049,6 @@ static size_t serialize_size;
size_t retro_serialize_size(void)
{
//if (serialize_size)
// return serialize_size;
if (!StateAction)
{
if (log_cb)
log_cb(RETRO_LOG_WARN, "[mednafen]: Module doesn't support save states.\n");
return 0;
}
StateMem st;
memset(&st, 0, sizeof(st));

33
mednafen/cdrom/SimpleFIFO.h
View File

@ -27,6 +27,39 @@ class SimpleFIFO
}
INLINE void SaveStatePostLoad(void)
{
read_pos %= data.size();
write_pos %= data.size();
in_count %= (data.size() + 1);
}
#if 0
INLINE int StateAction(StateMem *sm, int load, int data_only, const char* sname)
{
SFORMAT StateRegs[] =
{
std::vector<T> data;
uint32 size;
SFVAR(read_pos),
SFVAR(write_pos),
SFVAR(in_count),
SFEND;
}
int ret = MDFNSS_StateAction(sm, load, data_only, sname);
if(load)
{
read_pos %= data.size();
write_pos %= data.size();
in_count %= (data.size() + 1);
}
return(ret);
}
#endif
INLINE uint32 CanRead(void)
{
return(in_count);

3
mednafen/psx/cdc.cpp
View File

@ -329,7 +329,8 @@ int PS_CDC::StateAction(StateMem *sm, int load, int data_only)
if(load)
{
DMABuffer.SaveStatePostLoad();
SectorPipe_Pos %= SectorPipe_Count;
}
return(ret);
}

12
mednafen/psx/dma.cpp
View File

@ -233,7 +233,7 @@ static void RecalcHalt(void)
}
static INLINE void ChRW(const unsigned ch, const uint32_t CRModeCache, uint32_t *V)
static INLINE void ChRW(const unsigned ch, const uint32_t CRModeCache, uint32_t *V, int32_t *offset)
{
unsigned extra_cyc_overhead = 0;
@ -255,7 +255,7 @@ static INLINE void ChRW(const unsigned ch, const uint32_t CRModeCache, uint32_t
{
}
else
*V = MDEC_DMARead();
*V = MDEC_DMARead(offset);
break;
case CH_GPU:
@ -419,6 +419,7 @@ static INLINE void RunChannelI(const unsigned ch, const uint32_t CRModeCache, in
//
{
uint32_t vtmp;
int32_t voffs = 0;
if(MDFN_UNLIKELY(DMACH[ch].CurAddr & 0x800000))
{
@ -431,10 +432,10 @@ static INLINE void RunChannelI(const unsigned ch, const uint32_t CRModeCache, in
if(CRModeCache & 0x1)
vtmp = MainRAM.ReadU32(DMACH[ch].CurAddr & 0x1FFFFC);
ChRW(ch, CRModeCache, &vtmp);
ChRW(ch, CRModeCache, &vtmp, &voffs);
if(!(CRModeCache & 0x1))
MainRAM.WriteU32(DMACH[ch].CurAddr & 0x1FFFFC, vtmp);
MainRAM.WriteU32((DMACH[ch].CurAddr + (voffs << 2)) & 0x1FFFFC, vtmp);
}
if(CRModeCache & 0x2)
@ -687,7 +688,8 @@ void DMA_Write(const pscpu_timestamp_t timestamp, uint32_t A, uint32_t V)
if(!(OldCC & (1 << 24)) && (V & (1 << 24)))
{
//PSX_WARNING("[DMA] Started DMA for channel=%d --- CHCR=0x%08x --- BCR=0x%08x --- scanline=%d", ch, DMACH[ch].ChanControl, DMACH[ch].BlockControl, GPU->GetScanlineNum());
//if(ch == 0 || ch == 1)
// PSX_WARNING("[DMA] Started DMA for channel=%d --- CHCR=0x%08x --- BCR=0x%08x --- scanline=%d", ch, DMACH[ch].ChanControl, DMACH[ch].BlockControl, GPU->GetScanlineNum());
DMACH[ch].WordCounter = 0;
DMACH[ch].ClockCounter = 0;

16
mednafen/psx/frontio.cpp
View File

@ -149,13 +149,10 @@ int FrontIO::StateAction(StateMem* sm, int load, int data_only)
SFVAR(istatus),
// FIXME:
#if 0
pscpu_timestamp_t irq10_pulse_ts[2];
int32 dsr_pulse_delay[4];
int32 dsr_active_until_ts[4];
#endif
// FIXME: Step mode save states.
SFARRAY32(irq10_pulse_ts, sizeof(irq10_pulse_ts) / sizeof(irq10_pulse_ts[0])),
SFARRAY32(dsr_pulse_delay, sizeof(dsr_pulse_delay) / sizeof(dsr_pulse_delay[0])),
SFARRAY32(dsr_active_until_ts, sizeof(dsr_active_until_ts) / sizeof(dsr_active_until_ts[0])),
SFEND
};
@ -186,6 +183,11 @@ int FrontIO::StateAction(StateMem* sm, int load, int data_only)
ret &= DevicesTap[i]->StateAction(sm, load, data_only, tmpbuf);
}
if(load)
{
IRQ_Assert(IRQ_SIO, istatus);
}
return(ret);
}

115
mednafen/psx/gpu.cpp
View File

@ -1538,4 +1538,119 @@ void PS_GPU::StartFrame(EmulateSpecStruct *espec_arg)
LineWidths = espec->LineWidths;
}
int PS_GPU::StateAction(StateMem *sm, int load, int data_only)
{
SFORMAT StateRegs[] =
{
SFARRAY16(&GPURAM[0][0], sizeof(GPURAM) / sizeof(GPURAM[0][0])),
SFVAR(DMAControl),
SFVAR(ClipX0),
SFVAR(ClipY0),
SFVAR(ClipX1),
SFVAR(ClipY1),
SFVAR(OffsX),
SFVAR(OffsY),
SFVAR(dtd),
SFVAR(dfe),
SFVAR(MaskSetOR),
SFVAR(MaskEvalAND),
SFVAR(tww),
SFVAR(twh),
SFVAR(twx),
SFVAR(twy),
SFVAR(TexPageX),
SFVAR(TexPageY),
SFVAR(SpriteFlip),
SFVAR(abr),
SFVAR(TexMode),
SFARRAY32(&BlitterFIFO.data[0], BlitterFIFO.data.size()),
SFVAR(BlitterFIFO.read_pos),
SFVAR(BlitterFIFO.write_pos),
SFVAR(BlitterFIFO.in_count),
SFVAR(DataReadBuffer),
SFVAR(IRQPending),
SFVAR(InCmd),
SFVAR(InCmd_CC),
#define TVHELPER(n) SFVAR(n.x), SFVAR(n.y), SFVAR(n.u), SFVAR(n.v), SFVAR(n.r), SFVAR(n.g), SFVAR(n.b)
TVHELPER(InQuad_F3Vertices[0]),
TVHELPER(InQuad_F3Vertices[1]),
TVHELPER(InQuad_F3Vertices[2]),
#undef TVHELPER
SFVAR(InQuad_clut),
SFVAR(InPLine_PrevPoint.x),
SFVAR(InPLine_PrevPoint.y),
SFVAR(InPLine_PrevPoint.r),
SFVAR(InPLine_PrevPoint.g),
SFVAR(InPLine_PrevPoint.b),
SFVAR(FBRW_X),
SFVAR(FBRW_Y),
SFVAR(FBRW_W),
SFVAR(FBRW_H),
SFVAR(FBRW_CurY),
SFVAR(FBRW_CurX),
SFVAR(DisplayMode),
SFVAR(DisplayOff),
SFVAR(DisplayFB_XStart),
SFVAR(DisplayFB_YStart),
SFVAR(HorizStart),
SFVAR(HorizEnd),
SFVAR(VertStart),
SFVAR(VertEnd),
SFVAR(DisplayFB_CurYOffset),
SFVAR(DisplayFB_CurLineYReadout),
SFVAR(InVBlank),
SFVAR(LinesPerField),
SFVAR(scanline),
SFVAR(field),
SFVAR(field_ram_readout),
SFVAR(PhaseChange),
SFVAR(DotClockCounter),
SFVAR(GPUClockCounter),
SFVAR(LineClockCounter),
SFVAR(LinePhase),
SFVAR(DrawTimeAvail),
SFEND
};
int ret = MDFNSS_StateAction(sm, load, data_only, StateRegs, "GPU");
if(load)
{
RecalcTexWindowLUT();
BlitterFIFO.SaveStatePostLoad();
HorizStart &= 0xFFF;
HorizEnd &= 0xFFF;
IRQ_Assert(IRQ_GPU, IRQPending);
}
return(ret);
}
}

2
mednafen/psx/gpu.h
View File

@ -46,6 +46,8 @@ class PS_GPU
void Power(void) MDFN_COLD;
int StateAction(StateMem *sm, int load, int data_only);
void ResetTS(void);
void StartFrame(EmulateSpecStruct *espec);

47
mednafen/psx/input/guncon.cpp
View File

@ -30,6 +30,7 @@ class InputDevice_GunCon : public InputDevice
virtual ~InputDevice_GunCon();
virtual void Power(void);
virtual int StateAction(StateMem* sm, int load, int data_only, const char* section_name);
virtual void UpdateInput(const void *data);
virtual bool RequireNoFrameskip(void);
virtual pscpu_timestamp_t GPULineHook(const pscpu_timestamp_t line_timestamp, bool vsync, uint32 *pixels, const MDFN_PixelFormat* const format, const unsigned width, const unsigned pix_clock_offset, const unsigned pix_clock, const unsigned pix_clock_divider);
@ -113,6 +114,52 @@ void InputDevice_GunCon::Power(void)
line_counter = 0;
}
int InputDevice_GunCon::StateAction(StateMem* sm, int load, int data_only, const char* section_name)
{
SFORMAT StateRegs[] =
{
SFVAR(dtr),
SFVAR(buttons),
SFVAR(trigger_eff),
SFVAR(trigger_noclear),
SFVAR(hit_x),
SFVAR(hit_y),
SFVAR(nom_x),
SFVAR(nom_y),
SFVAR(os_shot_counter),
SFVAR(prev_oss),
SFVAR(command_phase),
SFVAR(bitpos),
SFVAR(receive_buffer),
SFVAR(command),
SFARRAY(transmit_buffer, sizeof(transmit_buffer)),
SFVAR(transmit_pos),
SFVAR(transmit_count),
SFVAR(prev_vsync),
SFVAR(line_counter),
SFEND
};
int ret = MDFNSS_StateAction(sm, load, data_only, StateRegs, section_name);
if(load)
{
if((transmit_pos + transmit_count) > sizeof(transmit_buffer))
{
transmit_pos = 0;
transmit_count = 0;
}
}
return(ret);
}
void InputDevice_GunCon::UpdateInput(const void *data)
{
uint8 *d8 = (uint8 *)data;

47
mednafen/psx/input/justifier.cpp
View File

@ -30,6 +30,7 @@ class InputDevice_Justifier : public InputDevice
virtual ~InputDevice_Justifier();
virtual void Power(void);
virtual int StateAction(StateMem* sm, int load, int data_only, const char* section_name);
virtual void UpdateInput(const void *data);
virtual bool RequireNoFrameskip(void);
virtual pscpu_timestamp_t GPULineHook(const pscpu_timestamp_t timestamp, bool vsync, uint32 *pixels, const MDFN_PixelFormat* const format, const unsigned width, const unsigned pix_clock_offset, const unsigned pix_clock, const unsigned pix_clock_divider);
@ -135,6 +136,52 @@ void InputDevice_Justifier::UpdateInput(const void *data)
prev_oss = d8[4] & 0x8;
}
int InputDevice_Justifier::StateAction(StateMem* sm, int load, int data_only, const char* section_name)
{
SFORMAT StateRegs[] =
{
SFVAR(dtr),
SFVAR(buttons),
SFVAR(trigger_eff),
SFVAR(trigger_noclear),
SFVAR(need_hit_detect),
SFVAR(nom_x),
SFVAR(nom_y),
SFVAR(os_shot_counter),
SFVAR(prev_oss),
SFVAR(command_phase),
SFVAR(bitpos),
SFVAR(receive_buffer),
SFVAR(command),
SFARRAY(transmit_buffer, sizeof(transmit_buffer)),
SFVAR(transmit_pos),
SFVAR(transmit_count),
SFVAR(prev_vsync),
SFVAR(line_counter),
SFEND
};
int ret = MDFNSS_StateAction(sm, load, data_only, StateRegs, section_name);
if(load)
{
if((transmit_pos + transmit_count) > sizeof(transmit_buffer))
{
transmit_pos = 0;
transmit_count = 0;
}
}
return(ret);
}
bool InputDevice_Justifier::RequireNoFrameskip(void)
{
return(true);

113
mednafen/psx/input/memcard.cpp
View File

@ -53,12 +53,26 @@ class InputDevice_Memcard : public InputDevice
private:
void Format(void);
bool presence_new;
uint8 card_data[1 << 17];
uint8 rw_buffer[128];
uint8 write_xor;
//
// Used to avoid saving unused memory cards' card data in save states.
// Set to false on object initialization, set to true when data is written to card_data that differs
// from existing data(either from loading a memory card saved to disk, or from a game writing to the memory card).
//
// Save and load its state to/from save states.
//
bool data_used;
//
// Do not save dirty_count in save states!
//
uint64 dirty_count;
bool dtr;
@ -74,38 +88,43 @@ class InputDevice_Memcard : public InputDevice
uint32 transmit_count;
};
void InputDevice_Memcard::Format(void)
{
memset(card_data, 0x00, sizeof(card_data));
card_data[0x00] = 0x4D;
card_data[0x01] = 0x43;
card_data[0x7F] = 0x0E;
for(unsigned int A = 0x80; A < 0x800; A += 0x80)
{
card_data[A + 0x00] = 0xA0;
card_data[A + 0x08] = 0xFF;
card_data[A + 0x09] = 0xFF;
card_data[A + 0x7F] = 0xA0;
}
for(unsigned int A = 0x0800; A < 0x1200; A += 0x80)
{
card_data[A + 0x00] = 0xFF;
card_data[A + 0x01] = 0xFF;
card_data[A + 0x02] = 0xFF;
card_data[A + 0x03] = 0xFF;
card_data[A + 0x08] = 0xFF;
card_data[A + 0x09] = 0xFF;
}
}
InputDevice_Memcard::InputDevice_Memcard()
{
Power();
data_used = false;
dirty_count = 0;
// Init memcard as formatted.
assert(sizeof(card_data) == (1 << 17));
memset(card_data, 0x00, sizeof(card_data));
card_data[0x00] = 0x4D;
card_data[0x01] = 0x43;
card_data[0x7F] = 0x0E;
for(unsigned int A = 0x80; A < 0x800; A += 0x80)
{
card_data[A + 0x00] = 0xA0;
card_data[A + 0x08] = 0xFF;
card_data[A + 0x09] = 0xFF;
card_data[A + 0x7F] = 0xA0;
}
for(unsigned int A = 0x0800; A < 0x1200; A += 0x80)
{
card_data[A + 0x00] = 0xFF;
card_data[A + 0x01] = 0xFF;
card_data[A + 0x02] = 0xFF;
card_data[A + 0x03] = 0xFF;
card_data[A + 0x08] = 0xFF;
card_data[A + 0x09] = 0xFF;
}
Format();
}
InputDevice_Memcard::~InputDevice_Memcard()
@ -143,7 +162,6 @@ int InputDevice_Memcard::StateAction(StateMem* sm, int load, int data_only, cons
{
SFVAR(presence_new),
SFARRAY(card_data, sizeof(card_data)),
SFARRAY(rw_buffer, sizeof(rw_buffer)),
SFVAR(write_xor),
@ -159,14 +177,41 @@ int InputDevice_Memcard::StateAction(StateMem* sm, int load, int data_only, cons
SFVAR(transmit_buffer),
SFVAR(transmit_count),
SFVAR(data_used),
SFEND
};
int ret = MDFNSS_StateAction(sm, load, data_only, StateRegs, section_name);
if(load)
SFORMAT CD_StateRegs[] =
{
dirty_count++;
SFARRAY(card_data, sizeof(card_data)),
SFEND
};
int ret = 1;
if(MDFNSS_StateAction(sm, load, data_only, StateRegs, section_name) != 0)
{
//printf("%s data_used=%d\n", section_name, data_used);
if(data_used)
{
std::string tmp_name = std::string(section_name) + "_DT";
ret &= MDFNSS_StateAction(sm, load, data_only, CD_StateRegs, tmp_name.c_str());
}
if(load)
{
if(data_used)
dirty_count++;
else
{
//printf("Format: %s\n", section_name);
Format();
}
}
}
else
ret = 0;
return(ret);
}
@ -417,6 +462,7 @@ bool InputDevice_Memcard::Clock(bool TxD, int32 &dsr_pulse_delay)
{
memcpy(&card_data[addr << 7], rw_buffer, 128);
dirty_count++;
data_used = true;
}
}
@ -461,13 +507,18 @@ void InputDevice_Memcard::ReadNV(uint8 *buffer, uint32 offset, uint32 size)
void InputDevice_Memcard::WriteNV(const uint8 *buffer, uint32 offset, uint32 size)
{
if(size)
{
dirty_count++;
}
while(size--)
{
card_data[offset & (sizeof(card_data) - 1)] = *buffer;
buffer++;
offset++;
if(card_data[offset & (sizeof(card_data) - 1)] != *buffer)
data_used = true;
card_data[offset & (sizeof(card_data) - 1)] = *buffer;
buffer++;
offset++;
}
}

40
mednafen/psx/input/mouse.cpp
View File

@ -13,6 +13,7 @@ class InputDevice_Mouse : public InputDevice
virtual ~InputDevice_Mouse();
virtual void Power(void);
virtual int StateAction(StateMem* sm, int load, int data_only, const char* section_name);
virtual void UpdateInput(const void *data);
virtual void Update(const pscpu_timestamp_t timestamp);
@ -105,6 +106,45 @@ void InputDevice_Mouse::Power(void)
transmit_count = 0;
}
int InputDevice_Mouse::StateAction(StateMem* sm, int load, int data_only, const char* section_name)
{
SFORMAT StateRegs[] =
{
SFVAR(clear_timeout),
SFVAR(dtr),
SFVAR(button),
SFVAR(button_post_mask),
SFVAR(accum_xdelta),
SFVAR(accum_ydelta),
SFVAR(command_phase),
SFVAR(bitpos),
SFVAR(receive_buffer),
SFVAR(command),
SFARRAY(transmit_buffer, sizeof(transmit_buffer)),
SFVAR(transmit_pos),
SFVAR(transmit_count),
SFEND
};
int ret = MDFNSS_StateAction(sm, load, data_only, StateRegs, section_name);
if(load)
{
if((transmit_pos + transmit_count) > sizeof(transmit_buffer))
{
transmit_pos = 0;
transmit_count = 0;
}
}
return(ret);
}
void InputDevice_Mouse::UpdateInput(const void *data)
{
accum_xdelta += (int32)MDFN_de32lsb((uint8*)data + 0);

36
mednafen/psx/input/multitap.cpp
View File

@ -144,6 +144,42 @@ void InputDevice_Multitap::Power(void)
}
}
int InputDevice_Multitap::StateAction(StateMem* sm, int load, int data_only, const char* section_name)
{
SFORMAT StateRegs[] =
{
SFVAR(dtr),
SFVAR(selected_device),
SFVAR(full_mode_setting),
SFVAR(full_mode),
SFVAR(mc_mode),
SFVAR(fm_dp),
SFARRAY(&fm_buffer[0][0], sizeof(fm_buffer) / sizeof(fm_buffer[0][0])),
SFVAR(fm_deferred_error_temp),
SFVAR(fm_deferred_error),
SFVAR(fm_command_error),
SFVAR(command),
SFVAR(receive_buffer),
SFVAR(bit_counter),
SFVAR(byte_counter),
SFEND
};
int ret = MDFNSS_StateAction(sm, load, data_only, StateRegs, section_name);
if(load)
{
}
return(ret);
}
void InputDevice_Multitap::SetDTR(bool new_dtr)
{
bool old_dtr = dtr;

1
mednafen/psx/input/multitap.h
View File

@ -11,6 +11,7 @@ class InputDevice_Multitap : public InputDevice
InputDevice_Multitap();
virtual ~InputDevice_Multitap();
virtual void Power(void);
virtual int StateAction(StateMem* sm, int load, int data_only, const char* section_name);
void SetSubDevice(unsigned int sub_index, InputDevice *device, InputDevice *mc_device);

1153
mednafen/psx/mdec.cpp
View File

File diff suppressed because it is too large Load Diff

2
mednafen/psx/mdec.h
View File

@ -6,7 +6,7 @@ namespace MDFN_IEN_PSX
void MDEC_DMAWrite(uint32_t V);
uint32_t MDEC_DMARead(void);
uint32_t MDEC_DMARead(int32_t *offs);
void MDEC_Write(const pscpu_timestamp_t timestamp, uint32_t A, uint32_t V);
uint32_t MDEC_Read(const pscpu_timestamp_t timestamp, uint32_t A);

22
mednafen/psx/sio.cpp
View File

@ -103,4 +103,26 @@ void SIO_Write(pscpu_timestamp_t timestamp, uint32_t A, uint32_t V)
}
}
int SIO_StateAction(StateMem *sm, int load, int data_only)
{
SFORMAT StateRegs[] =
{
SFVAR(Status),
SFVAR(Mode),
SFVAR(Control),
SFVAR(BaudRate),
SFVAR(DataBuffer),
SFEND
};
int ret = MDFNSS_StateAction(sm, load, data_only, StateRegs, "SIO");
if(load)
{
}
return(ret);
}
}

2
mednafen/psx/sio.h
View File

@ -8,6 +8,8 @@ void SIO_Write(pscpu_timestamp_t timestamp, uint32_t A, uint32_t V);
uint32_t SIO_Read(pscpu_timestamp_t timestamp, uint32_t A);
void SIO_Power(void);
int SIO_StateAction(StateMem *sm, int load, int data_only);
}
#endif

2136
mednafen/psx/spu.cpp
View File

File diff suppressed because it is too large Load Diff

19
mednafen/psx/spu.h
View File

@ -58,22 +58,31 @@ class SPU_Sweep
private:
uint16_t Control;
int16 Current;
uint16_t Current;
uint32_t Divider;
};
struct SPU_Voice
{
int32_t DecodeBuffer[32 + 4]; // + 4 so we don't have to do & 0x1F in our MAC
int32_t DecodeWritePos;
int16 DecodeBuffer[0x20];
int16 DecodeM2;
int16 DecodeM1;
uint32 DecodePlayDelay;
uint32 DecodeWritePos;
uint32 DecodeReadPos;
uint32 DecodeAvail;
bool IgnoreSampLA;
uint8 DecodeShift;
uint8 DecodeWeight;
uint8_t DecodeFlags;
SPU_Sweep Sweep[2];
uint16_t Pitch;
uint32_t CurPhase;
int32_t CurPhase_SD; // Offseted compared to CurPhase, used for triggering sample decode.
uint32_t StartAddr;
@ -116,7 +125,7 @@ class PS_SPU
void WriteSPURAM(uint32_t addr, uint16_t value);
uint16_t ReadSPURAM(uint32_t addr);
void DecodeSamples(SPU_Voice *voice);
void RunDecoder(SPU_Voice *voice);
void CacheEnvelope(SPU_Voice *voice);
void ResetEnvelope(SPU_Voice *voice);