X-Git-Url: https://notaz.gp2x.de/cgi-bin/gitweb.cgi?a=blobdiff_plain;f=libpcsxcore%2Fplugins.c;h=e6d8a11e155be021dd22ffc2226c4cec5b0777d1;hb=HEAD;hp=d44442b01d0c838b09f670618b454c47a666b915;hpb=ca640f335d4b230140a33f48c314ecaec5dcd901;p=pcsx_rearmed.git

diff --git a/libpcsxcore/plugins.c b/libpcsxcore/plugins.c
index d44442b0..3cf1cf61 100644
--- a/libpcsxcore/plugins.c
+++ b/libpcsxcore/plugins.c
@@ -23,6 +23,7 @@
 
 #include "plugins.h"
 #include "cdriso.h"
+#include "cdrom-async.h"
 #include "psxcounters.h"
 
 static char IsoFile[MAXPATHLEN] = "";
@@ -31,9 +32,6 @@ static s64 cdOpenCaseTime = 0;
 GPUupdateLace         GPU_updateLace;
 GPUinit               GPU_init;
 GPUshutdown           GPU_shutdown;
-GPUconfigure          GPU_configure;
-GPUtest               GPU_test;
-GPUabout              GPU_about;
 GPUopen               GPU_open;
 GPUclose              GPU_close;
 GPUreadStatus         GPU_readStatus;
@@ -43,35 +41,10 @@ GPUwriteStatus        GPU_writeStatus;
 GPUwriteData          GPU_writeData;
 GPUwriteDataMem       GPU_writeDataMem;
 GPUdmaChain           GPU_dmaChain;
-GPUkeypressed         GPU_keypressed;
-GPUdisplayText        GPU_displayText;
-GPUmakeSnapshot       GPU_makeSnapshot;
 GPUfreeze             GPU_freeze;
-GPUgetScreenPic       GPU_getScreenPic;
-GPUshowScreenPic      GPU_showScreenPic;
 GPUvBlank             GPU_vBlank;
 GPUgetScreenInfo      GPU_getScreenInfo;
 
-CDRinit               CDR_init;
-CDRshutdown           CDR_shutdown;
-CDRopen               CDR_open;
-CDRclose              CDR_close;
-CDRtest               CDR_test;
-CDRgetTN              CDR_getTN;
-CDRgetTD              CDR_getTD;
-CDRreadTrack          CDR_readTrack;
-CDRgetBuffer          CDR_getBuffer;
-CDRplay               CDR_play;
-CDRstop               CDR_stop;
-CDRgetStatus          CDR_getStatus;
-CDRgetDriveLetter     CDR_getDriveLetter;
-CDRgetBufferSub       CDR_getBufferSub;
-CDRconfigure          CDR_configure;
-CDRabout              CDR_about;
-CDRsetfilename        CDR_setfilename;
-CDRreadCDDA           CDR_readCDDA;
-CDRgetTE              CDR_getTE;
-
 SPUinit               SPU_init;
 SPUshutdown           SPU_shutdown;
 SPUopen               SPU_open;
@@ -86,51 +59,7 @@ SPUregisterCallback   SPU_registerCallback;
 SPUregisterScheduleCb SPU_registerScheduleCb;
 SPUasync              SPU_async;
 SPUplayCDDAchannel    SPU_playCDDAchannel;
-
-PADconfigure          PAD1_configure;
-PADabout              PAD1_about;
-PADinit               PAD1_init;
-PADshutdown           PAD1_shutdown;
-PADtest               PAD1_test;
-PADopen               PAD1_open;
-PADclose              PAD1_close;
-PADquery              PAD1_query;
-PADreadPort1          PAD1_readPort1;
-PADkeypressed         PAD1_keypressed;
-PADstartPoll          PAD1_startPoll;
-PADpoll               PAD1_poll;
-PADsetSensitive       PAD1_setSensitive;
-
-PADconfigure          PAD2_configure;
-PADabout              PAD2_about;
-PADinit               PAD2_init;
-PADshutdown           PAD2_shutdown;
-PADtest               PAD2_test;
-PADopen               PAD2_open;
-PADclose              PAD2_close;
-PADquery              PAD2_query;
-PADreadPort2          PAD2_readPort2;
-PADkeypressed         PAD2_keypressed;
-PADstartPoll          PAD2_startPoll;
-PADpoll               PAD2_poll;
-PADsetSensitive       PAD2_setSensitive;
-
-NETinit               NET_init;
-NETshutdown           NET_shutdown;
-NETopen               NET_open;
-NETclose              NET_close;
-NETtest               NET_test;
-NETconfigure          NET_configure;
-NETabout              NET_about;
-NETpause              NET_pause;
-NETresume             NET_resume;
-NETqueryPlayer        NET_queryPlayer;
-NETsendData           NET_sendData;
-NETrecvData           NET_recvData;
-NETsendPadData        NET_sendPadData;
-NETrecvPadData        NET_recvPadData;
-NETsetInfo            NET_setInfo;
-NETkeypressed         NET_keypressed;
+SPUsetCDvol           SPU_setCDvol;
 
 #ifdef ENABLE_SIO1API
 
@@ -179,24 +108,13 @@ static const char *err;
 
 #define LoadSym(dest, src, name, checkerr) { \
 	dest = (src)SysLoadSym(drv, name); \
-	if (checkerr) { CheckErr(name); } else SysLibError(); \
+	if (checkerr) { CheckErr(name); } \
 }
 
 void *hGPUDriver = NULL;
 
-void CALLBACK GPU__displayText(char *pText) {
-	SysPrintf("%s\n", pText);
-}
-
-long CALLBACK GPU__configure(void) { return 0; }
-long CALLBACK GPU__test(void) { return 0; }
-void CALLBACK GPU__about(void) {}
-void CALLBACK GPU__makeSnapshot(void) {}
-void CALLBACK GPU__keypressed(int key) {}
-long CALLBACK GPU__getScreenPic(unsigned char *pMem) { return -1; }
-long CALLBACK GPU__showScreenPic(unsigned char *pMem) { return -1; }
-void CALLBACK GPU__vBlank(int val) {}
-void CALLBACK GPU__getScreenInfo(int *y, int *base_hres) {}
+static void CALLBACK GPU__vBlank(int val) {}
+static void CALLBACK GPU__getScreenInfo(int *y, int *base_hres) {}
 
 #define LoadGpuSym1(dest, name) \
 	LoadSym(GPU_##dest, GPU##dest, name, TRUE);
@@ -213,7 +131,6 @@ static int LoadGPUplugin(const char *GPUdll) {
 
 	hGPUDriver = SysLoadLibrary(GPUdll);
 	if (hGPUDriver == NULL) {
-		GPU_configure = NULL;
 		SysMessage (_("Could not load GPU plugin %s!"), GPUdll); return -1;
 	}
 	drv = hGPUDriver;
@@ -229,27 +146,14 @@ static int LoadGPUplugin(const char *GPUdll) {
 	LoadGpuSym1(writeStatus, "GPUwriteStatus");
 	LoadGpuSym1(dmaChain, "GPUdmaChain");
 	LoadGpuSym1(updateLace, "GPUupdateLace");
-	LoadGpuSym0(keypressed, "GPUkeypressed");
-	LoadGpuSym0(displayText, "GPUdisplayText");
-	LoadGpuSym0(makeSnapshot, "GPUmakeSnapshot");
 	LoadGpuSym1(freeze, "GPUfreeze");
-	LoadGpuSym0(getScreenPic, "GPUgetScreenPic");
-	LoadGpuSym0(showScreenPic, "GPUshowScreenPic");
 	LoadGpuSym0(vBlank, "GPUvBlank");
 	LoadGpuSym0(getScreenInfo, "GPUgetScreenInfo");
-	LoadGpuSym0(configure, "GPUconfigure");
-	LoadGpuSym0(test, "GPUtest");
-	LoadGpuSym0(about, "GPUabout");
 
 	return 0;
 }
 
-void *hCDRDriver = NULL;
-
-long CALLBACK CDR__play(unsigned char *sector) { return 0; }
-long CALLBACK CDR__stop(void) { return 0; }
-
-long CALLBACK CDR__getStatus(struct CdrStat *stat) {
+int CDR__getStatus(struct CdrStat *stat) {
 	if (cdOpenCaseTime < 0 || cdOpenCaseTime > (s64)time(NULL))
 		stat->Status = 0x10;
 	else
@@ -258,68 +162,17 @@ long CALLBACK CDR__getStatus(struct CdrStat *stat) {
 	return 0;
 }
 
-char* CALLBACK CDR__getDriveLetter(void) { return NULL; }
-long CALLBACK CDR__configure(void) { return 0; }
-long CALLBACK CDR__test(void) { return 0; }
-void CALLBACK CDR__about(void) {}
-long CALLBACK CDR__setfilename(char*filename) { return 0; }
-
-#define LoadCdrSym1(dest, name) \
-	LoadSym(CDR_##dest, CDR##dest, name, TRUE);
-
-#define LoadCdrSym0(dest, name) \
-	LoadSym(CDR_##dest, CDR##dest, name, FALSE); \
-	if (CDR_##dest == NULL) CDR_##dest = (CDR##dest) CDR__##dest;
-
-#define LoadCdrSymN(dest, name) \
-	LoadSym(CDR_##dest, CDR##dest, name, FALSE);
-
-static int LoadCDRplugin(const char *CDRdll) {
-	void *drv;
-
-	if (CDRdll == NULL) {
-		cdrIsoInit();
-		return 0;
-	}
-
-	hCDRDriver = SysLoadLibrary(CDRdll);
-	if (hCDRDriver == NULL) {
-		CDR_configure = NULL;
-		SysMessage (_("Could not load CD-ROM plugin %s!"), CDRdll);  return -1;
-	}
-	drv = hCDRDriver;
-	LoadCdrSym1(init, "CDRinit");
-	LoadCdrSym1(shutdown, "CDRshutdown");
-	LoadCdrSym1(open, "CDRopen");
-	LoadCdrSym1(close, "CDRclose");
-	LoadCdrSym1(getTN, "CDRgetTN");
-	LoadCdrSym1(getTD, "CDRgetTD");
-	LoadCdrSym1(readTrack, "CDRreadTrack");
-	LoadCdrSym1(getBuffer, "CDRgetBuffer");
-	LoadCdrSym1(getBufferSub, "CDRgetBufferSub");
-	LoadCdrSym0(play, "CDRplay");
-	LoadCdrSym0(stop, "CDRstop");
-	LoadCdrSym0(getStatus, "CDRgetStatus");
-	LoadCdrSym0(getDriveLetter, "CDRgetDriveLetter");
-	LoadCdrSym0(configure, "CDRconfigure");
-	LoadCdrSym0(test, "CDRtest");
-	LoadCdrSym0(about, "CDRabout");
-	LoadCdrSym0(setfilename, "CDRsetfilename");
-	LoadCdrSymN(readCDDA, "CDRreadCDDA");
-	LoadCdrSymN(getTE, "CDRgetTE");
-
-	return 0;
-}
-
 static void *hSPUDriver = NULL;
 static void CALLBACK SPU__registerScheduleCb(void (CALLBACK *cb)(unsigned int)) {}
+static void CALLBACK SPU__setCDvol(unsigned char ll, unsigned char lr,
+		unsigned char rl, unsigned char rr, unsigned int cycle) {}
 
 #define LoadSpuSym1(dest, name) \
 	LoadSym(SPU_##dest, SPU##dest, name, TRUE);
 
 #define LoadSpuSym0(dest, name) \
 	LoadSym(SPU_##dest, SPU##dest, name, FALSE); \
-	if (SPU_##dest == NULL) SPU_##dest = (SPU##dest) SPU__##dest;
+	if (SPU_##dest == NULL) SPU_##dest = SPU__##dest;
 
 #define LoadSpuSymN(dest, name) \
 	LoadSym(SPU_##dest, SPU##dest, name, FALSE);
@@ -346,15 +199,13 @@ static int LoadSPUplugin(const char *SPUdll) {
 	LoadSpuSym0(registerScheduleCb, "SPUregisterScheduleCb");
 	LoadSpuSymN(async, "SPUasync");
 	LoadSpuSymN(playCDDAchannel, "SPUplayCDDAchannel");
+	LoadSpuSym0(setCDvol, "SPUsetCDvol");
 
 	return 0;
 }
 
 extern int in_type[8];
 
-void *hPAD1Driver = NULL;
-void *hPAD2Driver = NULL;
-
 // Pad information, keystate, mode, config mode, vibration
 static PadDataS pads[8];
 
@@ -490,16 +341,28 @@ static void initBufForRequest(int padIndex, char value) {
 		return;
 	}
 
-	// switch to analog mode automatically after the game finishes init
-	if (value == 0x42 && pads[padIndex].ds.padMode == 0)
-		pads[padIndex].ds.digitalModeFrames++;
-	if (pads[padIndex].ds.digitalModeFrames == 60*4) {
-		pads[padIndex].ds.padMode = 1;
-		pads[padIndex].ds.digitalModeFrames = 0;
-	}
-
-	if ((u32)(frame_counter - pads[padIndex].ds.lastUseFrame) > 60u)
+	if ((u32)(frame_counter - pads[padIndex].ds.lastUseFrame) > 2*60u
+	    && pads[padIndex].ds.configModeUsed
+	    && !Config.hacks.dualshock_init_analog)
+	{
+		//SysPrintf("Pad reset\n");
 		pads[padIndex].ds.padMode = 0; // according to nocash
+		pads[padIndex].ds.autoAnalogTried = 0;
+	}
+	else if (pads[padIndex].ds.padMode == 0 && value == CMD_READ_DATA_AND_VIBRATE
+		 && pads[padIndex].ds.configModeUsed
+		 && !pads[padIndex].ds.configMode
+		 && !pads[padIndex].ds.userToggled)
+	{
+		if (pads[padIndex].ds.autoAnalogTried == 16) {
+			// auto-enable for convenience
+			SysPrintf("Auto-enabling dualshock analog mode.\n");
+			pads[padIndex].ds.padMode = 1;
+			pads[padIndex].ds.autoAnalogTried = 255;
+		}
+		else if (pads[padIndex].ds.autoAnalogTried < 16)
+			pads[padIndex].ds.autoAnalogTried++;
+	}
 	pads[padIndex].ds.lastUseFrame = frame_counter;
 
 	switch (value) {
@@ -833,12 +696,12 @@ static unsigned char PADpollMain(int port, unsigned char value, int *more_data)
 
 // refresh the button state on port 1.
 // int pad is not needed.
-unsigned char CALLBACK PAD1__startPoll(int unused) {
+unsigned char PAD1_startPoll(int unused) {
 	int i;
 
 	reqPos = 0;
 	pads[0].requestPadIndex = 0;
-	PAD1_readPort1(&pads[0]);
+	PAD1_readPort(&pads[0]);
 
 	pads[0].multitapLongModeEnabled = 0;
 	if (pads[0].portMultitap)
@@ -850,72 +713,24 @@ unsigned char CALLBACK PAD1__startPoll(int unused) {
 		// a multitap is plugged and enabled: refresh pads 1-3
 		for (i = 1; i < 4; i++) {
 			pads[i].requestPadIndex = i;
-			PAD1_readPort1(&pads[i]);
+			PAD1_readPort(&pads[i]);
 		}
 	}
 	return 0xff;
 }
 
-unsigned char CALLBACK PAD1__poll(unsigned char value, int *more_data) {
+unsigned char PAD1_poll(unsigned char value, int *more_data) {
 	return PADpollMain(0, value, more_data);
 }
 
 
-long CALLBACK PAD1__configure(void) { return 0; }
-void CALLBACK PAD1__about(void) {}
-long CALLBACK PAD1__test(void) { return 0; }
-long CALLBACK PAD1__query(void) { return 3; }
-long CALLBACK PAD1__keypressed() { return 0; }
-
-#define LoadPad1Sym1(dest, name) \
-	LoadSym(PAD1_##dest, PAD##dest, name, TRUE);
-
-#define LoadPad1SymN(dest, name) \
-	LoadSym(PAD1_##dest, PAD##dest, name, FALSE);
-
-#define LoadPad1Sym0(dest, name) \
-	LoadSym(PAD1_##dest, PAD##dest, name, FALSE); \
-	if (PAD1_##dest == NULL) PAD1_##dest = (PAD##dest) PAD1__##dest;
-
-static int LoadPAD1plugin(const char *PAD1dll) {
-	void *drv;
-	size_t p;
-
-	hPAD1Driver = SysLoadLibrary(PAD1dll);
-	if (hPAD1Driver == NULL) {
-		PAD1_configure = NULL;
-		SysMessage (_("Could not load Controller 1 plugin %s!"), PAD1dll); return -1;
-	}
-	drv = hPAD1Driver;
-	LoadPad1Sym1(init, "PADinit");
-	LoadPad1Sym1(shutdown, "PADshutdown");
-	LoadPad1Sym1(open, "PADopen");
-	LoadPad1Sym1(close, "PADclose");
-	LoadPad1Sym0(query, "PADquery");
-	LoadPad1Sym1(readPort1, "PADreadPort1");
-	LoadPad1Sym0(configure, "PADconfigure");
-	LoadPad1Sym0(test, "PADtest");
-	LoadPad1Sym0(about, "PADabout");
-	LoadPad1Sym0(keypressed, "PADkeypressed");
-	LoadPad1Sym0(startPoll, "PADstartPoll");
-	LoadPad1Sym0(poll, "PADpoll");
-	LoadPad1SymN(setSensitive, "PADsetSensitive");
-
-	memset(pads, 0, sizeof(pads));
-	for (p = 0; p < sizeof(pads) / sizeof(pads[0]); p++) {
-		memset(pads[p].ds.cmd4dConfig, 0xff, sizeof(pads[p].ds.cmd4dConfig));
-	}
-
-	return 0;
-}
-
-unsigned char CALLBACK PAD2__startPoll(int pad) {
+unsigned char PAD2_startPoll(int pad) {
 	int pad_index = pads[0].portMultitap ? 4 : 1;
 	int i;
 
 	reqPos = 0;
 	pads[pad_index].requestPadIndex = pad_index;
-	PAD2_readPort2(&pads[pad_index]);
+	PAD2_readPort(&pads[pad_index]);
 
 	pads[pad_index].multitapLongModeEnabled = 0;
 	if (pads[pad_index].portMultitap)
@@ -926,56 +741,23 @@ unsigned char CALLBACK PAD2__startPoll(int pad) {
 	} else {
 		for (i = 1; i < 4; i++) {
 			pads[pad_index + i].requestPadIndex = pad_index + i;
-			PAD2_readPort2(&pads[pad_index + i]);
+			PAD2_readPort(&pads[pad_index + i]);
 		}
 	}
 	return 0xff;
 }
 
-unsigned char CALLBACK PAD2__poll(unsigned char value, int *more_data) {
+unsigned char PAD2_poll(unsigned char value, int *more_data) {
 	return PADpollMain(pads[0].portMultitap ? 4 : 1, value, more_data);
 }
 
-long CALLBACK PAD2__configure(void) { return 0; }
-void CALLBACK PAD2__about(void) {}
-long CALLBACK PAD2__test(void) { return 0; }
-long CALLBACK PAD2__query(void) { return PSE_PAD_USE_PORT1 | PSE_PAD_USE_PORT2; }
-long CALLBACK PAD2__keypressed() { return 0; }
-
-#define LoadPad2Sym1(dest, name) \
-	LoadSym(PAD2_##dest, PAD##dest, name, TRUE);
-
-#define LoadPad2Sym0(dest, name) \
-	LoadSym(PAD2_##dest, PAD##dest, name, FALSE); \
-	if (PAD2_##dest == NULL) PAD2_##dest = (PAD##dest) PAD2__##dest;
-
-#define LoadPad2SymN(dest, name) \
-	LoadSym(PAD2_##dest, PAD##dest, name, FALSE);
-
-static int LoadPAD2plugin(const char *PAD2dll) {
-	void *drv;
+static void PAD_init(void) {
+	size_t p;
 
-	hPAD2Driver = SysLoadLibrary(PAD2dll);
-	if (hPAD2Driver == NULL) {
-		PAD2_configure = NULL;
-		SysMessage (_("Could not load Controller 2 plugin %s!"), PAD2dll); return -1;
+	memset(pads, 0, sizeof(pads));
+	for (p = 0; p < sizeof(pads) / sizeof(pads[0]); p++) {
+		memset(pads[p].ds.cmd4dConfig, 0xff, sizeof(pads[p].ds.cmd4dConfig));
 	}
-	drv = hPAD2Driver;
-	LoadPad2Sym1(init, "PADinit");
-	LoadPad2Sym1(shutdown, "PADshutdown");
-	LoadPad2Sym1(open, "PADopen");
-	LoadPad2Sym1(close, "PADclose");
-	LoadPad2Sym0(query, "PADquery");
-	LoadPad2Sym1(readPort2, "PADreadPort2");
-	LoadPad2Sym0(configure, "PADconfigure");
-	LoadPad2Sym0(test, "PADtest");
-	LoadPad2Sym0(about, "PADabout");
-	LoadPad2Sym0(keypressed, "PADkeypressed");
-	LoadPad2Sym0(startPoll, "PADstartPoll");
-	LoadPad2Sym0(poll, "PADpoll");
-	LoadPad2SymN(setSensitive, "PADsetSensitive");
-
-	return 0;
 }
 
 int padFreeze(void *f, int Mode) {
@@ -991,51 +773,15 @@ int padFreeze(void *f, int Mode) {
 	return 0;
 }
 
+int padToggleAnalog(unsigned int index)
+{
+	int r = -1;
 
-void *hNETDriver = NULL;
-
-void CALLBACK NET__setInfo(netInfo *info) {}
-void CALLBACK NET__keypressed(int key) {}
-long CALLBACK NET__configure(void) { return 0; }
-long CALLBACK NET__test(void) { return 0; }
-void CALLBACK NET__about(void) {}
-
-#define LoadNetSym1(dest, name) \
-	LoadSym(NET_##dest, NET##dest, name, TRUE);
-
-#define LoadNetSymN(dest, name) \
-	LoadSym(NET_##dest, NET##dest, name, FALSE);
-
-#define LoadNetSym0(dest, name) \
-	LoadSym(NET_##dest, NET##dest, name, FALSE); \
-	if (NET_##dest == NULL) NET_##dest = (NET##dest) NET__##dest;
-
-static int LoadNETplugin(const char *NETdll) {
-	void *drv;
-
-	hNETDriver = SysLoadLibrary(NETdll);
-	if (hNETDriver == NULL) {
-		SysMessage (_("Could not load NetPlay plugin %s!"), NETdll); return -1;
+	if (index < sizeof(pads) / sizeof(pads[0])) {
+		r = (pads[index].ds.padMode ^= 1);
+		pads[index].ds.userToggled = 1;
 	}
-	drv = hNETDriver;
-	LoadNetSym1(init, "NETinit");
-	LoadNetSym1(shutdown, "NETshutdown");
-	LoadNetSym1(open, "NETopen");
-	LoadNetSym1(close, "NETclose");
-	LoadNetSymN(sendData, "NETsendData");
-	LoadNetSymN(recvData, "NETrecvData");
-	LoadNetSym1(sendPadData, "NETsendPadData");
-	LoadNetSym1(recvPadData, "NETrecvPadData");
-	LoadNetSym1(queryPlayer, "NETqueryPlayer");
-	LoadNetSym1(pause, "NETpause");
-	LoadNetSym1(resume, "NETresume");
-	LoadNetSym0(setInfo, "NETsetInfo");
-	LoadNetSym0(keypressed, "NETkeypressed");
-	LoadNetSym0(configure, "NETconfigure");
-	LoadNetSym0(test, "NETtest");
-	LoadNetSym0(about, "NETabout");
-
-	return 0;
+	return r;
 }
 
 #ifdef ENABLE_SIO1API
@@ -1138,59 +884,30 @@ static int LoadSIO1plugin(const char *SIO1dll) {
 #endif
 
 int LoadPlugins() {
-	int ret;
 	char Plugin[MAXPATHLEN * 2];
+	int ret;
 
 	ReleasePlugins();
 	SysLibError();
 
-	if (UsingIso()) {
-		LoadCDRplugin(NULL);
-	} else {
-		sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Cdr);
-		if (LoadCDRplugin(Plugin) == -1) return -1;
-	}
-
 	sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Gpu);
 	if (LoadGPUplugin(Plugin) == -1) return -1;
 
 	sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Spu);
 	if (LoadSPUplugin(Plugin) == -1) return -1;
 
-	sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Pad1);
-	if (LoadPAD1plugin(Plugin) == -1) return -1;
-
-	sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Pad2);
-	if (LoadPAD2plugin(Plugin) == -1) return -1;
-
-	if (strcmp("Disabled", Config.Net) == 0 || strcmp("", Config.Net) == 0)
-		Config.UseNet = FALSE;
-	else {
-		Config.UseNet = TRUE;
-		sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Net);
-		if (LoadNETplugin(Plugin) == -1) Config.UseNet = FALSE;
-	}
-
 #ifdef ENABLE_SIO1API
 	sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Sio1);
 	if (LoadSIO1plugin(Plugin) == -1) return -1;
 #endif
 
-	ret = CDR_init();
+	ret = cdra_init();
 	if (ret < 0) { SysMessage (_("Error initializing CD-ROM plugin: %d"), ret); return -1; }
 	ret = GPU_init();
 	if (ret < 0) { SysMessage (_("Error initializing GPU plugin: %d"), ret); return -1; }
 	ret = SPU_init();
 	if (ret < 0) { SysMessage (_("Error initializing SPU plugin: %d"), ret); return -1; }
-	ret = PAD1_init(1);
-	if (ret < 0) { SysMessage (_("Error initializing Controller 1 plugin: %d"), ret); return -1; }
-	ret = PAD2_init(2);
-	if (ret < 0) { SysMessage (_("Error initializing Controller 2 plugin: %d"), ret); return -1; }
-
-	if (Config.UseNet) {
-		ret = NET_init();
-		if (ret < 0) { SysMessage (_("Error initializing NetPlay plugin: %d"), ret); return -1; }
-	}
+	PAD_init();
 
 #ifdef ENABLE_SIO1API
 	ret = SIO1_init();
@@ -1202,29 +919,12 @@ int LoadPlugins() {
 }
 
 void ReleasePlugins() {
-	if (Config.UseNet) {
-		int ret = NET_close();
-		if (ret < 0) Config.UseNet = FALSE;
-	}
-	NetOpened = FALSE;
-
-	if (hCDRDriver != NULL || cdrIsoActive()) CDR_shutdown();
+	cdra_shutdown();
 	if (hGPUDriver != NULL) GPU_shutdown();
 	if (hSPUDriver != NULL) SPU_shutdown();
-	if (hPAD1Driver != NULL) PAD1_shutdown();
-	if (hPAD2Driver != NULL) PAD2_shutdown();
 
-	if (Config.UseNet && hNETDriver != NULL) NET_shutdown();
-
-	if (hCDRDriver != NULL) { SysCloseLibrary(hCDRDriver); hCDRDriver = NULL; }
 	if (hGPUDriver != NULL) { SysCloseLibrary(hGPUDriver); hGPUDriver = NULL; }
 	if (hSPUDriver != NULL) { SysCloseLibrary(hSPUDriver); hSPUDriver = NULL; }
-	if (hPAD1Driver != NULL) { SysCloseLibrary(hPAD1Driver); hPAD1Driver = NULL; }
-	if (hPAD2Driver != NULL) { SysCloseLibrary(hPAD2Driver); hPAD2Driver = NULL; }
-
-	if (Config.UseNet && hNETDriver != NULL) {
-		SysCloseLibrary(hNETDriver); hNETDriver = NULL;
-	}
 
 #ifdef ENABLE_SIO1API
 	if (hSIO1Driver != NULL) {
@@ -1238,18 +938,8 @@ void ReleasePlugins() {
 // for CD swap
 int ReloadCdromPlugin()
 {
-	if (hCDRDriver != NULL || cdrIsoActive()) CDR_shutdown();
-	if (hCDRDriver != NULL) { SysCloseLibrary(hCDRDriver); hCDRDriver = NULL; }
-
-	if (UsingIso()) {
-		LoadCDRplugin(NULL);
-	} else {
-		char Plugin[MAXPATHLEN * 2];
-		sprintf(Plugin, "%s/%s", Config.PluginsDir, Config.Cdr);
-		if (LoadCDRplugin(Plugin) == -1) return -1;
-	}
-
-	return CDR_init();
+	cdra_shutdown();
+	return cdra_init();
 }
 
 void SetIsoFile(const char *filename) {