ShuriZma
/
pcsx2
mirror of https://github.com/PCSX2/pcsx2.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

SaveState: Use enum for freeze mode 

Instead of preprocessor defines.
This commit is contained in:
Ziemas 2021-07-06 08:08:18 +02:00 committed by lightningterror
parent 4f50e7e478
commit 3ba2ae0275
32 changed files with 104 additions and 98 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
pcsx2/GS.h
View File

@ -366,7 +366,7 @@ public:
void SendDataPacket(); void SendDataPacket();
void SendGameCRC( u32 crc ); void SendGameCRC( u32 crc );
void WaitForOpen(); void WaitForOpen();
void Freeze( int mode, MTGS_FreezeData& data ); void Freeze( FreezeAction mode, MTGS_FreezeData& data );
void SendSimpleGSPacket( MTGS_RingCommand type, u32 offset, u32 size, GIF_PATH path ); void SendSimpleGSPacket( MTGS_RingCommand type, u32 offset, u32 size, GIF_PATH path );
void SendSimplePacket( MTGS_RingCommand type, int data0, int data1, int data2 ); void SendSimplePacket( MTGS_RingCommand type, int data0, int data1, int data2 );

10
pcsx2/GS/GS.cpp
View File

@ -675,19 +675,19 @@ void GSkeyEvent(GSKeyEventData* e)
} }
} }
int GSfreeze(int mode, freezeData* data) int GSfreeze(FreezeAction mode, freezeData* data)
{ {
try try
{ {
if (mode == FREEZE_SAVE) if (mode == FreezeAction::Save)
{ {
return s_gs->Freeze(data, false); return s_gs->Freeze(data, false);
} }
else if (mode == FREEZE_SIZE) else if (mode == FreezeAction::Size)
{ {
return s_gs->Freeze(data, true); return s_gs->Freeze(data, true);
} }
else if (mode == FREEZE_LOAD) else if (mode == FreezeAction::Load)
{ {
return s_gs->Defrost(data); return s_gs->Defrost(data);
} }
@ -950,7 +950,7 @@ void GSReplay(char* lpszCmdLine, int renderer)
fd.data = new char[fd.size]; fd.data = new char[fd.size];
file->Read(fd.data, fd.size); file->Read(fd.data, fd.size);
GSfreeze(FREEZE_LOAD, &fd); GSfreeze(FreezeAction::Load, &fd);
delete[] fd.data; delete[] fd.data;
file->Read(regs, 0x2000); file->Read(regs, 0x2000);

2
pcsx2/GS/GS.h
View File

@ -1805,7 +1805,7 @@ void GSgifTransfer3(uint8* mem, uint32 size);
void GSvsync(int field); void GSvsync(int field);
uint32 GSmakeSnapshot(char* path); uint32 GSmakeSnapshot(char* path);
void GSkeyEvent(GSKeyEventData* e); void GSkeyEvent(GSKeyEventData* e);
int GSfreeze(int mode, freezeData* data); int GSfreeze(FreezeAction mode, freezeData* data);
void GSconfigure(); void GSconfigure();
int GStest(); int GStest();
void GSirqCallback(void (*irq)()); void GSirqCallback(void (*irq)());

6
pcsx2/MTGS.cpp
View File

@ -501,7 +501,7 @@ void SysMtgsThread::ExecuteTaskInThread()
{ {
MTGS_FreezeData* data = (MTGS_FreezeData*)tag.pointer; MTGS_FreezeData* data = (MTGS_FreezeData*)tag.pointer;
int mode = tag.data[0]; int mode = tag.data[0];
data->retval = GSfreeze(mode, (freezeData*)data->fdata); data->retval = GSfreeze((FreezeAction)mode, (freezeData*)data->fdata);
} }
break; break;
@ -927,10 +927,10 @@ void SysMtgsThread::WaitForOpen()
RethrowException(); RethrowException();
} }
void SysMtgsThread::Freeze(int mode, MTGS_FreezeData& data) void SysMtgsThread::Freeze(FreezeAction mode, MTGS_FreezeData& data)
{ {
pxAssertDev(!IsSelf(), "This method is only allowed from threads *not* named MTGS."); pxAssertDev(!IsSelf(), "This method is only allowed from threads *not* named MTGS.");
SendPointerPacket(GS_RINGTYPE_FREEZE, mode, &data); SendPointerPacket(GS_RINGTYPE_FREEZE, (int)mode, &data);
// make sure MTGS is processing the packet we send it // make sure MTGS is processing the packet we send it
Resume(); Resume();
// we are forced to wait for the semaphore to be released, otherwise // we are forced to wait for the semaphore to be released, otherwise

8
pcsx2/PAD/Linux/PAD.cpp
View File

@ -151,16 +151,16 @@ s32 PADsetSlot(u8 port, u8 slot)
return 1; return 1;
} }
s32 PADfreeze(int mode, freezeData* data) s32 PADfreeze(FreezeAction mode, freezeData* data)
{ {
if (!data) if (!data)
return -1; return -1;
if (mode == FREEZE_SIZE) if (mode == FreezeAction::Size)
{ {
data->size = sizeof(PadFullFreezeData); data->size = sizeof(PadFullFreezeData);
} }
else if (mode == FREEZE_LOAD) else if (mode == FreezeAction::Load)
{ {
PadFullFreezeData* pdata = (PadFullFreezeData*)(data->data); PadFullFreezeData* pdata = (PadFullFreezeData*)(data->data);
@ -196,7 +196,7 @@ s32 PADfreeze(int mode, freezeData* data)
slots[port] = pdata->slot[port]; slots[port] = pdata->slot[port];
} }
} }
else if (mode == FREEZE_SAVE) else if (mode == FreezeAction::Save)
{ {
if (data->size != sizeof(PadFullFreezeData)) if (data->size != sizeof(PadFullFreezeData))
return 0; return 0;

2
pcsx2/PAD/Linux/PAD.h
View File

@ -47,7 +47,7 @@ s32 PADopen(void* pDsp);
void PADsetLogDir(const char* dir); void PADsetLogDir(const char* dir);
void PADclose(); void PADclose();
s32 PADsetSlot(u8 port, u8 slot); s32 PADsetSlot(u8 port, u8 slot);
s32 PADfreeze(int mode, freezeData* data); s32 PADfreeze(FreezeAction mode, freezeData* data);
u8 PADstartPoll(int pad); u8 PADstartPoll(int pad);
u8 PADpoll(u8 value); u8 PADpoll(u8 value);
keyEvent* PADkeyEvent(); keyEvent* PADkeyEvent();

8
pcsx2/PAD/Windows/PAD.cpp
View File

@ -1567,7 +1567,7 @@ struct PadFullFreezeData
QueryInfo query; QueryInfo query;
}; };
s32 PADfreeze(int mode, freezeData* data) s32 PADfreeze(FreezeAction mode, freezeData* data)
{ {
if (!data) if (!data)
{ {
@ -1575,11 +1575,11 @@ s32 PADfreeze(int mode, freezeData* data)
return -1; return -1;
} }
if (mode == FREEZE_SIZE) if (mode == FreezeAction::Size)
{ {
data->size = sizeof(PadFullFreezeData); data->size = sizeof(PadFullFreezeData);
} }
else if (mode == FREEZE_LOAD) else if (mode == FreezeAction::Load)
{ {
PadFullFreezeData& pdata = *(PadFullFreezeData*)(data->data); PadFullFreezeData& pdata = *(PadFullFreezeData*)(data->data);
StopVibrate(); StopVibrate();
@ -1618,7 +1618,7 @@ s32 PADfreeze(int mode, freezeData* data)
slots[port] = pdata.slot[port]; slots[port] = pdata.slot[port];
} }
} }
else if (mode == FREEZE_SAVE) else if (mode == FreezeAction::Save)
{ {
if (data->size != sizeof(PadFullFreezeData)) if (data->size != sizeof(PadFullFreezeData))
return 0; return 0;

3
pcsx2/PAD/Windows/PAD.h
View File

@ -34,6 +34,7 @@
#include <queue> #include <queue>
#include "App.h" #include "App.h"
#include "SaveState.h"
typedef struct typedef struct
{ {
@ -53,6 +54,6 @@ u8 PADstartPoll(int pad);
u8 PADpoll(u8 value); u8 PADpoll(u8 value);
keyEvent* PADkeyEvent(); keyEvent* PADkeyEvent();
void PADconfigure(); void PADconfigure();
s32 PADfreeze(int mode, freezeData* data); s32 PADfreeze(FreezeAction mode, freezeData* data);
s32 PADsetSlot(u8 port, u8 slot); s32 PADsetSlot(u8 port, u8 slot);
void PADsetSettingsDir(const char* dir); void PADsetSettingsDir(const char* dir);

12
pcsx2/SPU2/spu2.cpp
View File

@ -541,7 +541,7 @@ void SPU2endRecording()
RecordStop(); RecordStop();
} }
s32 SPU2freeze(int mode, freezeData* data) s32 SPU2freeze(FreezeAction mode, freezeData* data)
{ {
pxAssume(data != nullptr); pxAssume(data != nullptr);
if (!data) if (!data)
@ -550,13 +550,13 @@ s32 SPU2freeze(int mode, freezeData* data)
return -1; return -1;
} }
if (mode == FREEZE_SIZE) if (mode == FreezeAction::Size)
{ {
data->size = SPU2Savestate::SizeIt(); data->size = SPU2Savestate::SizeIt();
return 0; return 0;
} }
pxAssume(mode == FREEZE_LOAD || mode == FREEZE_SAVE); pxAssume(mode == FreezeAction::Load || mode == FreezeAction::Save);
if (data->data == nullptr) if (data->data == nullptr)
{ {
@ -564,13 +564,13 @@ s32 SPU2freeze(int mode, freezeData* data)
return -1; return -1;
} }
SPU2Savestate::DataBlock& spud = (SPU2Savestate::DataBlock&)*(data->data); auto& spud = (SPU2Savestate::DataBlock&)*(data->data);
switch (mode) switch (mode)
{ {
case FREEZE_LOAD: case FreezeAction::Load:
return SPU2Savestate::ThawIt(spud); return SPU2Savestate::ThawIt(spud);
case FREEZE_SAVE: case FreezeAction::Save:
return SPU2Savestate::FreezeIt(spud); return SPU2Savestate::FreezeIt(spud);
jNO_DEFAULT; jNO_DEFAULT;

2
pcsx2/SPU2/spu2.h
View File

@ -36,7 +36,7 @@ bool SPU2setupRecording(const std::string* filename);
void SPU2endRecording(); void SPU2endRecording();
void SPU2async(u32 cycles); void SPU2async(u32 cycles);
s32 SPU2freeze(int mode, freezeData* data); s32 SPU2freeze(FreezeAction mode, freezeData* data);
void SPU2configure(); void SPU2configure();

11
pcsx2/SaveState.h
View File

@ -15,13 +15,16 @@
#pragma once #pragma once
#define FREEZE_LOAD 0
#define FREEZE_SAVE 1
#define FREEZE_SIZE 2
#include "System.h" #include "System.h"
#include "Utilities/Exceptions.h" #include "Utilities/Exceptions.h"
enum class FreezeAction
{
Load,
Save,
Size,
};
// Savestate Versioning! // Savestate Versioning!
// If you make changes to the savestate version, please increment the value below. // If you make changes to the savestate version, please increment the value below.
// If the change is minor and compatibility with old states is retained, increment // If the change is minor and compatibility with old states is retained, increment

16
pcsx2/USB/USB.cpp
View File

@ -341,12 +341,12 @@ void USBsetRAM(void* mem)
Reset(); Reset();
} }
s32 USBfreeze(int mode, freezeData* data) s32 USBfreeze(FreezeAction mode, freezeData* data)
{ {
USBfreezeData usbd = {0}; USBfreezeData usbd = {0};
//TODO FREEZE_SIZE mismatch causes loading to fail in PCSX2 beforehand //TODO FREEZE_SIZE mismatch causes loading to fail in PCSX2 beforehand
if (mode == FREEZE_LOAD) if (mode == FreezeAction::Load)
{ {
if ((long unsigned int)data->size < sizeof(USBfreezeData)) if ((long unsigned int)data->size < sizeof(USBfreezeData))
{ {
@ -412,7 +412,7 @@ s32 USBfreeze(int mode, freezeData* data)
if (proxy && usb_device[i]) /* usb device creation may have failed for some reason */ if (proxy && usb_device[i]) /* usb device creation may have failed for some reason */
{ {
if (proxy->Freeze(FREEZE_SIZE, usb_device[i], nullptr) != (s32)usbd.device[i].size) if (proxy->Freeze(FreezeAction::Size, usb_device[i], nullptr) != (s32)usbd.device[i].size)
{ {
Console.WriteLn(Color_Red, "USB: Port %d: device's freeze size doesn't match.", i); Console.WriteLn(Color_Red, "USB: Port %d: device's freeze size doesn't match.", i);
return -1; return -1;
@ -442,7 +442,7 @@ s32 USBfreeze(int mode, freezeData* data)
usb_desc_set_interface(usb_device[i], k, tmp.altsetting[k]); usb_desc_set_interface(usb_device[i], k, tmp.altsetting[k]);
} }
proxy->Freeze(FREEZE_LOAD, usb_device[i], ptr); proxy->Freeze(FreezeAction::Load, usb_device[i], ptr);
if (!usb_device[i]->attached) if (!usb_device[i]->attached)
{ // FIXME FREEZE_SAVE fcked up { // FIXME FREEZE_SAVE fcked up
usb_device[i]->attached = true; usb_device[i]->attached = true;
@ -496,7 +496,7 @@ s32 USBfreeze(int mode, freezeData* data)
} }
} }
//TODO straight copying of structs can break cross-platform/cross-compiler save states 'cause padding 'n' stuff //TODO straight copying of structs can break cross-platform/cross-compiler save states 'cause padding 'n' stuff
else if (mode == FREEZE_SAVE) else if (mode == FreezeAction::Save)
{ {
memset(data->data, 0, data->size); //maybe it already is... memset(data->data, 0, data->size); //maybe it already is...
RegisterDevice& regInst = RegisterDevice::instance(); RegisterDevice& regInst = RegisterDevice::instance();
@ -510,7 +510,7 @@ s32 USBfreeze(int mode, freezeData* data)
usbd.device[i].index = index; usbd.device[i].index = index;
if (proxy && usb_device[i]) if (proxy && usb_device[i])
usbd.device[i].size = proxy->Freeze(FREEZE_SIZE, usb_device[i], nullptr); usbd.device[i].size = proxy->Freeze(FreezeAction::Size, usb_device[i], nullptr);
else else
usbd.device[i].size = 0; usbd.device[i].size = 0;
@ -545,7 +545,7 @@ s32 USBfreeze(int mode, freezeData* data)
{ {
usbd.device[i].dev = *usb_device[i]; usbd.device[i].dev = *usb_device[i];
if (proxy && usbd.device[i].size) if (proxy && usbd.device[i].size)
proxy->Freeze(FREEZE_SAVE, usb_device[i], ptr); proxy->Freeze(FreezeAction::Save, usb_device[i], ptr);
} }
memset(&usbd.device[i].dev.klass, 0, sizeof(USBDeviceClass)); memset(&usbd.device[i].dev.klass, 0, sizeof(USBDeviceClass));
@ -559,7 +559,7 @@ s32 USBfreeze(int mode, freezeData* data)
*(USBfreezeData*)data->data = usbd; *(USBfreezeData*)data->data = usbd;
} }
else if (mode == FREEZE_SIZE) else if (mode == FreezeAction::Size)
{ {
data->size = 0x10000; data->size = 0x10000;
} }

2
pcsx2/USB/USB.h
View File

@ -39,7 +39,7 @@ void USBasync(u32 cycles);
void USBshutdown(); void USBshutdown();
void USBclose(); void USBclose();
s32 USBopen(void* pDsp); s32 USBopen(void* pDsp);
s32 USBfreeze(int mode, freezeData* data); s32 USBfreeze(FreezeAction mode, freezeData* data);
u8 USBread8(u32 addr); u8 USBread8(u32 addr);
u16 USBread16(u32 addr); u16 USBread16(u32 addr);

2
pcsx2/USB/USBNull.cpp
View File

@ -27,7 +27,7 @@ void USBasync(u32 cycles) {}
void USBshutdown() {} void USBshutdown() {}
void USBclose() {} void USBclose() {}
s32 USBopen(void* pDsp) { return 0; } s32 USBopen(void* pDsp) { return 0; }
s32 USBfreeze(int mode, freezeData* data) { return 0; } s32 USBfreeze(FreezeAction mode, freezeData* data) { return 0; }
u8 USBread8(u32 addr) { return 0; } u8 USBread8(u32 addr) { return 0; }
u16 USBread16(u32 addr) { return 0; } u16 USBread16(u32 addr) { return 0; }

5
pcsx2/USB/deviceproxy.h
View File

@ -26,6 +26,7 @@
#include "helpers.h" #include "helpers.h"
#include "proxybase.h" #include "proxybase.h"
#include "qemu-usb/USBinternal.h" #include "qemu-usb/USBinternal.h"
#include "SaveState.h"
void RegisterAPIs(); void RegisterAPIs();
void UnregisterAPIs(); void UnregisterAPIs();
@ -79,7 +80,7 @@ public:
virtual int Configure(int port, const std::string& api, void* data) = 0; virtual int Configure(int port, const std::string& api, void* data) = 0;
virtual std::list<std::string> ListAPIs() = 0; virtual std::list<std::string> ListAPIs() = 0;
virtual const TCHAR* LongAPIName(const std::string& name) = 0; virtual const TCHAR* LongAPIName(const std::string& name) = 0;
virtual int Freeze(int mode, USBDevice* dev, void* data) = 0; virtual int Freeze(FreezeAction mode, USBDevice* dev, void* data) = 0;
virtual std::vector<std::string> SubTypes() = 0; virtual std::vector<std::string> SubTypes() = 0;
virtual bool IsValidAPI(const std::string& api) virtual bool IsValidAPI(const std::string& api)
@ -124,7 +125,7 @@ public:
{ {
return T::LongAPIName(name); return T::LongAPIName(name);
} }
virtual int Freeze(int mode, USBDevice* dev, void* data) virtual int Freeze(FreezeAction mode, USBDevice* dev, void* data)
{ {
return T::Freeze(mode, dev, data); return T::Freeze(mode, dev, data);
} }

2
pcsx2/USB/usb-eyetoy/usb-eyetoy-webcam.cpp
View File

@ -607,7 +607,7 @@ namespace usb_eyetoy
return RESULT_CANCELED; return RESULT_CANCELED;
} }
int EyeToyWebCamDevice::Freeze(int mode, USBDevice* dev, void* data) int EyeToyWebCamDevice::Freeze(FreezeAction mode, USBDevice* dev, void* data)
{ {
/*switch (mode) /*switch (mode)
{ {

2
pcsx2/USB/usb-eyetoy/usb-eyetoy-webcam.h
View File

@ -51,7 +51,7 @@ namespace usb_eyetoy
return nullptr; return nullptr;
} }
static int Configure(int port, const std::string& api, void* data); static int Configure(int port, const std::string& api, void* data);
static int Freeze(int mode, USBDevice* dev, void* data); static int Freeze(FreezeAction mode, USBDevice* dev, void* data);
static std::vector<std::string> SubTypes() static std::vector<std::string> SubTypes()
{ {
return {}; return {};

18
pcsx2/USB/usb-hid/usb-hid.cpp
View File

@ -794,7 +794,7 @@ namespace usb_hid
return RESULT_CANCELED; return RESULT_CANCELED;
} }
int HIDKbdDevice::Freeze(int mode, USBDevice* dev, void* data) int HIDKbdDevice::Freeze(FreezeAction mode, USBDevice* dev, void* data)
{ {
auto s = reinterpret_cast<UsbHIDState*>(dev); auto s = reinterpret_cast<UsbHIDState*>(dev);
auto freezed = reinterpret_cast<UsbHIDState::freeze*>(data); auto freezed = reinterpret_cast<UsbHIDState::freeze*>(data);
@ -803,19 +803,19 @@ namespace usb_hid
return 0; return 0;
switch (mode) switch (mode)
{ {
case FREEZE_LOAD: case FreezeAction::Load:
if (!s) if (!s)
return -1; return -1;
s->f = *freezed; s->f = *freezed;
hid_init(&s->f.hid, HID_KEYBOARD, usb_hid_changed); hid_init(&s->f.hid, HID_KEYBOARD, usb_hid_changed);
return sizeof(UsbHIDState::freeze); return sizeof(UsbHIDState::freeze);
case FREEZE_SAVE: case FreezeAction::Save:
if (!s) if (!s)
return -1; return -1;
*freezed = s->f; *freezed = s->f;
return sizeof(UsbHIDState::freeze); return sizeof(UsbHIDState::freeze);
case FREEZE_SIZE: case FreezeAction::Size:
return sizeof(UsbHIDState::freeze); return sizeof(UsbHIDState::freeze);
default: default:
break; break;
@ -893,7 +893,7 @@ namespace usb_hid
return RESULT_CANCELED; return RESULT_CANCELED;
} }
int HIDMouseDevice::Freeze(int mode, USBDevice* dev, void* data) int HIDMouseDevice::Freeze(FreezeAction mode, USBDevice* dev, void* data)
{ {
auto s = reinterpret_cast<UsbHIDState*>(dev); auto s = reinterpret_cast<UsbHIDState*>(dev);
auto freezed = reinterpret_cast<UsbHIDState::freeze*>(data); auto freezed = reinterpret_cast<UsbHIDState::freeze*>(data);
@ -902,19 +902,19 @@ namespace usb_hid
return 0; return 0;
switch (mode) switch (mode)
{ {
case FREEZE_LOAD: case FreezeAction::Load:
if (!s) if (!s)
return -1; return -1;
s->f = *freezed; s->f = *freezed;
hid_init(&s->f.hid, HID_MOUSE, usb_hid_changed); hid_init(&s->f.hid, HID_MOUSE, usb_hid_changed);
return sizeof(UsbHIDState::freeze); return sizeof(UsbHIDState::freeze);
case FREEZE_SAVE: case FreezeAction::Save:
if (!s) if (!s)
return -1; return -1;
*freezed = s->f; *freezed = s->f;
return sizeof(UsbHIDState::freeze); return sizeof(UsbHIDState::freeze);
case FREEZE_SIZE: case FreezeAction::Size:
return sizeof(UsbHIDState::freeze); return sizeof(UsbHIDState::freeze);
default: default:
break; break;
@ -996,7 +996,7 @@ namespace usb_hid
return RESULT_CANCELED; return RESULT_CANCELED;
} }
int BeatManiaDevice::Freeze(int mode, USBDevice* dev, void* data) int BeatManiaDevice::Freeze(FreezeAction mode, USBDevice* dev, void* data)
{ {
return HIDKbdDevice::Freeze(mode, dev, data); return HIDKbdDevice::Freeze(mode, dev, data);
} }

7
pcsx2/USB/usb-hid/usb-hid.h
View File

@ -14,6 +14,7 @@
*/ */
#pragma once #pragma once
#include "SaveState.h"
#include "USB/configuration.h" #include "USB/configuration.h"
#include "USB/qemu-usb/hid.h" #include "USB/qemu-usb/hid.h"
#include <list> #include <list>
@ -71,7 +72,7 @@ namespace usb_hid
static std::list<std::string> ListAPIs(); static std::list<std::string> ListAPIs();
static const TCHAR* LongAPIName(const std::string& name); static const TCHAR* LongAPIName(const std::string& name);
static int Configure(int port, const std::string& api, void* data); static int Configure(int port, const std::string& api, void* data);
static int Freeze(int mode, USBDevice* dev, void* data); static int Freeze(FreezeAction mode, USBDevice* dev, void* data);
static std::vector<std::string> SubTypes() static std::vector<std::string> SubTypes()
{ {
return {}; return {};
@ -94,7 +95,7 @@ namespace usb_hid
static std::list<std::string> ListAPIs(); static std::list<std::string> ListAPIs();
static const TCHAR* LongAPIName(const std::string& name); static const TCHAR* LongAPIName(const std::string& name);
static int Configure(int port, const std::string& api, void* data); static int Configure(int port, const std::string& api, void* data);
static int Freeze(int mode, USBDevice* dev, void* data); static int Freeze(FreezeAction mode, USBDevice* dev, void* data);
static std::vector<std::string> SubTypes() static std::vector<std::string> SubTypes()
{ {
return {}; return {};
@ -117,7 +118,7 @@ namespace usb_hid
static std::list<std::string> ListAPIs(); static std::list<std::string> ListAPIs();
static const TCHAR* LongAPIName(const std::string& name); static const TCHAR* LongAPIName(const std::string& name);
static int Configure(int port, const std::string& api, void* data); static int Configure(int port, const std::string& api, void* data);
static int Freeze(int mode, USBDevice* dev, void* data); static int Freeze(FreezeAction mode, USBDevice* dev, void* data);
static std::vector<std::string> SubTypes() static std::vector<std::string> SubTypes()
{ {
return {}; return {};

8
pcsx2/USB/usb-mic/usb-headset.cpp
View File

@ -1053,24 +1053,24 @@ namespace usb_mic
return RESULT_CANCELED; return RESULT_CANCELED;
} }
int HeadsetDevice::Freeze(int mode, USBDevice* dev, void* data) int HeadsetDevice::Freeze(FreezeAction mode, USBDevice* dev, void* data)
{ {
HeadsetState* s = (HeadsetState*)dev; HeadsetState* s = (HeadsetState*)dev;
if (!s) if (!s)
return 0; return 0;
switch (mode) switch (mode)
{ {
case FREEZE_LOAD: case FreezeAction::Load:
s->f = *(HeadsetState::freeze*)data; s->f = *(HeadsetState::freeze*)data;
if (s->audsrc) if (s->audsrc)
s->audsrc->SetResampling(s->f.in.srate); s->audsrc->SetResampling(s->f.in.srate);
if (s->audsink) if (s->audsink)
s->audsink->SetResampling(s->f.out.srate); s->audsink->SetResampling(s->f.out.srate);
return sizeof(HeadsetState::freeze); return sizeof(HeadsetState::freeze);
case FREEZE_SAVE: case FreezeAction::Save:
*(HeadsetState::freeze*)data = s->f; *(HeadsetState::freeze*)data = s->f;
return sizeof(HeadsetState::freeze); return sizeof(HeadsetState::freeze);
case FREEZE_SIZE: case FreezeAction::Size:
return sizeof(HeadsetState::freeze); return sizeof(HeadsetState::freeze);
default: default:
break; break;

2
pcsx2/USB/usb-mic/usb-headset.h
View File

@ -36,7 +36,7 @@ namespace usb_mic
static std::list<std::string> ListAPIs(); static std::list<std::string> ListAPIs();
static const TCHAR* LongAPIName(const std::string& name); static const TCHAR* LongAPIName(const std::string& name);
static int Configure(int port, const std::string& api, void* data); static int Configure(int port, const std::string& api, void* data);
static int Freeze(int mode, USBDevice* dev, void* data); static int Freeze(FreezeAction mode, USBDevice* dev, void* data);
static std::vector<std::string> SubTypes() static std::vector<std::string> SubTypes()
{ {
return {}; return {};

8
pcsx2/USB/usb-mic/usb-mic-singstar.cpp
View File

@ -862,24 +862,24 @@ namespace usb_mic
return RESULT_CANCELED; return RESULT_CANCELED;
} }
int SingstarDevice::Freeze(int mode, USBDevice* dev, void* data) int SingstarDevice::Freeze(FreezeAction mode, USBDevice* dev, void* data)
{ {
SINGSTARMICState* s = (SINGSTARMICState*)dev; SINGSTARMICState* s = (SINGSTARMICState*)dev;
if (!s) if (!s)
return 0; return 0;
switch (mode) switch (mode)
{ {
case FREEZE_LOAD: case FreezeAction::Load:
s->f = *(SINGSTARMICState::freeze*)data; s->f = *(SINGSTARMICState::freeze*)data;
if (s->audsrc[0]) if (s->audsrc[0])
s->audsrc[0]->SetResampling(s->f.srate[0]); s->audsrc[0]->SetResampling(s->f.srate[0]);
if (s->audsrc[1]) if (s->audsrc[1])
s->audsrc[1]->SetResampling(s->f.srate[1]); s->audsrc[1]->SetResampling(s->f.srate[1]);
return sizeof(SINGSTARMICState::freeze); return sizeof(SINGSTARMICState::freeze);
case FREEZE_SAVE: case FreezeAction::Save:
*(SINGSTARMICState::freeze*)data = s->f; *(SINGSTARMICState::freeze*)data = s->f;
return sizeof(SINGSTARMICState::freeze); return sizeof(SINGSTARMICState::freeze);
case FREEZE_SIZE: case FreezeAction::Size:
return sizeof(SINGSTARMICState::freeze); return sizeof(SINGSTARMICState::freeze);
default: default:
break; break;

2
pcsx2/USB/usb-mic/usb-mic-singstar.h
View File

@ -48,7 +48,7 @@ namespace usb_mic
return nullptr; return nullptr;
} }
static int Configure(int port, const std::string& api, void* data); static int Configure(int port, const std::string& api, void* data);
static int Freeze(int mode, USBDevice* dev, void* data); static int Freeze(FreezeAction mode, USBDevice* dev, void* data);
static std::vector<std::string> SubTypes() static std::vector<std::string> SubTypes()
{ {
return {}; return {};

8
pcsx2/USB/usb-msd/usb-msd.cpp
View File

@ -1049,7 +1049,7 @@ namespace usb_msd
return "msd"; return "msd";
} }
int MsdDevice::Freeze(int mode, USBDevice* dev, void* data) int MsdDevice::Freeze(FreezeAction mode, USBDevice* dev, void* data)
{ {
MSDState* s = (MSDState*)dev; MSDState* s = (MSDState*)dev;
MSDState::freeze* tmp; MSDState::freeze* tmp;
@ -1058,7 +1058,7 @@ namespace usb_msd
return 0; return 0;
switch (mode) switch (mode)
{ {
case FREEZE_LOAD: case FreezeAction::Load:
//if (s->f.req) free (s->f.req); //if (s->f.req) free (s->f.req);
tmp = (MSDState::freeze*)data; tmp = (MSDState::freeze*)data;
@ -1072,12 +1072,12 @@ namespace usb_msd
usb_reattach(dev->port); usb_reattach(dev->port);
return sizeof(MSDState::freeze); // + sizeof(ReqState); return sizeof(MSDState::freeze); // + sizeof(ReqState);
case FREEZE_SAVE: case FreezeAction::Save:
tmp = (MSDState::freeze*)data; tmp = (MSDState::freeze*)data;
*tmp = s->f; *tmp = s->f;
return sizeof(MSDState::freeze); return sizeof(MSDState::freeze);
case FREEZE_SIZE: case FreezeAction::Size:
return sizeof(MSDState::freeze); // + sizeof(ReqState); return sizeof(MSDState::freeze); // + sizeof(ReqState);
default: default:
break; break;

2
pcsx2/USB/usb-msd/usb-msd.h
View File

@ -41,7 +41,7 @@ namespace usb_msd
return TEXT("cstdio"); return TEXT("cstdio");
} }
static int Configure(int port, const std::string& api, void* data); static int Configure(int port, const std::string& api, void* data);
static int Freeze(int mode, USBDevice* dev, void* data); static int Freeze(FreezeAction mode, USBDevice* dev, void* data);
static std::vector<std::string> SubTypes() static std::vector<std::string> SubTypes()
{ {
return {}; return {};

12
pcsx2/USB/usb-pad/usb-pad.cpp
View File

@ -649,7 +649,7 @@ namespace usb_pad
return RESULT_CANCELED; return RESULT_CANCELED;
} }
int PadDevice::Freeze(int mode, USBDevice* dev, void* data) int PadDevice::Freeze(FreezeAction mode, USBDevice* dev, void* data)
{ {
PADState* s = (PADState*)dev; PADState* s = (PADState*)dev;
@ -657,14 +657,14 @@ namespace usb_pad
return 0; return 0;
switch (mode) switch (mode)
{ {
case FREEZE_LOAD: case FreezeAction::Load:
s->f = *(PADState::freeze*)data; s->f = *(PADState::freeze*)data;
s->pad->Type((PS2WheelTypes)s->f.dev_subtype); s->pad->Type((PS2WheelTypes)s->f.dev_subtype);
return sizeof(PADState::freeze); return sizeof(PADState::freeze);
case FREEZE_SAVE: case FreezeAction::Save:
*(PADState::freeze*)data = s->f; *(PADState::freeze*)data = s->f;
return sizeof(PADState::freeze); return sizeof(PADState::freeze);
case FREEZE_SIZE: case FreezeAction::Size:
return sizeof(PADState::freeze); return sizeof(PADState::freeze);
default: default:
break; break;
@ -724,7 +724,7 @@ namespace usb_pad
return RESULT_CANCELED; return RESULT_CANCELED;
} }
int RBDrumKitDevice::Freeze(int mode, USBDevice* dev, void* data) int RBDrumKitDevice::Freeze(FreezeAction mode, USBDevice* dev, void* data)
{ {
return PadDevice::Freeze(mode, dev, data); return PadDevice::Freeze(mode, dev, data);
} }
@ -781,7 +781,7 @@ namespace usb_pad
return RESULT_CANCELED; return RESULT_CANCELED;
} }
int BuzzDevice::Freeze(int mode, USBDevice* dev, void* data) int BuzzDevice::Freeze(FreezeAction mode, USBDevice* dev, void* data)
{ {
return PadDevice::Freeze(mode, dev, data); return PadDevice::Freeze(mode, dev, data);
} }

8
pcsx2/USB/usb-pad/usb-pad.h
View File

@ -58,7 +58,7 @@ namespace usb_pad
static std::list<std::string> ListAPIs(); static std::list<std::string> ListAPIs();
static const TCHAR* LongAPIName(const std::string& name); static const TCHAR* LongAPIName(const std::string& name);
static int Configure(int port, const std::string& api, void* data); static int Configure(int port, const std::string& api, void* data);
static int Freeze(int mode, USBDevice* dev, void* data); static int Freeze(FreezeAction mode, USBDevice* dev, void* data);
static std::vector<std::string> SubTypes() static std::vector<std::string> SubTypes()
{ {
return {"Driving Force", "Driving Force Pro", "Driving Force Pro (rev11.02)", "GT Force"}; return {"Driving Force", "Driving Force Pro", "Driving Force Pro (rev11.02)", "GT Force"};
@ -81,7 +81,7 @@ namespace usb_pad
static std::list<std::string> ListAPIs(); static std::list<std::string> ListAPIs();
static const TCHAR* LongAPIName(const std::string& name); static const TCHAR* LongAPIName(const std::string& name);
static int Configure(int port, const std::string& api, void* data); static int Configure(int port, const std::string& api, void* data);
static int Freeze(int mode, USBDevice* dev, void* data); static int Freeze(FreezeAction mode, USBDevice* dev, void* data);
static std::vector<std::string> SubTypes() static std::vector<std::string> SubTypes()
{ {
return {}; return {};
@ -104,7 +104,7 @@ namespace usb_pad
static std::list<std::string> ListAPIs(); static std::list<std::string> ListAPIs();
static const TCHAR* LongAPIName(const std::string& name); static const TCHAR* LongAPIName(const std::string& name);
static int Configure(int port, const std::string& api, void* data); static int Configure(int port, const std::string& api, void* data);
static int Freeze(int mode, USBDevice* dev, void* data); static int Freeze(FreezeAction mode, USBDevice* dev, void* data);
static std::vector<std::string> SubTypes() static std::vector<std::string> SubTypes()
{ {
return {}; return {};
@ -127,7 +127,7 @@ namespace usb_pad
static std::list<std::string> ListAPIs(); static std::list<std::string> ListAPIs();
static const TCHAR* LongAPIName(const std::string& name); static const TCHAR* LongAPIName(const std::string& name);
static int Configure(int port, const std::string& api, void* data); static int Configure(int port, const std::string& api, void* data);
static int Freeze(int mode, USBDevice* dev, void* data); static int Freeze(FreezeAction mode, USBDevice* dev, void* data);
static std::vector<std::string> SubTypes() static std::vector<std::string> SubTypes()
{ {
return {}; return {};

2
pcsx2/USB/usb-pad/usb-seamic.cpp
View File

@ -467,7 +467,7 @@ namespace usb_pad
return RESULT_CANCELED; return RESULT_CANCELED;
} }
int SeamicDevice::Freeze(int mode, USBDevice* dev, void* data) int SeamicDevice::Freeze(FreezeAction mode, USBDevice* dev, void* data)
{ {
return 0; return 0;
// SeamicState *s = (SeamicState *)dev; // SeamicState *s = (SeamicState *)dev;

4
pcsx2/gui/Dialogs/GSDumpDialog.cpp
View File

@ -781,12 +781,12 @@ void Dialogs::GSDumpDialog::GSThread::ExecuteTaskInThread()
GSsetGameCRC((int)crc, 0); GSsetGameCRC((int)crc, 0);
if (GSfreeze(0, &fd)) if (GSfreeze(FreezeAction::Load, &fd))
GSDump::isRunning = false; GSDump::isRunning = false;
GSvsync(1); GSvsync(1);
GSreset(); GSreset();
GSsetBaseMem((u8*)regs); GSsetBaseMem((u8*)regs);
GSfreeze(0, &fd); GSfreeze(FreezeAction::Load, &fd);
size_t i = 0; size_t i = 0;
m_debug_index = 0; m_debug_index = 0;

6
pcsx2/gui/GlobalCommands.cpp
View File

@ -404,12 +404,12 @@ namespace Implementations
ScopedCoreThreadPause paused_core; ScopedCoreThreadPause paused_core;
freezeData fP = {0, nullptr}; freezeData fP = {0, nullptr};
MTGS_FreezeData sstate = {&fP, 0}; MTGS_FreezeData sstate = {&fP, 0};
GetMTGS().Freeze(FREEZE_SIZE, sstate); GetMTGS().Freeze(FreezeAction::Size, sstate);
fP.data = new char[fP.size]; fP.data = new char[fP.size];
GetMTGS().Freeze(FREEZE_SAVE, sstate); GetMTGS().Freeze(FreezeAction::Save, sstate);
GetMTGS().Suspend(true); GetMTGS().Suspend(true);
renderswitch = !renderswitch; renderswitch = !renderswitch;
GetMTGS().Freeze(FREEZE_LOAD, sstate); GetMTGS().Freeze(FreezeAction::Load, sstate);
delete[] fP.data; delete[] fP.data;
paused_core.AllowResume(); paused_core.AllowResume();
reentrant = false; reentrant = false;

6
pcsx2/gui/MainMenuClicks.cpp
View File

@ -100,15 +100,15 @@ void MainEmuFrame::Menu_GSSettings_Click(wxCommandEvent& event)
MTGS_FreezeData sstate = {&fP, 0}; MTGS_FreezeData sstate = {&fP, 0};
if (is_frame_init) if (is_frame_init)
{ {
GetMTGS().Freeze(FREEZE_SIZE, sstate); GetMTGS().Freeze(FreezeAction::Size, sstate);
fP.data = new char[fP.size]; fP.data = new char[fP.size];
GetMTGS().Freeze(FREEZE_SAVE, sstate); GetMTGS().Freeze(FreezeAction::Save, sstate);
GetMTGS().Suspend(true); GetMTGS().Suspend(true);
} }
GSconfigure(); GSconfigure();
if (is_frame_init) if (is_frame_init)
{ {
GetMTGS().Freeze(FREEZE_LOAD, sstate); GetMTGS().Freeze(FreezeAction::Load, sstate);
delete[] fP.data; delete[] fP.data;
} }
if (need_shutdown) if (need_shutdown)

14
pcsx2/gui/SysState.cpp
View File

@ -48,10 +48,10 @@ static const wxChar* EntryFilename_InternalStructures = L"PCSX2 Internal Structu
struct SysState_Component struct SysState_Component
{ {
const char* name; const char* name;
int (*freeze)(int, freezeData*); int (*freeze)(FreezeAction, freezeData*);
}; };
int SysState_MTGSFreeze(int mode, freezeData* fP) int SysState_MTGSFreeze(FreezeAction mode, freezeData* fP)
{ {
ScopedCoreThreadPause paused_core; ScopedCoreThreadPause paused_core;
MTGS_FreezeData sstate = {fP, 0}; MTGS_FreezeData sstate = {fP, 0};
@ -69,21 +69,21 @@ static constexpr SysState_Component GS{"GS", SysState_MTGSFreeze};
void SysState_ComponentFreezeOutRoot(void* dest, SysState_Component comp) void SysState_ComponentFreezeOutRoot(void* dest, SysState_Component comp)
{ {
freezeData fP = {0, (char*)dest}; freezeData fP = {0, (char*)dest};
if (comp.freeze(FREEZE_SIZE, &fP) != 0) if (comp.freeze(FreezeAction::Size, &fP) != 0)
return; return;
if (!fP.size) if (!fP.size)
return; return;
Console.Indent().WriteLn("Saving %s", comp.name); Console.Indent().WriteLn("Saving %s", comp.name);
if (comp.freeze(FREEZE_SAVE, &fP) != 0) if (comp.freeze(FreezeAction::Save, &fP) != 0)
throw std::runtime_error(std::string(" * ") + comp.name + std::string(": Error saving state!\n")); throw std::runtime_error(std::string(" * ") + comp.name + std::string(": Error saving state!\n"));
} }
void SysState_ComponentFreezeIn(pxInputStream& infp, SysState_Component comp) void SysState_ComponentFreezeIn(pxInputStream& infp, SysState_Component comp)
{ {
freezeData fP = {0, nullptr}; freezeData fP = {0, nullptr};
if (comp.freeze(FREEZE_SIZE, &fP) != 0) if (comp.freeze(FreezeAction::Size, &fP) != 0)
fP.size = 0; fP.size = 0;
Console.Indent().WriteLn("Loading %s", comp.name); Console.Indent().WriteLn("Loading %s", comp.name);
@ -102,14 +102,14 @@ void SysState_ComponentFreezeIn(pxInputStream& infp, SysState_Component comp)
fP.data = data.GetPtr(); fP.data = data.GetPtr();
infp.Read(fP.data, fP.size); infp.Read(fP.data, fP.size);
if (comp.freeze(FREEZE_LOAD, &fP) != 0) if (comp.freeze(FreezeAction::Load, &fP) != 0)
throw std::runtime_error(std::string(" * ") + comp.name + std::string(": Error loading state!\n")); throw std::runtime_error(std::string(" * ") + comp.name + std::string(": Error loading state!\n"));
} }
void SysState_ComponentFreezeOut(SaveStateBase& writer, SysState_Component comp) void SysState_ComponentFreezeOut(SaveStateBase& writer, SysState_Component comp)
{ {
freezeData fP = {0, NULL}; freezeData fP = {0, NULL};
if (comp.freeze(FREEZE_SIZE, &fP) == 0) if (comp.freeze(FreezeAction::Size, &fP) == 0)
{ {
const int size = fP.size; const int size = fP.size;
writer.PrepBlock(size); writer.PrepBlock(size);