[pcsx_rearmed.git] / gui / Plugin.c

/*  Pcsx - Pc Psx Emulator
 *  Copyright (C) 1999-2002  Pcsx Team
 *
 *  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., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <dlfcn.h>
#include <X11/keysym.h>
#include <signal.h>

#include "Linux.h"

#include "../libpcsxcore/plugins.h"
#include "../libpcsxcore/spu.h"
#include "../libpcsxcore/cdriso.h"

#include "nopic.h"

#define MAX_SLOTS 5	/* ADB TODO Same as Gtk2Gui.c */

void OnFile_Exit();

unsigned long gpuDisp;

int StatesC = 0;
extern int UseGui;
int ShowPic = 0;

void gpuShowPic() {
	gchar *state_filename;
	gzFile f;

	if (!ShowPic) {
		unsigned char *pMem;

		pMem = (unsigned char *) malloc(128*96*3);
		if (pMem == NULL) return;

		state_filename = get_state_filename (StatesC);

		GPU_freeze(2, (GPUFreeze_t *)&StatesC);

		f = gzopen(state_filename, "rb");
		if (f != NULL) {
			gzseek(f, 32, SEEK_SET); // skip header
			gzread(f, pMem, 128*96*3);
			gzclose(f);
		} else {
			memcpy(pMem, NoPic_Image.pixel_data, 128*96*3);
			DrawNumBorPic(pMem, StatesC+1);
		}
		GPU_showScreenPic(pMem);

		free(pMem);
		ShowPic = 1;
		g_free (state_filename);
	} else {
		GPU_showScreenPic(NULL);
		ShowPic = 0;
	}
}

void KeyStateSave(int i) {
	gchar *state_filename;

	state_filename = get_state_filename (i);
	state_save (state_filename);

	g_free (state_filename);
}

void KeyStateLoad(int i) {
	gchar *state_filename;

	state_filename = get_state_filename (i);
	state_load (state_filename);

	g_free (state_filename);

	// HACKHACK: prevent crash when using recompiler due to execution not
	// returned from compiled code. This WILL cause memory leak, however a
	// large amount of refactor is needed for a proper fix.
	if (Config.Cpu == CPU_DYNAREC) psxCpu->Execute();
}

static short modctrl = 0, modalt = 0;

/* Handle keyboard keystrokes */
void PADhandleKey(int key) {
	char Text[MAXPATHLEN];
	gchar *state_filename;

	short rel = 0;	//released key flag

	if (key == 0)
		return;

	if ((key >> 30) & 1)	//specific to dfinput (padJoy)
		rel = 1;

	if (rel) {
		switch (key & ~0x40000000) {
		case XK_Alt_L:
		case XK_Alt_R:
			modalt=0;
			break;
		case XK_Control_L:
		case XK_Control_R:
			modctrl=0;
			break;
		}
		return;
	}

	switch (key) {
		case XK_Alt_L:
		case XK_Alt_R:
			modalt=1;
			break;
		case XK_Control_L:
		case XK_Control_R:
			modctrl=1;
			break;

		case XK_0:
			if (modalt && modctrl)
				return;
			if (modalt) KeyStateLoad(10);
			break;

		case XK_1:
			if (modalt && modctrl)
				return;
			if (modalt) KeyStateLoad(0);
			if (modctrl) KeyStateSave(0);
			break;
		case XK_2:
			if (modalt && modctrl)
				return;
			if (modalt) KeyStateLoad(1);
			if (modctrl) KeyStateSave(1);
			break;
		case XK_3:
			if (modalt && modctrl)
				return;
			if (modalt) KeyStateLoad(2);
			if (modctrl) KeyStateSave(2);
			break;
		case XK_4:
			if (modalt && modctrl)
				return;
			if (modalt) KeyStateLoad(3);
			if (modctrl) KeyStateSave(3);
			break;
		case XK_5:
			if (modalt && modctrl)
				return;
			if (modalt) KeyStateLoad(4);
			if (modctrl) KeyStateSave(4);
			break;

		case XK_F1:
			GPU_freeze(2, (GPUFreeze_t *)&StatesC);
			state_filename = get_state_filename (StatesC);
			state_save (state_filename);

			g_free (state_filename);

			if (ShowPic) { ShowPic = 0; gpuShowPic(); }

			break;
		case XK_F2:
			if (StatesC < (MAX_SLOTS - 1)) StatesC++;
			else StatesC = 0;
			GPU_freeze(2, (GPUFreeze_t *)&StatesC);
			if (ShowPic) { ShowPic = 0; gpuShowPic(); }
			break;
		case XK_F3:
			state_filename = get_state_filename (StatesC);
			state_load (state_filename);

			g_free (state_filename);

			// HACKHACK: prevent crash when using recompiler due to execution not
			// returned from compiled code. This WILL cause memory leak, however a
			// large amount of refactor is needed for a proper fix.
			if (Config.Cpu == CPU_DYNAREC) psxCpu->Execute();

			break;
		case XK_F4:
			gpuShowPic();
			break;
		case XK_F5:
			Config.Sio ^= 0x1;
			if (Config.Sio)
				sprintf(Text, _("SIO IRQ Always Enabled"));
			else sprintf(Text, _("SIO IRQ Not Always Enabled"));
			GPU_displayText(Text);
			break;
		case XK_F6:
			Config.Mdec ^= 0x1;
			if (Config.Mdec)
				sprintf(Text, _("Black & White Mdecs Only Enabled"));
			else sprintf(Text, _("Black & White Mdecs Only Disabled"));
			GPU_displayText(Text);
			break;
		case XK_F7:
			Config.Xa ^= 0x1;
			if (Config.Xa == 0)
				sprintf (Text, _("XA Enabled"));
			else sprintf (Text, _("XA Disabled"));
			GPU_displayText(Text);
			break;
		case XK_F8:
			GPU_makeSnapshot();
			break;
		case XK_F9:
			SetCdOpenCaseTime(-1);
			break;
		case XK_F10:
			SetCdOpenCaseTime(0);
			break;
		case XK_Escape:
			// TODO
			// the architecture is too broken to actually restart the GUI
			// because SysUpdate is called from deep within the actual
			// execution of the emulation code
			// Fixing this would probably require a complete reworking of
			// all functions, so that they return 0 or 1 for success
			// that way, execution wouldn't continue
			if (CdromId[0] != '\0')
				KeyStateSave(10);
			ClosePlugins();
			UpdateMenuSlots();
			if (!UseGui) OnFile_Exit();
			StartGui();
			break;
		case XK_Return:		//0xff0d
			if (modalt)	//alt-return
				//I just made this up: a special sym for fullscreen because the current interface can't handle key mods
				//though it can be used in the future as a convention...eg bit 29 for alt, bit 28 for cntl, etc.
				GPU_keypressed( (1<<29) | 0xFF0D );
			break;
		default:
			GPU_keypressed(key);
			if (Config.UseNet) NET_keypressed(key);
	}	
}

void OnFile_Exit();

void SignalExit(int sig) {
	ClosePlugins();
	OnFile_Exit();
}

#define PARSEPATH(dst, src) \
	ptr = src + strlen(src); \
	while (*ptr != '\\' && ptr != src) ptr--; \
	if (ptr != src) { \
		strcpy(dst, ptr+1); \
	}

int _OpenPlugins() {
	int ret;

	signal(SIGINT, SignalExit);
	signal(SIGPIPE, SignalExit);

	GPU_clearDynarec(clearDynarec);

	ret = CDR_open();
	if (ret < 0) { SysMessage(_("Error opening CD-ROM plugin!")); return -1; }
	ret = SPU_open();
	if (ret < 0) { SysMessage(_("Error opening SPU plugin!")); return -1; }
	SPU_registerCallback(SPUirq);
	ret = GPU_open(&gpuDisp, "PCSX", NULL);
	if (ret < 0) { SysMessage(_("Error opening GPU plugin!")); return -1; }
	ret = PAD1_open(&gpuDisp);
	if (ret < 0) { SysMessage(_("Error opening Controller 1 plugin!")); return -1; }
	ret = PAD2_open(&gpuDisp);
	if (ret < 0) { SysMessage(_("Error opening Controller 2 plugin!")); return -1; }

	if (Config.UseNet && !NetOpened) {
		netInfo info;
		char path[MAXPATHLEN];
		char dotdir[MAXPATHLEN];

		strncpy(dotdir, getenv("HOME"), MAXPATHLEN-100);
		strcat(dotdir, "/.pcsx/plugins/");

		strcpy(info.EmuName, "PCSX " PACKAGE_VERSION);
		strncpy(info.CdromID, CdromId, 9);
		strncpy(info.CdromLabel, CdromLabel, 9);
		info.psxMem = psxM;
		info.GPU_showScreenPic = GPU_showScreenPic;
		info.GPU_displayText = GPU_displayText;
		info.GPU_showScreenPic = GPU_showScreenPic;
		info.PAD_setSensitive = PAD1_setSensitive;
		sprintf(path, "%s%s", Config.BiosDir, Config.Bios);
		strcpy(info.BIOSpath, path);
		strcpy(info.MCD1path, Config.Mcd1);
		strcpy(info.MCD2path, Config.Mcd2);
		sprintf(path, "%s%s", dotdir, Config.Gpu);
		strcpy(info.GPUpath, path);
		sprintf(path, "%s%s", dotdir, Config.Spu);
		strcpy(info.SPUpath, path);
		sprintf(path, "%s%s", dotdir, Config.Cdr);
		strcpy(info.CDRpath, path);
		NET_setInfo(&info);

		ret = NET_open(&gpuDisp);
		if (ret < 0) {
			if (ret == -2) {
				// -2 is returned when something in the info
				// changed and needs to be synced
				char *ptr;

				PARSEPATH(Config.Bios, info.BIOSpath);
				PARSEPATH(Config.Gpu,  info.GPUpath);
				PARSEPATH(Config.Spu,  info.SPUpath);
				PARSEPATH(Config.Cdr,  info.CDRpath);

				strcpy(Config.Mcd1, info.MCD1path);
				strcpy(Config.Mcd2, info.MCD2path);
				return -2;
			} else {
				Config.UseNet = FALSE;
			}
		} else {
			if (NET_queryPlayer() == 1) {
				if (SendPcsxInfo() == -1) Config.UseNet = FALSE;
			} else {
				if (RecvPcsxInfo() == -1) Config.UseNet = FALSE;
			}
		}
		NetOpened = TRUE;
	} else if (Config.UseNet) {
		NET_resume();
	}

	return 0;
}

int OpenPlugins() {
	int ret;

	while ((ret = _OpenPlugins()) == -2) {
		ReleasePlugins();
		LoadMcds(Config.Mcd1, Config.Mcd2);
		if (LoadPlugins() == -1) return -1;
	}
	return ret;
}

void ClosePlugins() {
	int ret;

	signal(SIGINT, SIG_DFL);
	signal(SIGPIPE, SIG_DFL);
	ret = CDR_close();
	if (ret < 0) { SysMessage(_("Error closing CD-ROM plugin!")); return; }
	ret = SPU_close();
	if (ret < 0) { SysMessage(_("Error closing SPU plugin!")); return; }
	ret = PAD1_close();
	if (ret < 0) { SysMessage(_("Error closing Controller 1 Plugin!")); return; }
	ret = PAD2_close();
	if (ret < 0) { SysMessage(_("Error closing Controller 2 plugin!")); return; }
	ret = GPU_close();
	if (ret < 0) { SysMessage(_("Error closing GPU plugin!")); return; }

	if (Config.UseNet) {
		NET_pause();
	}
}
Commit	Line	Data
ef79bbde P	1	/* Pcsx - Pc Psx Emulator
	2	* Copyright (C) 1999-2002 Pcsx Team
	3	*
	4	* This program is free software; you can redistribute it and/or modify
	5	* it under the terms of the GNU General Public License as published by
	6	* the Free Software Foundation; either version 2 of the License, or
	7	* (at your option) any later version.
	8	*
	9	* This program is distributed in the hope that it will be useful,
	10	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	11	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	12	* GNU General Public License for more details.
	13	*
	14	* You should have received a copy of the GNU General Public License
	15	* along with this program; if not, write to the Free Software
	16	* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1307 USA
	17	*/
	18
	19	#include <stdio.h>
	20	#include <stdlib.h>
	21	#include <string.h>
	22	#include <dlfcn.h>
	23	#include <X11/keysym.h>
	24	#include <signal.h>
	25
	26	#include "Linux.h"
	27
	28	#include "../libpcsxcore/plugins.h"
	29	#include "../libpcsxcore/spu.h"
	30	#include "../libpcsxcore/cdriso.h"
	31
	32	#include "nopic.h"
	33
	34	#define MAX_SLOTS 5 /* ADB TODO Same as Gtk2Gui.c */
	35
	36	void OnFile_Exit();
	37
	38	unsigned long gpuDisp;
	39
	40	int StatesC = 0;
	41	extern int UseGui;
	42	int ShowPic = 0;
	43
	44	void gpuShowPic() {
	45	gchar *state_filename;
	46	gzFile f;
	47
	48	if (!ShowPic) {
	49	unsigned char *pMem;
	50
	51	pMem = (unsigned char ) malloc(12896*3);
	52	if (pMem == NULL) return;
	53
	54	state_filename = get_state_filename (StatesC);
	55
	56	GPU_freeze(2, (GPUFreeze_t *)&StatesC);
	57
	58	f = gzopen(state_filename, "rb");
	59	if (f != NULL) {
	60	gzseek(f, 32, SEEK_SET); // skip header
	61	gzread(f, pMem, 128963);
	62	gzclose(f);
	63	} else {
	64	memcpy(pMem, NoPic_Image.pixel_data, 128963);
65	DrawNumBorPic(pMem, StatesC+1);
66	}
67	GPU_showScreenPic(pMem);
68
69	free(pMem);
70	ShowPic = 1;
71	g_free (state_filename);
72	} else {
73	GPU_showScreenPic(NULL);
74	ShowPic = 0;
75	}
76	}
77
78	void KeyStateSave(int i) {
79	gchar *state_filename;
80
81	state_filename = get_state_filename (i);
82	state_save (state_filename);
83
84	g_free (state_filename);
85	}
86
87	void KeyStateLoad(int i) {
88	gchar *state_filename;
89
90	state_filename = get_state_filename (i);
91	state_load (state_filename);
92
93	g_free (state_filename);
94
95	// HACKHACK: prevent crash when using recompiler due to execution not
96	// returned from compiled code. This WILL cause memory leak, however a
97	// large amount of refactor is needed for a proper fix.
98	if (Config.Cpu == CPU_DYNAREC) psxCpu->Execute();
99	}
100
101	static short modctrl = 0, modalt = 0;
102
103	/* Handle keyboard keystrokes */
104	void PADhandleKey(int key) {
105	char Text[MAXPATHLEN];
106	gchar *state_filename;
107
108	short rel = 0; //released key flag
109
110	if (key == 0)
111	return;
112
113	if ((key >> 30) & 1) //specific to dfinput (padJoy)
114	rel = 1;
115
116	if (rel) {
117	switch (key & ~0x40000000) {
118	case XK_Alt_L:
119	case XK_Alt_R:
120	modalt=0;
121	break;
122	case XK_Control_L:
123	case XK_Control_R:
124	modctrl=0;
125	break;
126	}
127	return;
128	}
129
130	switch (key) {
131	case XK_Alt_L:
132	case XK_Alt_R:
133	modalt=1;
134	break;
135	case XK_Control_L:
136	case XK_Control_R:
137	modctrl=1;
138	break;
139
140	case XK_0:
141	if (modalt && modctrl)
142	return;
143	if (modalt) KeyStateLoad(10);
144	break;
145
146	case XK_1:
147	if (modalt && modctrl)
148	return;
149	if (modalt) KeyStateLoad(0);
150	if (modctrl) KeyStateSave(0);
151	break;
152	case XK_2:
153	if (modalt && modctrl)
154	return;
155	if (modalt) KeyStateLoad(1);
156	if (modctrl) KeyStateSave(1);
157	break;
158	case XK_3:
159	if (modalt && modctrl)
160	return;
161	if (modalt) KeyStateLoad(2);
162	if (modctrl) KeyStateSave(2);
163	break;
164	case XK_4:
165	if (modalt && modctrl)
166	return;
167	if (modalt) KeyStateLoad(3);
168	if (modctrl) KeyStateSave(3);
169	break;
170	case XK_5:
171	if (modalt && modctrl)
172	return;
173	if (modalt) KeyStateLoad(4);
174	if (modctrl) KeyStateSave(4);
175	break;
176
177	case XK_F1:
178	GPU_freeze(2, (GPUFreeze_t *)&StatesC);
179	state_filename = get_state_filename (StatesC);
180	state_save (state_filename);
181
182	g_free (state_filename);
183
184	if (ShowPic) { ShowPic = 0; gpuShowPic(); }
185
186	break;
187	case XK_F2:
188	if (StatesC < (MAX_SLOTS - 1)) StatesC++;
189	else StatesC = 0;
190	GPU_freeze(2, (GPUFreeze_t *)&StatesC);
191	if (ShowPic) { ShowPic = 0; gpuShowPic(); }
192	break;
193	case XK_F3:
194	state_filename = get_state_filename (StatesC);
195	state_load (state_filename);
196
197	g_free (state_filename);
198
199	// HACKHACK: prevent crash when using recompiler due to execution not
200	// returned from compiled code. This WILL cause memory leak, however a
201	// large amount of refactor is needed for a proper fix.
202	if (Config.Cpu == CPU_DYNAREC) psxCpu->Execute();
203
204	break;
205	case XK_F4:
206	gpuShowPic();
207	break;
208	case XK_F5:
209	Config.Sio ^= 0x1;
210	if (Config.Sio)
211	sprintf(Text, _("SIO IRQ Always Enabled"));
212	else sprintf(Text, _("SIO IRQ Not Always Enabled"));
213	GPU_displayText(Text);
214	break;
215	case XK_F6:
216	Config.Mdec ^= 0x1;
217	if (Config.Mdec)
218	sprintf(Text, _("Black & White Mdecs Only Enabled"));
219	else sprintf(Text, _("Black & White Mdecs Only Disabled"));
220	GPU_displayText(Text);
221	break;
222	case XK_F7:
223	Config.Xa ^= 0x1;
224	if (Config.Xa == 0)
225	sprintf (Text, _("XA Enabled"));
226	else sprintf (Text, _("XA Disabled"));
227	GPU_displayText(Text);
228	break;
229	case XK_F8:
230	GPU_makeSnapshot();
231	break;
232	case XK_F9:
233	SetCdOpenCaseTime(-1);
234	break;
235	case XK_F10:
236	SetCdOpenCaseTime(0);
237	break;
238	case XK_Escape:
239	// TODO
240	// the architecture is too broken to actually restart the GUI
241	// because SysUpdate is called from deep within the actual
242	// execution of the emulation code
243	// Fixing this would probably require a complete reworking of
244	// all functions, so that they return 0 or 1 for success
245	// that way, execution wouldn't continue
246	if (CdromId[0] != '\0')
247	KeyStateSave(10);
248	ClosePlugins();
249	UpdateMenuSlots();
250	if (!UseGui) OnFile_Exit();
251	StartGui();
252	break;
253	case XK_Return: //0xff0d
254	if (modalt) //alt-return
255	//I just made this up: a special sym for fullscreen because the current interface can't handle key mods
256	//though it can be used in the future as a convention...eg bit 29 for alt, bit 28 for cntl, etc.
257	GPU_keypressed( (1<<29) \| 0xFF0D );
258	break;
259	default:
260	GPU_keypressed(key);
261	if (Config.UseNet) NET_keypressed(key);
262	}
263	}
264
265	void OnFile_Exit();
266
267	void SignalExit(int sig) {
268	ClosePlugins();
269	OnFile_Exit();
270	}
271
272	#define PARSEPATH(dst, src) \
273	ptr = src + strlen(src); \
274	while (*ptr != '\\' && ptr != src) ptr--; \
275	if (ptr != src) { \
276	strcpy(dst, ptr+1); \
277	}
278
279	int _OpenPlugins() {
280	int ret;
281
282	signal(SIGINT, SignalExit);
283	signal(SIGPIPE, SignalExit);
284
285	GPU_clearDynarec(clearDynarec);
286
287	ret = CDR_open();
288	if (ret < 0) { SysMessage(_("Error opening CD-ROM plugin!")); return -1; }
289	ret = SPU_open();
290	if (ret < 0) { SysMessage(_("Error opening SPU plugin!")); return -1; }
291	SPU_registerCallback(SPUirq);
292	ret = GPU_open(&gpuDisp, "PCSX", NULL);
293	if (ret < 0) { SysMessage(_("Error opening GPU plugin!")); return -1; }
294	ret = PAD1_open(&gpuDisp);
295	if (ret < 0) { SysMessage(_("Error opening Controller 1 plugin!")); return -1; }
296	ret = PAD2_open(&gpuDisp);
297	if (ret < 0) { SysMessage(_("Error opening Controller 2 plugin!")); return -1; }
298
299	if (Config.UseNet && !NetOpened) {
300	netInfo info;
301	char path[MAXPATHLEN];
302	char dotdir[MAXPATHLEN];
303
304	strncpy(dotdir, getenv("HOME"), MAXPATHLEN-100);
305	strcat(dotdir, "/.pcsx/plugins/");
306
307	strcpy(info.EmuName, "PCSX " PACKAGE_VERSION);
308	strncpy(info.CdromID, CdromId, 9);
309	strncpy(info.CdromLabel, CdromLabel, 9);
310	info.psxMem = psxM;
311	info.GPU_showScreenPic = GPU_showScreenPic;
312	info.GPU_displayText = GPU_displayText;
313	info.GPU_showScreenPic = GPU_showScreenPic;
314	info.PAD_setSensitive = PAD1_setSensitive;
315	sprintf(path, "%s%s", Config.BiosDir, Config.Bios);
316	strcpy(info.BIOSpath, path);
317	strcpy(info.MCD1path, Config.Mcd1);
318	strcpy(info.MCD2path, Config.Mcd2);
319	sprintf(path, "%s%s", dotdir, Config.Gpu);
320	strcpy(info.GPUpath, path);
321	sprintf(path, "%s%s", dotdir, Config.Spu);
322	strcpy(info.SPUpath, path);
323	sprintf(path, "%s%s", dotdir, Config.Cdr);
324	strcpy(info.CDRpath, path);
325	NET_setInfo(&info);
326
327	ret = NET_open(&gpuDisp);
328	if (ret < 0) {
329	if (ret == -2) {
330	// -2 is returned when something in the info
331	// changed and needs to be synced
332	char *ptr;
333
334	PARSEPATH(Config.Bios, info.BIOSpath);
335	PARSEPATH(Config.Gpu, info.GPUpath);
336	PARSEPATH(Config.Spu, info.SPUpath);
337	PARSEPATH(Config.Cdr, info.CDRpath);
338
339	strcpy(Config.Mcd1, info.MCD1path);
340	strcpy(Config.Mcd2, info.MCD2path);
341	return -2;
342	} else {
343	Config.UseNet = FALSE;
344	}
345	} else {
346	if (NET_queryPlayer() == 1) {
347	if (SendPcsxInfo() == -1) Config.UseNet = FALSE;
348	} else {
349	if (RecvPcsxInfo() == -1) Config.UseNet = FALSE;
350	}
351	}
352	NetOpened = TRUE;
353	} else if (Config.UseNet) {
354	NET_resume();
355	}
356
357	return 0;
358	}
359
360	int OpenPlugins() {
361	int ret;
362
363	while ((ret = _OpenPlugins()) == -2) {
364	ReleasePlugins();
365	LoadMcds(Config.Mcd1, Config.Mcd2);
366	if (LoadPlugins() == -1) return -1;
367	}
368	return ret;
369	}
370
371	void ClosePlugins() {
372	int ret;
373
374	signal(SIGINT, SIG_DFL);
375	signal(SIGPIPE, SIG_DFL);
376	ret = CDR_close();
377	if (ret < 0) { SysMessage(_("Error closing CD-ROM plugin!")); return; }
378	ret = SPU_close();
379	if (ret < 0) { SysMessage(_("Error closing SPU plugin!")); return; }
380	ret = PAD1_close();
381	if (ret < 0) { SysMessage(_("Error closing Controller 1 Plugin!")); return; }
382	ret = PAD2_close();
383	if (ret < 0) { SysMessage(_("Error closing Controller 2 plugin!")); return; }
384	ret = GPU_close();
385	if (ret < 0) { SysMessage(_("Error closing GPU plugin!")); return; }
386
387	if (Config.UseNet) {
388	NET_pause();
389	}
390	}